10 changed files with 715 additions and 324 deletions
Unified View
Diff Options
-
+21 -23batchbuilder/batchbuilder.go
-
+7 -7batchbuilder/state.go
-
+121 -6common/account.go
-
+196 -0common/account_test.go
-
+0 -128common/leaf.go
-
+0 -158common/leaf_test.go
-
+215 -0db/statedb/statedb.go
-
+144 -0db/statedb/statedb_test.go
-
+2 -2go.mod
-
+9 -0go.sum
@ -1,18 +1,133 @@ |
|||||
package common |
package common |
||||
|
|
||||
import ( |
import ( |
||||
|
"bytes" |
||||
|
"encoding/binary" |
||||
|
"fmt" |
||||
"math/big" |
"math/big" |
||||
|
|
||||
eth "github.com/ethereum/go-ethereum/common" |
eth "github.com/ethereum/go-ethereum/common" |
||||
"github.com/iden3/go-iden3-crypto/babyjub" |
"github.com/iden3/go-iden3-crypto/babyjub" |
||||
|
"github.com/iden3/go-iden3-crypto/poseidon" |
||||
|
cryptoUtils "github.com/iden3/go-iden3-crypto/utils" |
||||
) |
) |
||||
|
|
||||
// Account is a struct that gives information of the holdings of an address for a specific token
|
|
||||
|
const NLEAFELEMS = 4 |
||||
|
|
||||
|
// Account is a struct that gives information of the holdings of an address for a specific token. Is the data structure that generates the Value stored in the leaf of the MerkleTree
|
||||
type Account struct { |
type Account struct { |
||||
|
TokenID TokenID |
||||
|
Nonce uint64 // max of 40 bits used
|
||||
|
Balance *big.Int // max of 192 bits used
|
||||
|
PublicKey *babyjub.PublicKey |
||||
EthAddr eth.Address |
EthAddr eth.Address |
||||
TokenID TokenID // effective 32 bits
|
|
||||
Idx uint32 // bits = SMT levels (SMT levels needs to be decided)
|
|
||||
Nonce uint64 // effective 48 bits
|
|
||||
Balance *big.Int // Up to 192 bits
|
|
||||
PublicKey babyjub.PublicKey |
|
||||
|
} |
||||
|
|
||||
|
// Bytes returns the bytes representing the Account, in a way that each BigInt is represented by 32 bytes, in spite of the BigInt could be represented in less bytes (due a small big.Int), so in this way each BigInt is always 32 bytes and can be automatically parsed from a byte array.
|
||||
|
func (l *Account) Bytes() ([32 * NLEAFELEMS]byte, error) { |
||||
|
var b [32 * NLEAFELEMS]byte |
||||
|
|
||||
|
if l.Nonce > 0xffffffffff { |
||||
|
return b, fmt.Errorf("%s Nonce", ErrNumOverflow) |
||||
|
} |
||||
|
if len(l.Balance.Bytes()) > 24 { |
||||
|
return b, fmt.Errorf("%s Balance", ErrNumOverflow) |
||||
|
} |
||||
|
|
||||
|
var tokenIDBytes [4]byte |
||||
|
binary.LittleEndian.PutUint32(tokenIDBytes[:], uint32(l.TokenID)) |
||||
|
var nonceBytes [8]byte |
||||
|
binary.LittleEndian.PutUint64(nonceBytes[:], l.Nonce) |
||||
|
|
||||
|
copy(b[0:4], tokenIDBytes[:]) |
||||
|
copy(b[4:9], nonceBytes[:]) |
||||
|
if babyjub.PointCoordSign(l.PublicKey.X) { |
||||
|
b[10] = 1 |
||||
|
} |
||||
|
copy(b[32:64], SwapEndianness(l.Balance.Bytes())) // SwapEndianness, as big.Int uses BigEndian
|
||||
|
copy(b[64:96], SwapEndianness(l.PublicKey.Y.Bytes())) |
||||
|
copy(b[96:116], l.EthAddr.Bytes()) |
||||
|
|
||||
|
return b, nil |
||||
|
} |
||||
|
|
||||
|
// BigInts returns the [5]*big.Int, where each *big.Int is inside the Finite Field
|
||||
|
func (l *Account) BigInts() ([NLEAFELEMS]*big.Int, error) { |
||||
|
e := [NLEAFELEMS]*big.Int{} |
||||
|
|
||||
|
b, err := l.Bytes() |
||||
|
if err != nil { |
||||
|
return e, err |
||||
|
} |
||||
|
|
||||
|
e[0] = new(big.Int).SetBytes(SwapEndianness(b[0:32])) |
||||
|
e[1] = new(big.Int).SetBytes(SwapEndianness(b[32:64])) |
||||
|
e[2] = new(big.Int).SetBytes(SwapEndianness(b[64:96])) |
||||
|
e[3] = new(big.Int).SetBytes(SwapEndianness(b[96:128])) |
||||
|
|
||||
|
return e, nil |
||||
|
} |
||||
|
|
||||
|
// HashValue returns the value of the Account, which is the Poseidon hash of its *big.Int representation
|
||||
|
func (l *Account) HashValue() (*big.Int, error) { |
||||
|
b0 := big.NewInt(0) |
||||
|
toHash := [poseidon.T]*big.Int{b0, b0, b0, b0, b0, b0} |
||||
|
lBI, err := l.BigInts() |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
copy(toHash[:], lBI[:]) |
||||
|
|
||||
|
v, err := poseidon.Hash(toHash) |
||||
|
return v, err |
||||
|
} |
||||
|
|
||||
|
// AccountFromBigInts returns a Account from a [5]*big.Int
|
||||
|
func AccountFromBigInts(e [NLEAFELEMS]*big.Int) (*Account, error) { |
||||
|
if !cryptoUtils.CheckBigIntArrayInField(e[:]) { |
||||
|
return nil, ErrNotInFF |
||||
|
} |
||||
|
var b [32 * NLEAFELEMS]byte |
||||
|
copy(b[0:32], SwapEndianness(e[0].Bytes())) // SwapEndianness, as big.Int uses BigEndian
|
||||
|
copy(b[32:64], SwapEndianness(e[1].Bytes())) |
||||
|
copy(b[64:96], SwapEndianness(e[2].Bytes())) |
||||
|
copy(b[96:128], SwapEndianness(e[3].Bytes())) |
||||
|
|
||||
|
return AccountFromBytes(b) |
||||
|
} |
||||
|
|
||||
|
// AccountFromBytes returns a Account from a byte array
|
||||
|
func AccountFromBytes(b [32 * NLEAFELEMS]byte) (*Account, error) { |
||||
|
tokenID := binary.LittleEndian.Uint32(b[0:4]) |
||||
|
var nonceBytes [8]byte |
||||
|
copy(nonceBytes[:], b[4:9]) |
||||
|
nonce := binary.LittleEndian.Uint64(nonceBytes[:]) |
||||
|
sign := b[10] == 1 |
||||
|
balance := new(big.Int).SetBytes(SwapEndianness(b[32:56])) // b[32:56], as Balance is 192 bits (24 bytes)
|
||||
|
if !bytes.Equal(b[56:64], []byte{0, 0, 0, 0, 0, 0, 0, 0}) { |
||||
|
return nil, fmt.Errorf("%s Balance", ErrNumOverflow) |
||||
|
} |
||||
|
ay := new(big.Int).SetBytes(SwapEndianness(b[64:96])) |
||||
|
pkPoint, err := babyjub.PointFromSignAndY(sign, ay) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
publicKey := babyjub.PublicKey(*pkPoint) |
||||
|
ethAddr := eth.BytesToAddress(b[96:116]) |
||||
|
|
||||
|
if !cryptoUtils.CheckBigIntInField(balance) { |
||||
|
return nil, ErrNotInFF |
||||
|
} |
||||
|
if !cryptoUtils.CheckBigIntInField(ay) { |
||||
|
return nil, ErrNotInFF |
||||
|
} |
||||
|
|
||||
|
l := Account{ |
||||
|
TokenID: TokenID(tokenID), |
||||
|
Nonce: nonce, |
||||
|
Balance: balance, |
||||
|
PublicKey: &publicKey, |
||||
|
EthAddr: ethAddr, |
||||
|
} |
||||
|
return &l, nil |
||||
} |
} |
||||
@ -0,0 +1,196 @@ |
|||||
|
package common |
||||
|
|
||||
|
import ( |
||||
|
"encoding/hex" |
||||
|
"fmt" |
||||
|
"math" |
||||
|
"math/big" |
||||
|
"testing" |
||||
|
|
||||
|
ethCommon "github.com/ethereum/go-ethereum/common" |
||||
|
ethCrypto "github.com/ethereum/go-ethereum/crypto" |
||||
|
"github.com/iden3/go-iden3-crypto/babyjub" |
||||
|
cryptoConstants "github.com/iden3/go-iden3-crypto/constants" |
||||
|
cryptoUtils "github.com/iden3/go-iden3-crypto/utils" |
||||
|
"github.com/stretchr/testify/assert" |
||||
|
) |
||||
|
|
||||
|
func TestAccount(t *testing.T) { |
||||
|
var sk babyjub.PrivateKey |
||||
|
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001")) |
||||
|
assert.Nil(t, err) |
||||
|
pk := sk.Public() |
||||
|
|
||||
|
account := &Account{ |
||||
|
TokenID: TokenID(1), |
||||
|
Nonce: uint64(1234), |
||||
|
Balance: big.NewInt(1000), |
||||
|
PublicKey: pk, |
||||
|
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"), |
||||
|
} |
||||
|
b, err := account.Bytes() |
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, byte(1), b[10]) |
||||
|
a1, err := AccountFromBytes(b) |
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, account, a1) |
||||
|
|
||||
|
e, err := account.BigInts() |
||||
|
assert.Nil(t, err) |
||||
|
assert.True(t, cryptoUtils.CheckBigIntInField(e[0])) |
||||
|
assert.True(t, cryptoUtils.CheckBigIntInField(e[1])) |
||||
|
assert.True(t, cryptoUtils.CheckBigIntInField(e[2])) |
||||
|
assert.True(t, cryptoUtils.CheckBigIntInField(e[3])) |
||||
|
|
||||
|
assert.Equal(t, "1000", e[1].String()) |
||||
|
assert.Equal(t, pk.Y.String(), e[2].String()) |
||||
|
assert.Equal(t, new(big.Int).SetBytes(SwapEndianness(account.EthAddr.Bytes())).String(), e[3].String()) |
||||
|
|
||||
|
a2, err := AccountFromBigInts(e) |
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, account, a2) |
||||
|
assert.Equal(t, a1, a2) |
||||
|
} |
||||
|
|
||||
|
func TestAccountLoop(t *testing.T) { |
||||
|
// check that for different Address there is no problem
|
||||
|
for i := 0; i < 256; i++ { |
||||
|
var sk babyjub.PrivateKey |
||||
|
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001")) |
||||
|
assert.Nil(t, err) |
||||
|
pk := sk.Public() |
||||
|
|
||||
|
key, err := ethCrypto.GenerateKey() |
||||
|
assert.Nil(t, err) |
||||
|
address := ethCrypto.PubkeyToAddress(key.PublicKey) |
||||
|
|
||||
|
account := &Account{ |
||||
|
TokenID: TokenID(i), |
||||
|
Nonce: uint64(i), |
||||
|
Balance: big.NewInt(1000), |
||||
|
PublicKey: pk, |
||||
|
EthAddr: address, |
||||
|
} |
||||
|
b, err := account.Bytes() |
||||
|
assert.Nil(t, err) |
||||
|
a1, err := AccountFromBytes(b) |
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, account, a1) |
||||
|
|
||||
|
e, err := account.BigInts() |
||||
|
assert.Nil(t, err) |
||||
|
assert.True(t, cryptoUtils.CheckBigIntInField(e[0])) |
||||
|
assert.True(t, cryptoUtils.CheckBigIntInField(e[1])) |
||||
|
assert.True(t, cryptoUtils.CheckBigIntInField(e[2])) |
||||
|
assert.True(t, cryptoUtils.CheckBigIntInField(e[3])) |
||||
|
|
||||
|
a2, err := AccountFromBigInts(e) |
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, account, a2) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func TestAccountHashValue(t *testing.T) { |
||||
|
var sk babyjub.PrivateKey |
||||
|
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001")) |
||||
|
assert.Nil(t, err) |
||||
|
pk := sk.Public() |
||||
|
|
||||
|
account := &Account{ |
||||
|
TokenID: TokenID(1), |
||||
|
Nonce: uint64(1234), |
||||
|
Balance: big.NewInt(1000), |
||||
|
PublicKey: pk, |
||||
|
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"), |
||||
|
} |
||||
|
|
||||
|
v, err := account.HashValue() |
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, "6335844662301214382338419199835935731871537354006112711277201708185593574314", v.String()) |
||||
|
} |
||||
|
|
||||
|
func TestAccountErrNotInFF(t *testing.T) { |
||||
|
z := big.NewInt(0) |
||||
|
|
||||
|
// Q-1 should not give error
|
||||
|
r := new(big.Int).Sub(cryptoConstants.Q, big.NewInt(1)) |
||||
|
e := [NLEAFELEMS]*big.Int{z, z, r, r} |
||||
|
_, err := AccountFromBigInts(e) |
||||
|
assert.Nil(t, err) |
||||
|
|
||||
|
// Q should give error
|
||||
|
r = cryptoConstants.Q |
||||
|
e = [NLEAFELEMS]*big.Int{z, z, r, r} |
||||
|
_, err = AccountFromBigInts(e) |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, ErrNotInFF, err) |
||||
|
|
||||
|
// Q+1 should give error
|
||||
|
r = new(big.Int).Add(cryptoConstants.Q, big.NewInt(1)) |
||||
|
e = [NLEAFELEMS]*big.Int{z, z, r, r} |
||||
|
_, err = AccountFromBigInts(e) |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, ErrNotInFF, err) |
||||
|
} |
||||
|
|
||||
|
func TestAccountErrNumOverflowNonce(t *testing.T) { |
||||
|
var sk babyjub.PrivateKey |
||||
|
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001")) |
||||
|
assert.Nil(t, err) |
||||
|
pk := sk.Public() |
||||
|
|
||||
|
// check limit
|
||||
|
account := &Account{ |
||||
|
TokenID: TokenID(1), |
||||
|
Nonce: uint64(math.Pow(2, 40) - 1), |
||||
|
Balance: big.NewInt(1000), |
||||
|
PublicKey: pk, |
||||
|
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"), |
||||
|
} |
||||
|
_, err = account.Bytes() |
||||
|
assert.Nil(t, err) |
||||
|
|
||||
|
// force value overflow
|
||||
|
account.Nonce = uint64(math.Pow(2, 40)) |
||||
|
b, err := account.Bytes() |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), err) |
||||
|
|
||||
|
_, err = AccountFromBytes(b) |
||||
|
assert.Nil(t, err) |
||||
|
} |
||||
|
|
||||
|
func TestAccountErrNumOverflowBalance(t *testing.T) { |
||||
|
var sk babyjub.PrivateKey |
||||
|
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001")) |
||||
|
assert.Nil(t, err) |
||||
|
pk := sk.Public() |
||||
|
|
||||
|
// check limit
|
||||
|
account := &Account{ |
||||
|
TokenID: TokenID(1), |
||||
|
Nonce: uint64(math.Pow(2, 40) - 1), |
||||
|
Balance: new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil), big.NewInt(1)), |
||||
|
PublicKey: pk, |
||||
|
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"), |
||||
|
} |
||||
|
assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", account.Balance.String()) |
||||
|
|
||||
|
_, err = account.Bytes() |
||||
|
assert.Nil(t, err) |
||||
|
|
||||
|
// force value overflow
|
||||
|
account.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil) |
||||
|
assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896", account.Balance.String()) |
||||
|
b, err := account.Bytes() |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err) |
||||
|
|
||||
|
_, err = AccountFromBytes(b) |
||||
|
assert.Nil(t, err) |
||||
|
|
||||
|
b[56] = 1 |
||||
|
_, err = AccountFromBytes(b) |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err) |
||||
|
} |
||||
@ -1,128 +0,0 @@ |
|||||
package common |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"encoding/binary" |
|
||||
"fmt" |
|
||||
"math/big" |
|
||||
|
|
||||
eth "github.com/ethereum/go-ethereum/common" |
|
||||
"github.com/iden3/go-iden3-crypto/poseidon" |
|
||||
cryptoUtils "github.com/iden3/go-iden3-crypto/utils" |
|
||||
) |
|
||||
|
|
||||
const NLEAFELEMS = 4 |
|
||||
|
|
||||
// Leaf is the data structure stored in the Leaf of the MerkleTree
|
|
||||
type Leaf struct { |
|
||||
TokenID TokenID |
|
||||
Nonce uint64 // max of 40 bits used
|
|
||||
Balance *big.Int // max of 192 bits used
|
|
||||
Sign bool |
|
||||
Ay *big.Int |
|
||||
EthAddr eth.Address |
|
||||
} |
|
||||
|
|
||||
// Bytes returns the bytes representing the Leaf, in a way that each BigInt is represented by 32 bytes, in spite of the BigInt could be represented in less bytes (due a small big.Int), so in this way each BigInt is always 32 bytes and can be automatically parsed from a byte array.
|
|
||||
func (l *Leaf) Bytes() ([32 * NLEAFELEMS]byte, error) { |
|
||||
var b [32 * NLEAFELEMS]byte |
|
||||
|
|
||||
if l.Nonce > 0xffffffffff { |
|
||||
return b, fmt.Errorf("%s Nonce", ErrNumOverflow) |
|
||||
} |
|
||||
if len(l.Balance.Bytes()) > 24 { |
|
||||
return b, fmt.Errorf("%s Balance", ErrNumOverflow) |
|
||||
} |
|
||||
|
|
||||
var tokenIDBytes [4]byte |
|
||||
binary.LittleEndian.PutUint32(tokenIDBytes[:], uint32(l.TokenID)) |
|
||||
var nonceBytes [8]byte |
|
||||
binary.LittleEndian.PutUint64(nonceBytes[:], l.Nonce) |
|
||||
|
|
||||
copy(b[0:4], tokenIDBytes[:]) |
|
||||
copy(b[4:9], nonceBytes[:]) |
|
||||
if l.Sign { |
|
||||
b[10] = 1 |
|
||||
} |
|
||||
copy(b[32:64], SwapEndianness(l.Balance.Bytes())) // SwapEndianness, as big.Int uses BigEndian
|
|
||||
copy(b[64:96], SwapEndianness(l.Ay.Bytes())) |
|
||||
copy(b[96:116], l.EthAddr.Bytes()) |
|
||||
|
|
||||
return b, nil |
|
||||
} |
|
||||
|
|
||||
// BigInts returns the [5]*big.Int, where each *big.Int is inside the Finite Field
|
|
||||
func (l *Leaf) BigInts() ([NLEAFELEMS]*big.Int, error) { |
|
||||
e := [NLEAFELEMS]*big.Int{} |
|
||||
|
|
||||
b, err := l.Bytes() |
|
||||
if err != nil { |
|
||||
return e, err |
|
||||
} |
|
||||
|
|
||||
e[0] = new(big.Int).SetBytes(SwapEndianness(b[0:32])) |
|
||||
e[1] = new(big.Int).SetBytes(SwapEndianness(b[32:64])) |
|
||||
e[2] = new(big.Int).SetBytes(SwapEndianness(b[64:96])) |
|
||||
e[3] = new(big.Int).SetBytes(SwapEndianness(b[96:128])) |
|
||||
|
|
||||
return e, nil |
|
||||
} |
|
||||
|
|
||||
// HashValue returns the value of the Leaf, which is the Poseidon hash of its *big.Int representation
|
|
||||
func (l *Leaf) HashValue() (*big.Int, error) { |
|
||||
toHash := [poseidon.T]*big.Int{} |
|
||||
lBI, err := l.BigInts() |
|
||||
if err != nil { |
|
||||
return nil, err |
|
||||
} |
|
||||
copy(toHash[:], lBI[:]) |
|
||||
|
|
||||
v, err := poseidon.Hash(toHash) |
|
||||
return v, err |
|
||||
} |
|
||||
|
|
||||
// LeafFromBigInts returns a Leaf from a [5]*big.Int
|
|
||||
func LeafFromBigInts(e [NLEAFELEMS]*big.Int) (*Leaf, error) { |
|
||||
if !cryptoUtils.CheckBigIntArrayInField(e[:]) { |
|
||||
return nil, ErrNotInFF |
|
||||
} |
|
||||
var b [32 * NLEAFELEMS]byte |
|
||||
copy(b[0:32], SwapEndianness(e[0].Bytes())) // SwapEndianness, as big.Int uses BigEndian
|
|
||||
copy(b[32:64], SwapEndianness(e[1].Bytes())) |
|
||||
copy(b[64:96], SwapEndianness(e[2].Bytes())) |
|
||||
copy(b[96:128], SwapEndianness(e[3].Bytes())) |
|
||||
|
|
||||
return LeafFromBytes(b) |
|
||||
} |
|
||||
|
|
||||
// LeafFromBytes returns a Leaf from a byte array
|
|
||||
func LeafFromBytes(b [32 * NLEAFELEMS]byte) (*Leaf, error) { |
|
||||
tokenID := binary.LittleEndian.Uint32(b[0:4]) |
|
||||
var nonceBytes [8]byte |
|
||||
copy(nonceBytes[:], b[4:9]) |
|
||||
nonce := binary.LittleEndian.Uint64(nonceBytes[:]) |
|
||||
sign := b[10] == 1 |
|
||||
balance := new(big.Int).SetBytes(SwapEndianness(b[32:56])) // b[32:56], as Balance is 192 bits (24 bytes)
|
|
||||
if !bytes.Equal(b[56:64], []byte{0, 0, 0, 0, 0, 0, 0, 0}) { |
|
||||
return nil, fmt.Errorf("%s Balance", ErrNumOverflow) |
|
||||
} |
|
||||
ay := new(big.Int).SetBytes(SwapEndianness(b[64:96])) |
|
||||
ethAddr := eth.BytesToAddress(b[96:116]) |
|
||||
|
|
||||
if !cryptoUtils.CheckBigIntInField(balance) { |
|
||||
return nil, ErrNotInFF |
|
||||
} |
|
||||
if !cryptoUtils.CheckBigIntInField(ay) { |
|
||||
return nil, ErrNotInFF |
|
||||
} |
|
||||
|
|
||||
l := Leaf{ |
|
||||
TokenID: TokenID(tokenID), |
|
||||
Nonce: nonce, |
|
||||
Balance: balance, |
|
||||
Sign: sign, |
|
||||
Ay: ay, |
|
||||
EthAddr: ethAddr, |
|
||||
} |
|
||||
return &l, nil |
|
||||
} |
|
||||
@ -1,158 +0,0 @@ |
|||||
package common |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"math" |
|
||||
"math/big" |
|
||||
"testing" |
|
||||
|
|
||||
ethCommon "github.com/ethereum/go-ethereum/common" |
|
||||
cryptoConstants "github.com/iden3/go-iden3-crypto/constants" |
|
||||
cryptoUtils "github.com/iden3/go-iden3-crypto/utils" |
|
||||
"github.com/stretchr/testify/assert" |
|
||||
) |
|
||||
|
|
||||
func TestLeaf(t *testing.T) { |
|
||||
leaf := &Leaf{ |
|
||||
TokenID: TokenID(1), |
|
||||
Nonce: uint64(1234), |
|
||||
Balance: big.NewInt(1000), |
|
||||
Sign: true, |
|
||||
Ay: big.NewInt(6789), |
|
||||
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"), |
|
||||
} |
|
||||
b, err := leaf.Bytes() |
|
||||
assert.Nil(t, err) |
|
||||
assert.Equal(t, byte(1), b[10]) |
|
||||
l1, err := LeafFromBytes(b) |
|
||||
assert.Nil(t, err) |
|
||||
assert.Equal(t, leaf, l1) |
|
||||
|
|
||||
e, err := leaf.BigInts() |
|
||||
assert.Nil(t, err) |
|
||||
assert.True(t, cryptoUtils.CheckBigIntInField(e[0])) |
|
||||
assert.True(t, cryptoUtils.CheckBigIntInField(e[1])) |
|
||||
assert.True(t, cryptoUtils.CheckBigIntInField(e[2])) |
|
||||
assert.True(t, cryptoUtils.CheckBigIntInField(e[3])) |
|
||||
|
|
||||
assert.Equal(t, "1000", e[1].String()) |
|
||||
assert.Equal(t, "6789", e[2].String()) |
|
||||
assert.Equal(t, new(big.Int).SetBytes(SwapEndianness(leaf.EthAddr.Bytes())).String(), e[3].String()) |
|
||||
|
|
||||
l2, err := LeafFromBigInts(e) |
|
||||
assert.Nil(t, err) |
|
||||
assert.Equal(t, leaf, l2) |
|
||||
assert.Equal(t, l1, l2) |
|
||||
} |
|
||||
|
|
||||
// func TestLeafLoop(t *testing.T) {
|
|
||||
// // check that for different Address there is no problem
|
|
||||
// for i := 0; i < 256; i++ {
|
|
||||
// key, err := ethCrypto.GenerateKey()
|
|
||||
// assert.Nil(t, err)
|
|
||||
// address := ethCrypto.PubkeyToAddress(key.PublicKey)
|
|
||||
//
|
|
||||
// leaf := &Leaf{
|
|
||||
// TokenID: TokenID(i),
|
|
||||
// Nonce: uint64(i),
|
|
||||
// Balance: big.NewInt(1000),
|
|
||||
// Sign: true,
|
|
||||
// Ay: big.NewInt(6789),
|
|
||||
// EthAddr: address,
|
|
||||
// }
|
|
||||
// b, err := leaf.Bytes()
|
|
||||
// assert.Nil(t, err)
|
|
||||
// l1, err := LeafFromBytes(b)
|
|
||||
// assert.Nil(t, err)
|
|
||||
// assert.Equal(t, leaf, l1)
|
|
||||
//
|
|
||||
// e, err := leaf.BigInts()
|
|
||||
// assert.Nil(t, err)
|
|
||||
// assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
|
|
||||
// assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
|
|
||||
// assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
|
|
||||
// assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
|
|
||||
//
|
|
||||
// l2, err := LeafFromBigInts(e)
|
|
||||
// assert.Nil(t, err)
|
|
||||
// assert.Equal(t, leaf, l2)
|
|
||||
// }
|
|
||||
// }
|
|
||||
|
|
||||
func TestLeafErrNotInFF(t *testing.T) { |
|
||||
z := big.NewInt(0) |
|
||||
|
|
||||
// Q-1 should not give error
|
|
||||
r := new(big.Int).Sub(cryptoConstants.Q, big.NewInt(1)) |
|
||||
e := [NLEAFELEMS]*big.Int{z, z, r, r} |
|
||||
_, err := LeafFromBigInts(e) |
|
||||
assert.Nil(t, err) |
|
||||
|
|
||||
// Q should give error
|
|
||||
r = cryptoConstants.Q |
|
||||
e = [NLEAFELEMS]*big.Int{z, z, r, r} |
|
||||
_, err = LeafFromBigInts(e) |
|
||||
assert.NotNil(t, err) |
|
||||
assert.Equal(t, ErrNotInFF, err) |
|
||||
|
|
||||
// Q+1 should give error
|
|
||||
r = new(big.Int).Add(cryptoConstants.Q, big.NewInt(1)) |
|
||||
e = [NLEAFELEMS]*big.Int{z, z, r, r} |
|
||||
_, err = LeafFromBigInts(e) |
|
||||
assert.NotNil(t, err) |
|
||||
assert.Equal(t, ErrNotInFF, err) |
|
||||
} |
|
||||
|
|
||||
func TestLeafErrNumOverflowNonce(t *testing.T) { |
|
||||
// check limit
|
|
||||
leaf := &Leaf{ |
|
||||
TokenID: TokenID(1), |
|
||||
Nonce: uint64(math.Pow(2, 40) - 1), |
|
||||
Balance: big.NewInt(1000), |
|
||||
Sign: true, |
|
||||
Ay: big.NewInt(6789), |
|
||||
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"), |
|
||||
} |
|
||||
_, err := leaf.Bytes() |
|
||||
assert.Nil(t, err) |
|
||||
|
|
||||
// force value overflow
|
|
||||
leaf.Nonce = uint64(math.Pow(2, 40)) |
|
||||
b, err := leaf.Bytes() |
|
||||
assert.NotNil(t, err) |
|
||||
assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), err) |
|
||||
|
|
||||
_, err = LeafFromBytes(b) |
|
||||
assert.Nil(t, err) |
|
||||
} |
|
||||
|
|
||||
func TestLeafErrNumOverflowBalance(t *testing.T) { |
|
||||
// check limit
|
|
||||
leaf := &Leaf{ |
|
||||
TokenID: TokenID(1), |
|
||||
Nonce: uint64(math.Pow(2, 40) - 1), |
|
||||
Balance: new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil), big.NewInt(1)), |
|
||||
Sign: true, |
|
||||
Ay: big.NewInt(6789), |
|
||||
EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"), |
|
||||
} |
|
||||
assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", leaf.Balance.String()) |
|
||||
|
|
||||
_, err := leaf.Bytes() |
|
||||
assert.Nil(t, err) |
|
||||
|
|
||||
// force value overflow
|
|
||||
leaf.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil) |
|
||||
assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896", leaf.Balance.String()) |
|
||||
b, err := leaf.Bytes() |
|
||||
assert.NotNil(t, err) |
|
||||
assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err) |
|
||||
|
|
||||
_, err = LeafFromBytes(b) |
|
||||
assert.Nil(t, err) |
|
||||
|
|
||||
b[56] = 1 |
|
||||
_, err = LeafFromBytes(b) |
|
||||
assert.NotNil(t, err) |
|
||||
assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err) |
|
||||
} |
|
||||
@ -0,0 +1,215 @@ |
|||||
|
package statedb |
||||
|
|
||||
|
import ( |
||||
|
"errors" |
||||
|
|
||||
|
"github.com/hermeznetwork/hermez-node/common" |
||||
|
"github.com/iden3/go-merkletree" |
||||
|
"github.com/iden3/go-merkletree/db" |
||||
|
"github.com/iden3/go-merkletree/db/leveldb" |
||||
|
"github.com/iden3/go-merkletree/db/memory" |
||||
|
) |
||||
|
|
||||
|
// ErrStateDBWithoutMT is used when a method that requires a MerkleTree is called in a StateDB that does not have a MerkleTree defined
|
||||
|
var ErrStateDBWithoutMT = errors.New("Can not call method to use MerkleTree in a StateDB without MerkleTree") |
||||
|
|
||||
|
// ErrAccountAlreadyExists is used when CreateAccount is called and the Account already exists
|
||||
|
var ErrAccountAlreadyExists = errors.New("Can not CreateAccount because Account already exists") |
||||
|
|
||||
|
// StateDB represents the StateDB object
|
||||
|
type StateDB struct { |
||||
|
db db.Storage |
||||
|
mt *merkletree.MerkleTree |
||||
|
} |
||||
|
|
||||
|
// NewStateDB creates a new StateDB, allowing to use an in-memory or in-disk
|
||||
|
// storage
|
||||
|
func NewStateDB(path string, inDisk bool, withMT bool, nLevels int) (*StateDB, error) { |
||||
|
var sto db.Storage |
||||
|
var err error |
||||
|
if inDisk { |
||||
|
sto, err = leveldb.NewLevelDbStorage(path, false) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
} else { |
||||
|
sto = memory.NewMemoryStorage() |
||||
|
} |
||||
|
var mt *merkletree.MerkleTree = nil |
||||
|
if withMT { |
||||
|
mt, err = merkletree.NewMerkleTree(sto, nLevels) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return &StateDB{ |
||||
|
db: sto, |
||||
|
mt: mt, |
||||
|
}, nil |
||||
|
} |
||||
|
|
||||
|
// CheckPointAt does a checkpoint at the given batchNum in the defined path
|
||||
|
func (s *StateDB) CheckPointAt(batchNum int, path string) error { |
||||
|
// TODO
|
||||
|
|
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// Reset resets the StateDB to the checkpoint at the given batchNum
|
||||
|
func (s *StateDB) Reset(batchNum int) error { |
||||
|
// TODO
|
||||
|
|
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// Checkpoints returns a list of the checkpoints (batchNums)
|
||||
|
func (s *StateDB) Checkpoints() ([]int, error) { |
||||
|
// TODO
|
||||
|
|
||||
|
//batchnums, err
|
||||
|
return nil, nil |
||||
|
} |
||||
|
|
||||
|
// GetAccount returns the account for the given Idx
|
||||
|
func (s *StateDB) GetAccount(idx common.Idx) (*common.Account, error) { |
||||
|
vBytes, err := s.db.Get(idx.Bytes()) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
accBytes, err := s.db.Get(vBytes) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
var b [32 * common.NLEAFELEMS]byte |
||||
|
copy(b[:], accBytes) |
||||
|
return common.AccountFromBytes(b) |
||||
|
} |
||||
|
|
||||
|
// CreateAccount creates a new Account in the StateDB for the given Idx.
|
||||
|
// MerkleTree is not affected.
|
||||
|
func (s *StateDB) CreateAccount(idx common.Idx, account *common.Account) error { |
||||
|
// store at the DB the key: v, and value: leaf.Bytes()
|
||||
|
v, err := account.HashValue() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
accountBytes, err := account.Bytes() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
// store the Leaf value
|
||||
|
tx, err := s.db.NewTx() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
_, err = tx.Get(idx.Bytes()) |
||||
|
if err != db.ErrNotFound { |
||||
|
return ErrAccountAlreadyExists |
||||
|
} |
||||
|
|
||||
|
tx.Put(v.Bytes(), accountBytes[:]) |
||||
|
tx.Put(idx.Bytes(), v.Bytes()) |
||||
|
|
||||
|
return tx.Commit() |
||||
|
} |
||||
|
|
||||
|
// UpdateAccount updates the Account in the StateDB for the given Idx.
|
||||
|
// MerkleTree is not affected.
|
||||
|
func (s *StateDB) UpdateAccount(idx common.Idx, account *common.Account) error { |
||||
|
// store at the DB the key: v, and value: leaf.Bytes()
|
||||
|
v, err := account.HashValue() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
accountBytes, err := account.Bytes() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
tx, err := s.db.NewTx() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
tx.Put(v.Bytes(), accountBytes[:]) |
||||
|
tx.Put(idx.Bytes(), v.Bytes()) |
||||
|
|
||||
|
return tx.Commit() |
||||
|
} |
||||
|
|
||||
|
// MTCreateAccount creates a new the Account in the StateDB for the given Idx,
|
||||
|
// and updates the MerkleTree, returning a CircomProcessorProof
|
||||
|
func (s *StateDB) MTCreateAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) { |
||||
|
if s.mt == nil { |
||||
|
return nil, ErrStateDBWithoutMT |
||||
|
} |
||||
|
err := s.CreateAccount(idx, account) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
|
||||
|
v, err := account.HashValue() // already computed in s.CreateAccount, next iteration reuse first computation
|
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
// Add k & v into the MT
|
||||
|
return s.mt.AddAndGetCircomProof(idx.BigInt(), v) |
||||
|
} |
||||
|
|
||||
|
// MTUpdateAccount updates the Account in the StateDB for the given Idx, and
|
||||
|
// updates the MerkleTree, returning a CircomProcessorProof
|
||||
|
func (s *StateDB) MTUpdateAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) { |
||||
|
if s.mt == nil { |
||||
|
return nil, ErrStateDBWithoutMT |
||||
|
} |
||||
|
err := s.UpdateAccount(idx, account) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
|
||||
|
v, err := account.HashValue() // already computed in s.CreateAccount, next iteration reuse first computation
|
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
// Add k & v into the MT
|
||||
|
return s.mt.Update(idx.BigInt(), v) |
||||
|
} |
||||
|
|
||||
|
// MTGetProof returns the CircomVerifierProof for a given Idx
|
||||
|
func (s *StateDB) MTGetProof(idx common.Idx) (*merkletree.CircomVerifierProof, error) { |
||||
|
if s.mt == nil { |
||||
|
return nil, ErrStateDBWithoutMT |
||||
|
} |
||||
|
return s.mt.GenerateCircomVerifierProof(idx.BigInt(), s.mt.Root()) |
||||
|
} |
||||
|
|
||||
|
// LocalStateDB represents the local StateDB which allows to make copies from
|
||||
|
// the synchronizer StateDB, and is used by the tx-selector and the
|
||||
|
// batch-builder. LocalStateDB is an in-memory storage.
|
||||
|
type LocalStateDB struct { |
||||
|
*StateDB |
||||
|
synchronizerStateDB *StateDB |
||||
|
} |
||||
|
|
||||
|
// NewLocalStateDB returns a new LocalStateDB connected to the given
|
||||
|
// synchronizerDB
|
||||
|
func NewLocalStateDB(synchronizerDB *StateDB, withMT bool, nLevels int) (*LocalStateDB, error) { |
||||
|
s, err := NewStateDB("", false, withMT, nLevels) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
return &LocalStateDB{ |
||||
|
s, |
||||
|
synchronizerDB, |
||||
|
}, nil |
||||
|
} |
||||
|
|
||||
|
// Reset performs a reset, getting the state from
|
||||
|
// LocalStateDB.synchronizerStateDB for the given batchNum
|
||||
|
func (l *LocalStateDB) Reset(batchNum int, fromSynchronizer bool) error { |
||||
|
// TODO
|
||||
|
|
||||
|
return nil |
||||
|
} |
||||
@ -0,0 +1,144 @@ |
|||||
|
package statedb |
||||
|
|
||||
|
import ( |
||||
|
"encoding/hex" |
||||
|
"io/ioutil" |
||||
|
"math/big" |
||||
|
"testing" |
||||
|
|
||||
|
ethCrypto "github.com/ethereum/go-ethereum/crypto" |
||||
|
"github.com/hermeznetwork/hermez-node/common" |
||||
|
"github.com/iden3/go-iden3-crypto/babyjub" |
||||
|
"github.com/iden3/go-merkletree/db" |
||||
|
"github.com/stretchr/testify/assert" |
||||
|
"github.com/stretchr/testify/require" |
||||
|
) |
||||
|
|
||||
|
func newAccount(t *testing.T, i int) *common.Account { |
||||
|
var sk babyjub.PrivateKey |
||||
|
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001")) |
||||
|
require.Nil(t, err) |
||||
|
pk := sk.Public() |
||||
|
|
||||
|
key, err := ethCrypto.GenerateKey() |
||||
|
require.Nil(t, err) |
||||
|
address := ethCrypto.PubkeyToAddress(key.PublicKey) |
||||
|
|
||||
|
return &common.Account{ |
||||
|
TokenID: common.TokenID(i), |
||||
|
Nonce: uint64(i), |
||||
|
Balance: big.NewInt(1000), |
||||
|
PublicKey: pk, |
||||
|
EthAddr: address, |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
func TestStateDBWithoutMT(t *testing.T) { |
||||
|
dir, err := ioutil.TempDir("", "tmpdb") |
||||
|
require.Nil(t, err) |
||||
|
|
||||
|
sdb, err := NewStateDB(dir, false, false, 0) |
||||
|
assert.Nil(t, err) |
||||
|
|
||||
|
// create test accounts
|
||||
|
var accounts []*common.Account |
||||
|
for i := 0; i < 100; i++ { |
||||
|
accounts = append(accounts, newAccount(t, i)) |
||||
|
} |
||||
|
|
||||
|
// get non-existing account, expecting an error
|
||||
|
_, err = sdb.GetAccount(common.Idx(1)) |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, db.ErrNotFound, err) |
||||
|
|
||||
|
// add test accounts
|
||||
|
for i := 0; i < len(accounts); i++ { |
||||
|
err = sdb.CreateAccount(common.Idx(i), accounts[i]) |
||||
|
assert.Nil(t, err) |
||||
|
} |
||||
|
|
||||
|
for i := 0; i < len(accounts); i++ { |
||||
|
accGetted, err := sdb.GetAccount(common.Idx(i)) |
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, accounts[i], accGetted) |
||||
|
} |
||||
|
|
||||
|
// try already existing idx and get error
|
||||
|
_, err = sdb.GetAccount(common.Idx(1)) // check that exist
|
||||
|
assert.Nil(t, err) |
||||
|
err = sdb.CreateAccount(common.Idx(1), accounts[1]) // check that can not be created twice
|
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, ErrAccountAlreadyExists, err) |
||||
|
|
||||
|
// update accounts
|
||||
|
for i := 0; i < len(accounts); i++ { |
||||
|
accounts[i].Nonce = accounts[i].Nonce + 1 |
||||
|
err = sdb.UpdateAccount(common.Idx(i), accounts[i]) |
||||
|
assert.Nil(t, err) |
||||
|
} |
||||
|
|
||||
|
// check that can not call MerkleTree methods of the StateDB
|
||||
|
_, err = sdb.MTCreateAccount(common.Idx(1), accounts[1]) |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, ErrStateDBWithoutMT, err) |
||||
|
|
||||
|
_, err = sdb.MTUpdateAccount(common.Idx(1), accounts[1]) |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, ErrStateDBWithoutMT, err) |
||||
|
|
||||
|
_, err = sdb.MTGetProof(common.Idx(1)) |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, ErrStateDBWithoutMT, err) |
||||
|
} |
||||
|
|
||||
|
func TestStateDBWithMT(t *testing.T) { |
||||
|
dir, err := ioutil.TempDir("", "tmpdb") |
||||
|
require.Nil(t, err) |
||||
|
|
||||
|
sdb, err := NewStateDB(dir, false, true, 32) |
||||
|
assert.Nil(t, err) |
||||
|
|
||||
|
// create test accounts
|
||||
|
var accounts []*common.Account |
||||
|
for i := 0; i < 100; i++ { |
||||
|
accounts = append(accounts, newAccount(t, i)) |
||||
|
} |
||||
|
|
||||
|
// get non-existing account, expecting an error
|
||||
|
_, err = sdb.GetAccount(common.Idx(1)) |
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, db.ErrNotFound, err) |
||||
|
|
||||
|
// add test accounts
|
||||
|
for i := 0; i < len(accounts); i++ { |
||||
|
_, err = sdb.MTCreateAccount(common.Idx(i), accounts[i]) |
||||
|
assert.Nil(t, err) |
||||
|
} |
||||
|
|
||||
|
for i := 0; i < len(accounts); i++ { |
||||
|
accGetted, err := sdb.GetAccount(common.Idx(i)) |
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, accounts[i], accGetted) |
||||
|
} |
||||
|
|
||||
|
// try already existing idx and get error
|
||||
|
_, err = sdb.GetAccount(common.Idx(1)) // check that exist
|
||||
|
assert.Nil(t, err) |
||||
|
_, err = sdb.MTCreateAccount(common.Idx(1), accounts[1]) // check that can not be created twice
|
||||
|
assert.NotNil(t, err) |
||||
|
assert.Equal(t, ErrAccountAlreadyExists, err) |
||||
|
|
||||
|
_, err = sdb.MTGetProof(common.Idx(1)) |
||||
|
assert.Nil(t, err) |
||||
|
|
||||
|
// update accounts
|
||||
|
for i := 0; i < len(accounts); i++ { |
||||
|
accounts[i].Nonce = accounts[i].Nonce + 1 |
||||
|
_, err = sdb.MTUpdateAccount(common.Idx(i), accounts[i]) |
||||
|
assert.Nil(t, err) |
||||
|
} |
||||
|
a, err := sdb.GetAccount(common.Idx(1)) // check that account value has been updated
|
||||
|
assert.Nil(t, err) |
||||
|
assert.Equal(t, accounts[1].Nonce, a.Nonce) |
||||
|
} |
||||