diff --git a/account/account.go b/account/account.go
index 3aec5db87403458036df2a8d44e60411bf0b198f..4cb846ace1b0f74c2c95f08ac8c5d8e86793f25b 100644
--- a/account/account.go
+++ b/account/account.go
@@ -55,7 +55,7 @@ type Account interface {
Balance() uint64
// The EVM byte code held by this account (or equivalently, this contract)
Code() Bytecode
- // The sequence number (or nonce) of this account, incremented each time a mutation of the
+ // The sequence number of this account, incremented each time a mutation of the
// Account is persisted to the blockchain state
Sequence() uint64
// The hash of all the values in this accounts storage (typically the root of some subtree
diff --git a/client/cmd/status.go b/client/cmd/status.go
index dac02391fa515adfa01291a3172e598dbfb4a314..555e9428d8214eb2a0c5b30a4e35ad041bf629e5 100644
--- a/client/cmd/status.go
+++ b/client/cmd/status.go
@@ -38,7 +38,7 @@ func buildStatusCommand() *cobra.Command {
// TransactionCmd.PersistentFlags().StringVarP(&clientDo.PubkeyFlag, "pubkey", "", defaultPublicKey(), "specify the public key to sign with (defaults to $BURROW_CLIENT_PUBLIC_KEY)")
// TransactionCmd.PersistentFlags().StringVarP(&clientDo.AddrFlag, "addr", "", defaultAddress(), "specify the account address (for which the public key can be found at monax-keys) (default respects $BURROW_CLIENT_ADDRESS)")
// TransactionCmd.PersistentFlags().StringVarP(&clientDo.ChainidFlag, "chain-id", "", defaultChainId(), "specify the chainID (default respects $CHAIN_ID)")
- // TransactionCmd.PersistentFlags().StringVarP(&clientDo.NonceFlag, "nonce", "", "", "specify the nonce to use for the transaction (should equal the sender account's nonce + 1)")
+ // TransactionCmd.PersistentFlags().StringVarP(&clientDo.NonceFlag, "sequence", "", "", "specify the sequence to use for the transaction (should equal the sender account's sequence + 1)")
// // TransactionCmd.PersistentFlags().BoolVarP(&clientDo.SignFlag, "sign", "s", false, "sign the transaction using the monax-keys daemon")
// TransactionCmd.PersistentFlags().BoolVarP(&clientDo.BroadcastFlag, "broadcast", "b", true, "broadcast the transaction to the blockchain")
diff --git a/client/cmd/transaction.go b/client/cmd/transaction.go
index 0bffd93875ac8f25a9c6aab49dfd719f508eb819..a5a1c0ac1ad231de5d1c823a3ebd0888fc79b938 100644
--- a/client/cmd/transaction.go
+++ b/client/cmd/transaction.go
@@ -145,7 +145,7 @@ func addTransactionPersistentFlags(transactionCmd *cobra.Command) {
transactionCmd.PersistentFlags().StringVarP(&clientDo.NodeAddrFlag, "node-addr", "", defaultNodeRpcAddress(), "set the burrow node rpc server address (default respects $BURROW_CLIENT_NODE_ADDRESS)")
transactionCmd.PersistentFlags().StringVarP(&clientDo.PubkeyFlag, "pubkey", "", defaultPublicKey(), "specify the public key to sign with (defaults to $BURROW_CLIENT_PUBLIC_KEY)")
transactionCmd.PersistentFlags().StringVarP(&clientDo.AddrFlag, "addr", "", defaultAddress(), "specify the account address (for which the public key can be found at monax-keys) (default respects $BURROW_CLIENT_ADDRESS)")
- transactionCmd.PersistentFlags().StringVarP(&clientDo.NonceFlag, "nonce", "", "", "specify the nonce to use for the transaction (should equal the sender account's nonce + 1)")
+ transactionCmd.PersistentFlags().StringVarP(&clientDo.NonceFlag, "sequence", "", "", "specify the sequence to use for the transaction (should equal the sender account's sequence + 1)")
// transactionCmd.PersistentFlags().BoolVarP(&clientDo.SignFlag, "sign", "s", false, "sign the transaction using the monax-keys daemon")
transactionCmd.PersistentFlags().BoolVarP(&clientDo.BroadcastFlag, "broadcast", "b", true, "broadcast the transaction to the blockchain")
diff --git a/client/rpc/client.go b/client/rpc/client.go
index a874a2ee38f01ae3885f9b2272c5052f0388cfd9..8e8f98e6af858732638c98b26bb4213338c9f8c5 100644
--- a/client/rpc/client.go
+++ b/client/rpc/client.go
@@ -31,8 +31,8 @@ import (
// core functions with string args.
// validates strings and forms transaction
-func Send(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr, toAddr, amtS, nonceS string) (*txs.SendTx, error) {
- pub, amt, nonce, err := checkCommon(nodeClient, keyClient, pubkey, addr, amtS, nonceS)
+func Send(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr, toAddr, amtS, sequenceS string) (*txs.SendTx, error) {
+ pub, amt, sequence, err := checkCommon(nodeClient, keyClient, pubkey, addr, amtS, sequenceS)
if err != nil {
return nil, err
}
@@ -47,14 +47,14 @@ func Send(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr,
}
tx := txs.NewSendTx()
- tx.AddInputWithNonce(pub, amt, nonce)
+ tx.AddInputWithSequence(pub, amt, sequence)
tx.AddOutput(toAddress, amt)
return tx, nil
}
-func Call(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr, toAddr, amtS, nonceS, gasS, feeS, data string) (*txs.CallTx, error) {
- pub, amt, nonce, err := checkCommon(nodeClient, keyClient, pubkey, addr, amtS, nonceS)
+func Call(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr, toAddr, amtS, sequenceS, gasS, feeS, data string) (*txs.CallTx, error) {
+ pub, amt, sequence, err := checkCommon(nodeClient, keyClient, pubkey, addr, amtS, sequenceS)
if err != nil {
return nil, err
}
@@ -84,12 +84,12 @@ func Call(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr,
return nil, fmt.Errorf("data is bad hex: %v", err)
}
- tx := txs.NewCallTxWithNonce(pub, toAddress, dataBytes, amt, gas, fee, nonce)
+ tx := txs.NewCallTxWithSequence(pub, toAddress, dataBytes, amt, gas, fee, sequence)
return tx, nil
}
-func Name(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr, amtS, nonceS, feeS, name, data string) (*txs.NameTx, error) {
- pub, amt, nonce, err := checkCommon(nodeClient, keyClient, pubkey, addr, amtS, nonceS)
+func Name(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr, amtS, sequenceS, feeS, name, data string) (*txs.NameTx, error) {
+ pub, amt, sequence, err := checkCommon(nodeClient, keyClient, pubkey, addr, amtS, sequenceS)
if err != nil {
return nil, err
}
@@ -99,12 +99,12 @@ func Name(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr,
return nil, fmt.Errorf("fee is misformatted: %v", err)
}
- tx := txs.NewNameTxWithNonce(pub, name, data, amt, fee, nonce)
+ tx := txs.NewNameTxWithSequence(pub, name, data, amt, fee, sequence)
return tx, nil
}
-func Permissions(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addrS, nonceS, permFunc string, argsS []string) (*txs.PermissionsTx, error) {
- pub, _, nonce, err := checkCommon(nodeClient, keyClient, pubkey, addrS, "0", nonceS)
+func Permissions(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addrS, sequenceS, permFunc string, argsS []string) (*txs.PermissionsTx, error) {
+ pub, _, sequence, err := checkCommon(nodeClient, keyClient, pubkey, addrS, "0", sequenceS)
if err != nil {
return nil, err
}
@@ -163,13 +163,13 @@ func Permissions(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey,
return nil, fmt.Errorf("invalid permission function for use in PermissionsTx: %s", permFunc)
}
// args := snativeArgs(
- tx := txs.NewPermissionsTxWithNonce(pub, args, nonce)
+ tx := txs.NewPermissionsTxWithSequence(pub, args, sequence)
return tx, nil
}
-func Bond(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, unbondAddr, amtS, nonceS string) (*txs.BondTx, error) {
+func Bond(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, unbondAddr, amtS, sequenceS string) (*txs.BondTx, error) {
return nil, fmt.Errorf("Bond Transaction formation to be implemented on 0.12.0")
- // pub, amt, nonce, err := checkCommon(nodeAddr, signAddr, pubkey, "", amtS, nonceS)
+ // pub, amt, sequence, err := checkCommon(nodeAddr, signAddr, pubkey, "", amtS, sequenceS)
// if err != nil {
// return nil, err
// }
@@ -192,7 +192,7 @@ func Bond(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, unbond
// if err != nil {
// return nil, err
// }
- // tx.AddInputWithNonce(pub, amt, int(nonce))
+ // tx.AddInputWithSequence(pub, amt, int(sequence))
// tx.AddOutput(unbondAddrBytes, amt)
// return tx, nil
diff --git a/client/rpc/client_test.go b/client/rpc/client_test.go
index c731e491d28340fc56c85767810e7b17b87f9e79..a8cd5df5772da1c636204d6a38b31b7eb8ba302f 100644
--- a/client/rpc/client_test.go
+++ b/client/rpc/client_test.go
@@ -52,11 +52,11 @@ func testSend(t *testing.T,
toAddressString := keyClient.NewKey().String()
// set an amount to transfer
amountString := "1000"
- // unset nonce so that we retrieve nonce from account
- nonceString := ""
+ // unset sequence so that we retrieve sequence from account
+ sequenceString := ""
_, err := Send(nodeClient, keyClient, publicKeyString, addressString,
- toAddressString, amountString, nonceString)
+ toAddressString, amountString, sequenceString)
require.NoError(t, err, "Error in Send")
// assert.NotEqual(t, txSend)
// TODO: test content of Transaction
@@ -77,8 +77,8 @@ func testCall(t *testing.T,
toAddressString := keyClient.NewKey().String()
// set an amount to transfer
amountString := "1000"
- // unset nonce so that we retrieve nonce from account
- nonceString := ""
+ // unset sequence so that we retrieve sequence from account
+ sequenceString := ""
// set gas
gasString := "1000"
// set fee
@@ -87,7 +87,7 @@ func testCall(t *testing.T,
dataString := fmt.Sprintf("%X", "We are DOUG.")
_, err := Call(nodeClient, keyClient, publicKeyString, addressString,
- toAddressString, amountString, nonceString, gasString, feeString, dataString)
+ toAddressString, amountString, sequenceString, gasString, feeString, dataString)
if err != nil {
t.Logf("Error in CallTx: %s", err)
t.Fail()
@@ -108,8 +108,8 @@ func testName(t *testing.T,
publicKeyString := ""
// set an amount to transfer
amountString := "1000"
- // unset nonce so that we retrieve nonce from account
- nonceString := ""
+ // unset sequence so that we retrieve sequence from account
+ sequenceString := ""
// set fee
feeString := "100"
// set data
@@ -118,7 +118,7 @@ func testName(t *testing.T,
nameString := "DOUG"
_, err := Name(nodeClient, keyClient, publicKeyString, addressString,
- amountString, nonceString, feeString, nameString, dataString)
+ amountString, sequenceString, feeString, nameString, dataString)
if err != nil {
t.Logf("Error in NameTx: %s", err)
t.Fail()
@@ -139,11 +139,11 @@ func testPermissions(t *testing.T,
publicKeyString := ""
// generate an additional address to set permissions for
permAddressString := keyClient.NewKey().String()
- // unset nonce so that we retrieve nonce from account
- nonceString := ""
+ // unset sequence so that we retrieve sequence from account
+ sequenceString := ""
_, err := Permissions(nodeClient, keyClient, publicKeyString, addressString,
- nonceString, "setBase", []string{permAddressString, "root", "true"})
+ sequenceString, "setBase", []string{permAddressString, "root", "true"})
if err != nil {
t.Logf("Error in PermissionsTx: %s", err)
t.Fail()
diff --git a/client/rpc/client_util.go b/client/rpc/client_util.go
index 02e6ae056541ed97a720164b5f6928b490fc10dd..8ad34c261e2787ea75e14cf73b9cf860f2548ee8 100644
--- a/client/rpc/client_util.go
+++ b/client/rpc/client_util.go
@@ -92,7 +92,7 @@ func decodeAddressPermFlag(addrS, permFlagS string) (addr acm.Address, pFlag pty
}
func checkCommon(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey, addr, amtS,
- nonceS string) (pub acm.PublicKey, amt uint64, nonce uint64, err error) {
+ sequenceS string) (pub acm.PublicKey, amt uint64, sequence uint64, err error) {
if amtS == "" {
err = fmt.Errorf("input must specify an amount with the --amt flag")
@@ -145,25 +145,25 @@ func checkCommon(nodeClient client.NodeClient, keyClient keys.KeyClient, pubkey,
err = fmt.Errorf("amt is misformatted: %v", err)
}
- if nonceS == "" {
+ if sequenceS == "" {
if nodeClient == nil {
- err = fmt.Errorf("input must specify a nonce with the --nonce flag or use --node-addr (or BURROW_CLIENT_NODE_ADDR) to fetch the nonce from a node")
+ err = fmt.Errorf("input must specify a sequence with the --sequence flag or use --node-addr (or BURROW_CLIENT_NODE_ADDR) to fetch the sequence from a node")
return
}
- // fetch nonce from node
+ // fetch sequence from node
account, err2 := nodeClient.GetAccount(address)
if err2 != nil {
- return pub, amt, nonce, err2
+ return pub, amt, sequence, err2
}
- nonce = account.Sequence() + 1
- logging.TraceMsg(nodeClient.Logger(), "Fetch nonce from node",
- "nonce", nonce,
+ sequence = account.Sequence() + 1
+ logging.TraceMsg(nodeClient.Logger(), "Fetch sequence from node",
+ "sequence", sequence,
"account address", address,
)
} else {
- nonce, err = strconv.ParseUint(nonceS, 10, 64)
+ sequence, err = strconv.ParseUint(sequenceS, 10, 64)
if err != nil {
- err = fmt.Errorf("nonce is misformatted: %v", err)
+ err = fmt.Errorf("sequence is misformatted: %v", err)
return
}
}
diff --git a/core/kernel.go b/core/kernel.go
index 81ddfce577ae1552775b3deadbe143d83bd72a7a..5465f0462007ace8a6262aadf0022d2785900a2b 100644
--- a/core/kernel.go
+++ b/core/kernel.go
@@ -89,7 +89,7 @@ func NewKernel(privValidator tm_types.PrivValidator, genesisDoc *genesis.Genesis
// TODO: consider whether we need to be more explicit about pre-commit (check cache) versus committed (state) values
// Note we pass the checker as the StateIterable to NewService which means the RPC layers will query the check
// cache state. This is in line with previous behaviour of Burrow and chiefly serves to get provide a pre-commit
- // view of nonce values on the node that a client is communicating with.
+ // view of sequence values on the node that a client is communicating with.
// Since we don't currently execute EVM code in the checker possible conflicts are limited to account creation
// which increments the creator's account Sequence and SendTxs
service := rpc.NewService(state, eventEmitter, nameReg, blockchain, transactor, query.NewNodeView(tmNode, txCodec),
diff --git a/docs/specs/api.md b/docs/specs/api.md
index 41e337420d6e08e54c76f3f70118cfd1a25f4a60..5f94b755afe89ea07a2eab9bbcd025b5aaa87fcb 100644
--- a/docs/specs/api.md
+++ b/docs/specs/api.md
@@ -632,8 +632,6 @@ Parameter:
##### Additional info
-Sequence is sometimes referred to as the "nonce".
-
There are two types of objects used to represent accounts, one is public accounts (like the one here), the other is private accounts, which only holds information about an accounts address, public and private key.
***
diff --git a/execution/execution.go b/execution/execution.go
index cf6342330bb09a8425d8dd26fa0fd3f50a73ad25..103a8607fda0dd9e645e67c650426eb1b95076f4 100644
--- a/execution/execution.go
+++ b/execution/execution.go
@@ -310,7 +310,7 @@ func (exe *executor) Execute(tx txs.Tx) error {
// if you call an account that doesn't exist
// or an account with no code then we take fees (sorry pal)
// NOTE: it's fine to create a contract and call it within one
- // block (nonce will prevent re-ordering of those txs)
+ // block (sequence number will prevent re-ordering of those txs)
// but to create with one contract and call with another
// you have to wait a block to avoid a re-ordering attack
// that will take your fees
diff --git a/execution/state_test.go b/execution/state_test.go
index 909b77d0ef61938fcec026ba9d7359e312f95ef5..8ffb5ff23ac92f19f1cf11b8fd56c61a92a46809 100644
--- a/execution/state_test.go
+++ b/execution/state_test.go
@@ -243,7 +243,7 @@ func TestTxSequence(t *testing.T) {
for i := uint64(0); i < 3; i++ {
sequence := acc0.Sequence() + i
tx := txs.NewSendTx()
- tx.AddInputWithNonce(acc0PubKey, 1, sequence)
+ tx.AddInputWithSequence(acc0PubKey, 1, sequence)
tx.AddOutput(acc1.Address(), 1)
tx.Inputs[0].Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
stateCopy := state.Copy()
@@ -881,7 +881,7 @@ func TestSelfDestruct(t *testing.T) {
state.UpdateAccount(newAcc1)
// send call tx with no data, cause self-destruct
- tx := txs.NewCallTxWithNonce(acc0PubKey, addressPtr(acc1), nil, sendingAmount, 1000, 0, acc0.Sequence()+1)
+ tx := txs.NewCallTxWithSequence(acc0PubKey, addressPtr(acc1), nil, sendingAmount, 1000, 0, acc0.Sequence()+1)
tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
// we use cache instead of execTxWithState so we can run the tx twice
diff --git a/execution/transactor.go b/execution/transactor.go
index e99573100b71ce967989b2c8eba89cf5fc3f2333..fc917c07b065cc2c1b1c92230b55043d3da21e83 100644
--- a/execution/transactor.go
+++ b/execution/transactor.go
@@ -391,7 +391,7 @@ func (trans *transactor) TransactNameReg(privKey []byte, name, data string, amou
if acc == nil {
sequence = acc.Sequence() + uint64(1)
}
- tx := txs.NewNameTxWithNonce(pa.PublicKey(), name, data, amount, fee, sequence)
+ tx := txs.NewNameTxWithSequence(pa.PublicKey(), name, data, amount, fee, sequence)
// Got ourselves a tx.
txS, errS := trans.SignTx(tx, []acm.PrivateAccount{pa})
if errS != nil {
diff --git a/rpc/tm/client/client_test.go b/rpc/tm/client/client_test.go
index 4140a21531bce1e39af38662784a4e5c44150e8a..fb3e37a9ff0de2031b2391e54d8f7c6e641b8b23 100644
--- a/rpc/tm/client/client_test.go
+++ b/rpc/tm/client/client_test.go
@@ -250,8 +250,8 @@ func TestNameReg(t *testing.T) {
assert.Equal(t, updatedData, entry.Data)
// try to update as non owner, should fail
- tx = txs.NewNameTxWithNonce(privateAccounts[1].PublicKey(), name, "never mind", amt, fee,
- getNonce(t, client, privateAccounts[1].Address())+1)
+ tx = txs.NewNameTxWithSequence(privateAccounts[1].PublicKey(), name, "never mind", amt, fee,
+ getSequence(t, client, privateAccounts[1].Address())+1)
tx.Sign(genesisDoc.ChainID(), privateAccounts[1])
_, err := broadcastTxAndWaitForBlock(t, client, wsc, tx)
@@ -267,8 +267,8 @@ func TestNameReg(t *testing.T) {
//now the entry should be expired, so we can update as non owner
const data2 = "this is not my beautiful house"
- tx = txs.NewNameTxWithNonce(privateAccounts[1].PublicKey(), name, data2, amt, fee,
- getNonce(t, client, privateAccounts[1].Address())+1)
+ tx = txs.NewNameTxWithSequence(privateAccounts[1].PublicKey(), name, data2, amt, fee,
+ getSequence(t, client, privateAccounts[1].Address())+1)
tx.Sign(genesisDoc.ChainID(), privateAccounts[1])
_, err = broadcastTxAndWaitForBlock(t, client, wsc, tx)
assert.NoError(t, err, "Should be able to update a previously expired name"+
diff --git a/rpc/tm/client/shared.go b/rpc/tm/client/shared.go
index 0aaf157c5433901056eccaa4aadf933e3fa342bf..c0b946f2edbef52f39f50c8c70e06f403f5d1f07 100644
--- a/rpc/tm/client/shared.go
+++ b/rpc/tm/client/shared.go
@@ -126,9 +126,9 @@ func makePrivateAccounts(n int) []acm.PrivateAccount {
// some default transaction functions
func makeDefaultSendTx(t *testing.T, client RPCClient, addr acm.Address, amt uint64) *txs.SendTx {
- nonce := getNonce(t, client, privateAccounts[0].Address())
+ sequence := getSequence(t, client, privateAccounts[0].Address())
tx := txs.NewSendTx()
- tx.AddInputWithNonce(privateAccounts[0].PublicKey(), amt, nonce+1)
+ tx.AddInputWithSequence(privateAccounts[0].PublicKey(), amt, sequence+1)
tx.AddOutput(addr, amt)
return tx
}
@@ -141,24 +141,16 @@ func makeDefaultSendTxSigned(t *testing.T, client RPCClient, addr acm.Address, a
func makeDefaultCallTx(t *testing.T, client RPCClient, addr *acm.Address, code []byte, amt, gasLim,
fee uint64) *txs.CallTx {
- nonce := getNonce(t, client, privateAccounts[0].Address())
- tx := txs.NewCallTxWithNonce(privateAccounts[0].PublicKey(), addr, code, amt, gasLim, fee,
- nonce+1)
- tx.Sign(genesisDoc.ChainID(), privateAccounts[0])
- return tx
-}
-
-func makeDefaultCallTxWithNonce(t *testing.T, addr *acm.Address, sequence uint64, code []byte,
- amt, gasLim, fee uint64) *txs.CallTx {
-
- tx := txs.NewCallTxWithNonce(privateAccounts[0].PublicKey(), addr, code, amt, gasLim, fee, sequence)
+ sequence := getSequence(t, client, privateAccounts[0].Address())
+ tx := txs.NewCallTxWithSequence(privateAccounts[0].PublicKey(), addr, code, amt, gasLim, fee,
+ sequence+1)
tx.Sign(genesisDoc.ChainID(), privateAccounts[0])
return tx
}
func makeDefaultNameTx(t *testing.T, client RPCClient, name, value string, amt, fee uint64) *txs.NameTx {
- nonce := getNonce(t, client, privateAccounts[0].Address())
- tx := txs.NewNameTxWithNonce(privateAccounts[0].PublicKey(), name, value, amt, fee, nonce+1)
+ sequence := getSequence(t, client, privateAccounts[0].Address())
+ tx := txs.NewNameTxWithSequence(privateAccounts[0].PublicKey(), name, value, amt, fee, sequence+1)
tx.Sign(genesisDoc.ChainID(), privateAccounts[0])
return tx
}
@@ -166,8 +158,8 @@ func makeDefaultNameTx(t *testing.T, client RPCClient, name, value string, amt,
//-------------------------------------------------------------------------------
// rpc call wrappers (fail on err)
-// get an account's nonce
-func getNonce(t *testing.T, client RPCClient, addr acm.Address) uint64 {
+// get an account's sequence number
+func getSequence(t *testing.T, client RPCClient, addr acm.Address) uint64 {
acc, err := GetAccount(client, addr)
if err != nil {
t.Fatal(err)
diff --git a/rpc/v0/json_service_test.go b/rpc/v0/json_service_test.go
index 5428f94a727d2593427ea5e65f2c03d6758f4bb6..087b89696e6c2b3daac5421480b046e213d7dff4 100644
--- a/rpc/v0/json_service_test.go
+++ b/rpc/v0/json_service_test.go
@@ -33,7 +33,7 @@ func TestBroadcastTx(t *testing.T) {
pubKey := account.GenPrivAccount().PubKey
address := []byte{1}
code := opcodes.Bytecode(opcodes.PUSH1, 1, opcodes.PUSH1, 1, opcodes.ADD)
- var tx txs.Tx = txs.NewCallTxWithNonce(pubKey, address, code, 10, 2,
+ var tx txs.Tx = txs.NewCallTxWithSequence(pubKey, address, code, 10, 2,
1, 0)
jsonBytes := wire.JSONBytesPretty(wrappedTx{tx})
request := rpc.NewRPCRequest("TestBroadcastTx", "BroadcastTx", jsonBytes)
diff --git a/txs/tx_test.go b/txs/tx_test.go
index 6bc2f110a832ee7073ca335d5fae594dd1b46322..c8c39a6200c9c5172594ab88fcf900b10bf5cd93 100644
--- a/txs/tx_test.go
+++ b/txs/tx_test.go
@@ -206,11 +206,11 @@ func TestTxWrapper_MarshalJSON(t *testing.T) {
testTxMarshalJSON(t, callTx)
}
-func TestNewPermissionsTxWithNonce(t *testing.T) {
+func TestNewPermissionsTxWithSequence(t *testing.T) {
privateKey := acm.PrivateKeyFromSecret("Shhh...")
args := ptypes.SetBaseArgs(privateKey.PublicKey().Address(), ptypes.HasRole, true)
- permTx := NewPermissionsTxWithNonce(privateKey.PublicKey(), args, 1)
+ permTx := NewPermissionsTxWithSequence(privateKey.PublicKey(), args, 1)
testTxMarshalJSON(t, permTx)
}
diff --git a/txs/tx_utils.go b/txs/tx_utils.go
index c680a7f478807e2d704242dd7c665d3794524382..1b2d65fe3f3a693c41c7fe29e51022c8e1971d6f 100644
--- a/txs/tx_utils.go
+++ b/txs/tx_utils.go
@@ -42,10 +42,10 @@ func (tx *SendTx) AddInput(st acm.Getter, pubkey acm.PublicKey, amt uint64) erro
if acc == nil {
return fmt.Errorf("invalid address %s from pubkey %s", addr, pubkey)
}
- return tx.AddInputWithNonce(pubkey, amt, acc.Sequence()+1)
+ return tx.AddInputWithSequence(pubkey, amt, acc.Sequence()+1)
}
-func (tx *SendTx) AddInputWithNonce(pubkey acm.PublicKey, amt uint64, sequence uint64) error {
+func (tx *SendTx) AddInputWithSequence(pubkey acm.PublicKey, amt uint64, sequence uint64) error {
addr := pubkey.Address()
tx.Inputs = append(tx.Inputs, &TxInput{
Address: addr,
@@ -89,11 +89,11 @@ func NewCallTx(st acm.Getter, from acm.PublicKey, to *acm.Address, data []byte,
return nil, fmt.Errorf("invalid address %s from pubkey %s", addr, from)
}
- nonce := acc.Sequence() + 1
- return NewCallTxWithNonce(from, to, data, amt, gasLimit, fee, nonce), nil
+ sequence := acc.Sequence() + 1
+ return NewCallTxWithSequence(from, to, data, amt, gasLimit, fee, sequence), nil
}
-func NewCallTxWithNonce(from acm.PublicKey, to *acm.Address, data []byte,
+func NewCallTxWithSequence(from acm.PublicKey, to *acm.Address, data []byte,
amt, gasLimit, fee, sequence uint64) *CallTx {
input := &TxInput{
Address: from.Address(),
@@ -130,11 +130,11 @@ func NewNameTx(st acm.Getter, from acm.PublicKey, name, data string, amt, fee ui
return nil, fmt.Errorf("Invalid address %s from pubkey %s", addr, from)
}
- nonce := acc.Sequence() + 1
- return NewNameTxWithNonce(from, name, data, amt, fee, nonce), nil
+ sequence := acc.Sequence() + 1
+ return NewNameTxWithSequence(from, name, data, amt, fee, sequence), nil
}
-func NewNameTxWithNonce(from acm.PublicKey, name, data string, amt, fee, sequence uint64) *NameTx {
+func NewNameTxWithSequence(from acm.PublicKey, name, data string, amt, fee, sequence uint64) *NameTx {
input := &TxInput{
Address: from.Address(),
Amount: amt,
@@ -176,10 +176,10 @@ func (tx *BondTx) AddInput(st acm.Getter, pubkey acm.PublicKey, amt uint64) erro
if acc == nil {
return fmt.Errorf("Invalid address %s from pubkey %s", addr, pubkey)
}
- return tx.AddInputWithNonce(pubkey, amt, acc.Sequence()+uint64(1))
+ return tx.AddInputWithSequence(pubkey, amt, acc.Sequence()+uint64(1))
}
-func (tx *BondTx) AddInputWithNonce(pubkey acm.PublicKey, amt uint64, sequence uint64) error {
+func (tx *BondTx) AddInputWithSequence(pubkey acm.PublicKey, amt uint64, sequence uint64) error {
tx.Inputs = append(tx.Inputs, &TxInput{
Address: pubkey.Address(),
Amount: amt,
@@ -253,11 +253,11 @@ func NewPermissionsTx(st acm.Getter, from acm.PublicKey, args *ptypes.PermArgs)
return nil, fmt.Errorf("Invalid address %s from pubkey %s", addr, from)
}
- nonce := acc.Sequence() + 1
- return NewPermissionsTxWithNonce(from, args, nonce), nil
+ sequence := acc.Sequence() + 1
+ return NewPermissionsTxWithSequence(from, args, sequence), nil
}
-func NewPermissionsTxWithNonce(from acm.PublicKey, args *ptypes.PermArgs, sequence uint64) *PermissionsTx {
+func NewPermissionsTxWithSequence(from acm.PublicKey, args *ptypes.PermArgs, sequence uint64) *PermissionsTx {
input := &TxInput{
Address: from.Address(),
Amount: 1, // NOTE: amounts can't be 0 ...