hermez-node/synchronizer/synchronizer.go

package synchronizer

import (
	"context"
	"database/sql"
	"fmt"
	"math/big"
	"sync"
	"time"

	"github.com/ethereum/go-ethereum"
	"github.com/hermeznetwork/hermez-node/common"
	"github.com/hermeznetwork/hermez-node/db/historydb"
	"github.com/hermeznetwork/hermez-node/db/statedb"
	"github.com/hermeznetwork/hermez-node/eth"
	"github.com/hermeznetwork/hermez-node/log"
)

var (
// ErrNotAbleToSync is used when there is not possible to find a valid block to sync
// ErrNotAbleToSync = errors.New("it has not been possible to synchronize any block")
)

// // SyncronizerState describes the synchronization progress of the smart contracts
// type SyncronizerState struct {
// 	LastUpdate                time.Time // last time this information was updated
// 	CurrentBatchNum           BatchNum  // Last batch that was forged on the blockchain
// 	CurrentBlockNum           uint64    // Last block that was mined on Ethereum
// 	CurrentToForgeL1TxsNum    uint32
// 	LastSyncedBatchNum        BatchNum // last batch synchronized by the coordinator
// 	LastSyncedBlockNum        uint64   // last Ethereum block synchronized by the coordinator
// 	LastSyncedToForgeL1TxsNum uint32
// }

// // SyncStatus is returned by the Status method of the Synchronizer
// type SyncStatus struct {
// 	CurrentBlock      int64
// 	CurrentBatch      BatchNum
// 	CurrentForgerAddr ethCommon.Address
// 	NextForgerAddr    ethCommon.Address
// 	Synchronized      bool
// }

// Stats of the syncrhonizer
type Stats struct {
	Eth struct {
		RefreshPeriod time.Duration
		Updated       time.Time
		FirstBlock    int64
		LastBlock     int64
		LastBatch     int64
	}
	Sync struct {
		Updated   time.Time
		LastBlock int64
		LastBatch int64
	}
}

// StatsHolder stores stats and that allows reading and writing them
// concurrently
type StatsHolder struct {
	stats Stats
	rw    sync.RWMutex
}

// NewStatsHolder creates a new StatsHolder
func NewStatsHolder(firstBlock int64, refreshPeriod time.Duration) *StatsHolder {
	stats := Stats{}
	stats.Eth.RefreshPeriod = refreshPeriod
	stats.Eth.FirstBlock = firstBlock
	return &StatsHolder{stats: stats}
}

// UpdateSync updates the synchronizer stats
func (s *StatsHolder) UpdateSync(lastBlock int64, lastBatch *common.BatchNum) {
	now := time.Now()
	s.rw.Lock()
	s.stats.Sync.LastBlock = lastBlock
	if lastBatch != nil {
		s.stats.Sync.LastBatch = int64(*lastBatch)
	}
	s.stats.Sync.Updated = now
	s.rw.Unlock()
}

// UpdateEth updates the ethereum stats, only if the previous stats expired
func (s *StatsHolder) UpdateEth(ethClient eth.ClientInterface) error {
	now := time.Now()
	s.rw.RLock()
	elapsed := now.Sub(s.stats.Eth.Updated)
	s.rw.RUnlock()
	if elapsed < s.stats.Eth.RefreshPeriod {
		return nil
	}

	lastBlock, err := ethClient.EthCurrentBlock()
	if err != nil {
		return err
	}
	lastBatch, err := ethClient.RollupLastForgedBatch()
	if err != nil {
		return err
	}
	s.rw.Lock()
	s.stats.Eth.Updated = now
	s.stats.Eth.LastBlock = lastBlock
	s.stats.Eth.LastBatch = lastBatch
	s.rw.Unlock()
	return nil
}

// CopyStats returns a copy of the inner Stats
func (s *StatsHolder) CopyStats() *Stats {
	s.rw.RLock()
	sCopy := s.stats
	s.rw.RUnlock()
	return &sCopy
}

func (s *StatsHolder) blocksPerc() float64 {
	return float64(s.stats.Sync.LastBlock-s.stats.Eth.FirstBlock) * 100.0 /
		float64(s.stats.Eth.LastBlock-s.stats.Eth.FirstBlock)
}

