arnaucube/hermez-node
1
0
Fork 0
mirror of https://github.com/arnaucube/hermez-node.git synced 2026-02-07 03:16:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

mv of babyjub.PublicKey to babyjub.PublicKeyComp

Browse Source 
Update usage of `*babyjub.PublicKey` to `babyjub.PublicKeyComp`
- when the key is not defined, internally is used `babyjub.EmptyBJJComp`, which is a `[32]byte` of zeroes of type `babyjub.PublicKeyComp`
- the API continues returning `nil` when the key is not defined
This commit is contained in:
arnaucube
2020-12-18 17:19:07 +01:00
parent b9943182b8
commit 4b10549822
47 changed files with 761 additions and 733 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
db/statedb/statedb_test.go
View File

@@ -12,6 +12,7 @@ import (
ethCommon "github.com/ethereum/go-ethereum/common"
ethCrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/hermeznetwork/hermez-node/common"
"github.com/hermeznetwork/hermez-node/log"
"github.com/hermeznetwork/tracerr"
"github.com/iden3/go-iden3-crypto/babyjub"
"github.com/iden3/go-merkletree/db"
@@ -22,11 +23,11 @@ import (
func newAccount(t *testing.T, i int) *common.Account {
var sk babyjub.PrivateKey
_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
require.Nil(t, err)
require.NoError(t, err)
pk := sk.Public()
key, err := ethCrypto.GenerateKey()
require.Nil(t, err)
require.NoError(t, err)
address := ethCrypto.PubkeyToAddress(key.PublicKey)
return &common.Account{
@@ -34,18 +35,18 @@ func newAccount(t *testing.T, i int) *common.Account {
TokenID: common.TokenID(i),
Nonce: common.Nonce(i),
Balance: big.NewInt(1000),
PublicKey: pk,
PublicKey: pk.Compress(),
EthAddr: address,
}
}
func TestNewStateDBIntermediateState(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeTxSelector, 0)
assert.Nil(t, err)
assert.NoError(t, err)
// test values
k0 := []byte("testkey0")
@@ -55,19 +56,19 @@ func TestNewStateDBIntermediateState(t *testing.T) {
// store some data
tx, err := sdb.db.NewTx()
assert.Nil(t, err)
assert.NoError(t, err)
err = tx.Put(k0, v0)
assert.Nil(t, err)
assert.NoError(t, err)
err = tx.Commit()
assert.Nil(t, err)
assert.NoError(t, err)
v, err := sdb.db.Get(k0)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, v0, v)
// call NewStateDB which should get the db at the last checkpoint state
// executing a Reset (discarding the last 'testkey0'&'testvalue0' data)
sdb, err = NewStateDB(dir, TypeTxSelector, 0)
assert.Nil(t, err)
assert.NoError(t, err)
v, err = sdb.db.Get(k0)
assert.NotNil(t, err)
assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
@@ -75,44 +76,44 @@ func TestNewStateDBIntermediateState(t *testing.T) {
// store the same data from the beginning that has ben lost since last NewStateDB
tx, err = sdb.db.NewTx()
assert.Nil(t, err)
assert.NoError(t, err)
err = tx.Put(k0, v0)
assert.Nil(t, err)
assert.NoError(t, err)
err = tx.Commit()
assert.Nil(t, err)
assert.NoError(t, err)
v, err = sdb.db.Get(k0)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, v0, v)
// make checkpoints with the current state
bn, err := sdb.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(0), bn)
err = sdb.MakeCheckpoint()
assert.Nil(t, err)
assert.NoError(t, err)
bn, err = sdb.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(1), bn)
// write more data
tx, err = sdb.db.NewTx()
assert.Nil(t, err)
assert.NoError(t, err)
err = tx.Put(k1, v1)
assert.Nil(t, err)
assert.NoError(t, err)
err = tx.Commit()
assert.Nil(t, err)
assert.NoError(t, err)
v, err = sdb.db.Get(k1)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, v1, v)
// call NewStateDB which should get the db at the last checkpoint state
// executing a Reset (discarding the last 'testkey1'&'testvalue1' data)
sdb, err = NewStateDB(dir, TypeTxSelector, 0)
assert.Nil(t, err)
assert.NoError(t, err)
v, err = sdb.db.Get(k0)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, v0, v)
v, err = sdb.db.Get(k1)
@@ -123,11 +124,11 @@ func TestNewStateDBIntermediateState(t *testing.T) {
func TestStateDBWithoutMT(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeTxSelector, 0)
assert.Nil(t, err)
assert.NoError(t, err)
// create test accounts
var accounts []*common.Account
@@ -144,20 +145,20 @@ func TestStateDBWithoutMT(t *testing.T) {
// add test accounts
for i := 0; i < len(accounts); i++ {
_, err = sdb.CreateAccount(accounts[i].Idx, accounts[i])
assert.Nil(t, err)
assert.NoError(t, err)
}
for i := 0; i < len(accounts); i++ {
existingAccount := accounts[i].Idx
accGetted, err := sdb.GetAccount(existingAccount)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, accounts[i], accGetted)
}
// try already existing idx and get error
existingAccount := common.Idx(256)
_, err = sdb.GetAccount(existingAccount) // check that exist
assert.Nil(t, err)
assert.NoError(t, err)
_, err = sdb.CreateAccount(common.Idx(256), accounts[1]) // check that can not be created twice
assert.NotNil(t, err)
assert.Equal(t, ErrAccountAlreadyExists, tracerr.Unwrap(err))
@@ -167,7 +168,7 @@ func TestStateDBWithoutMT(t *testing.T) {
accounts[i].Nonce = accounts[i].Nonce + 1
existingAccount = common.Idx(i)
_, err = sdb.UpdateAccount(existingAccount, accounts[i])
assert.Nil(t, err)
assert.NoError(t, err)
}
_, err = sdb.MTGetProof(common.Idx(1))
@@ -177,11 +178,11 @@ func TestStateDBWithoutMT(t *testing.T) {
func TestStateDBWithMT(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeSynchronizer, 32)
assert.Nil(t, err)
assert.NoError(t, err)
// create test accounts
var accounts []*common.Account
@@ -197,43 +198,43 @@ func TestStateDBWithMT(t *testing.T) {
// add test accounts
for i := 0; i < len(accounts); i++ {
_, err = sdb.CreateAccount(accounts[i].Idx, accounts[i])
assert.Nil(t, err)
assert.NoError(t, err)
}
for i := 0; i < len(accounts); i++ {
accGetted, err := sdb.GetAccount(accounts[i].Idx)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, accounts[i], accGetted)
}
// try already existing idx and get error
_, err = sdb.GetAccount(common.Idx(256)) // check that exist
assert.Nil(t, err)
assert.NoError(t, err)
_, err = sdb.CreateAccount(common.Idx(256), accounts[1]) // check that can not be created twice
assert.NotNil(t, err)
assert.Equal(t, ErrAccountAlreadyExists, tracerr.Unwrap(err))
_, err = sdb.MTGetProof(common.Idx(256))
assert.Nil(t, err)
assert.NoError(t, err)
// update accounts
for i := 0; i < len(accounts); i++ {
accounts[i].Nonce = accounts[i].Nonce + 1
_, err = sdb.UpdateAccount(accounts[i].Idx, accounts[i])
assert.Nil(t, err)
assert.NoError(t, err)
}
a, err := sdb.GetAccount(common.Idx(256)) // check that account value has been updated
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, accounts[0].Nonce, a.Nonce)
}
func TestCheckpoints(t *testing.T) {
dir, err := ioutil.TempDir("", "sdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeSynchronizer, 32)
assert.Nil(t, err)
assert.NoError(t, err)
// create test accounts
var accounts []*common.Account
@@ -244,22 +245,22 @@ func TestCheckpoints(t *testing.T) {
// add test accounts
for i := 0; i < len(accounts); i++ {
_, err = sdb.CreateAccount(accounts[i].Idx, accounts[i])
assert.Nil(t, err)
assert.NoError(t, err)
}
// do checkpoints and check that currentBatch is correct
err = sdb.MakeCheckpoint()
assert.Nil(t, err)
assert.NoError(t, err)
cb, err := sdb.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(1), cb)
for i := 1; i < 10; i++ {
err = sdb.MakeCheckpoint()
assert.Nil(t, err)
assert.NoError(t, err)
cb, err = sdb.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(i+1), cb)
}
@@ -267,29 +268,29 @@ func TestCheckpoints(t *testing.T) {
// reset checkpoint
err = sdb.Reset(3)
assert.Nil(t, err)
assert.NoError(t, err)
// check that reset can be repeated (as there exist the 'current' and
// 'BatchNum3', from where the 'current' is a copy)
err = sdb.Reset(3)
require.Nil(t, err)
require.NoError(t, err)
// check that currentBatch is as expected after Reset
cb, err = sdb.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(3), cb)
// advance one checkpoint and check that currentBatch is fine
err = sdb.MakeCheckpoint()
assert.Nil(t, err)
assert.NoError(t, err)
cb, err = sdb.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(4), cb)
err = sdb.DeleteCheckpoint(common.BatchNum(9))
assert.Nil(t, err)
assert.NoError(t, err)
err = sdb.DeleteCheckpoint(common.BatchNum(10))
assert.Nil(t, err)
assert.NoError(t, err)
err = sdb.DeleteCheckpoint(common.BatchNum(9)) // does not exist, should return err
assert.NotNil(t, err)
err = sdb.DeleteCheckpoint(common.BatchNum(11)) // does not exist, should return err
@@ -297,44 +298,44 @@ func TestCheckpoints(t *testing.T) {
// Create a LocalStateDB from the initial StateDB
dirLocal, err := ioutil.TempDir("", "ldb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dirLocal))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dirLocal))
ldb, err := NewLocalStateDB(dirLocal, sdb, TypeBatchBuilder, 32)
assert.Nil(t, err)
assert.NoError(t, err)
// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
err = ldb.Reset(4, true)
assert.Nil(t, err)
assert.NoError(t, err)
// check that currentBatch is 4 after the Reset
cb, err = ldb.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(4), cb)
// advance one checkpoint in ldb
err = ldb.MakeCheckpoint()
assert.Nil(t, err)
assert.NoError(t, err)
cb, err = ldb.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(5), cb)
// Create a 2nd LocalStateDB from the initial StateDB
dirLocal2, err := ioutil.TempDir("", "ldb2")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dirLocal2))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dirLocal2))
ldb2, err := NewLocalStateDB(dirLocal2, sdb, TypeBatchBuilder, 32)
assert.Nil(t, err)
assert.NoError(t, err)
// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
err = ldb2.Reset(4, true)
assert.Nil(t, err)
assert.NoError(t, err)
// check that currentBatch is 4 after the Reset
cb, err = ldb2.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(4), cb)
// advance one checkpoint in ldb2
err = ldb2.MakeCheckpoint()
assert.Nil(t, err)
assert.NoError(t, err)
cb, err = ldb2.GetCurrentBatch()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, common.BatchNum(5), cb)
debug := false
@@ -347,10 +348,10 @@ func TestCheckpoints(t *testing.T) {
func TestStateDBGetAccounts(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
require.NoError(t, err)
sdb, err := NewStateDB(dir, TypeTxSelector, 0)
assert.Nil(t, err)
assert.NoError(t, err)
// create test accounts
var accounts []common.Account
@@ -362,17 +363,17 @@ func TestStateDBGetAccounts(t *testing.T) {
// add test accounts
for i := range accounts {
_, err = sdb.CreateAccount(accounts[i].Idx, &accounts[i])
require.Nil(t, err)
require.NoError(t, err)
}
dbAccounts, err := sdb.GetAccounts()
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, accounts, dbAccounts)
}
func printCheckpoints(t *testing.T, path string) {
files, err := ioutil.ReadDir(path)
assert.Nil(t, err)
assert.NoError(t, err)
fmt.Println(path)
for _, f := range files {
@@ -393,33 +394,34 @@ func bigFromStr(h string, u int) *big.Int {
func TestCheckAccountsTreeTestVectors(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeSynchronizer, 32)
require.Nil(t, err)
require.NoError(t, err)
ay0 := new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(253), nil), big.NewInt(1))
// test value from js version (compatibility-canary)
assert.Equal(t, "1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", (hex.EncodeToString(ay0.Bytes())))
bjj0, err := babyjub.PointFromSignAndY(true, ay0)
require.Nil(t, err)
bjjPoint0Comp := babyjub.PackSignY(true, ay0)
bjj0 := babyjub.PublicKeyComp(bjjPoint0Comp)
ay1 := bigFromStr("00", 16)
bjj1, err := babyjub.PointFromSignAndY(false, ay1)
require.Nil(t, err)
bjjPoint1Comp := babyjub.PackSignY(false, ay1)
bjj1 := babyjub.PublicKeyComp(bjjPoint1Comp)
ay2 := bigFromStr("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7", 16)
bjj2, err := babyjub.PointFromSignAndY(false, ay2)
require.Nil(t, err)
bjjPoint2Comp := babyjub.PackSignY(false, ay2)
bjj2 := babyjub.PublicKeyComp(bjjPoint2Comp)
ay3 := bigFromStr("0x10", 16) // 0x10=16
bjj3, err := babyjub.PointFromSignAndY(false, ay3)
require.Nil(t, err)
bjjPoint3Comp := babyjub.PackSignY(false, ay3)
require.NoError(t, err)
bjj3 := babyjub.PublicKeyComp(bjjPoint3Comp)
accounts := []*common.Account{
{
Idx: 1,
TokenID: 0xFFFFFFFF,
PublicKey: (*babyjub.PublicKey)(bjj0),
PublicKey: bjj0,
EthAddr: ethCommon.HexToAddress("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
Nonce: common.Nonce(0xFFFFFFFFFF),
Balance: bigFromStr("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16),
@@ -427,7 +429,7 @@ func TestCheckAccountsTreeTestVectors(t *testing.T) {
{
Idx: 100,
TokenID: 0,
PublicKey: (*babyjub.PublicKey)(bjj1),
PublicKey: bjj1,
EthAddr: ethCommon.HexToAddress("0x00"),
Nonce: common.Nonce(0),
Balance: bigFromStr("0", 10),
@@ -435,7 +437,7 @@ func TestCheckAccountsTreeTestVectors(t *testing.T) {
{
Idx: 0xFFFFFFFFFFFF,
TokenID: 3,
PublicKey: (*babyjub.PublicKey)(bjj2),
PublicKey: bjj2,
EthAddr: ethCommon.HexToAddress("0xA3C88ac39A76789437AED31B9608da72e1bbfBF9"),
Nonce: common.Nonce(129),
Balance: bigFromStr("42000000000000000000", 10),
@@ -443,7 +445,7 @@ func TestCheckAccountsTreeTestVectors(t *testing.T) {
{
Idx: 10000,
TokenID: 1000,
PublicKey: (*babyjub.PublicKey)(bjj3),
PublicKey: bjj3,
EthAddr: ethCommon.HexToAddress("0x64"),
Nonce: common.Nonce(1900),
Balance: bigFromStr("14000000000000000000", 10),
@@ -451,9 +453,12 @@ func TestCheckAccountsTreeTestVectors(t *testing.T) {
}
for i := 0; i < len(accounts); i++ {
_, err = accounts[i].HashValue()
require.Nil(t, err)
require.NoError(t, err)
_, err = sdb.CreateAccount(accounts[i].Idx, accounts[i])
require.Nil(t, err)
if err != nil {
log.Error(err)
}
require.NoError(t, err)
}
// root value generated by js version:
assert.Equal(t, "17298264051379321456969039521810887093935433569451713402227686942080129181291", sdb.mt.Root().BigInt().String())

63
db/statedb/txprocessors.go
View File

@@ -304,10 +304,11 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
if s.zki != nil {
s.zki.TokenID3[iFee] = accCoord.TokenID.BigInt()
s.zki.Nonce3[iFee] = accCoord.Nonce.BigInt()
if babyjub.PointCoordSign(accCoord.PublicKey.X) {
coordBJJSign, coordBJJY := babyjub.UnpackSignY(accCoord.PublicKey)
if coordBJJSign {
s.zki.Sign3[iFee] = big.NewInt(1)
}
s.zki.Ay3[iFee] = accCoord.PublicKey.Y
s.zki.Ay3[iFee] = coordBJJY
s.zki.Balance3[iFee] = accCoord.Balance
s.zki.EthAddr3[iFee] = common.EthAddrToBigInt(accCoord.EthAddr)
}
@@ -432,8 +433,8 @@ func (s *StateDB) processL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx)
}
s.zki.DepositAmountF[s.i] = big.NewInt(int64(depositAmountF16))
s.zki.FromEthAddr[s.i] = common.EthAddrToBigInt(tx.FromEthAddr)
if tx.FromBJJ != nil {
s.zki.FromBJJCompressed[s.i] = BJJCompressedTo256BigInts(tx.FromBJJ.Compress())
if tx.FromBJJ != common.EmptyBJJComp {
s.zki.FromBJJCompressed[s.i] = BJJCompressedTo256BigInts(tx.FromBJJ)
}
// Intermediate States, for all the transactions except for the last one
@@ -567,8 +568,8 @@ func (s *StateDB) processL2Tx(coordIdxsMap map[common.TokenID]common.Idx, collec
s.zki.AuxToIdx[s.i] = tx.AuxToIdx.BigInt()
}
if tx.ToBJJ != nil {
s.zki.ToBJJAy[s.i] = tx.ToBJJ.Y
if tx.ToBJJ != common.EmptyBJJComp {
_, s.zki.ToBJJAy[s.i] = babyjub.UnpackSignY(tx.ToBJJ)
}
s.zki.ToEthAddr[s.i] = common.EthAddrToBigInt(tx.ToEthAddr)
@@ -643,10 +644,11 @@ func (s *StateDB) applyCreateAccount(tx *common.L1Tx) error {
if s.zki != nil {
s.zki.TokenID1[s.i] = tx.TokenID.BigInt()
s.zki.Nonce1[s.i] = big.NewInt(0)
if babyjub.PointCoordSign(tx.FromBJJ.X) {
fromBJJSign, fromBJJY := babyjub.UnpackSignY(tx.FromBJJ)
if fromBJJSign {
s.zki.Sign1[s.i] = big.NewInt(1)
}
s.zki.Ay1[s.i] = tx.FromBJJ.Y
s.zki.Ay1[s.i] = fromBJJY
s.zki.Balance1[s.i] = tx.EffectiveDepositAmount
s.zki.EthAddr1[s.i] = common.EthAddrToBigInt(tx.FromEthAddr)
s.zki.Siblings1[s.i] = siblingsToZKInputFormat(p.Siblings)
@@ -683,10 +685,11 @@ func (s *StateDB) applyDeposit(tx *common.L1Tx, transfer bool) error {
if s.zki != nil {
s.zki.TokenID1[s.i] = accSender.TokenID.BigInt()
s.zki.Nonce1[s.i] = accSender.Nonce.BigInt()
if babyjub.PointCoordSign(accSender.PublicKey.X) {
senderBJJSign, senderBJJY := babyjub.UnpackSignY(accSender.PublicKey)
if senderBJJSign {
s.zki.Sign1[s.i] = big.NewInt(1)
}
s.zki.Ay1[s.i] = accSender.PublicKey.Y
s.zki.Ay1[s.i] = senderBJJY
s.zki.Balance1[s.i] = accSender.Balance
s.zki.EthAddr1[s.i] = common.EthAddrToBigInt(accSender.EthAddr)
}
@@ -721,10 +724,11 @@ func (s *StateDB) applyDeposit(tx *common.L1Tx, transfer bool) error {
if s.zki != nil {
s.zki.TokenID2[s.i] = accReceiver.TokenID.BigInt()
s.zki.Nonce2[s.i] = accReceiver.Nonce.BigInt()
if babyjub.PointCoordSign(accReceiver.PublicKey.X) {
receiverBJJSign, receiverBJJY := babyjub.UnpackSignY(accReceiver.PublicKey)
if receiverBJJSign {
s.zki.Sign2[s.i] = big.NewInt(1)
}
s.zki.Ay2[s.i] = accReceiver.PublicKey.Y
s.zki.Ay2[s.i] = receiverBJJY
s.zki.Balance2[s.i] = accReceiver.Balance
s.zki.EthAddr2[s.i] = common.EthAddrToBigInt(accReceiver.EthAddr)
}
@@ -769,10 +773,11 @@ func (s *StateDB) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
// Set the State1 before updating the Sender leaf
s.zki.TokenID1[s.i] = accSender.TokenID.BigInt()
s.zki.Nonce1[s.i] = accSender.Nonce.BigInt()
if babyjub.PointCoordSign(accSender.PublicKey.X) {
senderBJJSign, senderBJJY := babyjub.UnpackSignY(accSender.PublicKey)
if senderBJJSign {
s.zki.Sign1[s.i] = big.NewInt(1)
}
s.zki.Ay1[s.i] = accSender.PublicKey.Y
s.zki.Ay1[s.i] = senderBJJY
s.zki.Balance1[s.i] = accSender.Balance
s.zki.EthAddr1[s.i] = common.EthAddrToBigInt(accSender.EthAddr)
}
@@ -835,10 +840,11 @@ func (s *StateDB) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
// Set the State2 before updating the Receiver leaf
s.zki.TokenID2[s.i] = accReceiver.TokenID.BigInt()
s.zki.Nonce2[s.i] = accReceiver.Nonce.BigInt()
if babyjub.PointCoordSign(accReceiver.PublicKey.X) {
receiverBJJSign, receiverBJJY := babyjub.UnpackSignY(accReceiver.PublicKey)
if receiverBJJSign {
s.zki.Sign2[s.i] = big.NewInt(1)
}
s.zki.Ay2[s.i] = accReceiver.PublicKey.Y
s.zki.Ay2[s.i] = receiverBJJY
s.zki.Balance2[s.i] = accReceiver.Balance
s.zki.EthAddr2[s.i] = common.EthAddrToBigInt(accReceiver.EthAddr)
}
@@ -874,10 +880,11 @@ func (s *StateDB) applyCreateAccountDepositTransfer(tx *common.L1Tx) error {
// Set the State1 before updating the Sender leaf
s.zki.TokenID1[s.i] = tx.TokenID.BigInt()
s.zki.Nonce1[s.i] = big.NewInt(0)
if babyjub.PointCoordSign(tx.FromBJJ.X) {
fromBJJSign, fromBJJY := babyjub.UnpackSignY(tx.FromBJJ)
if fromBJJSign {
s.zki.Sign1[s.i] = big.NewInt(1)
}
s.zki.Ay1[s.i] = tx.FromBJJ.Y
s.zki.Ay1[s.i] = fromBJJY
s.zki.Balance1[s.i] = tx.EffectiveDepositAmount
s.zki.EthAddr1[s.i] = common.EthAddrToBigInt(tx.FromEthAddr)
}
@@ -921,10 +928,11 @@ func (s *StateDB) applyCreateAccountDepositTransfer(tx *common.L1Tx) error {
// Set the State2 before updating the Receiver leaf
s.zki.TokenID2[s.i] = accReceiver.TokenID.BigInt()
s.zki.Nonce2[s.i] = accReceiver.Nonce.BigInt()
if babyjub.PointCoordSign(accReceiver.PublicKey.X) {
receiverBJJSign, receiverBJJY := babyjub.UnpackSignY(accReceiver.PublicKey)
if receiverBJJSign {
s.zki.Sign2[s.i] = big.NewInt(1)
}
s.zki.Ay2[s.i] = accReceiver.PublicKey.Y
s.zki.Ay2[s.i] = receiverBJJY
s.zki.Balance2[s.i] = accReceiver.Balance
s.zki.EthAddr2[s.i] = common.EthAddrToBigInt(accReceiver.EthAddr)
}
@@ -959,10 +967,11 @@ func (s *StateDB) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
if s.zki != nil {
s.zki.TokenID1[s.i] = acc.TokenID.BigInt()
s.zki.Nonce1[s.i] = acc.Nonce.BigInt()
if babyjub.PointCoordSign(acc.PublicKey.X) {
accBJJSign, accBJJY := babyjub.UnpackSignY(acc.PublicKey)
if accBJJSign {
s.zki.Sign1[s.i] = big.NewInt(1)
}
s.zki.Ay1[s.i] = acc.PublicKey.Y
s.zki.Ay1[s.i] = accBJJY
s.zki.Balance1[s.i] = acc.Balance
s.zki.EthAddr1[s.i] = common.EthAddrToBigInt(acc.EthAddr)
@@ -1027,10 +1036,11 @@ func (s *StateDB) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
// Set the State2 before creating the Exit leaf
s.zki.TokenID2[s.i] = acc.TokenID.BigInt()
s.zki.Nonce2[s.i] = big.NewInt(0)
if babyjub.PointCoordSign(acc.PublicKey.X) {
accBJJSign, accBJJY := babyjub.UnpackSignY(acc.PublicKey)
if accBJJSign {
s.zki.Sign2[s.i] = big.NewInt(1)
}
s.zki.Ay2[s.i] = acc.PublicKey.Y
s.zki.Ay2[s.i] = accBJJY
s.zki.Balance2[s.i] = tx.Amount
s.zki.EthAddr2[s.i] = common.EthAddrToBigInt(acc.EthAddr)
}
@@ -1057,10 +1067,11 @@ func (s *StateDB) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
// Set the State2 before updating the Exit leaf
s.zki.TokenID2[s.i] = acc.TokenID.BigInt()
s.zki.Nonce2[s.i] = big.NewInt(0)
if babyjub.PointCoordSign(acc.PublicKey.X) {
accBJJSign, accBJJY := babyjub.UnpackSignY(acc.PublicKey)
if accBJJSign {
s.zki.Sign2[s.i] = big.NewInt(1)
}
s.zki.Ay2[s.i] = acc.PublicKey.Y
s.zki.Ay2[s.i] = accBJJY
s.zki.Balance2[s.i] = tx.Amount
s.zki.EthAddr2[s.i] = common.EthAddrToBigInt(acc.EthAddr)
}

136
db/statedb/txprocessors_test.go
View File

@@ -19,17 +19,17 @@ import (
func checkBalance(t *testing.T, tc *til.Context, sdb *StateDB, username string, tokenid int, expected string) {
idx := tc.Users[username].Accounts[common.TokenID(tokenid)].Idx
acc, err := sdb.GetAccount(idx)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, expected, acc.Balance.String())
}
func TestComputeEffectiveAmounts(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeSynchronizer, 32)
assert.Nil(t, err)
assert.NoError(t, err)
set := `
Type: Blockchain
@@ -44,7 +44,7 @@ func TestComputeEffectiveAmounts(t *testing.T) {
`
tc := til.NewContext(common.RollupConstMaxL1UserTx)
blocks, err := tc.GenerateBlocks(set)
require.Nil(t, err)
require.NoError(t, err)
ptc := ProcessTxsConfig{
NLevels: 32,
@@ -53,7 +53,7 @@ func TestComputeEffectiveAmounts(t *testing.T) {
MaxL1Tx: 16,
}
_, err = sdb.ProcessTxs(ptc, nil, blocks[0].Rollup.L1UserTxs, nil, nil)
require.Nil(t, err)
require.NoError(t, err)
tx := common.L1Tx{
FromIdx: 256,
@@ -198,16 +198,16 @@ func TestComputeEffectiveAmounts(t *testing.T) {
func TestProcessTxsBalances(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeSynchronizer, 32)
assert.Nil(t, err)
assert.NoError(t, err)
// generate test transactions from test.SetBlockchain0 code
tc := til.NewContext(common.RollupConstMaxL1UserTx)
blocks, err := tc.GenerateBlocks(til.SetBlockchainMinimumFlow0)
require.Nil(t, err)
require.NoError(t, err)
// Coordinator Idx where to send the fees
coordIdxs := []common.Idx{256, 257}
@@ -220,26 +220,26 @@ func TestProcessTxsBalances(t *testing.T) {
log.Debug("block:0 batch:0, only L1CoordinatorTxs")
_, err = sdb.ProcessTxs(ptc, nil, nil, blocks[0].Rollup.Batches[0].L1CoordinatorTxs, nil)
require.Nil(t, err)
require.NoError(t, err)
log.Debug("block:0 batch:1")
l1UserTxs := []common.L1Tx{}
l2Txs := common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[1].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
log.Debug("block:0 batch:2")
l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[2].Batch.ForgeL1TxsNum])
l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[2].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[2].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
checkBalance(t, tc, sdb, "A", 0, "500")
log.Debug("block:0 batch:3")
l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[3].Batch.ForgeL1TxsNum])
l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[3].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[3].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
checkBalance(t, tc, sdb, "A", 0, "500")
checkBalance(t, tc, sdb, "A", 1, "500")
@@ -247,7 +247,7 @@ func TestProcessTxsBalances(t *testing.T) {
l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[4].Batch.ForgeL1TxsNum])
l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[4].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[4].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
checkBalance(t, tc, sdb, "A", 0, "500")
checkBalance(t, tc, sdb, "A", 1, "500")
@@ -255,7 +255,7 @@ func TestProcessTxsBalances(t *testing.T) {
l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[5].Batch.ForgeL1TxsNum])
l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[5].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[5].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
checkBalance(t, tc, sdb, "A", 0, "600")
checkBalance(t, tc, sdb, "A", 1, "500")
checkBalance(t, tc, sdb, "B", 0, "400")
@@ -264,7 +264,7 @@ func TestProcessTxsBalances(t *testing.T) {
l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[6].Batch.ForgeL1TxsNum])
l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[6].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[6].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
checkBalance(t, tc, sdb, "Coord", 0, "10")
checkBalance(t, tc, sdb, "Coord", 1, "20")
checkBalance(t, tc, sdb, "A", 0, "600")
@@ -278,7 +278,7 @@ func TestProcessTxsBalances(t *testing.T) {
l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[7].Batch.ForgeL1TxsNum])
l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[7].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[7].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
checkBalance(t, tc, sdb, "Coord", 0, "35")
checkBalance(t, tc, sdb, "Coord", 1, "30")
checkBalance(t, tc, sdb, "A", 0, "430")
@@ -293,7 +293,7 @@ func TestProcessTxsBalances(t *testing.T) {
l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[1].Rollup.Batches[0].Batch.ForgeL1TxsNum])
l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[0].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[1].Rollup.Batches[0].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
checkBalance(t, tc, sdb, "Coord", 0, "75")
checkBalance(t, tc, sdb, "Coord", 1, "30")
checkBalance(t, tc, sdb, "A", 0, "730")
@@ -308,14 +308,14 @@ func TestProcessTxsBalances(t *testing.T) {
l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[1].Rollup.Batches[1].Batch.ForgeL1TxsNum])
l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[1].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[1].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
// use Set of PoolL2 txs
poolL2Txs, err := tc.GeneratePoolL2Txs(til.SetPoolL2MinimumFlow1)
assert.Nil(t, err)
assert.NoError(t, err)
_, err = sdb.ProcessTxs(ptc, coordIdxs, []common.L1Tx{}, []common.L1Tx{}, poolL2Txs)
require.Nil(t, err)
require.NoError(t, err)
checkBalance(t, tc, sdb, "Coord", 0, "105")
checkBalance(t, tc, sdb, "Coord", 1, "40")
checkBalance(t, tc, sdb, "A", 0, "510")
@@ -330,16 +330,16 @@ func TestProcessTxsBalances(t *testing.T) {
func TestProcessTxsSynchronizer(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeSynchronizer, 32)
assert.Nil(t, err)
assert.NoError(t, err)
// generate test transactions from test.SetBlockchain0 code
tc := til.NewContext(common.RollupConstMaxL1UserTx)
blocks, err := tc.GenerateBlocks(til.SetBlockchain0)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, 31, len(blocks[0].Rollup.L1UserTxs))
assert.Equal(t, 4, len(blocks[0].Rollup.Batches[0].L1CoordinatorTxs))
@@ -367,7 +367,7 @@ func TestProcessTxsSynchronizer(t *testing.T) {
// to create the Coordinator accounts to receive the fees
log.Debug("block:0 batch:0, only L1CoordinatorTxs")
ptOut, err := sdb.ProcessTxs(ptc, nil, nil, blocks[0].Rollup.Batches[0].L1CoordinatorTxs, nil)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, 4, len(ptOut.CreatedAccounts))
assert.Equal(t, 0, len(ptOut.CollectedFees))
@@ -375,7 +375,7 @@ func TestProcessTxsSynchronizer(t *testing.T) {
l2Txs := common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[1].L2Txs)
ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, blocks[0].Rollup.L1UserTxs,
blocks[0].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, 0, len(ptOut.ExitInfos))
assert.Equal(t, 31, len(ptOut.CreatedAccounts))
assert.Equal(t, 4, len(ptOut.CollectedFees))
@@ -384,13 +384,13 @@ func TestProcessTxsSynchronizer(t *testing.T) {
assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(2)].String())
assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(3)].String())
acc, err := sdb.GetAccount(idxA1)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "50", acc.Balance.String())
log.Debug("block:0 batch:2")
l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[2].L2Txs)
ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, nil, blocks[0].Rollup.Batches[2].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, 0, len(ptOut.ExitInfos))
assert.Equal(t, 0, len(ptOut.CreatedAccounts))
assert.Equal(t, 4, len(ptOut.CollectedFees))
@@ -399,7 +399,7 @@ func TestProcessTxsSynchronizer(t *testing.T) {
assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(2)].String())
assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(3)].String())
acc, err = sdb.GetAccount(idxA1)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "35", acc.Balance.String())
log.Debug("block:1 batch:0")
@@ -410,7 +410,7 @@ func TestProcessTxsSynchronizer(t *testing.T) {
assert.Equal(t, common.Nonce(0), l2Txs[2].Nonce)
ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, nil, blocks[1].Rollup.Batches[0].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
// after processing expect l2Txs[0:2].Nonce!=0 and has expected value
assert.Equal(t, common.Nonce(6), l2Txs[0].Nonce)
@@ -425,14 +425,14 @@ func TestProcessTxsSynchronizer(t *testing.T) {
assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(2)].String())
assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(3)].String())
acc, err = sdb.GetAccount(idxA1)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "57", acc.Balance.String())
log.Debug("block:1 batch:1")
l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[1].L2Txs)
ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, blocks[1].Rollup.L1UserTxs,
blocks[1].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, 2, len(ptOut.ExitInfos)) // 2, as previous batch was without L1UserTxs, and has pending the 'ForceExit(1) A: 5'
assert.Equal(t, 1, len(ptOut.CreatedAccounts))
@@ -442,32 +442,32 @@ func TestProcessTxsSynchronizer(t *testing.T) {
assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(2)].String())
assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(3)].String())
acc, err = sdb.GetAccount(idxA1)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, "77", acc.Balance.String())
idxB0 := tc.Users["C"].Accounts[common.TokenID(0)].Idx
acc, err = sdb.GetAccount(idxB0)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "51", acc.Balance.String())
// get balance of Coordinator account for TokenID==0
acc, err = sdb.GetAccount(common.Idx(256))
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "2", acc.Balance.String())
}
func TestProcessTxsBatchBuilder(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeBatchBuilder, 32)
assert.Nil(t, err)
assert.NoError(t, err)
// generate test transactions from test.SetBlockchain0 code
tc := til.NewContext(common.RollupConstMaxL1UserTx)
blocks, err := tc.GenerateBlocks(til.SetBlockchain0)
require.Nil(t, err)
require.NoError(t, err)
// Coordinator Idx where to send the fees
coordIdxs := []common.Idx{256, 257, 258, 259}
@@ -486,58 +486,58 @@ func TestProcessTxsBatchBuilder(t *testing.T) {
// to create the Coordinator accounts to receive the fees
log.Debug("block:0 batch:0, only L1CoordinatorTxs")
ptOut, err := sdb.ProcessTxs(ptc, nil, nil, blocks[0].Rollup.Batches[0].L1CoordinatorTxs, nil)
require.Nil(t, err)
require.NoError(t, err)
// expect 0 at CreatedAccount, as is only computed when StateDB.Type==TypeSynchronizer
assert.Equal(t, 0, len(ptOut.CreatedAccounts))
log.Debug("block:0 batch:1")
l2Txs := common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[1].L2Txs)
ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, blocks[0].Rollup.L1UserTxs, blocks[0].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, 0, len(ptOut.ExitInfos))
assert.Equal(t, 0, len(ptOut.CreatedAccounts))
acc, err := sdb.GetAccount(idxA1)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "50", acc.Balance.String())
log.Debug("block:0 batch:2")
l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[2].L2Txs)
ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, nil, blocks[0].Rollup.Batches[2].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, 0, len(ptOut.ExitInfos))
assert.Equal(t, 0, len(ptOut.CreatedAccounts))
acc, err = sdb.GetAccount(idxA1)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "35", acc.Balance.String())
log.Debug("block:1 batch:0")
l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[0].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, nil, blocks[1].Rollup.Batches[0].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
acc, err = sdb.GetAccount(idxA1)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "57", acc.Balance.String())
log.Debug("block:1 batch:1")
l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[1].L2Txs)
_, err = sdb.ProcessTxs(ptc, coordIdxs, blocks[1].Rollup.L1UserTxs, blocks[1].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
acc, err = sdb.GetAccount(idxA1)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, "77", acc.Balance.String())
idxB0 := tc.Users["C"].Accounts[common.TokenID(0)].Idx
acc, err = sdb.GetAccount(idxB0)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "51", acc.Balance.String())
// get balance of Coordinator account for TokenID==0
acc, err = sdb.GetAccount(common.Idx(256))
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, common.TokenID(0), acc.TokenID)
assert.Equal(t, "2", acc.Balance.String())
acc, err = sdb.GetAccount(common.Idx(257))
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, common.TokenID(1), acc.TokenID)
assert.Equal(t, "2", acc.Balance.String())
@@ -546,15 +546,15 @@ func TestProcessTxsBatchBuilder(t *testing.T) {
func TestProcessTxsRootTestVectors(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeBatchBuilder, 32)
assert.Nil(t, err)
assert.NoError(t, err)
// same values than in the js test
bjj0, err := common.BJJFromStringWithChecksum("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7")
assert.Nil(t, err)
assert.NoError(t, err)
l1Txs := []common.L1Tx{
{
FromIdx: 0,
@@ -587,30 +587,30 @@ func TestProcessTxsRootTestVectors(t *testing.T) {
MaxL1Tx: 16,
}
_, err = sdb.ProcessTxs(ptc, nil, l1Txs, nil, l2Txs)
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, "9827704113668630072730115158977131501210702363656902211840117643154933433410", sdb.mt.Root().BigInt().String())
}
func TestCreateAccountDepositMaxValue(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
nLevels := 16
sdb, err := NewStateDB(dir, TypeBatchBuilder, nLevels)
assert.Nil(t, err)
assert.NoError(t, err)
users := generateJsUsers(t)
daMaxHex, err := hex.DecodeString("FFFF")
require.Nil(t, err)
require.NoError(t, err)
daMaxF16 := common.Float16(binary.BigEndian.Uint16(daMaxHex))
daMaxBI := daMaxF16.BigInt()
assert.Equal(t, "10235000000000000000000000000000000", daMaxBI.String())
daMax1Hex, err := hex.DecodeString("FFFE")
require.Nil(t, err)
require.NoError(t, err)
daMax1F16 := common.Float16(binary.BigEndian.Uint16(daMax1Hex))
daMax1BI := daMax1F16.BigInt()
assert.Equal(t, "10225000000000000000000000000000000", daMax1BI.String())
@@ -621,7 +621,7 @@ func TestCreateAccountDepositMaxValue(t *testing.T) {
DepositAmount: daMaxBI,
Amount: big.NewInt(0),
TokenID: 1,
FromBJJ: users[0].BJJ.Public(),
FromBJJ: users[0].BJJ.Public().Compress(),
FromEthAddr: users[0].Addr,
ToIdx: 0,
Type: common.TxTypeCreateAccountDeposit,
@@ -632,7 +632,7 @@ func TestCreateAccountDepositMaxValue(t *testing.T) {
DepositAmount: daMax1BI,
Amount: big.NewInt(0),
TokenID: 1,
FromBJJ: users[1].BJJ.Public(),
FromBJJ: users[1].BJJ.Public().Compress(),
FromEthAddr: users[1].Addr,
ToIdx: 0,
Type: common.TxTypeCreateAccountDeposit,
@@ -648,13 +648,13 @@ func TestCreateAccountDepositMaxValue(t *testing.T) {
}
_, err = sdb.ProcessTxs(ptc, nil, l1Txs, nil, nil)
require.Nil(t, err)
require.NoError(t, err)
// check balances
acc, err := sdb.GetAccount(common.Idx(256))
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, daMaxBI, acc.Balance)
acc, err = sdb.GetAccount(common.Idx(257))
require.Nil(t, err)
require.NoError(t, err)
assert.Equal(t, daMax1BI, acc.Balance)
}

22
db/statedb/utils.go
View File

@@ -19,8 +19,8 @@ func concatEthAddrTokenID(addr ethCommon.Address, tokenID common.TokenID) []byte
b = append(b[:], tokenID.Bytes()[:]...)
return b
}
func concatEthAddrBJJTokenID(addr ethCommon.Address, pk *babyjub.PublicKey, tokenID common.TokenID) []byte {
pkComp := pk.Compress()
func concatEthAddrBJJTokenID(addr ethCommon.Address, pk babyjub.PublicKeyComp, tokenID common.TokenID) []byte {
pkComp := pk
var b []byte
b = append(b, addr.Bytes()...)
b = append(b[:], pkComp[:]...)
@@ -33,7 +33,7 @@ func concatEthAddrBJJTokenID(addr ethCommon.Address, pk *babyjub.PublicKey, toke
// - key: EthAddr & BabyJubJub PublicKey Compressed, value: idx
// If Idx already exist for the given EthAddr & BJJ, the remaining Idx will be
// always the smallest one.
func (s *StateDB) setIdxByEthAddrBJJ(idx common.Idx, addr ethCommon.Address, pk *babyjub.PublicKey, tokenID common.TokenID) error {
func (s *StateDB) setIdxByEthAddrBJJ(idx common.Idx, addr ethCommon.Address, pk babyjub.PublicKeyComp, tokenID common.TokenID) error {
oldIdx, err := s.GetIdxByEthAddrBJJ(addr, pk, tokenID)
if err == nil {
// EthAddr & BJJ already have an Idx
@@ -46,10 +46,6 @@ func (s *StateDB) setIdxByEthAddrBJJ(idx common.Idx, addr ethCommon.Address, pk
}
}
if pk == nil {
return tracerr.Wrap(fmt.Errorf("BabyJubJub pk not defined"))
}
// store idx for EthAddr & BJJ assuming that EthAddr & BJJ still don't
// have an Idx stored in the DB, and if so, the already stored Idx is
// bigger than the given one, so should be updated to the new one
@@ -89,11 +85,13 @@ func (s *StateDB) GetIdxByEthAddr(addr ethCommon.Address, tokenID common.TokenID
k := concatEthAddrTokenID(addr, tokenID)
b, err := s.db.Get(append(PrefixKeyAddr, k...))
if err != nil {
return common.Idx(0), tracerr.Wrap(fmt.Errorf("GetIdxByEthAddr: %s: ToEthAddr: %s, TokenID: %d", ErrToIdxNotFound, addr.Hex(), tokenID))
return common.Idx(0), tracerr.Wrap(fmt.Errorf("GetIdxByEthAddr: %s: ToEthAddr: %s, TokenID: %d",
ErrToIdxNotFound, addr.Hex(), tokenID))
}
idx, err := common.IdxFromBytes(b)
if err != nil {
return common.Idx(0), tracerr.Wrap(fmt.Errorf("GetIdxByEthAddr: %s: ToEthAddr: %s, TokenID: %d", err, addr.Hex(), tokenID))
return common.Idx(0), tracerr.Wrap(fmt.Errorf("GetIdxByEthAddr: %s: ToEthAddr: %s, TokenID: %d",
err, addr.Hex(), tokenID))
}
return idx, nil
}
@@ -103,12 +101,12 @@ func (s *StateDB) GetIdxByEthAddr(addr ethCommon.Address, tokenID common.TokenID
// address, it's ignored in the query. If `pk` is nil, it's ignored in the
// query. Will return common.Idx(0) and error in case that Idx is not found in
// the StateDB.
func (s *StateDB) GetIdxByEthAddrBJJ(addr ethCommon.Address, pk *babyjub.PublicKey, tokenID common.TokenID) (common.Idx, error) {
if !bytes.Equal(addr.Bytes(), common.EmptyAddr.Bytes()) && pk == nil {
func (s *StateDB) GetIdxByEthAddrBJJ(addr ethCommon.Address, pk babyjub.PublicKeyComp, tokenID common.TokenID) (common.Idx, error) {
if !bytes.Equal(addr.Bytes(), common.EmptyAddr.Bytes()) && pk == common.EmptyBJJComp {
// ToEthAddr
// case ToEthAddr!=0 && ToBJJ=0
return s.GetIdxByEthAddr(addr, tokenID)
} else if !bytes.Equal(addr.Bytes(), common.EmptyAddr.Bytes()) && pk != nil {
} else if !bytes.Equal(addr.Bytes(), common.EmptyAddr.Bytes()) && pk != common.EmptyBJJComp {
// case ToEthAddr!=0 && ToBJJ!=0
k := concatEthAddrBJJTokenID(addr, pk, tokenID)
b, err := s.db.Get(append(PrefixKeyAddrBJJ, k...))

38
db/statedb/utils_test.go
View File

@@ -17,11 +17,11 @@ import (
func TestGetIdx(t *testing.T) {
dir, err := ioutil.TempDir("", "tmpdb")
require.Nil(t, err)
defer assert.Nil(t, os.RemoveAll(dir))
require.NoError(t, err)
defer assert.NoError(t, os.RemoveAll(dir))
sdb, err := NewStateDB(dir, TypeTxSelector, 0)
assert.Nil(t, err)
assert.NoError(t, err)
var sk babyjub.PrivateKey
copy(sk[:], []byte("1234")) // only for testing
@@ -39,50 +39,50 @@ func TestGetIdx(t *testing.T) {
tokenID1 := common.TokenID(1)
// store the keys for idx by Addr & BJJ
err = sdb.setIdxByEthAddrBJJ(idx, addr, pk, tokenID0)
require.Nil(t, err)
err = sdb.setIdxByEthAddrBJJ(idx, addr, pk.Compress(), tokenID0)
require.NoError(t, err)
idxR, err := sdb.GetIdxByEthAddrBJJ(addr, pk, tokenID0)
assert.Nil(t, err)
idxR, err := sdb.GetIdxByEthAddrBJJ(addr, pk.Compress(), tokenID0)
assert.NoError(t, err)
assert.Equal(t, idx, idxR)
// expect error when getting only by EthAddr, as value does not exist
// in the db for only EthAddr
_, err = sdb.GetIdxByEthAddr(addr, tokenID0)
assert.Nil(t, err)
assert.NoError(t, err)
_, err = sdb.GetIdxByEthAddr(addr2, tokenID0)
assert.NotNil(t, err)
// expect error when getting by EthAddr and BJJ, but for another TokenID
_, err = sdb.GetIdxByEthAddrBJJ(addr, pk, tokenID1)
_, err = sdb.GetIdxByEthAddrBJJ(addr, pk.Compress(), tokenID1)
assert.NotNil(t, err)
// expect to fail
idxR, err = sdb.GetIdxByEthAddrBJJ(addr2, pk, tokenID0)
idxR, err = sdb.GetIdxByEthAddrBJJ(addr2, pk.Compress(), tokenID0)
assert.NotNil(t, err)
assert.Equal(t, common.Idx(0), idxR)
idxR, err = sdb.GetIdxByEthAddrBJJ(addr, pk2, tokenID0)
idxR, err = sdb.GetIdxByEthAddrBJJ(addr, pk2.Compress(), tokenID0)
assert.NotNil(t, err)
assert.Equal(t, common.Idx(0), idxR)
// try to store bigger idx, will not affect as already exist a smaller
// Idx for that Addr & BJJ
err = sdb.setIdxByEthAddrBJJ(idx2, addr, pk, tokenID0)
assert.Nil(t, err)
err = sdb.setIdxByEthAddrBJJ(idx2, addr, pk.Compress(), tokenID0)
assert.NoError(t, err)
// store smaller idx
err = sdb.setIdxByEthAddrBJJ(idx3, addr, pk, tokenID0)
assert.Nil(t, err)
err = sdb.setIdxByEthAddrBJJ(idx3, addr, pk.Compress(), tokenID0)
assert.NoError(t, err)
idxR, err = sdb.GetIdxByEthAddrBJJ(addr, pk, tokenID0)
assert.Nil(t, err)
idxR, err = sdb.GetIdxByEthAddrBJJ(addr, pk.Compress(), tokenID0)
assert.NoError(t, err)
assert.Equal(t, idx3, idxR)
// by EthAddr should work
idxR, err = sdb.GetIdxByEthAddr(addr, tokenID0)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, idx3, idxR)
// expect error when trying to get Idx by addr2 & pk2
idxR, err = sdb.GetIdxByEthAddrBJJ(addr2, pk2, tokenID0)
idxR, err = sdb.GetIdxByEthAddrBJJ(addr2, pk2.Compress(), tokenID0)
assert.NotNil(t, err)
expectedErr := fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", ErrToIdxNotFound, addr2.Hex(), pk2, tokenID0)
assert.Equal(t, expectedErr, tracerr.Unwrap(err))

239
db/statedb/zkinputsgen_test.go
View File

File diff suppressed because one or more lines are too long