Skip to content
This repository has been archived by the owner on Apr 15, 2020. It is now read-only.

Rename coin to token & go fmt #15

Merged
merged 1 commit into from
Mar 25, 2019
Merged

Rename coin to token & go fmt #15

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 10 additions & 10 deletions consensus/signedtree.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,19 +12,19 @@ import (
)

const (
TransactionTypeEstablishCoin = "ESTABLISH_COIN"
TransactionTypeMintCoin = "MINT_COIN"
TransactionTypeSetData = "SET_DATA"
TransactionTypeSetOwnership = "SET_OWNERSHIP"
TransactionTypeStake = "STAKE"
TransactionTypeEstablishToken = "ESTABLISH_TOKEN"
TransactionTypeMintToken = "MINT_TOKEN"
TransactionTypeSetData = "SET_DATA"
TransactionTypeSetOwnership = "SET_OWNERSHIP"
TransactionTypeStake = "STAKE"
)

var DefaultTransactors = map[string]chaintree.TransactorFunc{
TransactionTypeEstablishCoin: EstablishCoinTransaction,
TransactionTypeMintCoin: MintCoinTransaction,
TransactionTypeSetData: SetDataTransaction,
TransactionTypeSetOwnership: SetOwnershipTransaction,
TransactionTypeStake: StakeTransaction,
TransactionTypeEstablishToken: EstablishTokenTransaction,
TransactionTypeMintToken: MintTokenTransaction,
TransactionTypeSetData: SetDataTransaction,
TransactionTypeSetOwnership: SetOwnershipTransaction,
TransactionTypeStake: StakeTransaction,
}