func (s *StatsHolder) batchesPerc(batchNum int64) float64 {
	return float64(batchNum) * 100.0 /
		float64(s.stats.Eth.LastBatch)
}

// ConfigStartBlockNum sets the first block used to start tracking the smart
// contracts
type ConfigStartBlockNum struct {
	Rollup   int64 `validate:"required"`
	Auction  int64 `validate:"required"`
	WDelayer int64 `validate:"required"`
}

// SCVariables joins all the smart contract variables in a single struct
type SCVariables struct {
	Rollup   common.RollupVariables   `validate:"required"`
	Auction  common.AuctionVariables  `validate:"required"`
	WDelayer common.WDelayerVariables `validate:"required"`
}

// Config is the Synchronizer configuration
type Config struct {
	StartBlockNum      ConfigStartBlockNum
	InitialVariables   SCVariables
	StatsRefreshPeriod time.Duration
}

// Synchronizer implements the Synchronizer type
type Synchronizer struct {
	ethClient         eth.ClientInterface
	auctionConstants  common.AuctionConstants
	rollupConstants   common.RollupConstants
	wDelayerConstants common.WDelayerConstants
	historyDB         *historydb.HistoryDB
	stateDB           *statedb.StateDB
	cfg               Config
	startBlockNum     int64
	vars              SCVariables
	stats             *StatsHolder
	// firstSavedBlock  *common.Block
	// mux sync.Mutex
}

// NewSynchronizer creates a new Synchronizer
func NewSynchronizer(ethClient eth.ClientInterface, historyDB *historydb.HistoryDB,
	stateDB *statedb.StateDB, cfg Config) (*Synchronizer, error) {
	auctionConstants, err := ethClient.AuctionConstants()
	if err != nil {
		log.Errorw("NewSynchronizer ethClient.AuctionConstants()", "err", err)
		return nil, err
	}
	rollupConstants, err := ethClient.RollupConstants()
	if err != nil {
		log.Errorw("NewSynchronizer ethClient.RollupConstants()", "err", err)
		return nil, err
	}
	wDelayerConstants, err := ethClient.WDelayerConstants()
	if err != nil {
		log.Errorw("NewSynchronizer ethClient.WDelayerConstants()", "err", err)
		return nil, err
	}

	// Set startBlockNum to the minimum between Auction, Rollup and
	// WDelayer StartBlockNum
	startBlockNum := cfg.StartBlockNum.Auction
	if startBlockNum < cfg.StartBlockNum.Rollup {
		startBlockNum = cfg.StartBlockNum.Rollup
	}
	if startBlockNum < cfg.StartBlockNum.WDelayer {
		startBlockNum = cfg.StartBlockNum.WDelayer
	}
	stats := NewStatsHolder(startBlockNum, cfg.StatsRefreshPeriod)
	s := &Synchronizer{
		ethClient:         ethClient,
		auctionConstants:  *auctionConstants,
		rollupConstants:   *rollupConstants,
		wDelayerConstants: *wDelayerConstants,
		historyDB:         historyDB,
		stateDB:           stateDB,
		cfg:               cfg,
		startBlockNum:     startBlockNum,
		stats:             stats,
	}
	return s, s.init()
}

// Stats returns a copy of the Synchronizer Stats
func (s *Synchronizer) Stats() *Stats {
	return s.stats.CopyStats()
}

// AuctionConstants returns the AuctionConstants read from the smart contract
func (s *Synchronizer) AuctionConstants() *common.AuctionConstants {
	return &s.auctionConstants
}

// RollupConstants returns the RollupConstants read from the smart contract
func (s *Synchronizer) RollupConstants() *common.RollupConstants {
	return &s.rollupConstants
}

// WDelayerConstants returns the WDelayerConstants read from the smart contract
func (s *Synchronizer) WDelayerConstants() *common.WDelayerConstants {
	return &s.wDelayerConstants
}

