Fix eth events query and sync inconsistent state - kvdb - Fix path in Last when doing `setNew` - Only close if db != nil, and after closing, always set db to nil - This will avoid a panic in the case where the db is closed but there's an error soon after, and a future call tries to close again. This is because pebble.Close() will panic if the db is already closed. - Avoid calling pebble methods when a the Storage interface already implements that method (like Close). - statedb - In test, avoid calling KVDB method if the same method is available for the StateDB (like MakeCheckpoint, CurrentBatch). - eth - In *EventByBlock methods, take blockHash as input argument and use it when querying the event logs. Previously the blockHash was only taken from the logs results *only if* there was any log. This caused the following issue: if there was no logs, it was not possible to know if the result was from the expected block or an uncle block! By querying logs by blockHash we make sure that even if there are no logs, they are from the right block. - Note that now the function can either be called with a blockNum or blockHash, but not both at the same time. - sync - If there's an error during call to Sync call resetState, which internally resets the stateDB to avoid stale checkpoints (and a corresponding invalid increase in the StateDB batchNum). - During a Sync, after very batch processed, make sure that the StateDB currentBatch corresponds to the batchNum in the smart contract log/event.
Eduard S eduard@iden3.io
Fri, 05 Feb 2021 13:28:14 +0100
12 files changed,
300 insertions(+),
217 deletions(-)
M
db/kvdb/kvdb.go
→
db/kvdb/kvdb.go
@@ -61,13 +61,13 @@ k.rw.Lock()
defer k.rw.Unlock() if k.db != nil { k.db.Close() + k.db = nil } lastPath := path.Join(k.path, PathLast) - err := os.RemoveAll(lastPath) - if err != nil { + if err := os.RemoveAll(lastPath); err != nil { return tracerr.Wrap(err) } - db, err := pebble.NewPebbleStorage(path.Join(k.path, lastPath), false) + db, err := pebble.NewPebbleStorage(lastPath, false) if err != nil { return tracerr.Wrap(err) }@@ -80,6 +80,7 @@ k.rw.Lock()
defer k.rw.Unlock() if k.db != nil { k.db.Close() + k.db = nil } lastPath := path.Join(k.path, PathLast) if err := kvdb.MakeCheckpointFromTo(batchNum, lastPath); err != nil {@@ -96,7 +97,10 @@
func (k *Last) close() { k.rw.Lock() defer k.rw.Unlock() - k.db.Close() + if k.db != nil { + k.db.Close() + k.db = nil + } } // NewKVDB creates a new KVDB, allowing to use an in-memory or in-disk storage.@@ -166,14 +170,12 @@ // opened db before doing the reset.
func (kvdb *KVDB) reset(batchNum common.BatchNum, closeCurrent bool) error { currentPath := path.Join(kvdb.path, PathCurrent) - if closeCurrent { - if err := kvdb.db.Pebble().Close(); err != nil { - return tracerr.Wrap(err) - } + if closeCurrent && kvdb.db != nil { + kvdb.db.Close() + kvdb.db = nil } // remove 'current' - err := os.RemoveAll(currentPath) - if err != nil { + if err := os.RemoveAll(currentPath); err != nil { return tracerr.Wrap(err) } // remove all checkpoints > batchNum@@ -249,13 +251,13 @@ return tracerr.Wrap(fmt.Errorf("synchronizerKVDB can not be nil"))
} currentPath := path.Join(kvdb.path, PathCurrent) - if err := kvdb.db.Pebble().Close(); err != nil { - return tracerr.Wrap(err) + if kvdb.db != nil { + kvdb.db.Close() + kvdb.db = nil } // remove 'current' - err := os.RemoveAll(currentPath) - if err != nil { + if err := os.RemoveAll(currentPath); err != nil { return tracerr.Wrap(err) } // remove all checkpoints@@ -394,8 +396,7 @@ }
// if checkpoint BatchNum already exist in disk, delete it if _, err := os.Stat(checkpointPath); !os.IsNotExist(err) { - err := os.RemoveAll(checkpointPath) - if err != nil { + if err := os.RemoveAll(checkpointPath); err != nil { return tracerr.Wrap(err) } } else if err != nil && !os.IsNotExist(err) {@@ -501,8 +502,7 @@
func pebbleMakeCheckpoint(source, dest string) error { // Remove dest folder (if it exists) before doing the checkpoint if _, err := os.Stat(dest); !os.IsNotExist(err) { - err := os.RemoveAll(dest) - if err != nil { + if err := os.RemoveAll(dest); err != nil { return tracerr.Wrap(err) } } else if err != nil && !os.IsNotExist(err) {@@ -513,12 +513,7 @@ sto, err := pebble.NewPebbleStorage(source, false)
if err != nil { return tracerr.Wrap(err) } - defer func() { - errClose := sto.Pebble().Close() - if errClose != nil { - log.Errorw("Pebble.Close", "err", errClose) - } - }() + defer sto.Close() // execute Checkpoint err = sto.Pebble().Checkpoint(dest)@@ -531,6 +526,9 @@ }
// Close the DB func (kvdb *KVDB) Close() { - kvdb.db.Close() + if kvdb.db != nil { + kvdb.db.Close() + kvdb.db = nil + } kvdb.last.close() }
M
db/statedb/statedb.go
→
db/statedb/statedb.go
@@ -230,8 +230,8 @@ // does not delete the checkpoints between old current and the new current,
// those checkpoints will remain in the storage, and eventually will be // deleted when MakeCheckpoint overwrites them. func (s *StateDB) Reset(batchNum common.BatchNum) error { - err := s.db.Reset(batchNum) - if err != nil { + log.Debugw("Making StateDB Reset", "batch", batchNum, "type", s.Typ) + if err := s.db.Reset(batchNum); err != nil { return tracerr.Wrap(err) } if s.MT != nil {@@ -242,7 +242,6 @@ return tracerr.Wrap(err)
} s.MT = mt } - log.Debugw("Making StateDB Reset", "batch", batchNum) return nil }@@ -478,13 +477,13 @@ // gets the state from LocalStateDB.synchronizerStateDB for the given batchNum.
// If fromSynchronizer is false, get the state from LocalStateDB checkpoints. func (l *LocalStateDB) Reset(batchNum common.BatchNum, fromSynchronizer bool) error { if fromSynchronizer { - err := l.db.ResetFromSynchronizer(batchNum, l.synchronizerStateDB.db) - if err != nil { + if err := l.db.ResetFromSynchronizer(batchNum, l.synchronizerStateDB.db); err != nil { return tracerr.Wrap(err) } // open the MT for the current s.db if l.MT != nil { - mt, err := merkletree.NewMerkleTree(l.db.StorageWithPrefix(PrefixKeyMT), l.MT.MaxLevels()) + mt, err := merkletree.NewMerkleTree(l.db.StorageWithPrefix(PrefixKeyMT), + l.MT.MaxLevels()) if err != nil { return tracerr.Wrap(err) }
M
db/statedb/statedb_test.go
→
db/statedb/statedb_test.go
@@ -116,7 +116,7 @@ // make checkpoints with the current state
bn, err := sdb.getCurrentBatch() require.NoError(t, err) assert.Equal(t, common.BatchNum(0), bn) - err = sdb.db.MakeCheckpoint() + err = sdb.MakeCheckpoint() require.NoError(t, err) bn, err = sdb.getCurrentBatch() require.NoError(t, err)@@ -399,14 +399,12 @@ // get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
err = ldb2.Reset(4, true) require.NoError(t, err) // check that currentBatch is 4 after the Reset - cb, err = ldb2.db.GetCurrentBatch() - require.NoError(t, err) + cb = ldb2.CurrentBatch() assert.Equal(t, common.BatchNum(4), cb) // advance one checkpoint in ldb2 - err = ldb2.db.MakeCheckpoint() - require.NoError(t, err) - cb, err = ldb2.db.GetCurrentBatch() + err = ldb2.MakeCheckpoint() require.NoError(t, err) + cb = ldb2.CurrentBatch() assert.Equal(t, common.BatchNum(5), cb) debug := false@@ -624,3 +622,24 @@
idx = sdb.CurrentIdx() assert.Equal(t, common.Idx(255), idx) } + +func TestResetFromBadCheckpoint(t *testing.T) { + dir, err := ioutil.TempDir("", "tmpdb") + require.NoError(t, err) + defer require.NoError(t, os.RemoveAll(dir)) + + keep := 16 + sdb, err := NewStateDB(dir, keep, TypeSynchronizer, 32) + require.NoError(t, err) + + err = sdb.MakeCheckpoint() + require.NoError(t, err) + err = sdb.MakeCheckpoint() + require.NoError(t, err) + err = sdb.MakeCheckpoint() + require.NoError(t, err) + + // reset from a checkpoint that doesn't exist + err = sdb.Reset(10) + require.Error(t, err) +}
M
eth/auction.go
→
eth/auction.go
@@ -254,7 +254,7 @@ // Smart Contract Status
// AuctionConstants() (*common.AuctionConstants, error) - AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *ethCommon.Hash, error) + AuctionEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*AuctionEvents, error) AuctionEventInit() (*AuctionEventInitialize, int64, error) }@@ -797,15 +797,22 @@ return &auctionInit, int64(vLog.BlockNumber), tracerr.Wrap(err)
} // AuctionEventsByBlock returns the events in a block that happened in the -// Auction Smart Contract and the blockHash where the eents happened. If there -// are no events in that block, blockHash is nil. -func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *ethCommon.Hash, error) { +// Auction Smart Contract. +// To query by blockNum, set blockNum >= 0 and blockHash == nil. +// To query by blockHash, set blockNum == -1 and blockHash != nil. +// If there are no events in that block the result is nil. +func (c *AuctionClient) AuctionEventsByBlock(blockNum int64, + blockHash *ethCommon.Hash) (*AuctionEvents, error) { var auctionEvents AuctionEvents - var blockHash *ethCommon.Hash + var blockNumBigInt *big.Int + if blockNum >= 0 { + blockNumBigInt = big.NewInt(blockNum) + } query := ethereum.FilterQuery{ - FromBlock: big.NewInt(blockNum), - ToBlock: big.NewInt(blockNum), + BlockHash: blockHash, + FromBlock: blockNumBigInt, + ToBlock: blockNumBigInt, Addresses: []ethCommon.Address{ c.address, },@@ -814,15 +821,16 @@ }
logs, err := c.client.client.FilterLogs(context.TODO(), query) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } - if len(logs) > 0 { - blockHash = &logs[0].BlockHash + if len(logs) == 0 { + return nil, nil } + for _, vLog := range logs { - if vLog.BlockHash != *blockHash { + if blockHash != nil && vLog.BlockHash != *blockHash { log.Errorw("Block hash mismatch", "expected", blockHash.String(), "got", vLog.BlockHash.String()) - return nil, nil, tracerr.Wrap(ErrBlockHashMismatchEvent) + return nil, tracerr.Wrap(ErrBlockHashMismatchEvent) } switch vLog.Topics[0] { case logAuctionNewBid:@@ -833,7 +841,7 @@ Address ethCommon.Address
} var newBid AuctionEventNewBid if err := c.contractAbi.UnpackIntoInterface(&auxNewBid, "NewBid", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } newBid.BidAmount = auxNewBid.BidAmount newBid.Slot = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()@@ -842,19 +850,19 @@ auctionEvents.NewBid = append(auctionEvents.NewBid, newBid)
case logAuctionNewSlotDeadline: var newSlotDeadline AuctionEventNewSlotDeadline if err := c.contractAbi.UnpackIntoInterface(&newSlotDeadline, "NewSlotDeadline", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } auctionEvents.NewSlotDeadline = append(auctionEvents.NewSlotDeadline, newSlotDeadline) case logAuctionNewClosedAuctionSlots: var newClosedAuctionSlots AuctionEventNewClosedAuctionSlots if err := c.contractAbi.UnpackIntoInterface(&newClosedAuctionSlots, "NewClosedAuctionSlots", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } auctionEvents.NewClosedAuctionSlots = append(auctionEvents.NewClosedAuctionSlots, newClosedAuctionSlots) case logAuctionNewOutbidding: var newOutbidding AuctionEventNewOutbidding if err := c.contractAbi.UnpackIntoInterface(&newOutbidding, "NewOutbidding", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } auctionEvents.NewOutbidding = append(auctionEvents.NewOutbidding, newOutbidding) case logAuctionNewDonationAddress:@@ -864,26 +872,26 @@ auctionEvents.NewDonationAddress = append(auctionEvents.NewDonationAddress, newDonationAddress)
case logAuctionNewBootCoordinator: var newBootCoordinator AuctionEventNewBootCoordinator if err := c.contractAbi.UnpackIntoInterface(&newBootCoordinator, "NewBootCoordinator", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } newBootCoordinator.NewBootCoordinator = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) auctionEvents.NewBootCoordinator = append(auctionEvents.NewBootCoordinator, newBootCoordinator) case logAuctionNewOpenAuctionSlots: var newOpenAuctionSlots AuctionEventNewOpenAuctionSlots if err := c.contractAbi.UnpackIntoInterface(&newOpenAuctionSlots, "NewOpenAuctionSlots", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } auctionEvents.NewOpenAuctionSlots = append(auctionEvents.NewOpenAuctionSlots, newOpenAuctionSlots) case logAuctionNewAllocationRatio: var newAllocationRatio AuctionEventNewAllocationRatio if err := c.contractAbi.UnpackIntoInterface(&newAllocationRatio, "NewAllocationRatio", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } auctionEvents.NewAllocationRatio = append(auctionEvents.NewAllocationRatio, newAllocationRatio) case logAuctionSetCoordinator: var setCoordinator AuctionEventSetCoordinator if err := c.contractAbi.UnpackIntoInterface(&setCoordinator, "SetCoordinator", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } setCoordinator.BidderAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) setCoordinator.ForgerAddress = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())@@ -891,7 +899,7 @@ auctionEvents.SetCoordinator = append(auctionEvents.SetCoordinator, setCoordinator)
case logAuctionNewForgeAllocated: var newForgeAllocated AuctionEventNewForgeAllocated if err := c.contractAbi.UnpackIntoInterface(&newForgeAllocated, "NewForgeAllocated", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } newForgeAllocated.Bidder = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) newForgeAllocated.Forger = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())@@ -904,7 +912,7 @@ NewInitialMinBid *big.Int
} var newDefaultSlotSetBid AuctionEventNewDefaultSlotSetBid if err := c.contractAbi.UnpackIntoInterface(&auxNewDefaultSlotSetBid, "NewDefaultSlotSetBid", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } newDefaultSlotSetBid.NewInitialMinBid = auxNewDefaultSlotSetBid.NewInitialMinBid newDefaultSlotSetBid.SlotSet = auxNewDefaultSlotSetBid.SlotSet.Int64()@@ -917,11 +925,11 @@ auctionEvents.NewForge = append(auctionEvents.NewForge, newForge)
case logAuctionHEZClaimed: var HEZClaimed AuctionEventHEZClaimed if err := c.contractAbi.UnpackIntoInterface(&HEZClaimed, "HEZClaimed", vLog.Data); err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } HEZClaimed.Owner = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) auctionEvents.HEZClaimed = append(auctionEvents.HEZClaimed, HEZClaimed) } } - return &auctionEvents, blockHash, nil + return &auctionEvents, nil }
M
eth/auction_test.go
→
eth/auction_test.go
@@ -88,7 +88,7 @@ require.Nil(t, err)
assert.Equal(t, newSlotDeadline, slotDeadline) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, newSlotDeadline, auctionEvents.NewSlotDeadline[0].NewSlotDeadline) }@@ -109,7 +109,7 @@ require.Nil(t, err)
assert.Equal(t, newOpenAuctionSlots, openAuctionSlots) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, newOpenAuctionSlots, auctionEvents.NewOpenAuctionSlots[0].NewOpenAuctionSlots) }@@ -130,7 +130,7 @@ require.Nil(t, err)
assert.Equal(t, newClosedAuctionSlots, closedAuctionSlots) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, newClosedAuctionSlots, auctionEvents.NewClosedAuctionSlots[0].NewClosedAuctionSlots) _, err = auctionClientTest.AuctionSetClosedAuctionSlots(closedAuctionSlots)@@ -153,7 +153,7 @@ require.Nil(t, err)
assert.Equal(t, newOutbidding, outbidding) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, newOutbidding, auctionEvents.NewOutbidding[0].NewOutbidding) _, err = auctionClientTest.AuctionSetOutbidding(outbiddingConst)@@ -176,7 +176,7 @@ require.Nil(t, err)
assert.Equal(t, newAllocationRatio, allocationRatio) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, newAllocationRatio, auctionEvents.NewAllocationRatio[0].NewAllocationRatio) _, err = auctionClientTest.AuctionSetAllocationRatio(allocationRatioConst)@@ -205,7 +205,7 @@ require.Nil(t, err)
assert.Equal(t, &newDonationAddress, donationAddress) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, newDonationAddress, auctionEvents.NewDonationAddress[0].NewDonationAddress) _, err = auctionClientTest.AuctionSetDonationAddress(donationAddressConst)@@ -224,7 +224,7 @@ require.Nil(t, err)
assert.Equal(t, &newBootCoordinator, bootCoordinator) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, newBootCoordinator, auctionEvents.NewBootCoordinator[0].NewBootCoordinator) assert.Equal(t, newBootCoordinatorURL, auctionEvents.NewBootCoordinator[0].NewBootCoordinatorURL)@@ -261,7 +261,7 @@ require.Nil(t, err)
assert.Equal(t, minBid, newInitialMinBid) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, slotSet, auctionEvents.NewDefaultSlotSetBid[0].SlotSet) assert.Equal(t, newInitialMinBid, auctionEvents.NewDefaultSlotSetBid[0].NewInitialMinBid)@@ -287,7 +287,7 @@ _, err := auctionClientTest.AuctionSetCoordinator(forgerAddress, URL)
require.Nil(t, err) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, forgerAddress, auctionEvents.SetCoordinator[0].ForgerAddress) assert.Equal(t, bidderAddress, auctionEvents.SetCoordinator[0].BidderAddress)@@ -306,7 +306,7 @@ _, err = auctionClientTest.AuctionBid(amount, currentSlot+4, bidAmount, deadline)
require.Nil(t, err) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, bidAmount, auctionEvents.NewBid[0].BidAmount) assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)@@ -346,7 +346,7 @@ _, err = auctionClientTest.AuctionMultiBid(budget, currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, deadline)
require.Nil(t, err) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder) assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)@@ -376,7 +376,7 @@ _, err := auctionClientTest.AuctionClaimHEZ()
require.Nil(t, err) currentBlockNum, err := auctionClientTest.client.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum) + auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, amount, auctionEvents.HEZClaimed[0].Amount) assert.Equal(t, governanceAddressConst, auctionEvents.HEZClaimed[0].Owner)
M
eth/rollup.go
→
eth/rollup.go
@@ -264,7 +264,7 @@ // Smart Contract Status
// RollupConstants() (*common.RollupConstants, error) - RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error) + RollupEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*RollupEvents, error) RollupForgeBatchArgs(ethCommon.Hash, uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error) RollupEventInit() (*RollupEventInitialize, int64, error) }@@ -735,31 +735,40 @@ }
return &rollupInit, int64(vLog.BlockNumber), tracerr.Wrap(err) } -// RollupEventsByBlock returns the events in a block that happened in the Rollup Smart Contract -func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error) { +// RollupEventsByBlock returns the events in a block that happened in the +// Rollup Smart Contract. +// To query by blockNum, set blockNum >= 0 and blockHash == nil. +// To query by blockHash, set blockNum == -1 and blockHash != nil. +// If there are no events in that block the result is nil. +func (c *RollupClient) RollupEventsByBlock(blockNum int64, + blockHash *ethCommon.Hash) (*RollupEvents, error) { var rollupEvents RollupEvents - var blockHash *ethCommon.Hash + var blockNumBigInt *big.Int + if blockNum >= 0 { + blockNumBigInt = big.NewInt(blockNum) + } query := ethereum.FilterQuery{ - FromBlock: big.NewInt(blockNum), - ToBlock: big.NewInt(blockNum), + BlockHash: blockHash, + FromBlock: blockNumBigInt, + ToBlock: blockNumBigInt, Addresses: []ethCommon.Address{ c.address, }, - BlockHash: nil, - Topics: [][]ethCommon.Hash{}, + Topics: [][]ethCommon.Hash{}, } logs, err := c.client.client.FilterLogs(context.Background(), query) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } - if len(logs) > 0 { - blockHash = &logs[0].BlockHash + if len(logs) == 0 { + return nil, nil } + for _, vLog := range logs { - if vLog.BlockHash != *blockHash { + if blockHash != nil && vLog.BlockHash != *blockHash { log.Errorw("Block hash mismatch", "expected", blockHash.String(), "got", vLog.BlockHash.String()) - return nil, nil, tracerr.Wrap(ErrBlockHashMismatchEvent) + return nil, tracerr.Wrap(ErrBlockHashMismatchEvent) } switch vLog.Topics[0] { case logHermezL1UserTxEvent:@@ -767,11 +776,11 @@ var L1UserTxAux rollupEventL1UserTxAux
var L1UserTx RollupEventL1UserTx err := c.contractAbi.UnpackIntoInterface(&L1UserTxAux, "L1UserTxEvent", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } L1Tx, err := common.L1UserTxFromBytes(L1UserTxAux.L1UserTx) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } toForgeL1TxsNum := new(big.Int).SetBytes(vLog.Topics[1][:]).Int64() L1Tx.ToForgeL1TxsNum = &toForgeL1TxsNum@@ -783,7 +792,7 @@ case logHermezAddToken:
var addToken RollupEventAddToken err := c.contractAbi.UnpackIntoInterface(&addToken, "AddToken", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } addToken.TokenAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) rollupEvents.AddToken = append(rollupEvents.AddToken, addToken)@@ -791,7 +800,7 @@ case logHermezForgeBatch:
var forgeBatch RollupEventForgeBatch err := c.contractAbi.UnpackIntoInterface(&forgeBatch, "ForgeBatch", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } forgeBatch.BatchNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64() forgeBatch.EthTxHash = vLog.TxHash@@ -803,7 +812,7 @@ NewForgeL1L2BatchTimeout uint8
} err := c.contractAbi.UnpackIntoInterface(&updateForgeL1L2BatchTimeout, "UpdateForgeL1L2BatchTimeout", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } rollupEvents.UpdateForgeL1L2BatchTimeout = append(rollupEvents.UpdateForgeL1L2BatchTimeout, RollupEventUpdateForgeL1L2BatchTimeout{@@ -813,7 +822,7 @@ case logHermezUpdateFeeAddToken:
var updateFeeAddToken RollupEventUpdateFeeAddToken err := c.contractAbi.UnpackIntoInterface(&updateFeeAddToken, "UpdateFeeAddToken", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } rollupEvents.UpdateFeeAddToken = append(rollupEvents.UpdateFeeAddToken, updateFeeAddToken) case logHermezWithdrawEvent:@@ -831,7 +840,7 @@ var updateBucketWithdrawAux rollupEventUpdateBucketWithdrawAux
var updateBucketWithdraw RollupEventUpdateBucketWithdraw err := c.contractAbi.UnpackIntoInterface(&updateBucketWithdrawAux, "UpdateBucketWithdraw", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } updateBucketWithdraw.Withdrawals = updateBucketWithdrawAux.Withdrawals updateBucketWithdraw.NumBucket = int(new(big.Int).SetBytes(vLog.Topics[1][:]).Int64())@@ -842,7 +851,7 @@ case logHermezUpdateWithdrawalDelay:
var withdrawalDelay RollupEventUpdateWithdrawalDelay err := c.contractAbi.UnpackIntoInterface(&withdrawalDelay, "UpdateWithdrawalDelay", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } rollupEvents.UpdateWithdrawalDelay = append(rollupEvents.UpdateWithdrawalDelay, withdrawalDelay) case logHermezUpdateBucketsParameters:@@ -850,7 +859,7 @@ var bucketsParametersAux rollupEventUpdateBucketsParametersAux
var bucketsParameters RollupEventUpdateBucketsParameters err := c.contractAbi.UnpackIntoInterface(&bucketsParametersAux, "UpdateBucketsParameters", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } for i, bucket := range bucketsParametersAux.ArrayBuckets { bucketsParameters.ArrayBuckets[i].CeilUSD = bucket[0]@@ -863,7 +872,7 @@ case logHermezUpdateTokenExchange:
var tokensExchange RollupEventUpdateTokenExchange err := c.contractAbi.UnpackIntoInterface(&tokensExchange, "UpdateTokenExchange", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } rollupEvents.UpdateTokenExchange = append(rollupEvents.UpdateTokenExchange, tokensExchange) case logHermezSafeMode:@@ -885,7 +894,7 @@ rollupEvents.UpdateBucketsParameters = append(rollupEvents.UpdateBucketsParameters,
bucketsParameters) } } - return &rollupEvents, blockHash, nil + return &rollupEvents, nil } // RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the@@ -893,7 +902,7 @@ // Rollup Smart Contract in the given transaction, and the sender address.
func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsLen uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error) { tx, _, err := c.client.client.TransactionByHash(context.Background(), ethTxHash) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, nil, tracerr.Wrap(fmt.Errorf("TransactionByHash: %w", err)) } txData := tx.Data()
M
eth/rollup_test.go
→
eth/rollup_test.go
@@ -91,7 +91,7 @@ _, err = rollupClient.RollupAddToken(tokenHEZAddressConst, feeAddToken, deadline)
require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, tokenHEZAddressConst, rollupEvents.AddToken[0].TokenAddress)@@ -174,7 +174,7 @@ require.NoError(t, err)
currentBlockNum, err = rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, int64(1), rollupEvents.ForgeBatch[0].BatchNum)@@ -203,7 +203,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, newForgeL1L2BatchTimeout, rollupEvents.UpdateForgeL1L2BatchTimeout[0].NewForgeL1L2BatchTimeout)@@ -216,7 +216,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, newFeeAddToken, rollupEvents.UpdateFeeAddToken[0].NewFeeAddToken)@@ -235,7 +235,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) blockStampBucket = currentBlockNum - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, bucketsParameters, rollupEvents.UpdateBucketsParameters[0].ArrayBuckets) }@@ -246,7 +246,7 @@ _, err := rollupClient.RollupUpdateWithdrawalDelay(newWithdrawalDelay)
require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, newWithdrawalDelay, int64(rollupEvents.UpdateWithdrawalDelay[0].NewWithdrawalDelay)) }@@ -263,7 +263,7 @@ _, err = rollupClient.RollupUpdateTokenExchange(addressArray, valueArray)
require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, addressArray, rollupEvents.UpdateTokenExchange[0].AddressArray) assert.Equal(t, valueArray, rollupEvents.UpdateTokenExchange[0].ValueArray)@@ -292,7 +292,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)@@ -324,7 +324,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)@@ -356,7 +356,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)@@ -388,7 +388,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -418,7 +418,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -447,7 +447,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -478,7 +478,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -508,7 +508,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -538,7 +538,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -569,7 +569,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -599,7 +599,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -629,7 +629,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -659,7 +659,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -688,7 +688,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -717,7 +717,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -747,7 +747,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -776,7 +776,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -807,7 +807,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)@@ -822,7 +822,7 @@ _, err := rollupClient.RollupForgeBatch(argsForge, nil)
require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, int64(2), rollupEvents.ForgeBatch[0].BatchNum)@@ -876,7 +876,7 @@ require.NoError(t, err)
currentBlockNum, err = rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err = rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err = rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, int64(3), rollupEvents.ForgeBatch[0].BatchNum)@@ -928,7 +928,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) assert.Equal(t, uint64(fromIdx), rollupEvents.Withdraw[0].Idx)@@ -951,7 +951,7 @@ require.NoError(t, err)
currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) - rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) + rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil) require.NoError(t, err) auxEvent := new(RollupEventSafeMode) assert.Equal(t, auxEvent, &rollupEvents.SafeMode[0])
M
eth/wdelayer.go
→
eth/wdelayer.go
@@ -134,7 +134,7 @@ WDelayerDeposit(onwer, token ethCommon.Address, amount *big.Int) (*types.Transaction, error)
WDelayerWithdrawal(owner, token ethCommon.Address) (*types.Transaction, error) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address, amount *big.Int) (*types.Transaction, error) - WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents, *ethCommon.Hash, error) + WDelayerEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*WDelayerEvents, error) WDelayerConstants() (*common.WDelayerConstants, error) WDelayerEventInit() (*WDelayerEventInitialize, int64, error) }@@ -424,40 +424,47 @@ return &wDelayerInit, int64(vLog.BlockNumber), tracerr.Wrap(err)
} // WDelayerEventsByBlock returns the events in a block that happened in the -// WDelayer Smart Contract and the blockHash where the eents happened. If -// there are no events in that block, blockHash is nil. -func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents, *ethCommon.Hash, error) { +// WDelayer Smart Contract. +// To query by blockNum, set blockNum >= 0 and blockHash == nil. +// To query by blockHash, set blockNum == -1 and blockHash != nil. +// If there are no events in that block the result is nil. +func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64, + blockHash *ethCommon.Hash) (*WDelayerEvents, error) { var wdelayerEvents WDelayerEvents - var blockHash *ethCommon.Hash + var blockNumBigInt *big.Int + if blockNum >= 0 { + blockNumBigInt = big.NewInt(blockNum) + } query := ethereum.FilterQuery{ - FromBlock: big.NewInt(blockNum), - ToBlock: big.NewInt(blockNum), + BlockHash: blockHash, + FromBlock: blockNumBigInt, + ToBlock: blockNumBigInt, Addresses: []ethCommon.Address{ c.address, }, - BlockHash: nil, - Topics: [][]ethCommon.Hash{}, + Topics: [][]ethCommon.Hash{}, } logs, err := c.client.client.FilterLogs(context.Background(), query) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } - if len(logs) > 0 { - blockHash = &logs[0].BlockHash + if len(logs) == 0 { + return nil, nil } + for _, vLog := range logs { - if vLog.BlockHash != *blockHash { + if blockHash != nil && vLog.BlockHash != *blockHash { log.Errorw("Block hash mismatch", "expected", blockHash.String(), "got", vLog.BlockHash.String()) - return nil, nil, tracerr.Wrap(ErrBlockHashMismatchEvent) + return nil, tracerr.Wrap(ErrBlockHashMismatchEvent) } switch vLog.Topics[0] { case logWDelayerDeposit: var deposit WDelayerEventDeposit err := c.contractAbi.UnpackIntoInterface(&deposit, "Deposit", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } deposit.Owner = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) deposit.Token = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())@@ -468,7 +475,7 @@ case logWDelayerWithdraw:
var withdraw WDelayerEventWithdraw err := c.contractAbi.UnpackIntoInterface(&withdraw, "Withdraw", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } withdraw.Token = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) withdraw.Owner = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())@@ -482,7 +489,7 @@ case logWDelayerNewWithdrawalDelay:
var withdrawalDelay WDelayerEventNewWithdrawalDelay err := c.contractAbi.UnpackIntoInterface(&withdrawalDelay, "NewWithdrawalDelay", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } wdelayerEvents.NewWithdrawalDelay = append(wdelayerEvents.NewWithdrawalDelay, withdrawalDelay)@@ -490,7 +497,7 @@ case logWDelayerEscapeHatchWithdrawal:
var escapeHatchWithdrawal WDelayerEventEscapeHatchWithdrawal err := c.contractAbi.UnpackIntoInterface(&escapeHatchWithdrawal, "EscapeHatchWithdrawal", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } escapeHatchWithdrawal.Who = ethCommon.BytesToAddress(vLog.Topics[1].Bytes()) escapeHatchWithdrawal.To = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())@@ -501,7 +508,7 @@ case logWDelayerNewEmergencyCouncil:
var emergencyCouncil WDelayerEventNewEmergencyCouncil err := c.contractAbi.UnpackIntoInterface(&emergencyCouncil, "NewEmergencyCouncil", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } wdelayerEvents.NewEmergencyCouncil = append(wdelayerEvents.NewEmergencyCouncil, emergencyCouncil)@@ -509,10 +516,10 @@ case logWDelayerNewHermezGovernanceAddress:
var governanceAddress WDelayerEventNewHermezGovernanceAddress err := c.contractAbi.UnpackIntoInterface(&governanceAddress, "NewHermezGovernanceAddress", vLog.Data) if err != nil { - return nil, nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(err) } wdelayerEvents.NewHermezGovernanceAddress = append(wdelayerEvents.NewHermezGovernanceAddress, governanceAddress) } } - return &wdelayerEvents, blockHash, nil + return &wdelayerEvents, nil }
M
eth/wdelayer_test.go
→
eth/wdelayer_test.go
@@ -52,7 +52,7 @@ require.Nil(t, err)
assert.Equal(t, &auxAddressConst, auxAddress) currentBlockNum, err := wdelayerClientTest.client.EthLastBlock() require.Nil(t, err) - wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum) + wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezGovernanceAddress[0].NewHermezGovernanceAddress) _, err = wdelayerClientAux.WDelayerTransferGovernance(governanceAddressConst)@@ -81,7 +81,7 @@ require.Nil(t, err)
assert.Equal(t, &auxAddressConst, auxAddress) currentBlockNum, err := wdelayerClientTest.client.EthLastBlock() require.Nil(t, err) - wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum) + wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, auxAddressConst, wdelayerEvents.NewEmergencyCouncil[0].NewEmergencyCouncil) _, err = wdelayerClientAux.WDelayerTransferEmergencyCouncil(emergencyCouncilAddressConst)@@ -110,7 +110,7 @@ require.Nil(t, err)
assert.Equal(t, newWithdrawalDelay, withdrawalDelay) currentBlockNum, err := wdelayerClientTest.client.EthLastBlock() require.Nil(t, err) - wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum) + wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, uint64(newWithdrawalDelay), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay) }@@ -124,7 +124,7 @@ _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
require.Nil(t, err) currentBlockNum, err := wdelayerClientTest.client.EthLastBlock() require.Nil(t, err) - wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum) + wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount) assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)@@ -150,7 +150,7 @@ _, err = wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
require.Nil(t, err) currentBlockNum, err := wdelayerClientTest.client.EthLastBlock() require.Nil(t, err) - wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum) + wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, amount, wdelayerEvents.Withdraw[0].Amount) assert.Equal(t, auxAddressConst, wdelayerEvents.Withdraw[0].Owner)@@ -166,7 +166,7 @@ _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
require.Nil(t, err) currentBlockNum, err := wdelayerClientTest.client.EthLastBlock() require.Nil(t, err) - wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum) + wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount) assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)@@ -181,7 +181,7 @@ require.Nil(t, err)
assert.Equal(t, true, emergencyMode) currentBlockNum, err := wdelayerClientTest.client.EthLastBlock() require.Nil(t, err) - wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum) + wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil) require.Nil(t, err) auxEvent := new(WDelayerEventEmergencyModeEnabled) assert.Equal(t, auxEvent, &wdelayerEvents.EmergencyModeEnabled[0])@@ -210,7 +210,7 @@ _, err = wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
require.Nil(t, err) currentBlockNum, err := wdelayerClientTest.client.EthLastBlock() require.Nil(t, err) - wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum) + wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil) require.Nil(t, err) assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token) assert.Equal(t, governanceAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].To)
M
synchronizer/synchronizer.go
→
synchronizer/synchronizer.go
@@ -195,15 +195,16 @@ }
// Synchronizer implements the Synchronizer type type Synchronizer struct { - ethClient eth.ClientInterface - consts SCConsts - historyDB *historydb.HistoryDB - stateDB *statedb.StateDB - cfg Config - initVars SCVariables - startBlockNum int64 - vars SCVariables - stats *StatsHolder + ethClient eth.ClientInterface + consts SCConsts + historyDB *historydb.HistoryDB + stateDB *statedb.StateDB + cfg Config + initVars SCVariables + startBlockNum int64 + vars SCVariables + stats *StatsHolder + resetStateFailed bool } // NewSynchronizer creates a new Synchronizer@@ -445,8 +446,10 @@ } else {
lastBlock = lastSavedBlock } if err := s.resetState(lastBlock); err != nil { + s.resetStateFailed = true return tracerr.Wrap(err) } + s.resetStateFailed = false log.Infow("Sync init block", "syncLastBlock", s.stats.Sync.LastBlock,@@ -462,16 +465,37 @@ )
return nil } +func (s *Synchronizer) resetIntermediateState() error { + lastBlock, err := s.historyDB.GetLastBlock() + if tracerr.Unwrap(err) == sql.ErrNoRows { + lastBlock = &common.Block{} + } else if err != nil { + return tracerr.Wrap(fmt.Errorf("historyDB.GetLastBlock: %w", err)) + } + if err := s.resetState(lastBlock); err != nil { + s.resetStateFailed = true + return tracerr.Wrap(fmt.Errorf("resetState at block %v: %w", lastBlock.Num, err)) + } + s.resetStateFailed = false + return nil +} + // Sync2 attems to synchronize an ethereum block starting from lastSavedBlock. // If lastSavedBlock is nil, the lastSavedBlock value is obtained from de DB. // If a block is synched, it will be returned and also stored in the DB. If a // reorg is detected, the number of discarded blocks will be returned and no // synchronization will be made. // TODO: Be smart about locking: only lock during the read/write operations -func (s *Synchronizer) Sync2(ctx context.Context, lastSavedBlock *common.Block) (*common.BlockData, *int64, error) { +func (s *Synchronizer) Sync2(ctx context.Context, + lastSavedBlock *common.Block) (blockData *common.BlockData, discarded *int64, err error) { + if s.resetStateFailed { + if err := s.resetIntermediateState(); err != nil { + return nil, nil, tracerr.Wrap(err) + } + } + var nextBlockNum int64 // next block number to sync if lastSavedBlock == nil { - var err error // Get lastSavedBlock from History DB lastSavedBlock, err = s.historyDB.GetLastBlock() if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {@@ -527,6 +551,20 @@ return nil, &discarded, nil
} } + defer func() { + // If there was an error during sync, reset to the last block + // in the historyDB because the historyDB is written last in + // the Sync method and is the source of consistency. This + // allows reseting the stateDB in the case a batch was + // processed but the historyDB block was not committed due to an + // error. + if err != nil { + if err2 := s.resetIntermediateState(); err2 != nil { + log.Errorw("sync revert", "err", err2) + } + } + }() + // Get data from the rollup contract rollupData, err := s.rollupSync(ethBlock) if err != nil {@@ -564,14 +602,14 @@ }
} // Group all the block data into the structs to save into HistoryDB - blockData := common.BlockData{ + blockData = &common.BlockData{ Block: *ethBlock, Rollup: *rollupData, Auction: *auctionData, WDelayer: *wDelayerData, } - err = s.historyDB.AddBlockSCData(&blockData) + err = s.historyDB.AddBlockSCData(blockData) if err != nil { return nil, nil, tracerr.Wrap(err) }@@ -613,7 +651,7 @@ "ethLastBatch", s.stats.Eth.LastBatch,
) } - return &blockData, nil, nil + return blockData, nil, nil } // reorg manages a reorg, updating History and State DB as needed. Keeps@@ -645,14 +683,15 @@ total := uncleBlock.Num - block.Num
log.Debugw("Discarding blocks", "total", total, "from", uncleBlock.Num, "to", block.Num+1) // Set History DB and State DB to the correct state - err := s.historyDB.Reorg(block.Num) - if err != nil { + if err := s.historyDB.Reorg(block.Num); err != nil { return 0, tracerr.Wrap(err) } if err := s.resetState(block); err != nil { + s.resetStateFailed = true return 0, tracerr.Wrap(err) } + s.resetStateFailed = false return block.Num, nil }@@ -722,6 +761,11 @@ if tracerr.Unwrap(err) == sql.ErrNoRows {
batchNum = 0 } + err = s.stateDB.Reset(batchNum) + if err != nil { + return tracerr.Wrap(fmt.Errorf("stateDB.Reset: %w", err)) + } + lastL1BatchBlockNum, err := s.historyDB.GetLastL1BatchBlockNum() if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows { return tracerr.Wrap(fmt.Errorf("historyDB.GetLastL1BatchBlockNum: %w", err))@@ -739,11 +783,6 @@ n := int64(-1)
lastForgeL1TxsNum = &n } - err = s.stateDB.Reset(batchNum) - if err != nil { - return tracerr.Wrap(fmt.Errorf("stateDB.Reset: %w", err)) - } - s.stats.UpdateSync(block, &batchNum, &lastL1BatchBlockNum, lastForgeL1TxsNum) if err := s.updateCurrentNextSlotIfSync(true, nil); err != nil {@@ -761,19 +800,14 @@ // var forgeL1TxsNum int64
// Get rollup events in the block, and make sure the block hash matches // the expected one. - rollupEvents, blockHash, err := s.ethClient.RollupEventsByBlock(blockNum) + rollupEvents, err := s.ethClient.RollupEventsByBlock(blockNum, ðBlock.Hash) if err != nil { return nil, tracerr.Wrap(err) } // No events in this block - if blockHash == nil { + if rollupEvents == nil { return &rollupData, nil } - if *blockHash != ethBlock.Hash { - log.Errorw("Block hash mismatch in Rollup events", "expected", ethBlock.Hash.String(), - "got", blockHash.String()) - return nil, tracerr.Wrap(eth.ErrBlockHashMismatchEvent) - } var nextForgeL1TxsNum int64 // forgeL1TxsNum for the next L1Batch nextForgeL1TxsNumPtr, err := s.historyDB.GetLastL1TxsNum()@@ -801,7 +835,7 @@ // Get the input for each Tx
forgeBatchArgs, sender, err := s.ethClient.RollupForgeBatchArgs(evtForgeBatch.EthTxHash, evtForgeBatch.L1UserTxsLen) if err != nil { - return nil, tracerr.Wrap(err) + return nil, tracerr.Wrap(fmt.Errorf("RollupForgeBatchArgs: %w", err)) } batchNum := common.BatchNum(evtForgeBatch.BatchNum)@@ -883,6 +917,10 @@ processTxsOut, err := tp.ProcessTxs(forgeBatchArgs.FeeIdxCoordinator,
l1UserTxs, batchData.L1CoordinatorTxs, poolL2Txs) if err != nil { return nil, tracerr.Wrap(err) + } + if s.stateDB.CurrentBatch() != batchNum { + return nil, tracerr.Wrap(fmt.Errorf("stateDB.BatchNum (%v) != evtForgeBatch.BatchNum = (%v)", + s.stateDB.CurrentBatch(), batchNum)) } // Transform processed PoolL2 txs to L2 and store in BatchData@@ -1066,19 +1104,14 @@ blockNum := ethBlock.Num
var auctionData = common.NewAuctionData() // Get auction events in the block - auctionEvents, blockHash, err := s.ethClient.AuctionEventsByBlock(blockNum) + auctionEvents, err := s.ethClient.AuctionEventsByBlock(blockNum, ðBlock.Hash) if err != nil { return nil, tracerr.Wrap(err) } // No events in this block - if blockHash == nil { + if auctionEvents == nil { return &auctionData, nil } - if *blockHash != ethBlock.Hash { - log.Errorw("Block hash mismatch in Auction events", "expected", ethBlock.Hash.String(), - "got", blockHash.String()) - return nil, tracerr.Wrap(eth.ErrBlockHashMismatchEvent) - } // Get bids for _, evt := range auctionEvents.NewBid {@@ -1168,18 +1201,13 @@ blockNum := ethBlock.Num
wDelayerData := common.NewWDelayerData() // Get wDelayer events in the block - wDelayerEvents, blockHash, err := s.ethClient.WDelayerEventsByBlock(blockNum) + wDelayerEvents, err := s.ethClient.WDelayerEventsByBlock(blockNum, ðBlock.Hash) if err != nil { return nil, tracerr.Wrap(err) } // No events in this block - if blockHash == nil { + if wDelayerEvents == nil { return &wDelayerData, nil - } - if *blockHash != ethBlock.Hash { - log.Errorw("Block hash mismatch in WDelayer events", "expected", ethBlock.Hash.String(), - "got", blockHash.String()) - return nil, tracerr.Wrap(eth.ErrBlockHashMismatchEvent) } for _, evt := range wDelayerEvents.Deposit {
M
test/ethclient.go
→
test/ethclient.go
@@ -1116,15 +1116,20 @@ return c.rollupConstants, nil
} // RollupEventsByBlock returns the events in a block that happened in the Rollup Smart Contract -func (c *Client) RollupEventsByBlock(blockNum int64) (*eth.RollupEvents, *ethCommon.Hash, error) { +func (c *Client) RollupEventsByBlock(blockNum int64, + blockHash *ethCommon.Hash) (*eth.RollupEvents, error) { c.rw.RLock() defer c.rw.RUnlock() block, ok := c.blocks[blockNum] if !ok { - return nil, nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum)) + return nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum)) + } + if blockHash != nil && *blockHash != block.Eth.Hash { + return nil, tracerr.Wrap(fmt.Errorf("Hash mismatch, requested %v got %v", + blockHash, block.Eth.Hash)) } - return &block.Rollup.Events, &block.Eth.Hash, nil + return &block.Rollup.Events, nil } // RollupEventInit returns the initialize event with its corresponding block number@@ -1573,15 +1578,20 @@ return c.auctionConstants, nil
} // AuctionEventsByBlock returns the events in a block that happened in the Auction Smart Contract -func (c *Client) AuctionEventsByBlock(blockNum int64) (*eth.AuctionEvents, *ethCommon.Hash, error) { +func (c *Client) AuctionEventsByBlock(blockNum int64, + blockHash *ethCommon.Hash) (*eth.AuctionEvents, error) { c.rw.RLock() defer c.rw.RUnlock() block, ok := c.blocks[blockNum] if !ok { - return nil, nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum)) + return nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum)) + } + if blockHash != nil && *blockHash != block.Eth.Hash { + return nil, tracerr.Wrap(fmt.Errorf("Hash mismatch, requested %v got %v", + blockHash, block.Eth.Hash)) } - return &block.Auction.Events, &block.Eth.Hash, nil + return &block.Auction.Events, nil } // AuctionEventInit returns the initialize event with its corresponding block number@@ -1789,15 +1799,20 @@ return nil, tracerr.Wrap(errTODO)
} // WDelayerEventsByBlock returns the events in a block that happened in the WDelayer Contract -func (c *Client) WDelayerEventsByBlock(blockNum int64) (*eth.WDelayerEvents, *ethCommon.Hash, error) { +func (c *Client) WDelayerEventsByBlock(blockNum int64, + blockHash *ethCommon.Hash) (*eth.WDelayerEvents, error) { c.rw.RLock() defer c.rw.RUnlock() block, ok := c.blocks[blockNum] if !ok { - return nil, nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum)) + return nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum)) + } + if blockHash != nil && *blockHash != block.Eth.Hash { + return nil, tracerr.Wrap(fmt.Errorf("Hash mismatch, requested %v got %v", + blockHash, block.Eth.Hash)) } - return &block.WDelayer.Events, &block.Eth.Hash, nil + return &block.WDelayer.Events, nil } // WDelayerConstants returns the Constants of the WDelayer Contract
M
test/ethclient_test.go
→
test/ethclient_test.go
@@ -130,7 +130,7 @@
blockNum, err := c.EthLastBlock() require.Nil(t, err) - auctionEvents, _, err := c.AuctionEventsByBlock(blockNum) + auctionEvents, err := c.AuctionEventsByBlock(blockNum, nil) require.Nil(t, err) assert.Equal(t, 2, len(auctionEvents.NewBid)) }@@ -171,7 +171,7 @@ c.CtlMineBlock()
blockNum, err := c.EthLastBlock() require.Nil(t, err) - rollupEvents, _, err := c.RollupEventsByBlock(blockNum) + rollupEvents, err := c.RollupEventsByBlock(blockNum, nil) require.Nil(t, err) assert.Equal(t, N, len(rollupEvents.L1UserTx)) assert.Equal(t, 1, len(rollupEvents.AddToken))@@ -192,7 +192,7 @@ c.CtlMineBlock()
blockNumA, err := c.EthLastBlock() require.Nil(t, err) - rollupEvents, hashA, err := c.RollupEventsByBlock(blockNumA) + rollupEvents, err = c.RollupEventsByBlock(blockNumA, nil) require.Nil(t, err) assert.Equal(t, 0, len(rollupEvents.L1UserTx)) assert.Equal(t, 0, len(rollupEvents.AddToken))@@ -205,14 +205,14 @@ c.CtlMineBlock()
blockNumB, err := c.EthLastBlock() require.Nil(t, err) - rollupEvents, hashB, err := c.RollupEventsByBlock(blockNumA) + rollupEventsB, err := c.RollupEventsByBlock(blockNumA, nil) require.Nil(t, err) - assert.Equal(t, 0, len(rollupEvents.L1UserTx)) - assert.Equal(t, 0, len(rollupEvents.AddToken)) - assert.Equal(t, 0, len(rollupEvents.ForgeBatch)) + assert.Equal(t, 0, len(rollupEventsB.L1UserTx)) + assert.Equal(t, 0, len(rollupEventsB.AddToken)) + assert.Equal(t, 0, len(rollupEventsB.ForgeBatch)) assert.Equal(t, blockNumA, blockNumB) - assert.NotEqual(t, hashA, hashB) + assert.NotEqual(t, rollupEvents, rollupEventsB) // Forge again rollupForgeBatchArgs0 := ð.RollupForgeBatchArgs{@@ -232,7 +232,7 @@ // Retrieve ForgeBatchArguments starting from the events
blockNum, err = c.EthLastBlock() require.Nil(t, err) - rollupEvents, _, err = c.RollupEventsByBlock(blockNum) + rollupEvents, err = c.RollupEventsByBlock(blockNum, nil) require.Nil(t, err) rollupForgeBatchArgs1, sender, err := c.RollupForgeBatchArgs(rollupEvents.ForgeBatch[0].EthTxHash,