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 TestCircomTest(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, 8)
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: 8,
518 MaxFeeTx: 2,
519 MaxTx: 5,
520 MaxL1Tx: 2,
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 s, err := json.Marshal(ptOut.ZKInputs)
537 require.Nil(t, err)
538 debug := false
539 if debug {
540 fmt.Println("\nCopy&Paste into js circom test:\n let zkInput = JSON.parse(`" + string(s) + "`);")
541
542 h, err := ptOut.ZKInputs.HashGlobalData()
543 require.Nil(t, err)
544 fmt.Printf(`
545 const output={
546 hashGlobalInputs: "%s",
547 };
548 await circuit.assertOut(w, output);
549 `, h.String())
550 fmt.Println("")
551 }
552}
553
554func TestZKInputsHashTestVector0(t *testing.T) {
555 dir, err := ioutil.TempDir("", "tmpdb")
556 require.Nil(t, err)
557 defer assert.Nil(t, os.RemoveAll(dir))
558
559 sdb, err := NewStateDB(dir, TypeBatchBuilder, 32)
560 assert.Nil(t, err)
561
562 // same values than in the js test
563 bjj0, err := common.BJJFromStringWithChecksum("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7")
564 assert.Nil(t, err)
565 l1Txs := []common.L1Tx{
566 {
567 FromIdx: 0,
568 // LoadAmount: big.NewInt(10400),
569 LoadAmount: big.NewInt(16000000),
570 Amount: big.NewInt(0),
571 TokenID: 1,
572 FromBJJ: bjj0,
573 FromEthAddr: ethCommon.HexToAddress("0x7e5f4552091a69125d5dfcb7b8c2659029395bdf"),
574 ToIdx: 0,
575 Type: common.TxTypeCreateAccountDeposit,
576 },
577 }
578 l2Txs := []common.PoolL2Tx{
579 {
580 FromIdx: 256,
581 ToIdx: 256,
582 TokenID: 1,
583 Amount: big.NewInt(1000),
584 Nonce: 0,
585 Fee: 126,
586 Type: common.TxTypeTransfer,
587 },
588 }
589
590 ptc := ProcessTxsConfig{
591 NLevels: 32,
592 MaxFeeTx: 8,
593 MaxTx: 32,
594 MaxL1Tx: 16,
595 }
596 ptOut, err := sdb.ProcessTxs(ptc, nil, l1Txs, nil, l2Txs)
597 require.Nil(t, err)
598
599 // check expected account keys values from tx inputs
600 acc, err := sdb.GetAccount(common.Idx(256))
601 require.Nil(t, err)
602 assert.Equal(t, "d746824f7d0ac5044a573f51b278acb56d823bec39551d1d7bf7378b68a1b021", acc.PublicKey.Compress().String())
603 assert.Equal(t, "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf", acc.EthAddr.Hex())
604
605 // check that there no exist more accounts
606 _, err = sdb.GetAccount(common.Idx(257))
607 require.NotNil(t, err)
608 ptOut.ZKInputs.FeeIdxs[0] = common.Idx(256).BigInt()
609
610 toHash, err := ptOut.ZKInputs.ToHashGlobalData()
611 assert.Nil(t, err)
612 // value from js test vector
613 expectedToHash := "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"
614 // checks are splitted to find the difference easier
615 assert.Equal(t, expectedToHash[:1000], hex.EncodeToString(toHash)[:1000])
616 assert.Equal(t, expectedToHash[1000:2000], hex.EncodeToString(toHash)[1000:2000])
617 assert.Equal(t, expectedToHash[2000:], hex.EncodeToString(toHash)[2000:])
618
619 h, err := ptOut.ZKInputs.HashGlobalData()
620 require.Nil(t, err)
621 // value from js test vector
622 assert.Equal(t, "80757288244566854497474223360206077562032050734432637237701187686677568506", h.String())
623}
624
625func TestZKInputsHashTestVector1(t *testing.T) {
626 dir, err := ioutil.TempDir("", "tmpdb")
627 require.Nil(t, err)
628 defer assert.Nil(t, os.RemoveAll(dir))
629
630 sdb, err := NewStateDB(dir, TypeBatchBuilder, 32)
631 assert.Nil(t, err)
632
633 // same values than in the js test
634 bjj0, err := common.BJJFromStringWithChecksum("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7")
635 assert.Nil(t, err)
636 bjj1, err := common.BJJFromStringWithChecksum("093985b1993d9f743f9d7d943ed56f38601cb8b196db025f79650c4007c3054d")
637 assert.Nil(t, err)
638 l1Txs := []common.L1Tx{
639 {
640 FromIdx: 0,
641 // LoadAmount: big.NewInt(10400),
642 LoadAmount: big.NewInt(16000000),
643 Amount: big.NewInt(0),
644 TokenID: 1,
645 FromBJJ: bjj0,
646 FromEthAddr: ethCommon.HexToAddress("0x7e5f4552091a69125d5dfcb7b8c2659029395bdf"),
647 ToIdx: 0,
648 Type: common.TxTypeCreateAccountDeposit,
649 },
650 {
651 FromIdx: 0,
652 LoadAmount: big.NewInt(16000000),
653 Amount: big.NewInt(0),
654 TokenID: 1,
655 FromBJJ: bjj1,
656 FromEthAddr: ethCommon.HexToAddress("0x2b5ad5c4795c026514f8317c7a215e218dccd6cf"),
657 ToIdx: 0,
658 Type: common.TxTypeCreateAccountDeposit,
659 },
660 }
661 l2Txs := []common.PoolL2Tx{
662 {
663 FromIdx: 257,
664 ToIdx: 256,
665 TokenID: 1,
666 Amount: big.NewInt(1000),
667 Nonce: 0,
668 Fee: 137,
669 Type: common.TxTypeTransfer,
670 },
671 }
672
673 ptc := ProcessTxsConfig{
674 NLevels: 32,
675 MaxFeeTx: 8,
676 MaxTx: 32,
677 MaxL1Tx: 16,
678 }
679 ptOut, err := sdb.ProcessTxs(ptc, nil, l1Txs, nil, l2Txs)
680 require.Nil(t, err)
681
682 // check expected account keys values from tx inputs
683 acc, err := sdb.GetAccount(common.Idx(256))
684 require.Nil(t, err)
685 assert.Equal(t, "d746824f7d0ac5044a573f51b278acb56d823bec39551d1d7bf7378b68a1b021", acc.PublicKey.Compress().String())
686 assert.Equal(t, "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf", acc.EthAddr.Hex())
687 acc, err = sdb.GetAccount(common.Idx(257))
688 require.Nil(t, err)
689 assert.Equal(t, "4d05c307400c65795f02db96b1b81c60386fd53e947d9d3f749f3d99b1853909", acc.PublicKey.Compress().String())
690 assert.Equal(t, "0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF", acc.EthAddr.Hex())
691
692 // check that there no exist more accounts
693 _, err = sdb.GetAccount(common.Idx(258))
694 require.NotNil(t, err)
695 ptOut.ZKInputs.FeeIdxs[0] = common.Idx(257).BigInt()
696
697 toHash, err := ptOut.ZKInputs.ToHashGlobalData()
698 assert.Nil(t, err)
699 // value from js test vector
700 expectedToHash := "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"
701 // checks are splitted to find the difference easier
702 assert.Equal(t, expectedToHash[:1000], hex.EncodeToString(toHash)[:1000])
703 assert.Equal(t, expectedToHash[1000:2000], hex.EncodeToString(toHash)[1000:2000])
704 assert.Equal(t, expectedToHash[2000:], hex.EncodeToString(toHash)[2000:])
705
706 h, err := ptOut.ZKInputs.HashGlobalData()
707 require.Nil(t, err)
708 // value from js test vector
709 assert.Equal(t, "10900521462378877053056992084240080637954406133884857263674494661625916419481", h.String())
710}