func (s *Synchronizer) init() error {
	rollup, auction, wDelayer, err := s.historyDB.GetSCVars()
	// If SCVars are not in the HistoryDB, this is probably the first run
	// of the Synchronizer: store the initial vars taken from config
	if err == sql.ErrNoRows {
		rollup = &s.cfg.InitialVariables.Rollup
		auction = &s.cfg.InitialVariables.Auction
		wDelayer = &s.cfg.InitialVariables.WDelayer
		log.Info("Setting initial SCVars in HistoryDB")
		if err = s.historyDB.SetInitialSCVars(rollup, auction, wDelayer); err != nil {
			return err
		}
	}
	s.vars.Rollup = *rollup
	s.vars.Auction = *auction
	s.vars.WDelayer = *wDelayer

	// Update stats parameters so that they have valid values before the
	// first Sync call
	if err := s.stats.UpdateEth(s.ethClient); err != nil {
		return err
	}
	var lastBlockNum int64
	lastSavedBlock, err := s.historyDB.GetLastBlock()
	if err != nil && err != sql.ErrNoRows {
		return err
	}
	// If there's no block in the DB (or we only have the default block 0),
	// make sure that the stateDB is clean
	if err == sql.ErrNoRows || lastSavedBlock.EthBlockNum == 0 {
		if err := s.stateDB.Reset(0); err != nil {
			return err
		}
	} else {
		lastBlockNum = lastSavedBlock.EthBlockNum
	}
	lastBatchNum, err := s.historyDB.GetLastBatchNum()
	if err != nil && err != sql.ErrNoRows {
		return err
	}
	if err == sql.ErrNoRows {
		lastBatchNum = 0
	}

	s.stats.UpdateSync(lastBlockNum, &lastBatchNum)

	log.Infow("Sync init block",
		"syncLastBlock", s.stats.stats.Sync.LastBlock,
		"syncBlocksPerc", s.stats.blocksPerc(),
		"ethFirstBlock", s.stats.stats.Eth.FirstBlock,
		"ethLastBlock", s.stats.stats.Eth.LastBlock,
	)
	log.Infow("Sync init batch",
		"syncLastBatch", s.stats.stats.Sync.LastBatch,
		"syncBatchesPerc", s.stats.batchesPerc(s.stats.stats.Sync.LastBatch),
		"ethLastBatch", s.stats.stats.Eth.LastBatch,
	)
	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) {
	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 && err != sql.ErrNoRows {
			return nil, nil, err
		}
		// If we don't have any stored block, we must do a full sync
		// starting from the startBlockNum
		if err == sql.ErrNoRows || lastSavedBlock.EthBlockNum == 0 {
			nextBlockNum = s.startBlockNum
			lastSavedBlock = nil
		}
	}
	if lastSavedBlock != nil {
		nextBlockNum = lastSavedBlock.EthBlockNum + 1
	}

	ethBlock, err := s.ethClient.EthBlockByNumber(ctx, nextBlockNum)
	if err == ethereum.NotFound {
		return nil, nil, nil
	} else if err != nil {
		return nil, nil, err
	}
	log.Debugf("ethBlock: num: %v, parent: %v, hash: %v", ethBlock.EthBlockNum, ethBlock.ParentHash.String(), ethBlock.Hash.String())

	if err := s.stats.UpdateEth(s.ethClient); err != nil {
		return nil, nil, err
	}

	log.Debugw("Syncing...",
		"block", nextBlockNum,
		"ethLastBlock", s.stats.stats.Eth.LastBlock,
	)

	// Check that the obtianed ethBlock.ParentHash == prevEthBlock.Hash; if not, reorg!
	if lastSavedBlock != nil {
		if lastSavedBlock.Hash != ethBlock.ParentHash {
			// Reorg detected
			log.Debugw("Reorg Detected",
				"blockNum", ethBlock.EthBlockNum,
				"block.parent(got)", ethBlock.ParentHash, "parent.hash(exp)", lastSavedBlock.Hash)
			lastDBBlockNum, err := s.reorg(lastSavedBlock)
			if err != nil {
				return nil, nil, err
			}
			discarded := lastSavedBlock.EthBlockNum - lastDBBlockNum
			return nil, &discarded, nil
		}
	}

	// Get data from the rollup contract
	rollupData, err := s.rollupSync(ethBlock)
	if err != nil {
		return nil, nil, err
	}

	// Get data from the auction contract
	auctionData, err := s.auctionSync(ethBlock)
	if err != nil {
		return nil, nil, err
	}

	// Get data from the WithdrawalDelayer contract
	wDelayerData, err := s.wdelayerSync(ethBlock)
	if err != nil {
		return nil, nil, err
	}

	for i := range rollupData.Withdrawals {
		withdrawal := &rollupData.Withdrawals[i]
		if !withdrawal.InstantWithdraw {
			wDelayerTransfer, ok := wDelayerData.DepositsByTxHash[withdrawal.TxHash]
			if !ok {
				return nil, nil, fmt.Errorf("WDelayer deposit corresponding to " +
					"non-instant rollup withdrawal not found")
			}
			withdrawal.Owner = wDelayerTransfer.Owner
			withdrawal.Token = wDelayerTransfer.Token
		}
	}

	// Group all the block data into the structs to save into HistoryDB
	blockData := common.BlockData{
		Block:    *ethBlock,
		Rollup:   *rollupData,
		Auction:  *auctionData,
		WDelayer: *wDelayerData,
	}

	// log.Debugw("Sync()", "block", blockData)
	// err = s.historyDB.AddBlock(blockData.Block)
	// if err != nil {
	// 	return err
	// }
	err = s.historyDB.AddBlockSCData(&blockData)
	if err != nil {
		return nil, nil, err
	}

	batchesLen := len(rollupData.Batches)
	if batchesLen == 0 {
		s.stats.UpdateSync(ethBlock.EthBlockNum, nil)
	} else {
		s.stats.UpdateSync(ethBlock.EthBlockNum,
			&rollupData.Batches[batchesLen-1].Batch.BatchNum)
	}
	log.Debugw("Synced block",
		"syncLastBlock", s.stats.stats.Sync.LastBlock,
		"syncBlocksPerc", s.stats.blocksPerc(),
		"ethLastBlock", s.stats.stats.Eth.LastBlock,
	)
	for _, batchData := range rollupData.Batches {
		log.Debugw("Synced batch",
			"syncLastBatch", batchData.Batch.BatchNum,
			"syncBatchesPerc", s.stats.batchesPerc(int64(batchData.Batch.BatchNum)),
			"ethLastBatch", s.stats.stats.Eth.LastBatch,
		)
	}

	return &blockData, nil, nil
}