type SignedChainTree struct {
Expand Down
82 changes: 41 additions & 41 deletions consensus/transactions.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,27 +13,27 @@ import (

const (
TreePathForAuthentications = "_tupelo/authentications"
TreePathForCoins = "_tupelo/coins"
TreePathForTokens = "_tupelo/tokens"
TreePathForStake = "_tupelo/stake"
TreePathForData = "data"
)

func init() {
typecaster.AddType(SetDataPayload{})
typecaster.AddType(SetOwnershipPayload{})
typecaster.AddType(EstablishCoinPayload{})
typecaster.AddType(MintCoinPayload{})
typecaster.AddType(Coin{})
typecaster.AddType(CoinMonetaryPolicy{})
typecaster.AddType(CoinMint{})
typecaster.AddType(EstablishTokenPayload{})
typecaster.AddType(MintTokenPayload{})
typecaster.AddType(Token{})
typecaster.AddType(TokenMonetaryPolicy{})
typecaster.AddType(TokenMint{})
typecaster.AddType(StakePayload{})
cbornode.RegisterCborType(SetDataPayload{})
cbornode.RegisterCborType(SetOwnershipPayload{})
cbornode.RegisterCborType(EstablishCoinPayload{})
cbornode.RegisterCborType(MintCoinPayload{})
cbornode.RegisterCborType(Coin{})
cbornode.RegisterCborType(CoinMonetaryPolicy{})
cbornode.RegisterCborType(CoinMint{})
cbornode.RegisterCborType(EstablishTokenPayload{})
cbornode.RegisterCborType(MintTokenPayload{})
cbornode.RegisterCborType(Token{})
cbornode.RegisterCborType(TokenMonetaryPolicy{})
cbornode.RegisterCborType(TokenMint{})
cbornode.RegisterCborType(StakePayload{})
}

Expand Down Expand Up @@ -126,68 +126,68 @@ func SetOwnershipTransaction(tree *dag.Dag, transaction *chaintree.Transaction)
return newTree, true, nil
}

type Coin struct {
type Token struct {
MonetaryPolicy *cid.Cid
Mints *cid.Cid
Sends *cid.Cid
Receives *cid.Cid
}

type CoinMonetaryPolicy struct {
type TokenMonetaryPolicy struct {
Maximum uint64
}

type EstablishCoinPayload struct {
type EstablishTokenPayload struct {
Name string
MonetaryPolicy CoinMonetaryPolicy
MonetaryPolicy TokenMonetaryPolicy
}

func EstablishCoinTransaction(tree *dag.Dag, transaction *chaintree.Transaction) (newTree *dag.Dag, valid bool, codedErr chaintree.CodedError) {
payload := &EstablishCoinPayload{}
func EstablishTokenTransaction(tree *dag.Dag, transaction *chaintree.Transaction) (newTree *dag.Dag, valid bool, codedErr chaintree.CodedError) {
payload := &EstablishTokenPayload{}
err := typecaster.ToType(transaction.Payload, payload)

if err != nil {
return nil, false, &ErrorCode{Code: 999, Memo: fmt.Sprintf("error setting: %v", err)}
}

coinName := payload.Name
path, err := DecodePath(TreePathForCoins)
tokenName := payload.Name
path, err := DecodePath(TreePathForTokens)
if err != nil {
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error decoding path: %v", err)}
}
coinPath := append(path, coinName)
existingCoin, _, err := tree.Resolve(coinPath)
tokenPath := append(path, tokenName)
existingToken, _, err := tree.Resolve(tokenPath)
if err != nil {
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error attempting to resolve %v: %v", coinPath, err)}
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error attempting to resolve %v: %v", tokenPath, err)}
}
if existingCoin != nil {
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error, coin at path %v already exists", coinPath)}
if existingToken != nil {
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error, token at path %v already exists", tokenPath)}
}

newTree, err = tree.SetAsLink(coinPath, &Coin{})
newTree, err = tree.SetAsLink(tokenPath, &Token{})
if err != nil {
return nil, false, &ErrorCode{Code: 999, Memo: fmt.Sprintf("error setting: %v", err)}
}

newTree, err = tree.SetAsLink(append(coinPath, "monetaryPolicy"), payload.MonetaryPolicy)
newTree, err = tree.SetAsLink(append(tokenPath, "monetaryPolicy"), payload.MonetaryPolicy)
if err != nil {
return nil, false, &ErrorCode{Code: 999, Memo: fmt.Sprintf("error setting: %v", err)}
}

return newTree, true, nil
}

type MintCoinPayload struct {
type MintTokenPayload struct {
Name string
Amount uint64
}

type CoinMint struct {
type TokenMint struct {
Amount uint64
}

func MintCoinTransaction(tree *dag.Dag, transaction *chaintree.Transaction) (newTree *dag.Dag, valid bool, codedErr chaintree.CodedError) {
payload := &MintCoinPayload{}
func MintTokenTransaction(tree *dag.Dag, transaction *chaintree.Transaction) (newTree *dag.Dag, valid bool, codedErr chaintree.CodedError) {
payload := &MintTokenPayload{}
err := typecaster.ToType(transaction.Payload, payload)

if err != nil {
Expand All @@ -198,31 +198,31 @@ func MintCoinTransaction(tree *dag.Dag, transaction *chaintree.Transaction) (new
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: "error, can not mint an amount < 0"}
}

coinName := payload.Name
path, err := DecodePath(TreePathForCoins)
tokenName := payload.Name
path, err := DecodePath(TreePathForTokens)
if err != nil {
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error decoding path: %v", err)}
}
coinPath := append(path, coinName)
tokenPath := append(path, tokenName)

uncastMonetaryPolicy, _, err := tree.Resolve(append(coinPath, "monetaryPolicy"))
uncastMonetaryPolicy, _, err := tree.Resolve(append(tokenPath, "monetaryPolicy"))
if err != nil {
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error fetch coin at path %v: %v", coinPath, err)}
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error fetch token at path %v: %v", tokenPath, err)}
}
if uncastMonetaryPolicy == nil {
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error, coin at path %v does not exist, must MINT_COIN first", coinPath)}
return nil, false, &ErrorCode{Code: ErrUnknown, Memo: fmt.Sprintf("error, token at path %v does not exist, must MINT_TOKEN first", tokenPath)}
}

monetaryPolicy := &CoinMonetaryPolicy{}
monetaryPolicy := &TokenMonetaryPolicy{}
err = typecaster.ToType(uncastMonetaryPolicy, monetaryPolicy)

if err != nil {
return nil, false, &ErrorCode{Code: 999, Memo: fmt.Sprintf("error setting: %v", err)}
}

uncastMintCids, _, err := tree.Resolve(append(coinPath, "mints"))
uncastMintCids, _, err := tree.Resolve(append(tokenPath, "mints"))
if err != nil {
return nil, false, &ErrorCode{Code: 999, Memo: fmt.Sprintf("error fetching mints at %v: %v", coinPath, err)}
return nil, false, &ErrorCode{Code: 999, Memo: fmt.Sprintf("error fetching mints at %v: %v", tokenPath, err)}
}

var mintCids []cid.Cid
Expand Down Expand Up @@ -260,7 +260,7 @@ func MintCoinTransaction(tree *dag.Dag, transaction *chaintree.Transaction) (new
}
}

newMint, err := tree.CreateNode(&CoinMint{
newMint, err := tree.CreateNode(&TokenMint{
Amount: payload.Amount,
})
if err != nil {
Expand All @@ -269,7 +269,7 @@ func MintCoinTransaction(tree *dag.Dag, transaction *chaintree.Transaction) (new

mintCids = append(mintCids, newMint.Cid())

newTree, err = tree.SetAsLink(append(coinPath, "mints"), mintCids)
newTree, err = tree.SetAsLink(append(tokenPath, "mints"), mintCids)
if err != nil {
return nil, false, &ErrorCode{Code: 999, Memo: fmt.Sprintf("error setting: %v", err)}
}
Expand Down
28 changes: 14 additions & 14 deletions consensus/transactions_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,7 @@ import (
"github.com/stretchr/testify/require"
)

func TestEstablishCoinTransactionWithMaximum(t *testing.T) {
func TestEstablishTokenTransactionWithMaximum(t *testing.T) {
key, err := crypto.GenerateKey()
assert.Nil(t, err)

Expand All @@ -26,9 +26,9 @@ func TestEstablishCoinTransactionWithMaximum(t *testing.T) {
PreviousTip: nil,
Transactions: []*chaintree.Transaction{
{
Type: "ESTABLISH_COIN",
Type: "ESTABLISH_TOKEN",
Payload: map[string]interface{}{
"name": "testcoin",
"name": "testtoken",
"monetaryPolicy": map[string]interface{}{
"maximum": 42,
},
Expand All @@ -44,24 +44,24 @@ func TestEstablishCoinTransactionWithMaximum(t *testing.T) {
_, err = testTree.ProcessBlock(blockWithHeaders)
assert.Nil(t, err)

maximum, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "coins", "testcoin", "monetaryPolicy", "maximum"})
maximum, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "tokens", "testtoken", "monetaryPolicy", "maximum"})
assert.Nil(t, err)
assert.Equal(t, maximum, uint64(42))

mints, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "coins", "testcoin", "mints"})
mints, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "tokens", "testtoken", "mints"})
assert.Nil(t, err)
assert.Nil(t, mints)

sends, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "coins", "testcoin", "sends"})
sends, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "tokens", "testtoken", "sends"})
assert.Nil(t, err)
assert.Nil(t, sends)

receives, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "coins", "testcoin", "receives"})
receives, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "tokens", "testtoken", "receives"})
assert.Nil(t, err)
assert.Nil(t, receives)
}

func TestEstablishCoinTransactionWithoutMonetaryPolicy(t *testing.T) {
func TestEstablishTokenTransactionWithoutMonetaryPolicy(t *testing.T) {
key, err := crypto.GenerateKey()
assert.Nil(t, err)

Expand All @@ -74,9 +74,9 @@ func TestEstablishCoinTransactionWithoutMonetaryPolicy(t *testing.T) {
PreviousTip: nil,
Transactions: []*chaintree.Transaction{
{
Type: "ESTABLISH_COIN",
Type: "ESTABLISH_TOKEN",
Payload: map[string]interface{}{
"name": "testcoin",
"name": "testtoken",
},
},
},
Expand All @@ -89,19 +89,19 @@ func TestEstablishCoinTransactionWithoutMonetaryPolicy(t *testing.T) {
_, err = testTree.ProcessBlock(blockWithHeaders)
assert.Nil(t, err)

maximum, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "coins", "testcoin", "monetaryPolicy", "maximum"})
maximum, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "tokens", "testtoken", "monetaryPolicy", "maximum"})
assert.Nil(t, err)
assert.Empty(t, maximum)

mints, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "coins", "testcoin", "mints"})
mints, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "tokens", "testtoken", "mints"})
assert.Nil(t, err)
assert.Nil(t, mints)

sends, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "coins", "testcoin", "sends"})
sends, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "tokens", "testtoken", "sends"})
assert.Nil(t, err)
assert.Nil(t, sends)

receives, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "coins", "testcoin", "receives"})
receives, _, err := testTree.Dag.Resolve([]string{"tree", "_tupelo", "tokens", "testtoken", "receives"})
assert.Nil(t, err)
assert.Nil(t, receives)
}
Expand Down