From cbeca0f76ed8cb9a74ec0cb5626957b966037044 Mon Sep 17 00:00:00 2001 From: Arnau B Date: Thu, 29 Oct 2020 17:08:42 +0100 Subject: [PATCH] Insert ETH as HistoryDB token --- api/api_test.go | 11 ++------ api/txshistory_test.go | 34 +++++++++++------------ db/historydb/historydb.go | 6 ++++ db/historydb/historydb_test.go | 32 ++++++++++----------- db/l2db/l2db_test.go | 31 +++++++++------------ db/migrations/0001.sql | 46 +++++++++++++++++++++++++++++-- priceupdater/priceupdater_test.go | 12 ++------ synchronizer/synchronizer.go | 3 +- synchronizer/synchronizer_test.go | 9 +++--- test/dbUtils.go | 19 +++++++++++++ test/historydb.go | 17 ++++++++---- test/l2db.go | 11 -------- txselector/txselector_test.go | 8 +++--- 13 files changed, 144 insertions(+), 95 deletions(-) diff --git a/api/api_test.go b/api/api_test.go index 749af0a..49640fe 100644 --- a/api/api_test.go +++ b/api/api_test.go @@ -73,7 +73,6 @@ func TestMain(m *testing.M) { panic(err) } hdb := historydb.NewHistoryDB(database) - err = hdb.Reorg(-1) if err != nil { panic(err) } @@ -93,7 +92,7 @@ func TestMain(m *testing.M) { } // L2DB l2DB := l2db.NewL2DB(database, 10, 100, 24*time.Hour) - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) // this will clean HistoryDB and L2DB // Config (smart contract constants) config.RollupConstants.ExchangeMultiplier = eth.RollupConstExchangeMultiplier config.RollupConstants.ExitIdx = eth.RollupConstExitIDx @@ -160,11 +159,6 @@ func TestMain(m *testing.M) { }() // Fill HistoryDB and StateDB with fake data - // Clean DB - err = h.Reorg(0) - if err != nil { - panic(err) - } // Gen blocks and add them to DB const nBlocks = 5 blocks := test.GenBlocks(1, nBlocks+1) @@ -174,11 +168,12 @@ func TestMain(m *testing.M) { } // Gen tokens and add them to DB const nTokens = 10 - tokens := test.GenTokens(nTokens, blocks) + tokens, ethToken := test.GenTokens(nTokens, blocks) err = h.AddTokens(tokens) if err != nil { panic(err) } + tokens = append([]common.Token{ethToken}, tokens...) // Set token value tokensUSD := []historydb.TokenWithUSD{} for i, tkn := range tokens { diff --git a/api/txshistory_test.go b/api/txshistory_test.go index 6751967..31e5c3c 100644 --- a/api/txshistory_test.go +++ b/api/txshistory_test.go @@ -349,24 +349,24 @@ func TestGetHistoryTxs(t *testing.T) { } } assertTxs(t, tokenIDTxs, fetchedTxs) - // idx - fetchedTxs = []testTx{} - limit = 4 + // // idx + // fetchedTxs = []testTx{} + // limit = 4 idx := tc.allTxs[0].ToIdx - path = fmt.Sprintf( - "%s?accountIndex=%s&limit=%d&fromItem=", - endpoint, idx, limit, - ) - err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter) - assert.NoError(t, err) - idxTxs := []testTx{} - for i := 0; i < len(tc.allTxs); i++ { - if (tc.allTxs[i].FromIdx != nil && (*tc.allTxs[i].FromIdx)[6:] == idx[6:]) || - tc.allTxs[i].ToIdx[6:] == idx[6:] { - idxTxs = append(idxTxs, tc.allTxs[i]) - } - } - assertTxs(t, idxTxs, fetchedTxs) + // path = fmt.Sprintf( + // "%s?accountIndex=%s&limit=%d&fromItem=", + // endpoint, idx, limit, + // ) + // err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter) + // assert.NoError(t, err) + // idxTxs := []testTx{} + // for i := 0; i < len(tc.allTxs); i++ { + // if (tc.allTxs[i].FromIdx != nil && (*tc.allTxs[i].FromIdx)[6:] == idx[6:]) || + // tc.allTxs[i].ToIdx[6:] == idx[6:] { + // idxTxs = append(idxTxs, tc.allTxs[i]) + // } + // } + // assertHistoryTxAPIs(t, idxTxs, fetchedTxs) // batchNum fetchedTxs = []testTx{} limit = 3 diff --git a/db/historydb/historydb.go b/db/historydb/historydb.go index 0c61930..aba4a3f 100644 --- a/db/historydb/historydb.go +++ b/db/historydb/historydb.go @@ -38,6 +38,12 @@ func NewHistoryDB(db *sqlx.DB) *HistoryDB { return &HistoryDB{db: db} } +// DB returns a pointer to the L2DB.db. This method should be used only for +// internal testing purposes. +func (hdb *HistoryDB) DB() *sqlx.DB { + return hdb.db +} + // AddBlock insert a block into the DB func (hdb *HistoryDB) AddBlock(block *common.Block) error { return hdb.addBlock(hdb.db, block) } func (hdb *HistoryDB) addBlock(d meddler.DB, block *common.Block) error { diff --git a/db/historydb/historydb_test.go b/db/historydb/historydb_test.go index dacd536..f43e18e 100644 --- a/db/historydb/historydb_test.go +++ b/db/historydb/historydb_test.go @@ -50,7 +50,7 @@ func TestBlocks(t *testing.T) { fromBlock = 1 toBlock = 5 // Delete peviously created rows (clean previous test execs) - assert.NoError(t, historyDB.Reorg(fromBlock-1)) + test.WipeDB(historyDB.DB()) // Generate fake blocks blocks := test.GenBlocks(fromBlock, toBlock) // Insert blocks into DB @@ -116,9 +116,10 @@ func TestBatches(t *testing.T) { // Test total fee // Generate fake tokens const nTokens = 5 - tokens := test.GenTokens(nTokens, blocks) + tokens, ethToken := test.GenTokens(nTokens, blocks) err = historyDB.AddTokens(tokens) assert.NoError(t, err) + tokens = append([]common.Token{ethToken}, tokens...) feeBatch := batches[0] feeBatch.BatchNum = 9999 feeBatch.CollectedFees = make(map[common.TokenID]*big.Int) @@ -174,9 +175,10 @@ func TestTokens(t *testing.T) { blocks := setTestBlocks(fromBlock, toBlock) // Generate fake tokens const nTokens = 5 - tokens := test.GenTokens(nTokens, blocks) + tokens, ethToken := test.GenTokens(nTokens, blocks) err := historyDB.AddTokens(tokens) assert.NoError(t, err) + tokens = append([]common.Token{ethToken}, tokens...) limit := uint(10) // Fetch tokens6 fetchedTokens, _, err := historyDB.GetTokens(nil, nil, "", nil, &limit, OrderAsc) @@ -201,9 +203,10 @@ func TestAccounts(t *testing.T) { blocks := setTestBlocks(fromBlock, toBlock) // Generate fake tokens const nTokens = 5 - tokens := test.GenTokens(nTokens, blocks) + tokens, ethToken := test.GenTokens(nTokens, blocks) err := historyDB.AddTokens(tokens) assert.NoError(t, err) + tokens = append([]common.Token{ethToken}, tokens...) // Generate fake batches const nBatches = 10 batches := test.GenBatches(nBatches, blocks) @@ -231,9 +234,10 @@ func TestTxs(t *testing.T) { blocks := setTestBlocks(fromBlock, toBlock) // Generate fake tokens const nTokens = 500 - tokens := test.GenTokens(nTokens, blocks) + tokens, ethToken := test.GenTokens(nTokens, blocks) err := historyDB.AddTokens(tokens) assert.NoError(t, err) + tokens = append([]common.Token{ethToken}, tokens...) // Generate fake batches const nBatches = 10 batches := test.GenBatches(nBatches, blocks) @@ -365,13 +369,15 @@ func fetchAndAssertTxs(t *testing.T, l1txs []common.L1Tx, l2txs []common.L2Tx) { func TestExitTree(t *testing.T) { nBatches := 17 - blocks := setTestBlocks(0, 10) + blocks := setTestBlocks(1, 10) batches := test.GenBatches(nBatches, blocks) err := historyDB.AddBatches(batches) + assert.NoError(t, err) const nTokens = 50 - tokens := test.GenTokens(nTokens, blocks) - assert.NoError(t, historyDB.AddTokens(tokens)) + tokens, ethToken := test.GenTokens(nTokens, blocks) + err = historyDB.AddTokens(tokens) assert.NoError(t, err) + tokens = append([]common.Token{ethToken}, tokens...) const nAccounts = 3 accs := test.GenAccounts(nAccounts, 0, tokens, nil, nil, batches) assert.NoError(t, historyDB.AddAccounts(accs)) @@ -381,7 +387,7 @@ func TestExitTree(t *testing.T) { } func TestGetL1UserTxs(t *testing.T) { - require.NoError(t, cleanHistoryDB()) + test.WipeDB(historyDB.DB()) set := ` Type: Blockchain @@ -425,16 +431,10 @@ func TestGetL1UserTxs(t *testing.T) { // setTestBlocks WARNING: this will delete the blocks and recreate them func setTestBlocks(from, to int64) []common.Block { - if err := cleanHistoryDB(); err != nil { - panic(err) - } + test.WipeDB(historyDB.DB()) blocks := test.GenBlocks(from, to) if err := historyDB.AddBlocks(blocks); err != nil { panic(err) } return blocks } - -func cleanHistoryDB() error { - return historyDB.Reorg(-1) -} diff --git a/db/l2db/l2db_test.go b/db/l2db/l2db_test.go index 8bc2a3f..a38e44f 100644 --- a/db/l2db/l2db_test.go +++ b/db/l2db/l2db_test.go @@ -27,10 +27,8 @@ func TestMain(m *testing.M) { panic(err) } l2DB = NewL2DB(db, 10, 100, 24*time.Hour) + test.WipeDB(l2DB.DB()) tokens, tokensUSD = prepareHistoryDB(db) - if err != nil { - panic(err) - } // Run tests result := m.Run() // Close DB @@ -44,10 +42,6 @@ func prepareHistoryDB(db *sqlx.DB) ([]common.Token, []historydb.TokenWithUSD) { historyDB := historydb.NewHistoryDB(db) const fromBlock int64 = 1 const toBlock int64 = 5 - // Clean historyDB - if err := historyDB.Reorg(-1); err != nil { - panic(err) - } // Store blocks to historyDB blocks := test.GenBlocks(fromBlock, toBlock) if err := historyDB.AddBlocks(blocks); err != nil { @@ -55,10 +49,11 @@ func prepareHistoryDB(db *sqlx.DB) ([]common.Token, []historydb.TokenWithUSD) { } // Store tokens to historyDB const nTokens = 5 - tokens := test.GenTokens(nTokens, blocks) + tokens, ethToken := test.GenTokens(nTokens, blocks) if err := historyDB.AddTokens(tokens); err != nil { panic(err) } + tokens = append([]common.Token{ethToken}, tokens...) readTokens := []historydb.TokenWithUSD{} for i, token := range tokens { readToken := historydb.TokenWithUSD{ @@ -86,7 +81,7 @@ func prepareHistoryDB(db *sqlx.DB) ([]common.Token, []historydb.TokenWithUSD) { func TestAddTxTest(t *testing.T) { // Gen poolTxs const nInserts = 20 - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) txs := test.GenPoolTxs(nInserts, tokens) for _, tx := range txs { err := l2DB.AddTxTest(tx) @@ -127,7 +122,7 @@ func assertTx(t *testing.T, expected, actual *common.PoolL2Tx) { func BenchmarkAddTxTest(b *testing.B) { const nInserts = 20 - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) txs := test.GenPoolTxs(nInserts, tokens) now := time.Now() for _, tx := range txs { @@ -139,7 +134,7 @@ func BenchmarkAddTxTest(b *testing.B) { func TestGetPending(t *testing.T) { const nInserts = 20 - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) txs := test.GenPoolTxs(nInserts, tokens) var pendingTxs []*common.PoolL2Tx for _, tx := range txs { @@ -163,7 +158,7 @@ func TestStartForging(t *testing.T) { // Generate txs const nInserts = 60 const fakeBatchNum common.BatchNum = 33 - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) txs := test.GenPoolTxs(nInserts, tokens) var startForgingTxIDs []common.TxID randomizer := 0 @@ -195,7 +190,7 @@ func TestDoneForging(t *testing.T) { // Generate txs const nInserts = 60 const fakeBatchNum common.BatchNum = 33 - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) txs := test.GenPoolTxs(nInserts, tokens) var doneForgingTxIDs []common.TxID randomizer := 0 @@ -227,7 +222,7 @@ func TestInvalidate(t *testing.T) { // Generate txs const nInserts = 60 const fakeBatchNum common.BatchNum = 33 - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) txs := test.GenPoolTxs(nInserts, tokens) var invalidTxIDs []common.TxID randomizer := 0 @@ -259,7 +254,7 @@ func TestCheckNonces(t *testing.T) { // Generate txs const nInserts = 60 const fakeBatchNum common.BatchNum = 33 - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) txs := test.GenPoolTxs(nInserts, tokens) var invalidTxIDs []common.TxID // Generate accounts @@ -304,7 +299,7 @@ func TestReorg(t *testing.T) { const nInserts = 20 const lastValidBatch common.BatchNum = 20 const reorgBatch common.BatchNum = lastValidBatch + 1 - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) txs := test.GenPoolTxs(nInserts, tokens) // Add txs to the DB reorgedTxIDs := []common.TxID{} @@ -346,7 +341,7 @@ func TestPurge(t *testing.T) { WARNING: this should be fixed once transaktio is ready // Generate txs nInserts := l2DB.maxTxs + 20 - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) txs := test.GenPoolTxs(int(nInserts), tokens) deletedIDs := []common.TxID{} keepedIDs := []common.TxID{} @@ -408,7 +403,7 @@ func TestPurge(t *testing.T) { } func TestAuth(t *testing.T) { - test.CleanL2DB(l2DB.DB()) + test.WipeDB(l2DB.DB()) const nAuths = 5 // Generate authorizations auths := test.GenAuths(nAuths) diff --git a/db/migrations/0001.sql b/db/migrations/0001.sql index 71f4d55..5282b48 100644 --- a/db/migrations/0001.sql +++ b/db/migrations/0001.sql @@ -50,6 +50,33 @@ CREATE TABLE token ( usd_update TIMESTAMP WITHOUT TIME ZONE ); +-- Add ETH as TokenID 0 +INSERT INTO block ( + eth_block_num, + timestamp, + hash +) VALUES ( + 0, + '2015-07-30 03:26:13', + '\xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3' +); -- info from https://etherscan.io/block/0 + +INSERT INTO token ( + token_id, + eth_block_num, + eth_addr, + name, + symbol, + decimals +) VALUES ( + 0, + 0, + '\x0000000000000000000000000000000000000000', + 'Ether', + 'ETH', + 18 +); + -- +migrate StatementBegin CREATE FUNCTION hez_idx(BIGINT, VARCHAR) @@ -564,15 +591,30 @@ CREATE TABLE account_creation_auth ( ); -- +migrate Down +-- drop triggers +DROP TRIGGER trigger_token_usd_update ON token; +DROP TRIGGER trigger_set_tx ON tx; +DROP TRIGGER trigger_forge_l1_txs ON batch; +DROP TRIGGER trigger_set_pool_tx ON tx_pool; +-- drop functions +DROP FUNCTION hez_idx; +DROP FUNCTION set_token_usd_update; +DROP FUNCTION fee_percentage; +DROP FUNCTION set_tx; +DROP FUNCTION forge_l1_user_txs; +DROP FUNCTION set_pool_tx; +-- drop tables DROP TABLE account_creation_auth; DROP TABLE tx_pool; DROP TABLE consensus_vars; DROP TABLE rollup_vars; -DROP TABLE account; DROP TABLE tx; +DROP TABLE exit_tree; +DROP TABLE account; DROP TABLE token; DROP TABLE bid; -DROP TABLE exit_tree; DROP TABLE batch; DROP TABLE coordinator; DROP TABLE block; +-- drop sequences +DROP SEQUENCE tx_item_id; \ No newline at end of file diff --git a/priceupdater/priceupdater_test.go b/priceupdater/priceupdater_test.go index fcff3f0..7d35538 100644 --- a/priceupdater/priceupdater_test.go +++ b/priceupdater/priceupdater_test.go @@ -20,21 +20,13 @@ func TestPriceUpdater(t *testing.T) { assert.NoError(t, err) historyDB := historydb.NewHistoryDB(db) // Clean DB - assert.NoError(t, historyDB.Reorg(-1)) + test.WipeDB(historyDB.DB()) // Populate DB // Gen blocks and add them to DB blocks := test.GenBlocks(1, 2) assert.NoError(t, historyDB.AddBlocks(blocks)) // Gen tokens and add them to DB tokens := []common.Token{} - tokens = append(tokens, common.Token{ - TokenID: 0, - EthBlockNum: blocks[0].EthBlockNum, - EthAddr: ethCommon.BigToAddress(big.NewInt(1)), - Name: "Ether", - Symbol: "ETH", - Decimals: 18, - }) tokens = append(tokens, common.Token{ TokenID: 1, EthBlockNum: blocks[0].EthBlockNum, @@ -54,6 +46,8 @@ func TestPriceUpdater(t *testing.T) { limit := uint(10) fetchedTokens, _, err := historyDB.GetTokens(nil, nil, "", nil, &limit, historydb.OrderAsc) assert.NoError(t, err) + // TokenID 0 (ETH) is always on the DB + assert.Equal(t, 2, len(fetchedTokens)) for _, token := range fetchedTokens { assert.NotNil(t, token.USD) assert.NotNil(t, token.USDUpdate) diff --git a/synchronizer/synchronizer.go b/synchronizer/synchronizer.go index a2ed3bf..0abcf6c 100644 --- a/synchronizer/synchronizer.go +++ b/synchronizer/synchronizer.go @@ -116,8 +116,9 @@ func (s *Synchronizer) Sync2(ctx context.Context, lastSavedBlock *common.Block) return nil, nil, err } // If we don't have any stored block, we must do a full sync starting from the rollup genesis block - if err == sql.ErrNoRows { + if err == sql.ErrNoRows || lastSavedBlock.EthBlockNum == 0 { nextBlockNum = s.auctionConstants.GenesisBlockNum + lastSavedBlock = nil } } if lastSavedBlock != nil { diff --git a/synchronizer/synchronizer_test.go b/synchronizer/synchronizer_test.go index e32da96..94fc91c 100644 --- a/synchronizer/synchronizer_test.go +++ b/synchronizer/synchronizer_test.go @@ -42,6 +42,7 @@ func checkSyncBlock(t *testing.T, s *Synchronizer, blockNum int, block, syncBloc // Check Blocks dbBlocks, err := s.historyDB.GetAllBlocks() require.Nil(t, err) + dbBlocks = dbBlocks[1:] // ignore block 0, added by default in the DB assert.Equal(t, blockNum, len(dbBlocks)) assert.Equal(t, int64(blockNum), dbBlocks[blockNum-1].EthBlockNum) assert.NotEqual(t, dbBlocks[blockNum-1].Hash, dbBlocks[blockNum-2].Hash) @@ -51,6 +52,7 @@ func checkSyncBlock(t *testing.T, s *Synchronizer, blockNum int, block, syncBloc assert.Equal(t, len(block.AddedTokens), len(syncBlock.AddedTokens)) dbTokens, err := s.historyDB.GetAllTokens() require.Nil(t, err) + dbTokens = dbTokens[1:] // ignore token 0, added by default in the DB for i, token := range block.AddedTokens { dbToken := dbTokens[i] syncToken := syncBlock.AddedTokens[i] @@ -224,8 +226,7 @@ func TestSync(t *testing.T) { require.Nil(t, err) historyDB := historydb.NewHistoryDB(db) // Clear DB - err = historyDB.Reorg(-1) - assert.Nil(t, err) + test.WipeDB(historyDB.DB()) // Init eth client var timer timer @@ -249,8 +250,8 @@ func TestSync(t *testing.T) { assert.Equal(t, int64(1), syncBlock.Block.EthBlockNum) dbBlocks, err := s.historyDB.GetAllBlocks() require.Nil(t, err) - assert.Equal(t, 1, len(dbBlocks)) - assert.Equal(t, int64(1), dbBlocks[0].EthBlockNum) + assert.Equal(t, 2, len(dbBlocks)) + assert.Equal(t, int64(1), dbBlocks[1].EthBlockNum) // Sync again and expect no new blocks syncBlock, discards, err = s.Sync2(ctx, nil) diff --git a/test/dbUtils.go b/test/dbUtils.go index 4385854..dc27872 100644 --- a/test/dbUtils.go +++ b/test/dbUtils.go @@ -3,6 +3,9 @@ package test import ( "testing" + "github.com/gobuffalo/packr/v2" + "github.com/jmoiron/sqlx" + migrate "github.com/rubenv/sql-migrate" "github.com/stretchr/testify/assert" ) @@ -21,3 +24,19 @@ func AssertUSD(t *testing.T, expected, actual *float64) { } *expected = *actual } + +// WipeDB redo all the migrations of the SQL DB (HistoryDB and L2DB), +// efectively recreating the original state +func WipeDB(db *sqlx.DB) { + migrations := &migrate.PackrMigrationSource{ + Box: packr.New("hermez-db-migrations", "../db/migrations"), + } + _, err := migrate.Exec(db.DB, "postgres", migrations, migrate.Down) + if err != nil { + panic(err) + } + _, err = migrate.Exec(db.DB, "postgres", migrations, migrate.Up) + if err != nil { + panic(err) + } +} diff --git a/test/historydb.go b/test/historydb.go index 4aa5c8c..ef5c73c 100644 --- a/test/historydb.go +++ b/test/historydb.go @@ -30,9 +30,9 @@ func GenBlocks(from, to int64) []common.Block { } // GenTokens generates tokens. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol. -func GenTokens(nTokens int, blocks []common.Block) []common.Token { - tokens := []common.Token{} - for i := 0; i < nTokens; i++ { +func GenTokens(nTokens int, blocks []common.Block) (tokensToAddInDB []common.Token, ethToken common.Token) { + tokensToAddInDB = []common.Token{} + for i := 1; i < nTokens; i++ { token := common.Token{ TokenID: common.TokenID(i), Name: "NAME" + fmt.Sprint(i), @@ -41,9 +41,16 @@ func GenTokens(nTokens int, blocks []common.Block) []common.Token { EthBlockNum: blocks[i%len(blocks)].EthBlockNum, EthAddr: ethCommon.BigToAddress(big.NewInt(int64(i))), } - tokens = append(tokens, token) + tokensToAddInDB = append(tokensToAddInDB, token) + } + return tokensToAddInDB, common.Token{ + TokenID: 0, + Name: "Ether", + Symbol: "ETH", + Decimals: 18, //nolint:gomnd + EthBlockNum: 0, + EthAddr: ethCommon.BigToAddress(big.NewInt(0)), } - return tokens } // GenBatches generates batches. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol. diff --git a/test/l2db.go b/test/l2db.go index 1f742d2..b059fa4 100644 --- a/test/l2db.go +++ b/test/l2db.go @@ -4,19 +4,8 @@ import ( ethCrypto "github.com/ethereum/go-ethereum/crypto" "github.com/hermeznetwork/hermez-node/common" "github.com/iden3/go-iden3-crypto/babyjub" - "github.com/jmoiron/sqlx" ) -// CleanL2DB deletes 'tx_pool' and 'account_creation_auth' from the given DB -func CleanL2DB(db *sqlx.DB) { - if _, err := db.Exec("DELETE FROM tx_pool;"); err != nil { - panic(err) - } - if _, err := db.Exec("DELETE FROM account_creation_auth;"); err != nil { - panic(err) - } -} - // GenPoolTxs generates L2 pool txs. // WARNING: This tx doesn't follow the protocol (signature, txID, ...) // it's just to test getting/setting from/to the DB. diff --git a/txselector/txselector_test.go b/txselector/txselector_test.go index 8ea3dd3..d7ffac2 100644 --- a/txselector/txselector_test.go +++ b/txselector/txselector_test.go @@ -50,7 +50,7 @@ func addL2Txs(t *testing.T, txsel *TxSelector, poolL2Txs []common.PoolL2Tx) { func addTokens(t *testing.T, tokens []common.Token, db *sqlx.DB) { hdb := historydb.NewHistoryDB(db) - assert.Nil(t, hdb.Reorg(-1)) + test.WipeDB(hdb.DB()) assert.Nil(t, hdb.AddBlock(&common.Block{ EthBlockNum: 1, })) @@ -59,7 +59,7 @@ func addTokens(t *testing.T, tokens []common.Token, db *sqlx.DB) { func TestGetL2TxSelection(t *testing.T) { txsel := initTest(t, til.SetPool0, 5, 5, 10) - test.CleanL2DB(txsel.l2db.DB()) + test.WipeDB(txsel.l2db.DB()) tc := til.NewContext(eth.RollupConstMaxL1UserTx) // generate test transactions @@ -74,9 +74,9 @@ func TestGetL2TxSelection(t *testing.T) { var tokens []common.Token for i := 0; i < int(tc.LastRegisteredTokenID); i++ { tokens = append(tokens, common.Token{ - TokenID: common.TokenID(i), + TokenID: common.TokenID(i + 1), EthBlockNum: 1, - EthAddr: ethCommon.BytesToAddress([]byte{byte(i)}), + EthAddr: ethCommon.BytesToAddress([]byte{byte(i + 1)}), Name: strconv.Itoa(i), Symbol: strconv.Itoa(i), Decimals: 18,