// reorg manages a reorg, updating History and State DB as needed.  Keeps
// checking previous blocks from the HistoryDB against the blockchain until a
// block hash match is found.  All future blocks in the HistoryDB and
// corresponding batches in StateBD are discarded.  Returns the last valid
// blockNum from the HistoryDB.
func (s *Synchronizer) reorg(uncleBlock *common.Block) (int64, error) {
	blockNum := uncleBlock.EthBlockNum

	for blockNum >= s.startBlockNum {
		ethBlock, err := s.ethClient.EthBlockByNumber(context.Background(), blockNum)
		if err != nil {
			return 0, err
		}

		block, err := s.historyDB.GetBlock(blockNum)
		if err != nil {
			return 0, err
		}
		if block.Hash == ethBlock.Hash {
			log.Debugf("Found valid block: %v", blockNum)
			break
		}
		blockNum--
	}
	total := uncleBlock.EthBlockNum - blockNum
	log.Debugw("Discarding blocks", "total", total, "from", uncleBlock.EthBlockNum, "to", blockNum+1)

	// Set History DB and State DB to the correct state
	err := s.historyDB.Reorg(blockNum)
	if err != nil {
		return 0, err
	}

	batchNum, err := s.historyDB.GetLastBatchNum()
	if err != nil && err != sql.ErrNoRows {
		return 0, err
	}
	if err == sql.ErrNoRows {
		batchNum = 0
	}
	err = s.stateDB.Reset(batchNum)
	if err != nil {
		return 0, err
	}

	return blockNum, nil
}

