hermez-node/db/statedb/txprocessors_test.go
db/statedb/txprocessors_test.goRaw
1package statedb
2
3import (
4 "encoding/hex"
5 "encoding/json"
6 "fmt"
7 "io/ioutil"
8 "math/big"
9 "os"
10 "testing"
11
12 ethCommon "github.com/ethereum/go-ethereum/common"
13 "github.com/hermeznetwork/hermez-node/common"
14 "github.com/hermeznetwork/hermez-node/log"
15 "github.com/hermeznetwork/hermez-node/test/til"
16 "github.com/stretchr/testify/assert"
17 "github.com/stretchr/testify/require"
18)
19
20func checkBalance(t *testing.T, tc *til.Context, sdb *StateDB, username string, tokenid int, expected string) {
21 idx := tc.Users[username].Accounts[common.TokenID(tokenid)].Idx
22 acc, err := sdb.GetAccount(idx)
23 require.Nil(t, err)
24 assert.Equal(t, expected, acc.Balance.String())
25}
26
27func TestProcessTxsBalances(t *testing.T) {
28 dir, err := ioutil.TempDir("", "tmpdb")
29 require.Nil(t, err)
30 defer assert.Nil(t, os.RemoveAll(dir))
31
32 sdb, err := NewStateDB(dir, TypeSynchronizer, 32)
33 assert.Nil(t, err)
34
35 // generate test transactions from test.SetBlockchain0 code
36 tc := til.NewContext(common.RollupConstMaxL1UserTx)
37 blocks, err := tc.GenerateBlocks(til.SetBlockchainMinimumFlow0)
38 require.Nil(t, err)
39
40 // Coordinator Idx where to send the fees
41 coordIdxs := []common.Idx{256, 257}
42 ptc := ProcessTxsConfig{
43 NLevels: 32,
44 MaxFeeTx: 64,
45 MaxTx: 512,
46 MaxL1Tx: 16,
47 }
48
49 log.Debug("block:0 batch:0, only L1CoordinatorTxs")
50 _, err = sdb.ProcessTxs(ptc, nil, nil, blocks[0].Rollup.Batches[0].L1CoordinatorTxs, nil)
51 require.Nil(t, err)
52
53 log.Debug("block:0 batch:1")
54 l1UserTxs := []common.L1Tx{}
55 l2Txs := common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[1].L2Txs)
56 _, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
57 require.Nil(t, err)
58
59 log.Debug("block:0 batch:2")
60 l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[2].Batch.ForgeL1TxsNum])
61 l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[2].L2Txs)
62 _, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[2].L1CoordinatorTxs, l2Txs)
63 require.Nil(t, err)
64 checkBalance(t, tc, sdb, "A", 0, "500")
65
66 log.Debug("block:0 batch:3")
67 l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[3].Batch.ForgeL1TxsNum])
68 l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[3].L2Txs)
69 _, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[3].L1CoordinatorTxs, l2Txs)
70 require.Nil(t, err)
71 checkBalance(t, tc, sdb, "A", 0, "500")
72 checkBalance(t, tc, sdb, "A", 1, "500")
73
74 log.Debug("block:0 batch:4")
75 l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[4].Batch.ForgeL1TxsNum])
76 l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[4].L2Txs)
77 _, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[4].L1CoordinatorTxs, l2Txs)
78 require.Nil(t, err)
79 checkBalance(t, tc, sdb, "A", 0, "500")
80 checkBalance(t, tc, sdb, "A", 1, "500")
81
82 log.Debug("block:0 batch:5")
83 l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[5].Batch.ForgeL1TxsNum])
84 l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[5].L2Txs)
85 _, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[5].L1CoordinatorTxs, l2Txs)
86 require.Nil(t, err)
87 checkBalance(t, tc, sdb, "A", 0, "600")
88 checkBalance(t, tc, sdb, "A", 1, "500")
89 checkBalance(t, tc, sdb, "B", 0, "400")
90
91 log.Debug("block:0 batch:6")
92 l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[6].Batch.ForgeL1TxsNum])
93 l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[6].L2Txs)
94 _, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[6].L1CoordinatorTxs, l2Txs)
95 require.Nil(t, err)
96 checkBalance(t, tc, sdb, "Coord", 0, "10")
97 checkBalance(t, tc, sdb, "Coord", 1, "20")
98 checkBalance(t, tc, sdb, "A", 0, "600")
99 checkBalance(t, tc, sdb, "A", 1, "280")
100 checkBalance(t, tc, sdb, "B", 0, "290")
101 checkBalance(t, tc, sdb, "B", 1, "200")
102 checkBalance(t, tc, sdb, "C", 0, "100")
103 checkBalance(t, tc, sdb, "D", 0, "800")
104
105 log.Debug("block:0 batch:7")
106 l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[7].Batch.ForgeL1TxsNum])
107 l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[7].L2Txs)
108 _, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[7].L1CoordinatorTxs, l2Txs)
109 require.Nil(t, err)
110 checkBalance(t, tc, sdb, "Coord", 0, "35")
111 checkBalance(t, tc, sdb, "Coord", 1, "30")
112 checkBalance(t, tc, sdb, "A", 0, "430")
113 checkBalance(t, tc, sdb, "A", 1, "280")
114 checkBalance(t, tc, sdb, "B", 0, "390")
115 checkBalance(t, tc, sdb, "B", 1, "90")
116 checkBalance(t, tc, sdb, "C", 0, "45")
117 checkBalance(t, tc, sdb, "C", 1, "100")
118 checkBalance(t, tc, sdb, "D", 0, "800")
119
120 log.Debug("block:1 batch:0")
121 l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[1].Rollup.Batches[0].Batch.ForgeL1TxsNum])
122 l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[0].L2Txs)
123 _, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[1].Rollup.Batches[0].L1CoordinatorTxs, l2Txs)
124 require.Nil(t, err)
125 checkBalance(t, tc, sdb, "Coord", 0, "75")
126 checkBalance(t, tc, sdb, "Coord", 1, "30")
127 checkBalance(t, tc, sdb, "A", 0, "730")
128 checkBalance(t, tc, sdb, "A", 1, "280")
129 checkBalance(t, tc, sdb, "B", 0, "380")
130 checkBalance(t, tc, sdb, "B", 1, "90")
131 checkBalance(t, tc, sdb, "C", 0, "845")
132 checkBalance(t, tc, sdb, "C", 1, "100")
133 checkBalance(t, tc, sdb, "D", 0, "470")
134
135 log.Debug("block:1 batch:1")
136 l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[1].Rollup.Batches[1].Batch.ForgeL1TxsNum])
137 l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[1].L2Txs)
138 _, err = sdb.ProcessTxs(ptc, coordIdxs, l1UserTxs, blocks[1].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
139 require.Nil(t, err)
140
141 // use Set of PoolL2 txs
142 poolL2Txs, err := tc.GeneratePoolL2Txs(til.SetPoolL2MinimumFlow0)
143 assert.Nil(t, err)
144
145 _, err = sdb.ProcessTxs(ptc, coordIdxs, []common.L1Tx{}, []common.L1Tx{}, poolL2Txs)
146 require.Nil(t, err)
147 checkBalance(t, tc, sdb, "Coord", 0, "105")
148 checkBalance(t, tc, sdb, "Coord", 1, "40")
149 checkBalance(t, tc, sdb, "A", 0, "510")
150 checkBalance(t, tc, sdb, "A", 1, "170")
151 checkBalance(t, tc, sdb, "B", 0, "480")
152 checkBalance(t, tc, sdb, "B", 1, "190")
153 checkBalance(t, tc, sdb, "C", 0, "845")
154 checkBalance(t, tc, sdb, "C", 1, "100")
155 checkBalance(t, tc, sdb, "D", 0, "360")
156 checkBalance(t, tc, sdb, "F", 0, "100")
157}
158
159func TestProcessTxsSynchronizer(t *testing.T) {
160 dir, err := ioutil.TempDir("", "tmpdb")
161 require.Nil(t, err)
162 defer assert.Nil(t, os.RemoveAll(dir))
163
164 sdb, err := NewStateDB(dir, TypeSynchronizer, 32)
165 assert.Nil(t, err)
166
167 // generate test transactions from test.SetBlockchain0 code
168 tc := til.NewContext(common.RollupConstMaxL1UserTx)
169 blocks, err := tc.GenerateBlocks(til.SetBlockchain0)
170 require.Nil(t, err)
171
172 assert.Equal(t, 31, len(blocks[0].Rollup.L1UserTxs))
173 assert.Equal(t, 4, len(blocks[0].Rollup.Batches[0].L1CoordinatorTxs))
174 assert.Equal(t, 0, len(blocks[0].Rollup.Batches[1].L1CoordinatorTxs))
175 assert.Equal(t, 22, len(blocks[0].Rollup.Batches[2].L2Txs))
176 assert.Equal(t, 1, len(blocks[1].Rollup.Batches[0].L1CoordinatorTxs))
177 assert.Equal(t, 62, len(blocks[1].Rollup.Batches[0].L2Txs))
178 assert.Equal(t, 1, len(blocks[1].Rollup.Batches[1].L1CoordinatorTxs))
179 assert.Equal(t, 8, len(blocks[1].Rollup.Batches[1].L2Txs))
180
181 // Coordinator Idx where to send the fees
182 coordIdxs := []common.Idx{256, 257, 258, 259}
183
184 // Idx of user 'A'
185 idxA1 := tc.Users["A"].Accounts[common.TokenID(1)].Idx
186
187 ptc := ProcessTxsConfig{
188 NLevels: 32,
189 MaxFeeTx: 64,
190 MaxTx: 512,
191 MaxL1Tx: 16,
192 }
193
194 // Process the 1st batch, which contains the L1CoordinatorTxs necessary
195 // to create the Coordinator accounts to receive the fees
196 log.Debug("block:0 batch:0, only L1CoordinatorTxs")
197 ptOut, err := sdb.ProcessTxs(ptc, nil, nil, blocks[0].Rollup.Batches[0].L1CoordinatorTxs, nil)
198 require.Nil(t, err)
199 assert.Equal(t, 4, len(ptOut.CreatedAccounts))
200 assert.Equal(t, 0, len(ptOut.CollectedFees))
201
202 log.Debug("block:0 batch:1")
203 l2Txs := common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[1].L2Txs)
204 ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, blocks[0].Rollup.L1UserTxs,
205 blocks[0].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
206 require.Nil(t, err)
207 assert.Equal(t, 0, len(ptOut.ExitInfos))
208 assert.Equal(t, 31, len(ptOut.CreatedAccounts))
209 assert.Equal(t, 4, len(ptOut.CollectedFees))
210 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(0)].String())
211 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(1)].String())
212 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(2)].String())
213 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(3)].String())
214 acc, err := sdb.GetAccount(idxA1)
215 require.Nil(t, err)
216 assert.Equal(t, "50", acc.Balance.String())
217
218 log.Debug("block:0 batch:2")
219 l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[2].L2Txs)
220 ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, nil, blocks[0].Rollup.Batches[2].L1CoordinatorTxs, l2Txs)
221 require.Nil(t, err)
222 assert.Equal(t, 0, len(ptOut.ExitInfos))
223 assert.Equal(t, 0, len(ptOut.CreatedAccounts))
224 assert.Equal(t, 4, len(ptOut.CollectedFees))
225 assert.Equal(t, "2", ptOut.CollectedFees[common.TokenID(0)].String())
226 assert.Equal(t, "1", ptOut.CollectedFees[common.TokenID(1)].String())
227 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(2)].String())
228 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(3)].String())
229 acc, err = sdb.GetAccount(idxA1)
230 require.Nil(t, err)
231 assert.Equal(t, "35", acc.Balance.String())
232
233 log.Debug("block:1 batch:0")
234 l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[0].L2Txs)
235 // before processing expect l2Txs[0:2].Nonce==0
236 assert.Equal(t, common.Nonce(0), l2Txs[0].Nonce)
237 assert.Equal(t, common.Nonce(0), l2Txs[1].Nonce)
238 assert.Equal(t, common.Nonce(0), l2Txs[2].Nonce)
239
240 ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, nil, blocks[1].Rollup.Batches[0].L1CoordinatorTxs, l2Txs)
241 require.Nil(t, err)
242
243 // after processing expect l2Txs[0:2].Nonce!=0 and has expected value
244 assert.Equal(t, common.Nonce(6), l2Txs[0].Nonce)
245 assert.Equal(t, common.Nonce(7), l2Txs[1].Nonce)
246 assert.Equal(t, common.Nonce(8), l2Txs[2].Nonce)
247
248 assert.Equal(t, 4, len(ptOut.ExitInfos)) // the 'ForceExit(1)' is not computed yet, as the batch is without L1UserTxs
249 assert.Equal(t, 1, len(ptOut.CreatedAccounts))
250 assert.Equal(t, 4, len(ptOut.CollectedFees))
251 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(0)].String())
252 assert.Equal(t, "1", ptOut.CollectedFees[common.TokenID(1)].String())
253 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(2)].String())
254 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(3)].String())
255 acc, err = sdb.GetAccount(idxA1)
256 require.Nil(t, err)
257 assert.Equal(t, "57", acc.Balance.String())
258
259 log.Debug("block:1 batch:1")
260 l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[1].L2Txs)
261 ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, blocks[1].Rollup.L1UserTxs,
262 blocks[1].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
263 require.Nil(t, err)
264
265 assert.Equal(t, 2, len(ptOut.ExitInfos)) // 2, as previous batch was without L1UserTxs, and has pending the 'ForceExit(1) A: 5'
266 assert.Equal(t, 1, len(ptOut.CreatedAccounts))
267 assert.Equal(t, 4, len(ptOut.CollectedFees))
268 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(0)].String())
269 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(1)].String())
270 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(2)].String())
271 assert.Equal(t, "0", ptOut.CollectedFees[common.TokenID(3)].String())
272 acc, err = sdb.GetAccount(idxA1)
273 assert.Nil(t, err)
274 assert.Equal(t, "77", acc.Balance.String())
275
276 idxB0 := tc.Users["C"].Accounts[common.TokenID(0)].Idx
277 acc, err = sdb.GetAccount(idxB0)
278 require.Nil(t, err)
279 assert.Equal(t, "51", acc.Balance.String())
280
281 // get balance of Coordinator account for TokenID==0
282 acc, err = sdb.GetAccount(common.Idx(256))
283 require.Nil(t, err)
284 assert.Equal(t, "2", acc.Balance.String())
285}
286
287func TestProcessTxsBatchBuilder(t *testing.T) {
288 dir, err := ioutil.TempDir("", "tmpdb")
289 require.Nil(t, err)
290 defer assert.Nil(t, os.RemoveAll(dir))
291
292 sdb, err := NewStateDB(dir, TypeBatchBuilder, 32)
293 assert.Nil(t, err)
294
295 // generate test transactions from test.SetBlockchain0 code
296 tc := til.NewContext(common.RollupConstMaxL1UserTx)
297 blocks, err := tc.GenerateBlocks(til.SetBlockchain0)
298 require.Nil(t, err)
299
300 // Coordinator Idx where to send the fees
301 coordIdxs := []common.Idx{256, 257, 258, 259}
302
303 // Idx of user 'A'
304 idxA1 := tc.Users["A"].Accounts[common.TokenID(1)].Idx
305
306 ptc := ProcessTxsConfig{
307 NLevels: 32,
308 MaxFeeTx: 64,
309 MaxTx: 512,
310 MaxL1Tx: 32,
311 }
312
313 // Process the 1st batch, which contains the L1CoordinatorTxs necessary
314 // to create the Coordinator accounts to receive the fees
315 log.Debug("block:0 batch:0, only L1CoordinatorTxs")
316 ptOut, err := sdb.ProcessTxs(ptc, nil, nil, blocks[0].Rollup.Batches[0].L1CoordinatorTxs, nil)
317 require.Nil(t, err)
318 // expect 0 at CreatedAccount, as is only computed when StateDB.Type==TypeSynchronizer
319 assert.Equal(t, 0, len(ptOut.CreatedAccounts))
320
321 log.Debug("block:0 batch:1")
322 l2Txs := common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[1].L2Txs)
323 ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, blocks[0].Rollup.L1UserTxs, blocks[0].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
324 require.Nil(t, err)
325 assert.Equal(t, 0, len(ptOut.ExitInfos))
326 assert.Equal(t, 0, len(ptOut.CreatedAccounts))
327 acc, err := sdb.GetAccount(idxA1)
328 require.Nil(t, err)
329 assert.Equal(t, "50", acc.Balance.String())
330
331 log.Debug("block:0 batch:2")
332 l2Txs = common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[2].L2Txs)
333 ptOut, err = sdb.ProcessTxs(ptc, coordIdxs, nil, blocks[0].Rollup.Batches[2].L1CoordinatorTxs, l2Txs)
334 require.Nil(t, err)
335 assert.Equal(t, 0, len(ptOut.ExitInfos))
336 assert.Equal(t, 0, len(ptOut.CreatedAccounts))
337 acc, err = sdb.GetAccount(idxA1)
338 require.Nil(t, err)
339 assert.Equal(t, "35", acc.Balance.String())
340
341 log.Debug("block:1 batch:0")
342 l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[0].L2Txs)
343 _, err = sdb.ProcessTxs(ptc, coordIdxs, nil, blocks[1].Rollup.Batches[0].L1CoordinatorTxs, l2Txs)
344 require.Nil(t, err)
345 acc, err = sdb.GetAccount(idxA1)
346 require.Nil(t, err)
347 assert.Equal(t, "57", acc.Balance.String())
348
349 log.Debug("block:1 batch:1")
350 l2Txs = common.L2TxsToPoolL2Txs(blocks[1].Rollup.Batches[1].L2Txs)
351 _, err = sdb.ProcessTxs(ptc, coordIdxs, blocks[1].Rollup.L1UserTxs, blocks[1].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
352 require.Nil(t, err)
353 acc, err = sdb.GetAccount(idxA1)
354 assert.Nil(t, err)
355 assert.Equal(t, "77", acc.Balance.String())
356
357 idxB0 := tc.Users["C"].Accounts[common.TokenID(0)].Idx
358 acc, err = sdb.GetAccount(idxB0)
359 require.Nil(t, err)
360 assert.Equal(t, "51", acc.Balance.String())
361
362 // get balance of Coordinator account for TokenID==0
363 acc, err = sdb.GetAccount(common.Idx(256))
364 require.Nil(t, err)
365 assert.Equal(t, common.TokenID(0), acc.TokenID)
366 assert.Equal(t, "2", acc.Balance.String())
367 acc, err = sdb.GetAccount(common.Idx(257))
368 require.Nil(t, err)
369 assert.Equal(t, common.TokenID(1), acc.TokenID)
370 assert.Equal(t, "2", acc.Balance.String())
371}
372
373func TestZKInputsGeneration(t *testing.T) {
374 dir, err := ioutil.TempDir("", "tmpdb")
375 require.Nil(t, err)
376 defer assert.Nil(t, os.RemoveAll(dir))
377
378 sdb, err := NewStateDB(dir, TypeBatchBuilder, 4)
379 assert.Nil(t, err)
380
381 set := `
382 Type: Blockchain
383 AddToken(1)
384 CreateAccountDeposit(1) A: 10
385 > batchL1
386 CreateAccountCoordinator(1) B
387 CreateAccountCoordinator(1) C
388 > batchL1
389 // idxs: A:258, B:256, C:257
390
391 Transfer(1) A-B: 6 (1)
392 Transfer(1) A-C: 2 (1)
393 > batch
394 > block
395 `
396 // generate test transactions from test.SetBlockchain0 code
397 tc := til.NewContext(common.RollupConstMaxL1UserTx)
398 blocks, err := tc.GenerateBlocks(set)
399 require.Nil(t, err)
400
401 // Coordinator Idx where to send the fees
402 coordIdxs := []common.Idx{256}
403
404 ptc := ProcessTxsConfig{
405 NLevels: 32,
406 MaxFeeTx: 8,
407 MaxTx: 32,
408 MaxL1Tx: 16,
409 }
410
411 log.Debug("block:0 batch:0, only L1UserTx")
412 _, err = sdb.ProcessTxs(ptc, nil, blocks[0].Rollup.L1UserTxs, nil, nil)
413 require.Nil(t, err)
414
415 log.Debug("block:0 batch:1, only L1CoordinatorTxs")
416 _, err = sdb.ProcessTxs(ptc, nil, nil, blocks[0].Rollup.Batches[1].L1CoordinatorTxs, nil)
417 require.Nil(t, err)
418
419 log.Debug("block:0 batch:2, only L2Txs")
420 l2Txs := common.L2TxsToPoolL2Txs(blocks[0].Rollup.Batches[2].L2Txs)
421 ptOut, err := sdb.ProcessTxs(ptc, coordIdxs, nil, nil, l2Txs)
422 require.Nil(t, err)
423 checkBalance(t, tc, sdb, "A", 1, "2")
424
425 s, err := json.Marshal(ptOut.ZKInputs)
426 require.Nil(t, err)
427 debug := false
428 debug = true
429 if debug {
430 fmt.Println(string(s))
431 }
432}
433
434func TestProcessTxsRootTestVectors(t *testing.T) {
435 dir, err := ioutil.TempDir("", "tmpdb")
436 require.Nil(t, err)
437 defer assert.Nil(t, os.RemoveAll(dir))
438
439 sdb, err := NewStateDB(dir, TypeBatchBuilder, 32)
440 assert.Nil(t, err)
441
442 // same values than in the js test
443 bjj0, err := common.BJJFromStringWithChecksum("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7")
444 assert.Nil(t, err)
445 l1Txs := []common.L1Tx{
446 {
447 FromIdx: 0,
448 LoadAmount: big.NewInt(16000000),
449 Amount: big.NewInt(0),
450 TokenID: 1,
451 FromBJJ: bjj0,
452 FromEthAddr: ethCommon.HexToAddress("0x7e5f4552091a69125d5dfcb7b8c2659029395bdf"),
453 ToIdx: 0,
454 Type: common.TxTypeCreateAccountDeposit,
455 },
456 }
457 l2Txs := []common.PoolL2Tx{
458 {
459 FromIdx: 256,
460 ToIdx: 256,
461 TokenID: 1,
462 Amount: big.NewInt(1000),
463 Nonce: 0,
464 Fee: 126,
465 Type: common.TxTypeTransfer,
466 },
467 }
468
469 ptc := ProcessTxsConfig{
470 NLevels: 32,
471 MaxFeeTx: 8,
472 MaxTx: 32,
473 MaxL1Tx: 16,
474 }
475 _, err = sdb.ProcessTxs(ptc, nil, l1Txs, nil, l2Txs)
476 require.Nil(t, err)
477 assert.Equal(t, "9827704113668630072730115158977131501210702363656902211840117643154933433410", sdb.mt.Root().BigInt().String())
478}
479
480func TestZKInputsHashTestVector0(t *testing.T) {
481 dir, err := ioutil.TempDir("", "tmpdb")
482 require.Nil(t, err)
483 defer assert.Nil(t, os.RemoveAll(dir))
484
485 sdb, err := NewStateDB(dir, TypeBatchBuilder, 32)
486 assert.Nil(t, err)
487
488 // same values than in the js test
489 bjj0, err := common.BJJFromStringWithChecksum("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7")
490 assert.Nil(t, err)
491 l1Txs := []common.L1Tx{
492 {
493 FromIdx: 0,
494 // LoadAmount: big.NewInt(10400),
495 LoadAmount: big.NewInt(16000000),
496 Amount: big.NewInt(0),
497 TokenID: 1,
498 FromBJJ: bjj0,
499 FromEthAddr: ethCommon.HexToAddress("0x7e5f4552091a69125d5dfcb7b8c2659029395bdf"),
500 ToIdx: 0,
501 Type: common.TxTypeCreateAccountDeposit,
502 },
503 }
504 l2Txs := []common.PoolL2Tx{
505 {
506 FromIdx: 256,
507 ToIdx: 256,
508 TokenID: 1,
509 Amount: big.NewInt(1000),
510 Nonce: 0,
511 Fee: 126,
512 Type: common.TxTypeTransfer,
513 },
514 }
515
516 ptc := ProcessTxsConfig{
517 NLevels: 32,
518 MaxFeeTx: 8,
519 MaxTx: 32,
520 MaxL1Tx: 16,
521 }
522 ptOut, err := sdb.ProcessTxs(ptc, nil, l1Txs, nil, l2Txs)
523 require.Nil(t, err)
524
525 // check expected account keys values from tx inputs
526 acc, err := sdb.GetAccount(common.Idx(256))
527 require.Nil(t, err)
528 assert.Equal(t, "d746824f7d0ac5044a573f51b278acb56d823bec39551d1d7bf7378b68a1b021", acc.PublicKey.Compress().String())
529 assert.Equal(t, "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf", acc.EthAddr.Hex())
530
531 // check that there no exist more accounts
532 _, err = sdb.GetAccount(common.Idx(257))
533 require.NotNil(t, err)
534 ptOut.ZKInputs.FeeIdxs[0] = common.Idx(256).BigInt()
535
536 toHash, err := ptOut.ZKInputs.ToHashGlobalData()
537 assert.Nil(t, err)
538 // value from js test vector
539 expectedToHash := "0000000000ff000000000100000000000000000000000000000000000000000000000000000000000000000015ba488d749f6b891d29d0bf3a72481ec812e4d4ecef2bf7a3fc64f3c010444200000000000000000000000000000000000000000000000000000000000000007e5f4552091a69125d5dfcb7b8c2659029395bdf21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d700000000000028a00000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000010003e87e00000100000000000000000000000000000000000000000000000000000000000000"
540 // checks are splitted to find the difference easier
541 assert.Equal(t, expectedToHash[:1000], hex.EncodeToString(toHash)[:1000])
542 assert.Equal(t, expectedToHash[1000:2000], hex.EncodeToString(toHash)[1000:2000])
543 assert.Equal(t, expectedToHash[2000:], hex.EncodeToString(toHash)[2000:])
544
545 h, err := ptOut.ZKInputs.HashGlobalData()
546 require.Nil(t, err)
547 // value from js test vector
548 assert.Equal(t, "80757288244566854497474223360206077562032050734432637237701187686677568506", h.String())
549}
550
551func TestZKInputsHashTestVector1(t *testing.T) {
552 dir, err := ioutil.TempDir("", "tmpdb")
553 require.Nil(t, err)
554 defer assert.Nil(t, os.RemoveAll(dir))
555
556 sdb, err := NewStateDB(dir, TypeBatchBuilder, 32)
557 assert.Nil(t, err)
558
559 // same values than in the js test
560 bjj0, err := common.BJJFromStringWithChecksum("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7")
561 assert.Nil(t, err)
562 bjj1, err := common.BJJFromStringWithChecksum("093985b1993d9f743f9d7d943ed56f38601cb8b196db025f79650c4007c3054d")
563 assert.Nil(t, err)
564 l1Txs := []common.L1Tx{
565 {
566 FromIdx: 0,
567 // LoadAmount: big.NewInt(10400),
568 LoadAmount: big.NewInt(16000000),
569 Amount: big.NewInt(0),
570 TokenID: 1,
571 FromBJJ: bjj0,
572 FromEthAddr: ethCommon.HexToAddress("0x7e5f4552091a69125d5dfcb7b8c2659029395bdf"),
573 ToIdx: 0,
574 Type: common.TxTypeCreateAccountDeposit,
575 },
576 {
577 FromIdx: 0,
578 LoadAmount: big.NewInt(16000000),
579 Amount: big.NewInt(0),
580 TokenID: 1,
581 FromBJJ: bjj1,
582 FromEthAddr: ethCommon.HexToAddress("0x2b5ad5c4795c026514f8317c7a215e218dccd6cf"),
583 ToIdx: 0,
584 Type: common.TxTypeCreateAccountDeposit,
585 },
586 }
587 l2Txs := []common.PoolL2Tx{
588 {
589 FromIdx: 257,
590 ToIdx: 256,
591 TokenID: 1,
592 Amount: big.NewInt(1000),
593 Nonce: 0,
594 Fee: 137,
595 Type: common.TxTypeTransfer,
596 },
597 }
598
599 ptc := ProcessTxsConfig{
600 NLevels: 32,
601 MaxFeeTx: 8,
602 MaxTx: 32,
603 MaxL1Tx: 16,
604 }
605 ptOut, err := sdb.ProcessTxs(ptc, nil, l1Txs, nil, l2Txs)
606 require.Nil(t, err)
607
608 // check expected account keys values from tx inputs
609 acc, err := sdb.GetAccount(common.Idx(256))
610 require.Nil(t, err)
611 assert.Equal(t, "d746824f7d0ac5044a573f51b278acb56d823bec39551d1d7bf7378b68a1b021", acc.PublicKey.Compress().String())
612 assert.Equal(t, "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf", acc.EthAddr.Hex())
613 acc, err = sdb.GetAccount(common.Idx(257))
614 require.Nil(t, err)
615 assert.Equal(t, "4d05c307400c65795f02db96b1b81c60386fd53e947d9d3f749f3d99b1853909", acc.PublicKey.Compress().String())
616 assert.Equal(t, "0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF", acc.EthAddr.Hex())
617
618 // check that there no exist more accounts
619 _, err = sdb.GetAccount(common.Idx(258))
620 require.NotNil(t, err)
621 ptOut.ZKInputs.FeeIdxs[0] = common.Idx(257).BigInt()
622
623 toHash, err := ptOut.ZKInputs.ToHashGlobalData()
624 assert.Nil(t, err)
625 // value from js test vector
626 expectedToHash := "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"
627 // checks are splitted to find the difference easier
628 assert.Equal(t, expectedToHash[:1000], hex.EncodeToString(toHash)[:1000])
629 assert.Equal(t, expectedToHash[1000:2000], hex.EncodeToString(toHash)[1000:2000])
630 assert.Equal(t, expectedToHash[2000:], hex.EncodeToString(toHash)[2000:])
631
632 h, err := ptOut.ZKInputs.HashGlobalData()
633 require.Nil(t, err)
634 // value from js test vector
635 assert.Equal(t, "10900521462378877053056992084240080637954406133884857263674494661625916419481", h.String())
636}