hermez-node/synchronizer/synchronizer_test.go
synchronizer/synchronizer_test.goRaw
1package synchronizer
2
3import (
4 "context"
5 "encoding/json"
6 "fmt"
7 "io/ioutil"
8 "math/big"
9 "os"
10 "sort"
11 "testing"
12
13 ethCommon "github.com/ethereum/go-ethereum/common"
14 "github.com/hermeznetwork/hermez-node/common"
15 dbUtils "github.com/hermeznetwork/hermez-node/db"
16 "github.com/hermeznetwork/hermez-node/db/historydb"
17 "github.com/hermeznetwork/hermez-node/db/statedb"
18 "github.com/hermeznetwork/hermez-node/eth"
19 "github.com/hermeznetwork/hermez-node/test"
20 "github.com/hermeznetwork/hermez-node/test/til"
21 "github.com/jinzhu/copier"
22 "github.com/stretchr/testify/assert"
23 "github.com/stretchr/testify/require"
24)
25
26var tokenConsts = map[common.TokenID]eth.ERC20Consts{}
27
28type timer struct {
29 time int64
30}
31
32func (t *timer) Time() int64 {
33 currentTime := t.time
34 t.time++
35 return currentTime
36}
37
38func accountsCmp(accounts []common.Account) func(i, j int) bool {
39 return func(i, j int) bool { return accounts[i].Idx < accounts[j].Idx }
40}
41
42// Check Sync output and HistoryDB state against expected values generated by
43// til
44func checkSyncBlock(t *testing.T, s *Synchronizer, blockNum int, block, syncBlock *common.BlockData) {
45 // Check Blocks
46 dbBlocks, err := s.historyDB.GetAllBlocks()
47 require.Nil(t, err)
48 dbBlocks = dbBlocks[1:] // ignore block 0, added by default in the DB
49 assert.Equal(t, blockNum, len(dbBlocks))
50 assert.Equal(t, int64(blockNum), dbBlocks[blockNum-1].Num)
51 assert.NotEqual(t, dbBlocks[blockNum-1].Hash, dbBlocks[blockNum-2].Hash)
52 assert.Greater(t, dbBlocks[blockNum-1].Timestamp.Unix(), dbBlocks[blockNum-2].Timestamp.Unix())
53
54 // Check Tokens
55 assert.Equal(t, len(block.Rollup.AddedTokens), len(syncBlock.Rollup.AddedTokens))
56 dbTokens, err := s.historyDB.GetAllTokens()
57 require.Nil(t, err)
58 dbTokens = dbTokens[1:] // ignore token 0, added by default in the DB
59 for i, token := range block.Rollup.AddedTokens {
60 dbToken := dbTokens[i]
61 syncToken := syncBlock.Rollup.AddedTokens[i]
62
63 assert.Equal(t, block.Block.Num, syncToken.EthBlockNum)
64 assert.Equal(t, token.TokenID, syncToken.TokenID)
65 assert.Equal(t, token.EthAddr, syncToken.EthAddr)
66 tokenConst := tokenConsts[token.TokenID]
67 assert.Equal(t, tokenConst.Name, syncToken.Name)
68 assert.Equal(t, tokenConst.Symbol, syncToken.Symbol)
69 assert.Equal(t, tokenConst.Decimals, syncToken.Decimals)
70
71 var tokenCpy historydb.TokenWithUSD
72 //nolint:gosec
73 require.Nil(t, copier.Copy(&tokenCpy, &token)) // copy common.Token to historydb.TokenWithUSD
74 require.Nil(t, copier.Copy(&tokenCpy, &tokenConst)) // copy common.Token to historydb.TokenWithUSD
75 tokenCpy.ItemID = dbToken.ItemID // we don't care about ItemID
76 assert.Equal(t, tokenCpy, dbToken)
77 }
78
79 // Check submitted L1UserTxs
80 assert.Equal(t, len(block.Rollup.L1UserTxs), len(syncBlock.Rollup.L1UserTxs))
81 dbL1UserTxs, err := s.historyDB.GetAllL1UserTxs()
82 require.Nil(t, err)
83 // Ignore BatchNum in syncBlock.L1UserTxs because this value is set by
84 // the HistoryDB. Also ignore EffectiveAmount & EffectiveDepositAmount
85 // because this value is set by StateDB.ProcessTxs.
86 for i := range syncBlock.Rollup.L1UserTxs {
87 syncBlock.Rollup.L1UserTxs[i].BatchNum = block.Rollup.L1UserTxs[i].BatchNum
88 assert.Nil(t, syncBlock.Rollup.L1UserTxs[i].EffectiveDepositAmount)
89 assert.Nil(t, syncBlock.Rollup.L1UserTxs[i].EffectiveAmount)
90 }
91 assert.Equal(t, block.Rollup.L1UserTxs, syncBlock.Rollup.L1UserTxs)
92 for _, tx := range block.Rollup.L1UserTxs {
93 var dbTx *common.L1Tx
94 // Find tx in DB output
95 for _, _dbTx := range dbL1UserTxs {
96 if *tx.ToForgeL1TxsNum == *_dbTx.ToForgeL1TxsNum &&
97 tx.Position == _dbTx.Position {
98 dbTx = new(common.L1Tx)
99 *dbTx = _dbTx
100 break
101 }
102 }
103 // If the tx has been forged in this block, this will be
104 // reflected in the DB, and so the Effective values will be
105 // already set
106 if dbTx.BatchNum != nil {
107 tx.EffectiveAmount = tx.Amount
108 tx.EffectiveDepositAmount = tx.DepositAmount
109 }
110 assert.Equal(t, &tx, dbTx) //nolint:gosec
111 }
112
113 // Check Batches
114 assert.Equal(t, len(block.Rollup.Batches), len(syncBlock.Rollup.Batches))
115 dbBatches, err := s.historyDB.GetAllBatches()
116 require.Nil(t, err)
117
118 dbL1CoordinatorTxs, err := s.historyDB.GetAllL1CoordinatorTxs()
119 require.Nil(t, err)
120 dbL2Txs, err := s.historyDB.GetAllL2Txs()
121 require.Nil(t, err)
122 dbExits, err := s.historyDB.GetAllExits()
123 require.Nil(t, err)
124 // dbL1CoordinatorTxs := []common.L1Tx{}
125 for i, batch := range block.Rollup.Batches {
126 var dbBatch *common.Batch
127 // Find batch in DB output
128 for _, _dbBatch := range dbBatches {
129 if batch.Batch.BatchNum == _dbBatch.BatchNum {
130 dbBatch = new(common.Batch)
131 *dbBatch = _dbBatch
132 break
133 }
134 }
135 syncBatch := syncBlock.Rollup.Batches[i]
136
137 // We don't care about TotalFeesUSD. Use the syncBatch that
138 // has a TotalFeesUSD inserted by the HistoryDB
139 batch.Batch.TotalFeesUSD = syncBatch.Batch.TotalFeesUSD
140 assert.Equal(t, batch.CreatedAccounts, syncBatch.CreatedAccounts)
141 batch.Batch.NumAccounts = len(batch.CreatedAccounts)
142
143 // Test field by field to facilitate debugging of errors
144 assert.Equal(t, batch.L1UserTxs, syncBatch.L1UserTxs)
145 assert.Equal(t, batch.L1CoordinatorTxs, syncBatch.L1CoordinatorTxs)
146 assert.Equal(t, batch.L2Txs, syncBatch.L2Txs)
147 // In exit tree, we only check AccountIdx and Balance, because
148 // it's what we have precomputed before.
149 require.Equal(t, len(batch.ExitTree), len(syncBatch.ExitTree))
150 for j := range batch.ExitTree {
151 exit := &batch.ExitTree[j]
152 assert.Equal(t, exit.AccountIdx, syncBatch.ExitTree[j].AccountIdx)
153 assert.Equal(t, exit.Balance, syncBatch.ExitTree[j].Balance)
154 *exit = syncBatch.ExitTree[j]
155 }
156 assert.Equal(t, batch.Batch, syncBatch.Batch)
157 assert.Equal(t, batch, syncBatch)
158 assert.Equal(t, &batch.Batch, dbBatch) //nolint:gosec
159
160 // Check forged L1UserTxs from DB, and check effective values
161 // in sync output
162 for j, tx := range batch.L1UserTxs {
163 var dbTx *common.L1Tx
164 // Find tx in DB output
165 for _, _dbTx := range dbL1UserTxs {
166 if *tx.BatchNum == *_dbTx.BatchNum &&
167 tx.Position == _dbTx.Position {
168 dbTx = new(common.L1Tx)
169 *dbTx = _dbTx
170 break
171 }
172 }
173 assert.Equal(t, &tx, dbTx) //nolint:gosec
174
175 syncTx := &syncBlock.Rollup.Batches[i].L1UserTxs[j]
176 assert.Equal(t, syncTx.DepositAmount, syncTx.EffectiveDepositAmount)
177 assert.Equal(t, syncTx.Amount, syncTx.EffectiveAmount)
178 }
179
180 // Check L1CoordinatorTxs from DB
181 for _, tx := range batch.L1CoordinatorTxs {
182 var dbTx *common.L1Tx
183 // Find tx in DB output
184 for _, _dbTx := range dbL1CoordinatorTxs {
185 if *tx.BatchNum == *_dbTx.BatchNum &&
186 tx.Position == _dbTx.Position {
187 dbTx = new(common.L1Tx)
188 *dbTx = _dbTx
189 break
190 }
191 }
192 assert.Equal(t, &tx, dbTx) //nolint:gosec
193 }
194
195 // Check L2Txs from DB
196 for _, tx := range batch.L2Txs {
197 var dbTx *common.L2Tx
198 // Find tx in DB output
199 for _, _dbTx := range dbL2Txs {
200 if tx.BatchNum == _dbTx.BatchNum &&
201 tx.Position == _dbTx.Position {
202 dbTx = new(common.L2Tx)
203 *dbTx = _dbTx
204 break
205 }
206 }
207 assert.Equal(t, &tx, dbTx) //nolint:gosec
208 }
209
210 // Check Exits from DB
211 for _, exit := range batch.ExitTree {
212 var dbExit *common.ExitInfo
213 // Find exit in DB output
214 for _, _dbExit := range dbExits {
215 if exit.BatchNum == _dbExit.BatchNum &&
216 exit.AccountIdx == _dbExit.AccountIdx {
217 dbExit = new(common.ExitInfo)
218 *dbExit = _dbExit
219 break
220 }
221 }
222 // Compare MerkleProof in JSON because unmarshaled 0
223 // big.Int leaves the internal big.Int array at nil,
224 // and gives trouble when comparing big.Int with
225 // internal big.Int array != nil but empty.
226 mtp, err := json.Marshal(exit.MerkleProof)
227 require.Nil(t, err)
228 dbMtp, err := json.Marshal(dbExit.MerkleProof)
229 require.Nil(t, err)
230 assert.Equal(t, mtp, dbMtp)
231 dbExit.MerkleProof = exit.MerkleProof
232 assert.Equal(t, &exit, dbExit) //nolint:gosec
233 }
234 }
235
236 // Compare accounts from HistoryDB with StateDB (they should match)
237 dbAccounts, err := s.historyDB.GetAllAccounts()
238 require.Nil(t, err)
239 sdbAccounts, err := s.stateDB.GetAccounts()
240 require.Nil(t, err)
241 assertEqualAccountsHistoryDBStateDB(t, dbAccounts, sdbAccounts)
242}
243
244func assertEqualAccountsHistoryDBStateDB(t *testing.T, hdbAccs, sdbAccs []common.Account) {
245 assert.Equal(t, len(hdbAccs), len(sdbAccs))
246 sort.SliceStable(hdbAccs, accountsCmp(hdbAccs))
247 sort.SliceStable(sdbAccs, accountsCmp(sdbAccs))
248 for i := range hdbAccs {
249 hdbAcc := hdbAccs[i]
250 sdbAcc := sdbAccs[i]
251 assert.Equal(t, hdbAcc.Idx, sdbAcc.Idx)
252 assert.Equal(t, hdbAcc.TokenID, sdbAcc.TokenID)
253 assert.Equal(t, hdbAcc.EthAddr, sdbAcc.EthAddr)
254 assert.Equal(t, hdbAcc.PublicKey, sdbAcc.PublicKey)
255 }
256}
257
258// ethAddTokens adds the tokens from the blocks to the blockchain
259func ethAddTokens(blocks []common.BlockData, client *test.Client) {
260 for _, block := range blocks {
261 for _, token := range block.Rollup.AddedTokens {
262 consts := eth.ERC20Consts{
263 Name: fmt.Sprintf("Token %d", token.TokenID),
264 Symbol: fmt.Sprintf("TK%d", token.TokenID),
265 Decimals: 18,
266 }
267 tokenConsts[token.TokenID] = consts
268 client.CtlAddERC20(token.EthAddr, consts)
269 }
270 }
271}
272
273func TestSync(t *testing.T) {
274 //
275 // Setup
276 //
277
278 ctx := context.Background()
279 // Int State DB
280 dir, err := ioutil.TempDir("", "tmpdb")
281 require.Nil(t, err)
282 defer assert.Nil(t, os.RemoveAll(dir))
283
284 stateDB, err := statedb.NewStateDB(dir, statedb.TypeSynchronizer, 32)
285 require.NoError(t, err)
286
287 // Init History DB
288 pass := os.Getenv("POSTGRES_PASS")
289 db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
290 require.Nil(t, err)
291 historyDB := historydb.NewHistoryDB(db)
292 // Clear DB
293 test.WipeDB(historyDB.DB())
294
295 // Init eth client
296 var timer timer
297 clientSetup := test.NewClientSetupExample()
298 bootCoordAddr := clientSetup.AuctionVariables.BootCoordinator
299 client := test.NewClient(true, &timer, ðCommon.Address{}, clientSetup)
300
301 // Create Synchronizer
302 s, err := NewSynchronizer(client, historyDB, stateDB, Config{
303 StartBlockNum: ConfigStartBlockNum{
304 Rollup: 1,
305 Auction: 1,
306 WDelayer: 1,
307 },
308 InitialVariables: SCVariables{
309 Rollup: *clientSetup.RollupVariables,
310 Auction: *clientSetup.AuctionVariables,
311 WDelayer: *clientSetup.WDelayerVariables,
312 },
313 })
314 require.Nil(t, err)
315
316 //
317 // First Sync from an initial state
318 //
319 stats := s.Stats()
320 assert.Equal(t, false, stats.Synced())
321
322 // Test Sync for rollup genesis block
323 syncBlock, discards, err := s.Sync2(ctx, nil)
324 require.Nil(t, err)
325 require.Nil(t, discards)
326 require.NotNil(t, syncBlock)
327 require.Nil(t, syncBlock.Rollup.Vars)
328 require.Nil(t, syncBlock.Auction.Vars)
329 require.Nil(t, syncBlock.WDelayer.Vars)
330 assert.Equal(t, int64(1), syncBlock.Block.Num)
331 stats = s.Stats()
332 assert.Equal(t, int64(1), stats.Eth.FirstBlockNum)
333 assert.Equal(t, int64(1), stats.Eth.LastBlock.Num)
334 assert.Equal(t, int64(1), stats.Sync.LastBlock.Num)
335 vars := s.SCVars()
336 assert.Equal(t, clientSetup.RollupVariables, vars.Rollup)
337 assert.Equal(t, clientSetup.AuctionVariables, vars.Auction)
338 assert.Equal(t, clientSetup.WDelayerVariables, vars.WDelayer)
339
340 dbBlocks, err := s.historyDB.GetAllBlocks()
341 require.Nil(t, err)
342 assert.Equal(t, 2, len(dbBlocks))
343 assert.Equal(t, int64(1), dbBlocks[1].Num)
344
345 // Sync again and expect no new blocks
346 syncBlock, discards, err = s.Sync2(ctx, nil)
347 require.Nil(t, err)
348 require.Nil(t, discards)
349 require.Nil(t, syncBlock)
350
351 //
352 // Generate blockchain and smart contract data, and fill the test smart contracts
353 //
354
355 // Generate blockchain data with til
356 set1 := `
357 Type: Blockchain
358
359 AddToken(1)
360 AddToken(2)
361 AddToken(3)
362
363 CreateAccountDeposit(1) C: 2000 // Idx=256+2=258
364 CreateAccountDeposit(2) A: 2000 // Idx=256+3=259
365 CreateAccountDeposit(1) D: 500 // Idx=256+4=260
366 CreateAccountDeposit(2) B: 500 // Idx=256+5=261
367 CreateAccountDeposit(2) C: 500 // Idx=256+6=262
368
369 CreateAccountCoordinator(1) A // Idx=256+0=256
370 CreateAccountCoordinator(1) B // Idx=256+1=257
371
372 > batchL1 // forge L1UserTxs{nil}, freeze defined L1UserTxs{5}
373 > batchL1 // forge defined L1UserTxs{5}, freeze L1UserTxs{nil}
374 > block // blockNum=2
375
376 CreateAccountDepositTransfer(1) E-A: 1000, 200 // Idx=256+7=263
377 ForceTransfer(1) C-B: 80
378 ForceExit(1) A: 100
379 ForceExit(1) B: 80
380 ForceTransfer(1) A-D: 100
381
382 Transfer(1) C-A: 100 (200)
383 Exit(1) C: 50 (200)
384 Exit(1) D: 30 (200)
385
386 > batchL1 // forge L1UserTxs{nil}, freeze defined L1UserTxs{3}
387 > batchL1 // forge L1UserTxs{3}, freeze defined L1UserTxs{nil}
388 > block // blockNum=3
389 `
390 tc := til.NewContext(common.RollupConstMaxL1UserTx)
391 tilCfgExtra := til.ConfigExtra{
392 BootCoordAddr: bootCoordAddr,
393 CoordUser: "A",
394 }
395 blocks, err := tc.GenerateBlocks(set1)
396 require.Nil(t, err)
397 // Sanity check
398 require.Equal(t, 2, len(blocks))
399 // blocks 0 (blockNum=2)
400 i := 0
401 require.Equal(t, 2, int(blocks[i].Block.Num))
402 require.Equal(t, 3, len(blocks[i].Rollup.AddedTokens))
403 require.Equal(t, 5, len(blocks[i].Rollup.L1UserTxs))
404 require.Equal(t, 2, len(blocks[i].Rollup.Batches))
405 require.Equal(t, 2, len(blocks[i].Rollup.Batches[0].L1CoordinatorTxs))
406 // blocks 1 (blockNum=3)
407 i = 1
408 require.Equal(t, 3, int(blocks[i].Block.Num))
409 require.Equal(t, 5, len(blocks[i].Rollup.L1UserTxs))
410 require.Equal(t, 2, len(blocks[i].Rollup.Batches))
411 require.Equal(t, 3, len(blocks[i].Rollup.Batches[0].L2Txs))
412
413 // Generate extra required data
414 ethAddTokens(blocks, client)
415
416 err = tc.FillBlocksExtra(blocks, &tilCfgExtra)
417 require.NoError(t, err)
418 tc.FillBlocksL1UserTxsBatchNum(blocks)
419 err = tc.FillBlocksForgedL1UserTxs(blocks)
420 require.NoError(t, err)
421
422 // Add block data to the smart contracts
423 err = client.CtlAddBlocks(blocks)
424 require.NoError(t, err)
425
426 //
427 // Sync to synchronize the current state from the test smart contracts,
428 // and check the outcome
429 //
430
431 // Block 2
432
433 syncBlock, discards, err = s.Sync2(ctx, nil)
434 require.Nil(t, err)
435 require.Nil(t, discards)
436 require.NotNil(t, syncBlock)
437 assert.Nil(t, syncBlock.Rollup.Vars)
438 assert.Nil(t, syncBlock.Auction.Vars)
439 assert.Nil(t, syncBlock.WDelayer.Vars)
440 assert.Equal(t, int64(2), syncBlock.Block.Num)
441 stats = s.Stats()
442 assert.Equal(t, int64(1), stats.Eth.FirstBlockNum)
443 assert.Equal(t, int64(3), stats.Eth.LastBlock.Num)
444 assert.Equal(t, int64(2), stats.Sync.LastBlock.Num)
445
446 checkSyncBlock(t, s, 2, &blocks[0], syncBlock)
447
448 // Block 3
449
450 syncBlock, discards, err = s.Sync2(ctx, nil)
451 require.Nil(t, err)
452 require.Nil(t, discards)
453 require.NotNil(t, syncBlock)
454 assert.Nil(t, syncBlock.Rollup.Vars)
455 assert.Nil(t, syncBlock.Auction.Vars)
456 assert.Nil(t, syncBlock.WDelayer.Vars)
457 assert.Equal(t, int64(3), syncBlock.Block.Num)
458 stats = s.Stats()
459 assert.Equal(t, int64(1), stats.Eth.FirstBlockNum)
460 assert.Equal(t, int64(3), stats.Eth.LastBlock.Num)
461 assert.Equal(t, int64(3), stats.Sync.LastBlock.Num)
462
463 checkSyncBlock(t, s, 3, &blocks[1], syncBlock)
464
465 // Block 4
466 // Generate 2 withdraws manually
467 _, err = client.RollupWithdrawMerkleProof(tc.Users["A"].BJJ.Public(), 1, 4, 256, big.NewInt(100), []*big.Int{}, true)
468 require.Nil(t, err)
469 _, err = client.RollupWithdrawMerkleProof(tc.Users["C"].BJJ.Public(), 1, 3, 258, big.NewInt(50), []*big.Int{}, false)
470 require.Nil(t, err)
471 client.CtlMineBlock()
472
473 syncBlock, discards, err = s.Sync2(ctx, nil)
474 require.Nil(t, err)
475 require.Nil(t, discards)
476 require.NotNil(t, syncBlock)
477 assert.Nil(t, syncBlock.Rollup.Vars)
478 assert.Nil(t, syncBlock.Auction.Vars)
479 assert.Nil(t, syncBlock.WDelayer.Vars)
480 assert.Equal(t, int64(4), syncBlock.Block.Num)
481 stats = s.Stats()
482 assert.Equal(t, int64(1), stats.Eth.FirstBlockNum)
483 assert.Equal(t, int64(4), stats.Eth.LastBlock.Num)
484 assert.Equal(t, int64(4), stats.Sync.LastBlock.Num)
485 vars = s.SCVars()
486 assert.Equal(t, clientSetup.RollupVariables, vars.Rollup)
487 assert.Equal(t, clientSetup.AuctionVariables, vars.Auction)
488 assert.Equal(t, clientSetup.WDelayerVariables, vars.WDelayer)
489
490 dbExits, err := s.historyDB.GetAllExits()
491 require.Nil(t, err)
492 foundA1, foundC1 := false, false
493 for _, exit := range dbExits {
494 if exit.AccountIdx == 256 && exit.BatchNum == 4 {
495 foundA1 = true
496 assert.Equal(t, int64(4), *exit.InstantWithdrawn)
497 }
498 if exit.AccountIdx == 258 && exit.BatchNum == 3 {
499 foundC1 = true
500 assert.Equal(t, int64(4), *exit.DelayedWithdrawRequest)
501 }
502 }
503 assert.True(t, foundA1)
504 assert.True(t, foundC1)
505
506 // Block 5
507 // Update variables manually
508 rollupVars, auctionVars, wDelayerVars, err := s.historyDB.GetSCVars()
509 require.Nil(t, err)
510 rollupVars.ForgeL1L2BatchTimeout = 42
511 _, err = client.RollupUpdateForgeL1L2BatchTimeout(rollupVars.ForgeL1L2BatchTimeout)
512 require.Nil(t, err)
513
514 auctionVars.OpenAuctionSlots = 17
515 _, err = client.AuctionSetOpenAuctionSlots(auctionVars.OpenAuctionSlots)
516 require.Nil(t, err)
517
518 wDelayerVars.WithdrawalDelay = 99
519 _, err = client.WDelayerChangeWithdrawalDelay(wDelayerVars.WithdrawalDelay)
520 require.Nil(t, err)
521
522 client.CtlMineBlock()
523
524 syncBlock, discards, err = s.Sync2(ctx, nil)
525 require.Nil(t, err)
526 require.Nil(t, discards)
527 require.NotNil(t, syncBlock)
528 assert.NotNil(t, syncBlock.Rollup.Vars)
529 assert.NotNil(t, syncBlock.Auction.Vars)
530 assert.NotNil(t, syncBlock.WDelayer.Vars)
531 assert.Equal(t, int64(5), syncBlock.Block.Num)
532 stats = s.Stats()
533 assert.Equal(t, int64(1), stats.Eth.FirstBlockNum)
534 assert.Equal(t, int64(5), stats.Eth.LastBlock.Num)
535 assert.Equal(t, int64(5), stats.Sync.LastBlock.Num)
536 vars = s.SCVars()
537 assert.NotEqual(t, clientSetup.RollupVariables, vars.Rollup)
538 assert.NotEqual(t, clientSetup.AuctionVariables, vars.Auction)
539 assert.NotEqual(t, clientSetup.WDelayerVariables, vars.WDelayer)
540
541 dbRollupVars, dbAuctionVars, dbWDelayerVars, err := s.historyDB.GetSCVars()
542 require.Nil(t, err)
543 // Set EthBlockNum for Vars to the blockNum in which they were updated (should be 5)
544 rollupVars.EthBlockNum = syncBlock.Block.Num
545 auctionVars.EthBlockNum = syncBlock.Block.Num
546 wDelayerVars.EthBlockNum = syncBlock.Block.Num
547 assert.Equal(t, rollupVars, dbRollupVars)
548 assert.Equal(t, auctionVars, dbAuctionVars)
549 assert.Equal(t, wDelayerVars, dbWDelayerVars)
550
551 //
552 // Reorg test
553 //
554
555 // Redo blocks 2-5 (as a reorg) only leaving:
556 // - 2 create account transactions
557 // - 2 add tokens
558 // We add a 6th block so that the synchronizer can detect the reorg
559 set2 := `
560 Type: Blockchain
561
562 AddToken(1)
563 AddToken(2)
564
565 CreateAccountDeposit(1) C: 2000 // Idx=256+1=257
566
567 CreateAccountCoordinator(1) A // Idx=256+0=256
568
569 > batchL1 // forge L1UserTxs{nil}, freeze defined L1UserTxs{1}
570 > batchL1 // forge defined L1UserTxs{1}, freeze L1UserTxs{nil}
571 > block // blockNum=2
572 > block // blockNum=3
573 > block // blockNum=4
574 > block // blockNum=5
575 > block // blockNum=6
576 `
577 tc = til.NewContext(common.RollupConstMaxL1UserTx)
578 tilCfgExtra = til.ConfigExtra{
579 BootCoordAddr: bootCoordAddr,
580 CoordUser: "A",
581 }
582 blocks, err = tc.GenerateBlocks(set2)
583 require.Nil(t, err)
584
585 for i := 0; i < 4; i++ {
586 client.CtlRollback()
587 }
588 block := client.CtlLastBlock()
589 require.Equal(t, int64(1), block.Num)
590
591 // Generate extra required data
592 ethAddTokens(blocks, client)
593
594 err = tc.FillBlocksExtra(blocks, &tilCfgExtra)
595 require.NoError(t, err)
596 tc.FillBlocksL1UserTxsBatchNum(blocks)
597
598 // Add block data to the smart contracts
599 err = client.CtlAddBlocks(blocks)
600 require.NoError(t, err)
601
602 // First sync detects the reorg and discards 4 blocks
603 syncBlock, discards, err = s.Sync2(ctx, nil)
604 require.Nil(t, err)
605 expetedDiscards := int64(4)
606 require.Equal(t, &expetedDiscards, discards)
607 require.Nil(t, syncBlock)
608 stats = s.Stats()
609 assert.Equal(t, false, stats.Synced())
610 assert.Equal(t, int64(6), stats.Eth.LastBlock.Num)
611 vars = s.SCVars()
612 assert.Equal(t, clientSetup.RollupVariables, vars.Rollup)
613 assert.Equal(t, clientSetup.AuctionVariables, vars.Auction)
614 assert.Equal(t, clientSetup.WDelayerVariables, vars.WDelayer)
615
616 // At this point, the DB only has data up to block 1
617 dbBlock, err := s.historyDB.GetLastBlock()
618 require.Nil(t, err)
619 assert.Equal(t, int64(1), dbBlock.Num)
620
621 // Accounts in HistoryDB and StateDB must be empty
622 dbAccounts, err := s.historyDB.GetAllAccounts()
623 require.Nil(t, err)
624 sdbAccounts, err := s.stateDB.GetAccounts()
625 require.Nil(t, err)
626 assert.Equal(t, 0, len(dbAccounts))
627 assertEqualAccountsHistoryDBStateDB(t, dbAccounts, sdbAccounts)
628
629 // Sync blocks 2-6
630 for i := 0; i < 5; i++ {
631 syncBlock, discards, err = s.Sync2(ctx, nil)
632 require.Nil(t, err)
633 require.Nil(t, discards)
634 require.NotNil(t, syncBlock)
635 assert.Nil(t, syncBlock.Rollup.Vars)
636 assert.Nil(t, syncBlock.Auction.Vars)
637 assert.Nil(t, syncBlock.WDelayer.Vars)
638 assert.Equal(t, int64(2+i), syncBlock.Block.Num)
639
640 stats = s.Stats()
641 assert.Equal(t, int64(1), stats.Eth.FirstBlockNum)
642 assert.Equal(t, int64(6), stats.Eth.LastBlock.Num)
643 assert.Equal(t, int64(2+i), stats.Sync.LastBlock.Num)
644 if i == 4 {
645 assert.Equal(t, true, stats.Synced())
646 } else {
647 assert.Equal(t, false, stats.Synced())
648 }
649
650 vars = s.SCVars()
651 assert.Equal(t, clientSetup.RollupVariables, vars.Rollup)
652 assert.Equal(t, clientSetup.AuctionVariables, vars.Auction)
653 assert.Equal(t, clientSetup.WDelayerVariables, vars.WDelayer)
654 }
655
656 dbBlock, err = s.historyDB.GetLastBlock()
657 require.Nil(t, err)
658 assert.Equal(t, int64(6), dbBlock.Num)
659
660 // Accounts in HistoryDB and StateDB is only 2 entries
661 dbAccounts, err = s.historyDB.GetAllAccounts()
662 require.Nil(t, err)
663 sdbAccounts, err = s.stateDB.GetAccounts()
664 require.Nil(t, err)
665 assert.Equal(t, 2, len(dbAccounts))
666 assertEqualAccountsHistoryDBStateDB(t, dbAccounts, sdbAccounts)
667}