// TODO: Figure out who will use the Status output, and only return what's strictly need
/*
// Status returns current status values from the Synchronizer
func (s *Synchronizer) Status() (*common.SyncStatus, error) {
	// Avoid possible inconsistencies
	s.mux.Lock()
	defer s.mux.Unlock()

	var status *common.SyncStatus

	// TODO: Join all queries to the DB into a single transaction so that
	// we can remove the mutex locking here:
	// - HistoryDB.GetLastBlock
	// - HistoryDB.GetLastBatchNum
	// - HistoryDB.GetCurrentForgerAddr
	// - HistoryDB.GetNextForgerAddr

	// Get latest block in History DB
	lastSavedBlock, err := s.historyDB.GetLastBlock()
	if err != nil {
		return nil, err
	}
	status.CurrentBlock = lastSavedBlock.EthBlockNum

	// Get latest batch in History DB
	lastSavedBatch, err := s.historyDB.GetLastBatchNum()
	if err != nil && err != sql.ErrNoRows {
		return nil, err
	}
	status.CurrentBatch = lastSavedBatch

	// Get latest blockNum in blockchain
	latestBlockNum, err := s.ethClient.EthCurrentBlock()
	if err != nil {
		return nil, err
	}

	// TODO: Get CurrentForgerAddr & NextForgerAddr from the Auction SC / Or from the HistoryDB

	// Check if Synchronizer is synchronized
	status.Synchronized = status.CurrentBlock == latestBlockNum
	return status, nil
}
*/

// rollupSync retreives all the Rollup Smart Contract Data that happened at
// ethBlock.blockNum with ethBlock.Hash.
func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, error) {
	blockNum := ethBlock.EthBlockNum
	var rollupData = common.NewRollupData()
	// 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)
	if err != nil {
		return nil, err
	}
	// No events in this block
	if blockHash == 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, eth.ErrBlockHashMismatchEvent
	}

	var nextForgeL1TxsNum int64 // forgeL1TxsNum for the next L1Batch
	nextForgeL1TxsNumPtr, err := s.historyDB.GetLastL1TxsNum()
	if err != nil {
		return nil, err
	}
	if nextForgeL1TxsNumPtr != nil {
		nextForgeL1TxsNum = *nextForgeL1TxsNumPtr + 1
	} else {
		nextForgeL1TxsNum = 0
	}

	// Get L1UserTX
	rollupData.L1UserTxs, err = getL1UserTx(rollupEvents.L1UserTx, blockNum)
	if err != nil {
		return nil, err
	}

	// Get ForgeBatch events to get the L1CoordinatorTxs
	for _, evtForgeBatch := range rollupEvents.ForgeBatch {
		batchData := common.NewBatchData()
		position := 0

		// Get the input for each Tx
		forgeBatchArgs, sender, err := s.ethClient.RollupForgeBatchArgs(evtForgeBatch.EthTxHash)
		if err != nil {
			return nil, err
		}

		batchNum := common.BatchNum(evtForgeBatch.BatchNum)
		var l1UserTxs []common.L1Tx
		// Check if this is a L1Batch to get L1 Tx from it
		if forgeBatchArgs.L1Batch {
			// Get L1UserTxs with toForgeL1TxsNum, which correspond
			// to the L1UserTxs that are forged in this batch, so
			// that stateDB can process them.

			// First try to find them in HistoryDB.
			l1UserTxs, err = s.historyDB.GetL1UserTxs(nextForgeL1TxsNum)
			if err != nil {
				return nil, err
			}
			// Apart from the DB, try to find them in this block.
			// This could happen because in a block there could be
			// multiple batches with L1Batch = true (although it's
			// a very rare case).  If not found in the DB and the
			// block doesn't contain the l1UserTxs, it means that
			// the L1UserTxs queue with toForgeL1TxsNum was closed
			// empty, so we leave `l1UserTxs` as an empty slice.
			for _, l1UserTx := range rollupData.L1UserTxs {
				if *l1UserTx.ToForgeL1TxsNum == nextForgeL1TxsNum {
					l1UserTxs = append(l1UserTxs, l1UserTx)
				}
			}

			position = len(l1UserTxs)
		}
		// Get L1 Coordinator Txs
		for i := range forgeBatchArgs.L1CoordinatorTxs {
			l1CoordinatorTx := forgeBatchArgs.L1CoordinatorTxs[i]
			l1CoordinatorTx.Position = position
			// l1CoordinatorTx.ToForgeL1TxsNum = &forgeL1TxsNum
			l1CoordinatorTx.UserOrigin = false
			l1CoordinatorTx.EthBlockNum = blockNum
			l1CoordinatorTx.BatchNum = &batchNum
			l1Tx, err := common.NewL1Tx(&l1CoordinatorTx)
			if err != nil {
				return nil, err
			}

			batchData.L1CoordinatorTxs = append(batchData.L1CoordinatorTxs, *l1Tx)
			position++
			// fmt.Println("DGB l1coordtx")
		}

		// Insert all the txs forged in this batch (l1UserTxs,
		// L1CoordinatorTxs, PoolL2Txs) into stateDB so that they are
		// processed.
		poolL2Txs := common.L2TxsToPoolL2Txs(forgeBatchArgs.L2TxsData) // NOTE: This is a big ugly, find a better way

		// ProcessTxs updates poolL2Txs adding: Nonce (and also TokenID, but we don't use it).
		processTxsOut, err := s.stateDB.ProcessTxs(forgeBatchArgs.FeeIdxCoordinator, l1UserTxs,
			batchData.L1CoordinatorTxs, poolL2Txs)
		if err != nil {
			return nil, err
		}

		// Set batchNum in exits
		for i := range processTxsOut.ExitInfos {
			exit := &processTxsOut.ExitInfos[i]
			exit.BatchNum = batchNum
		}
		batchData.ExitTree = processTxsOut.ExitInfos

		l2Txs, err := common.PoolL2TxsToL2Txs(poolL2Txs) // NOTE: This is a big uggly, find a better way
		if err != nil {
			return nil, err
		}

		for i := range l2Txs {
			tx := &l2Txs[i]
			tx.Position = position
			tx.EthBlockNum = blockNum
			tx.BatchNum = batchNum
			nTx, err := common.NewL2Tx(tx)
			if err != nil {
				return nil, err
			}

			batchData.L2Txs = append(batchData.L2Txs, *nTx)
			position++
		}

		for i := range processTxsOut.CreatedAccounts {
			createdAccount := &processTxsOut.CreatedAccounts[i]
			createdAccount.Nonce = 0
			createdAccount.Balance = big.NewInt(0)
			createdAccount.BatchNum = batchNum
		}
		batchData.CreatedAccounts = processTxsOut.CreatedAccounts

		slotNum := int64(0)
		if ethBlock.EthBlockNum >= s.auctionConstants.GenesisBlockNum {
			slotNum = (ethBlock.EthBlockNum - s.auctionConstants.GenesisBlockNum) /
				int64(s.auctionConstants.BlocksPerSlot)
		}

		// Get Batch information
		batch := common.Batch{
			BatchNum:           batchNum,
			EthBlockNum:        blockNum,
			ForgerAddr:         *sender,
			CollectedFees:      processTxsOut.CollectedFees,
			FeeIdxsCoordinator: forgeBatchArgs.FeeIdxCoordinator,
			StateRoot:          forgeBatchArgs.NewStRoot,
			NumAccounts:        len(batchData.CreatedAccounts),
			LastIdx:            forgeBatchArgs.NewLastIdx,
			ExitRoot:           forgeBatchArgs.NewExitRoot,
			SlotNum:            slotNum,
		}
		nextForgeL1TxsNumCpy := nextForgeL1TxsNum
		if forgeBatchArgs.L1Batch {
			batch.ForgeL1TxsNum = &nextForgeL1TxsNumCpy
			batchData.L1Batch = true
			nextForgeL1TxsNum++
		}
		batchData.Batch = batch
		rollupData.Batches = append(rollupData.Batches, *batchData)
	}

	// Get Registered Tokens
	for _, evtAddToken := range rollupEvents.AddToken {
		var token common.Token

		token.TokenID = common.TokenID(evtAddToken.TokenID)
		token.EthAddr = evtAddToken.TokenAddress
		token.EthBlockNum = blockNum

		if consts, err := s.ethClient.EthERC20Consts(evtAddToken.TokenAddress); err != nil {
			log.Warnw("Error retreiving ERC20 token constants", "addr", evtAddToken.TokenAddress)
			token.Name = "ERC20_ETH_ERROR"
			token.Symbol = "ERROR"
			token.Decimals = 1
		} else {
			token.Name = cutStringMax(consts.Name, 20)
			token.Symbol = cutStringMax(consts.Symbol, 10)
			token.Decimals = consts.Decimals
		}

		rollupData.AddedTokens = append(rollupData.AddedTokens, token)
	}

	varsUpdate := false

	for _, evtUpdateForgeL1L2BatchTimeout := range rollupEvents.UpdateForgeL1L2BatchTimeout {
		s.vars.Rollup.ForgeL1L2BatchTimeout = evtUpdateForgeL1L2BatchTimeout.NewForgeL1L2BatchTimeout
		varsUpdate = true
	}

	for _, evtUpdateFeeAddToken := range rollupEvents.UpdateFeeAddToken {
		s.vars.Rollup.FeeAddToken = evtUpdateFeeAddToken.NewFeeAddToken
		varsUpdate = true
	}

	// NOTE: WithdrawDelay update doesn't have event, so we can't track changes

	// NOTE: Buckets update dones't have event, so we can't track changes

	for _, evtWithdraw := range rollupEvents.Withdraw {
		rollupData.Withdrawals = append(rollupData.Withdrawals, common.WithdrawInfo{
			Idx:             common.Idx(evtWithdraw.Idx),
			NumExitRoot:     common.BatchNum(evtWithdraw.NumExitRoot),
			InstantWithdraw: evtWithdraw.InstantWithdraw,
			TxHash:          evtWithdraw.TxHash,
		})
	}

	if varsUpdate {
		s.vars.Rollup.EthBlockNum = blockNum
		rollupData.Vars = s.vars.Rollup.Copy()
	}

	return &rollupData, nil
}

func cutStringMax(s string, max int) string {
	if len(s) > max {
		return s[:max]
	}
	return s
}

// auctionSync gets information from the Auction Contract
func (s *Synchronizer) auctionSync(ethBlock *common.Block) (*common.AuctionData, error) {
	blockNum := ethBlock.EthBlockNum
	var auctionData = common.NewAuctionData()

	// Get auction events in the block
	auctionEvents, blockHash, err := s.ethClient.AuctionEventsByBlock(blockNum)
	if err != nil {
		return nil, err
	}
	// No events in this block
	if blockHash == 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, eth.ErrBlockHashMismatchEvent
	}

	// Get bids
	for _, evtNewBid := range auctionEvents.NewBid {
		bid := common.Bid{
			SlotNum:     evtNewBid.Slot,
			BidValue:    evtNewBid.BidAmount,
			Bidder:      evtNewBid.Bidder,
			EthBlockNum: blockNum,
		}
		auctionData.Bids = append(auctionData.Bids, bid)
	}

	// Get Coordinators
	for _, evtSetCoordinator := range auctionEvents.SetCoordinator {
		coordinator := common.Coordinator{
			Bidder: evtSetCoordinator.BidderAddress,
			Forger: evtSetCoordinator.ForgerAddress,
			URL:    evtSetCoordinator.CoordinatorURL,
		}
		auctionData.Coordinators = append(auctionData.Coordinators, coordinator)
	}

	varsUpdate := false

	for _, evt := range auctionEvents.NewSlotDeadline {
		s.vars.Auction.SlotDeadline = evt.NewSlotDeadline
		varsUpdate = true
	}
	for _, evt := range auctionEvents.NewClosedAuctionSlots {
		s.vars.Auction.ClosedAuctionSlots = evt.NewClosedAuctionSlots
		varsUpdate = true
	}
	for _, evt := range auctionEvents.NewOutbidding {
		s.vars.Auction.Outbidding = evt.NewOutbidding
		varsUpdate = true
	}
	for _, evt := range auctionEvents.NewDonationAddress {
		s.vars.Auction.DonationAddress = evt.NewDonationAddress
		varsUpdate = true
	}
	for _, evt := range auctionEvents.NewBootCoordinator {
		s.vars.Auction.BootCoordinator = evt.NewBootCoordinator
		varsUpdate = true
	}
	for _, evt := range auctionEvents.NewOpenAuctionSlots {
		s.vars.Auction.OpenAuctionSlots = evt.NewOpenAuctionSlots
		varsUpdate = true
	}
	for _, evt := range auctionEvents.NewAllocationRatio {
		s.vars.Auction.AllocationRatio = evt.NewAllocationRatio
		varsUpdate = true
	}
	for _, evt := range auctionEvents.NewDefaultSlotSetBid {
		if evt.SlotSet > 6 { //nolint:gomnd
			return nil, fmt.Errorf("unexpected SlotSet in "+
				"auctionEvents.NewDefaultSlotSetBid: %v", evt.SlotSet)
		}
		s.vars.Auction.DefaultSlotSetBid[evt.SlotSet] = evt.NewInitialMinBid
		varsUpdate = true
	}

	// NOTE: We ignore NewForgeAllocated
	// NOTE: We ignore NewForge because we're already tracking ForgeBatch event from Rollup
	// NOTE: We ignore HEZClaimed

	if varsUpdate {
		s.vars.Auction.EthBlockNum = blockNum
		auctionData.Vars = s.vars.Auction.Copy()
	}

	return &auctionData, nil
}

// wdelayerSync gets information from the Withdrawal Delayer Contract
func (s *Synchronizer) wdelayerSync(ethBlock *common.Block) (*common.WDelayerData, error) {
	blockNum := ethBlock.EthBlockNum
	wDelayerData := common.NewWDelayerData()

	// Get wDelayer events in the block
	wDelayerEvents, blockHash, err := s.ethClient.WDelayerEventsByBlock(blockNum)
	if err != nil {
		return nil, err
	}
	// No events in this block
	if blockHash == 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, eth.ErrBlockHashMismatchEvent
	}

	for _, evt := range wDelayerEvents.Deposit {
		wDelayerData.Deposits = append(wDelayerData.Deposits, common.WDelayerTransfer{
			Owner:  evt.Owner,
			Token:  evt.Token,
			Amount: evt.Amount,
		})
		wDelayerData.DepositsByTxHash[evt.TxHash] =
			&wDelayerData.Deposits[len(wDelayerData.Deposits)-1]
	}
	for _, evt := range wDelayerEvents.Withdraw {
		wDelayerData.Withdrawals = append(wDelayerData.Withdrawals, common.WDelayerTransfer{
			Owner:  evt.Owner,
			Token:  evt.Token,
			Amount: evt.Amount,
		})
	}

	varsUpdate := false

	// TODO EscapeHatchWithdrawal
	for range wDelayerEvents.EmergencyModeEnabled {
		s.vars.WDelayer.EmergencyMode = true
		varsUpdate = true
	}
	for _, evt := range wDelayerEvents.NewWithdrawalDelay {
		s.vars.WDelayer.WithdrawalDelay = evt.WithdrawalDelay
		varsUpdate = true
	}
	for _, evt := range wDelayerEvents.NewHermezKeeperAddress {
		s.vars.WDelayer.HermezKeeperAddress = evt.NewHermezKeeperAddress
		varsUpdate = true
	}
	for _, evt := range wDelayerEvents.NewWhiteHackGroupAddress {
		s.vars.WDelayer.WhiteHackGroupAddress = evt.NewWhiteHackGroupAddress
		varsUpdate = true
	}
	for _, evt := range wDelayerEvents.NewHermezGovernanceDAOAddress {
		s.vars.WDelayer.HermezGovernanceDAOAddress = evt.NewHermezGovernanceDAOAddress
		varsUpdate = true
	}

	if varsUpdate {
		s.vars.WDelayer.EthBlockNum = blockNum
		wDelayerData.Vars = s.vars.WDelayer.Copy()
	}

	return &wDelayerData, nil
}

func getL1UserTx(eventsL1UserTx []eth.RollupEventL1UserTx, blockNum int64) ([]common.L1Tx, error) {
	l1Txs := make([]common.L1Tx, len(eventsL1UserTx))
	for i := range eventsL1UserTx {
		eventsL1UserTx[i].L1UserTx.EthBlockNum = blockNum
		// Check validity of L1UserTx
		l1Tx, err := common.NewL1Tx(&eventsL1UserTx[i].L1UserTx)
		if err != nil {
			return nil, err
		}
		l1Txs[i] = *l1Tx
	}
	return l1Txs, nil
}