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/l2db"
	"github.com/hermeznetwork/hermez-node/db/statedb"
	"github.com/hermeznetwork/hermez-node/eth"
	"github.com/hermeznetwork/hermez-node/log"
	"github.com/hermeznetwork/hermez-node/txprocessor"
	"github.com/hermeznetwork/tracerr"
)

const (
	// errStrUnknownBlock is the string returned by geth when querying an
	// unknown block
	errStrUnknownBlock = "unknown block"
)

var (
	// ErrUnknownBlock is the error returned by the Synchronizer when a
	// block is queried by hash but the ethereum node doesn't find it due
	// to it being discarded from a reorg.
	ErrUnknownBlock = fmt.Errorf("unknown block")
)

// Stats of the synchronizer
type Stats struct {
	Eth struct {
		RefreshPeriod time.Duration
		Updated       time.Time
		FirstBlockNum int64
		LastBlock     common.Block
		LastBatchNum  int64
	}
	Sync struct {
		Updated   time.Time
		LastBlock common.Block
		LastBatch common.Batch
		// LastL1BatchBlock is the last ethereum block in which an
		// l1Batch was forged
		LastL1BatchBlock  int64
		LastForgeL1TxsNum int64
		Auction           struct {
			CurrentSlot common.Slot
			NextSlot    common.Slot
		}
	}
}

// Synced returns true if the Synchronizer is up to date with the last ethereum block
func (s *Stats) Synced() bool {
	return s.Eth.LastBlock.Num == s.Sync.LastBlock.Num
}

// TODO(Edu): Consider removing all the mutexes from StatsHolder, make
// Synchronizer.Stats not thread-safe, don't pass the synchronizer to the
// debugAPI, and have a copy of the Stats in the DebugAPI that the node passes
// when the Sync updates.

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

// NewStatsHolder creates a new StatsHolder
func NewStatsHolder(firstBlockNum int64, refreshPeriod time.Duration) *StatsHolder {
	stats := Stats{}
	stats.Eth.RefreshPeriod = refreshPeriod
	stats.Eth.FirstBlockNum = firstBlockNum
	stats.Sync.LastForgeL1TxsNum = -1
	return &StatsHolder{Stats: stats}
}

// UpdateCurrentNextSlot updates the auction stats
func (s *StatsHolder) UpdateCurrentNextSlot(current *common.Slot, next *common.Slot) {
	s.rw.Lock()
	s.Sync.Auction.CurrentSlot = *current
	s.Sync.Auction.NextSlot = *next
	s.rw.Unlock()
}

// UpdateSync updates the synchronizer stats
func (s *StatsHolder) UpdateSync(lastBlock *common.Block, lastBatch *common.Batch,
	lastL1BatchBlock *int64, lastForgeL1TxsNum *int64) {
	now := time.Now()
	s.rw.Lock()
	s.Sync.LastBlock = *lastBlock
	if lastBatch != nil {
		s.Sync.LastBatch = *lastBatch
	}
	if lastL1BatchBlock != nil {
		s.Sync.LastL1BatchBlock = *lastL1BatchBlock
		s.Sync.LastForgeL1TxsNum = *lastForgeL1TxsNum
	}
	s.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.Eth.Updated)
	s.rw.RUnlock()
	if elapsed < s.Eth.RefreshPeriod {
		return nil
	}

	lastBlock, err := ethClient.EthBlockByNumber(context.TODO(), -1)
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("EthBlockByNumber: %w", err))
	}
	lastBatchNum, err := ethClient.RollupLastForgedBatch()
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("RollupLastForgedBatch: %w", err))
	}
	s.rw.Lock()
	s.Eth.Updated = now
	s.Eth.LastBlock = *lastBlock
	s.Eth.LastBatchNum = lastBatchNum
	s.rw.Unlock()
	return nil
}

// CopyStats returns a copy of the inner Stats
func (s *StatsHolder) CopyStats() *Stats {
	s.rw.RLock()
	sCopy := s.Stats
	if s.Sync.Auction.CurrentSlot.BidValue != nil {
		sCopy.Sync.Auction.CurrentSlot.BidValue =
			common.CopyBigInt(s.Sync.Auction.CurrentSlot.BidValue)
	}
	if s.Sync.Auction.CurrentSlot.DefaultSlotBid != nil {
		sCopy.Sync.Auction.CurrentSlot.DefaultSlotBid =
			common.CopyBigInt(s.Sync.Auction.CurrentSlot.DefaultSlotBid)
	}
	if s.Sync.Auction.NextSlot.BidValue != nil {
		sCopy.Sync.Auction.NextSlot.BidValue =
			common.CopyBigInt(s.Sync.Auction.NextSlot.BidValue)
	}
	if s.Sync.Auction.NextSlot.DefaultSlotBid != nil {
		sCopy.Sync.Auction.NextSlot.DefaultSlotBid =
			common.CopyBigInt(s.Sync.Auction.NextSlot.DefaultSlotBid)
	}
	if s.Sync.LastBatch.StateRoot != nil {
		sCopy.Sync.LastBatch.StateRoot =
			common.CopyBigInt(s.Sync.LastBatch.StateRoot)
	}
	s.rw.RUnlock()
	return &sCopy
}

func (s *StatsHolder) blocksPerc() float64 {
	syncLastBlockNum := s.Sync.LastBlock.Num
	if s.Sync.LastBlock.Num == 0 {
		syncLastBlockNum = s.Eth.FirstBlockNum - 1
	}
	return float64(syncLastBlockNum-(s.Eth.FirstBlockNum-1)) * 100.0 /
		float64(s.Eth.LastBlock.Num-(s.Eth.FirstBlockNum-1))
}

func (s *StatsHolder) batchesPerc(batchNum common.BatchNum) float64 {
	return float64(batchNum) * 100.0 /
		float64(s.Eth.LastBatchNum)
}

// StartBlockNums sets the first block used to start tracking the smart
// contracts
type StartBlockNums struct {
	Rollup   int64
	Auction  int64
	WDelayer int64
}

// Config is the Synchronizer configuration
type Config struct {
	StatsRefreshPeriod time.Duration
	ChainID            uint16
}

// Synchronizer implements the Synchronizer type
type Synchronizer struct {
	ethClient        eth.ClientInterface
	consts           common.SCConsts
	historyDB        *historydb.HistoryDB
	l2DB             *l2db.L2DB
	stateDB          *statedb.StateDB
	cfg              Config
	initVars         common.SCVariables
	startBlockNum    int64
	vars             common.SCVariables
	stats            *StatsHolder
	resetStateFailed bool
}

// NewSynchronizer creates a new Synchronizer
func NewSynchronizer(ethClient eth.ClientInterface, historyDB *historydb.HistoryDB,
	l2DB *l2db.L2DB, stateDB *statedb.StateDB, cfg Config) (*Synchronizer, error) {
	auctionConstants, err := ethClient.AuctionConstants()
	if err != nil {
		return nil, tracerr.Wrap(fmt.Errorf("NewSynchronizer ethClient.AuctionConstants(): %w",
			err))
	}
	rollupConstants, err := ethClient.RollupConstants()
	if err != nil {
		return nil, tracerr.Wrap(fmt.Errorf("NewSynchronizer ethClient.RollupConstants(): %w",
			err))
	}
	wDelayerConstants, err := ethClient.WDelayerConstants()
	if err != nil {
		return nil, tracerr.Wrap(fmt.Errorf("NewSynchronizer ethClient.WDelayerConstants(): %w",
			err))
	}
	consts := common.SCConsts{
		Rollup:   *rollupConstants,
		Auction:  *auctionConstants,
		WDelayer: *wDelayerConstants,
	}

	initVars, startBlockNums, err := getInitialVariables(ethClient, &consts)
	if err != nil {
		return nil, tracerr.Wrap(err)
	}
	log.Infow("Synchronizer syncing from smart contract blocks",
		"rollup", startBlockNums.Rollup,
		"auction", startBlockNums.Auction,
		"wdelayer", startBlockNums.WDelayer,
	)
	// Set startBlockNum to the minimum between Auction, Rollup and
	// WDelayer StartBlockNum
	startBlockNum := startBlockNums.Auction
	if startBlockNums.Rollup < startBlockNum {
		startBlockNum = startBlockNums.Rollup
	}
	if startBlockNums.WDelayer < startBlockNum {
		startBlockNum = startBlockNums.WDelayer
	}
	stats := NewStatsHolder(startBlockNum, cfg.StatsRefreshPeriod)
	s := &Synchronizer{
		ethClient:     ethClient,
		consts:        consts,
		historyDB:     historyDB,
		l2DB:          l2DB,
		stateDB:       stateDB,
		cfg:           cfg,
		initVars:      *initVars,
		startBlockNum: startBlockNum,
		stats:         stats,
	}
	return s, s.init()
}

// StateDB returns the inner StateDB
func (s *Synchronizer) StateDB() *statedb.StateDB {
	return s.stateDB
}

// Stats returns a copy of the Synchronizer Stats.  It is safe to call Stats()
// during a Sync call
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.consts.Auction
}

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

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

// SCVars returns a copy of the Smart Contract Variables
func (s *Synchronizer) SCVars() *common.SCVariables {
	return &common.SCVariables{
		Rollup:   *s.vars.Rollup.Copy(),
		Auction:  *s.vars.Auction.Copy(),
		WDelayer: *s.vars.WDelayer.Copy(),
	}
}

// setSlotCoordinator queries the highest bidder of a slot in the HistoryDB to
// determine the coordinator that can bid in a slot
func (s *Synchronizer) setSlotCoordinator(slot *common.Slot) error {
	bidCoord, err := s.historyDB.GetBestBidCoordinator(slot.SlotNum)
	if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
		return tracerr.Wrap(err)
	}
	if tracerr.Unwrap(err) == sql.ErrNoRows {
		slot.BootCoord = true
		slot.Forger = s.vars.Auction.BootCoordinator
		slot.URL = s.vars.Auction.BootCoordinatorURL
	} else if err == nil {
		slot.BidValue = bidCoord.BidValue
		slot.DefaultSlotBid = bidCoord.DefaultSlotSetBid[slot.SlotNum%6]
		// Only if the highest bid value is greater/equal than
		// the default slot bid, the bidder is the winner of
		// the slot.  Otherwise the boot coordinator is the
		// winner.
		if slot.BidValue.Cmp(slot.DefaultSlotBid) >= 0 {
			slot.Bidder = bidCoord.Bidder
			slot.Forger = bidCoord.Forger
			slot.URL = bidCoord.URL
		} else {
			slot.BootCoord = true
			slot.Forger = s.vars.Auction.BootCoordinator
			slot.URL = s.vars.Auction.BootCoordinatorURL
		}
	}
	return nil
}

// updateCurrentSlot updates the slot with information of the current slot.
// The information about which coordinator is allowed to forge is only updated
// when we are Synced.
// hasBatch is true when the last synced block contained at least one batch.
func (s *Synchronizer) updateCurrentSlot(slot *common.Slot, reset bool, hasBatch bool) error {
	// We want the next block because the current one is already mined
	blockNum := s.stats.Sync.LastBlock.Num + 1
	slotNum := s.consts.Auction.SlotNum(blockNum)
	syncLastBlockNum := s.stats.Sync.LastBlock.Num
	if reset {
		// Using this query only to know if there
		dbFirstBatchBlockNum, err := s.historyDB.GetFirstBatchBlockNumBySlot(slotNum)
		if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
			return tracerr.Wrap(fmt.Errorf("historyDB.GetFirstBatchBySlot: %w", err))
		} else if tracerr.Unwrap(err) == sql.ErrNoRows {
			hasBatch = false
		} else {
			hasBatch = true
			syncLastBlockNum = dbFirstBatchBlockNum
		}
		slot.ForgerCommitment = false
	} else if slotNum > slot.SlotNum {
		// We are in a new slotNum, start from default values
		slot.ForgerCommitment = false
	}
	slot.SlotNum = slotNum
	slot.StartBlock, slot.EndBlock = s.consts.Auction.SlotBlocks(slot.SlotNum)
	if hasBatch && s.consts.Auction.RelativeBlock(syncLastBlockNum) < int64(s.vars.Auction.SlotDeadline) {
		slot.ForgerCommitment = true
	}
	// If Synced, update the current coordinator
	if s.stats.Synced() && blockNum >= s.consts.Auction.GenesisBlockNum {
		if err := s.setSlotCoordinator(slot); err != nil {
			return tracerr.Wrap(err)
		}

		// TODO: Remove this SANITY CHECK once this code is tested enough
		// BEGIN SANITY CHECK
		canForge, err := s.ethClient.AuctionCanForge(slot.Forger, blockNum)
		if err != nil {
			return tracerr.Wrap(fmt.Errorf("AuctionCanForge: %w", err))
		}
		if !canForge {
			return tracerr.Wrap(fmt.Errorf("Synchronized value of forger address for closed slot "+
				"differs from smart contract: %+v", slot))
		}
		// END SANITY CHECK
	}
	return nil
}

// updateNextSlot updates the slot with information of the next slot.
// The information about which coordinator is allowed to forge is only updated
// when we are Synced.
func (s *Synchronizer) updateNextSlot(slot *common.Slot) error {
	// We want the next block because the current one is already mined
	blockNum := s.stats.Sync.LastBlock.Num + 1
	slotNum := s.consts.Auction.SlotNum(blockNum) + 1
	slot.SlotNum = slotNum
	slot.ForgerCommitment = false
	slot.StartBlock, slot.EndBlock = s.consts.Auction.SlotBlocks(slot.SlotNum)
	// If Synced, update the current coordinator
	if s.stats.Synced() && blockNum >= s.consts.Auction.GenesisBlockNum {
		if err := s.setSlotCoordinator(slot); err != nil {
			return tracerr.Wrap(err)
		}

		// TODO: Remove this SANITY CHECK once this code is tested enough
		// BEGIN SANITY CHECK
		canForge, err := s.ethClient.AuctionCanForge(slot.Forger, slot.StartBlock)
		if err != nil {
			return tracerr.Wrap(fmt.Errorf("AuctionCanForge: %w", err))
		}
		if !canForge {
			return tracerr.Wrap(fmt.Errorf("Synchronized value of forger address for closed slot "+
				"differs from smart contract: %+v", slot))
		}
		// END SANITY CHECK
	}
	return nil
}

// updateCurrentNextSlotIfSync updates the current and next slot.  Information
// about forger address that is allowed to forge is only updated if we are
// Synced.
func (s *Synchronizer) updateCurrentNextSlotIfSync(reset bool, hasBatch bool) error {
	current := s.stats.Sync.Auction.CurrentSlot
	next := s.stats.Sync.Auction.NextSlot
	if err := s.updateCurrentSlot(&current, reset, hasBatch); err != nil {
		return tracerr.Wrap(err)
	}
	if err := s.updateNextSlot(&next); err != nil {
		return tracerr.Wrap(err)
	}
	s.stats.UpdateCurrentNextSlot(&current, &next)
	return nil
}

func (s *Synchronizer) init() error {
	// Update stats parameters so that they have valid values before the
	// first Sync call
	if err := s.stats.UpdateEth(s.ethClient); err != nil {
		return tracerr.Wrap(err)
	}
	lastBlock := &common.Block{}
	lastSavedBlock, err := s.historyDB.GetLastBlock()
	// `s.historyDB.GetLastBlock()` will never return `sql.ErrNoRows`
	// because we always have the default block 0 in the DB
	if err != nil {
		return tracerr.Wrap(err)
	}
	// If we only have the default block 0,
	// make sure that the stateDB is clean
	if lastSavedBlock.Num == 0 {
		if err := s.stateDB.Reset(0); err != nil {
			return tracerr.Wrap(err)
		}
	} 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,
		"syncBlocksPerc", s.stats.blocksPerc(),
		"ethFirstBlockNum", s.stats.Eth.FirstBlockNum,
		"ethLastBlock", s.stats.Eth.LastBlock,
	)
	log.Infow("Sync init batch",
		"syncLastBatch", s.stats.Sync.LastBatch.BatchNum,
		"syncBatchesPerc", s.stats.batchesPerc(s.stats.Sync.LastBatch.BatchNum),
		"ethLastBatch", s.stats.Eth.LastBatchNum,
	)
	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
}

// Sync attempts to synchronize an ethereum block starting from lastSavedBlock.
// If lastSavedBlock is nil, the lastSavedBlock value is obtained from de DB.
// If a block is synced, 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) Sync(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 {
		// Get lastSavedBlock from History DB
		lastSavedBlock, err = s.historyDB.GetLastBlock()
		if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
			return nil, nil, tracerr.Wrap(err)
		}
		// If we don't have any stored block, we must do a full sync
		// starting from the startBlockNum
		if tracerr.Unwrap(err) == sql.ErrNoRows || lastSavedBlock.Num == 0 {
			nextBlockNum = s.startBlockNum
			lastSavedBlock = nil
		}
	}
	if lastSavedBlock != nil {
		nextBlockNum = lastSavedBlock.Num + 1
		if lastSavedBlock.Num < s.startBlockNum {
			return nil, nil, tracerr.Wrap(
				fmt.Errorf("lastSavedBlock (%v) < startBlockNum (%v)",
					lastSavedBlock.Num, s.startBlockNum))
		}
	}

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

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

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

	// Check that the obtained ethBlock.ParentHash == prevEthBlock.Hash; if not, reorg!
	if lastSavedBlock != nil {
		if lastSavedBlock.Hash != ethBlock.ParentHash {
			// Reorg detected
			log.Debugw("Reorg Detected",
				"blockNum", ethBlock.Num,
				"block.parent(got)", ethBlock.ParentHash, "parent.hash(exp)", lastSavedBlock.Hash)
			lastDBBlockNum, err := s.reorg(lastSavedBlock)
			if err != nil {
				return nil, nil, tracerr.Wrap(err)
			}
			discarded := lastSavedBlock.Num - lastDBBlockNum
			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 resetting 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 {
		return nil, nil, tracerr.Wrap(err)
	}

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

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

	for i := range rollupData.Withdrawals {
		withdrawal := &rollupData.Withdrawals[i]
		if !withdrawal.InstantWithdraw {
			wDelayerTransfers := wDelayerData.DepositsByTxHash[withdrawal.TxHash]
			if len(wDelayerTransfers) == 0 {
				return nil, nil, tracerr.Wrap(fmt.Errorf("WDelayer deposit corresponding to " +
					"non-instant rollup withdrawal not found"))
			}
			// Pop the first wDelayerTransfer to consume them in chronological order
			wDelayerTransfer := wDelayerTransfers[0]
			wDelayerData.DepositsByTxHash[withdrawal.TxHash] =
				wDelayerData.DepositsByTxHash[withdrawal.TxHash][1:]

			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,
	}

	err = s.historyDB.AddBlockSCData(blockData)
	if err != nil {
		return nil, nil, tracerr.Wrap(err)
	}

	batchesLen := len(rollupData.Batches)
	if batchesLen == 0 {
		s.stats.UpdateSync(ethBlock, nil, nil, nil)
	} else {
		var lastL1BatchBlock *int64
		var lastForgeL1TxsNum *int64
		for _, batchData := range rollupData.Batches {
			if batchData.L1Batch {
				lastL1BatchBlock = &batchData.Batch.EthBlockNum
				lastForgeL1TxsNum = batchData.Batch.ForgeL1TxsNum
			}
		}
		s.stats.UpdateSync(ethBlock,
			&rollupData.Batches[batchesLen-1].Batch,
			lastL1BatchBlock, lastForgeL1TxsNum)
	}
	hasBatch := false
	if len(rollupData.Batches) > 0 {
		hasBatch = true
	}
	if err = s.updateCurrentNextSlotIfSync(false, hasBatch); err != nil {
		return nil, nil, tracerr.Wrap(err)
	}

	for _, batchData := range rollupData.Batches {
		metricSyncedLastBatchNum.Set(float64(batchData.Batch.BatchNum))
		metricEthLastBatchNum.Set(float64(s.stats.Eth.LastBatchNum))
		log.Debugw("Synced batch",
			"syncLastBatch", batchData.Batch.BatchNum,
			"syncBatchesPerc", s.stats.batchesPerc(batchData.Batch.BatchNum),
			"ethLastBatch", s.stats.Eth.LastBatchNum,
		)
	}
	metricSyncedLastBlockNum.Set(float64(s.stats.Sync.LastBlock.Num))
	metricEthLastBlockNum.Set(float64(s.stats.Eth.LastBlock.Num))
	log.Debugw("Synced block",
		"syncLastBlockNum", s.stats.Sync.LastBlock.Num,
		"syncBlocksPerc", s.stats.blocksPerc(),
		"ethLastBlockNum", s.stats.Eth.LastBlock.Num,
	)

	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.Num

	var block *common.Block
	for blockNum >= s.startBlockNum {
		ethBlock, err := s.ethClient.EthBlockByNumber(context.Background(), blockNum)
		if err != nil {
			return 0, tracerr.Wrap(fmt.Errorf("ethClient.EthBlockByNumber: %w", err))
		}

		block, err = s.historyDB.GetBlock(blockNum)
		if err != nil {
			return 0, tracerr.Wrap(fmt.Errorf("historyDB.GetBlock: %w", err))
		}
		if block.Hash == ethBlock.Hash {
			log.Debugf("Found valid block: %v", blockNum)
			break
		}
		blockNum--
	}
	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
	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
}

func getInitialVariables(ethClient eth.ClientInterface,
	consts *common.SCConsts) (*common.SCVariables, *StartBlockNums, error) {
	rollupInit, rollupInitBlock, err := ethClient.RollupEventInit()
	if err != nil {
		return nil, nil, tracerr.Wrap(fmt.Errorf("RollupEventInit: %w", err))
	}
	auctionInit, auctionInitBlock, err := ethClient.AuctionEventInit()
	if err != nil {
		return nil, nil, tracerr.Wrap(fmt.Errorf("AuctionEventInit: %w", err))
	}
	wDelayerInit, wDelayerInitBlock, err := ethClient.WDelayerEventInit()
	if err != nil {
		return nil, nil, tracerr.Wrap(fmt.Errorf("WDelayerEventInit: %w", err))
	}
	rollupVars := rollupInit.RollupVariables()
	auctionVars := auctionInit.AuctionVariables(consts.Auction.InitialMinimalBidding)
	wDelayerVars := wDelayerInit.WDelayerVariables()
	return &common.SCVariables{
			Rollup:   *rollupVars,
			Auction:  *auctionVars,
			WDelayer: *wDelayerVars,
		}, &StartBlockNums{
			Rollup:   rollupInitBlock,
			Auction:  auctionInitBlock,
			WDelayer: wDelayerInitBlock,
		}, nil
}

func (s *Synchronizer) resetState(block *common.Block) 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 tracerr.Unwrap(err) == sql.ErrNoRows {
		vars := s.initVars
		log.Info("Setting initial SCVars in HistoryDB")
		if err = s.historyDB.SetInitialSCVars(&vars.Rollup, &vars.Auction, &vars.WDelayer); err != nil {
			return tracerr.Wrap(fmt.Errorf("historyDB.SetInitialSCVars: %w", err))
		}
		s.vars.Rollup = *vars.Rollup.Copy()
		s.vars.Auction = *vars.Auction.Copy()
		s.vars.WDelayer = *vars.WDelayer.Copy()
		// Add initial boot coordinator to HistoryDB
		if err := s.historyDB.AddCoordinators([]common.Coordinator{{
			Forger:      s.initVars.Auction.BootCoordinator,
			URL:         s.initVars.Auction.BootCoordinatorURL,
			EthBlockNum: s.initVars.Auction.EthBlockNum,
		}}); err != nil {
			return tracerr.Wrap(err)
		}
	} else if err != nil {
		return tracerr.Wrap(err)
	} else {
		s.vars.Rollup = *rollup
		s.vars.Auction = *auction
		s.vars.WDelayer = *wDelayer
	}

	batch, err := s.historyDB.GetLastBatch()
	if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
		return tracerr.Wrap(fmt.Errorf("historyDB.GetLastBatchNum: %w", err))
	}
	if tracerr.Unwrap(err) == sql.ErrNoRows {
		batch = &common.Batch{}
	}

	err = s.stateDB.Reset(batch.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))
	}
	if tracerr.Unwrap(err) == sql.ErrNoRows {
		lastL1BatchBlockNum = 0
	}

	lastForgeL1TxsNum, err := s.historyDB.GetLastL1TxsNum()
	if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
		return tracerr.Wrap(fmt.Errorf("historyDB.GetLastL1BatchBlockNum: %w", err))
	}
	if tracerr.Unwrap(err) == sql.ErrNoRows || lastForgeL1TxsNum == nil {
		n := int64(-1)
		lastForgeL1TxsNum = &n
	}

	s.stats.UpdateSync(block, batch, &lastL1BatchBlockNum, lastForgeL1TxsNum)

	if err := s.updateCurrentNextSlotIfSync(true, false); err != nil {
		return tracerr.Wrap(err)
	}
	return nil
}

// rollupSync retrieves 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.Num
	var rollupData = common.NewRollupData()
	// var forgeL1TxsNum int64

	// Get rollup events in the block, and make sure the block hash matches
	// the expected one.
	rollupEvents, err := s.ethClient.RollupEventsByBlock(blockNum, &ethBlock.Hash)
	if err != nil && err.Error() == errStrUnknownBlock {
		return nil, tracerr.Wrap(ErrUnknownBlock)
	} else if err != nil {
		return nil, tracerr.Wrap(fmt.Errorf("RollupEventsByBlock: %w", err))
	}
	// No events in this block
	if rollupEvents == nil {
		return &rollupData, nil
	}

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

	// Get L1UserTX
	rollupData.L1UserTxs, err = getL1UserTx(rollupEvents.L1UserTx, blockNum)
	if err != nil {
		return nil, tracerr.Wrap(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,
			evtForgeBatch.L1UserTxsLen)
		if err != nil {
			return nil, tracerr.Wrap(fmt.Errorf("RollupForgeBatchArgs: %w", 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.GetUnforgedL1UserTxs(nextForgeL1TxsNum)
			if err != nil {
				return nil, tracerr.Wrap(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)
		}

		l1TxsAuth := make([]common.AccountCreationAuth,
			0, len(forgeBatchArgs.L1CoordinatorTxsAuths))
		// 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, tracerr.Wrap(err)
			}

			batchData.L1CoordinatorTxs = append(batchData.L1CoordinatorTxs, *l1Tx)
			position++

			// Create a slice of account creation auth to be
			// inserted later if not exists
			if l1CoordinatorTx.FromEthAddr != common.RollupConstEthAddressInternalOnly {
				l1CoordinatorTxAuth := forgeBatchArgs.L1CoordinatorTxsAuths[i]
				l1TxsAuth = append(l1TxsAuth, common.AccountCreationAuth{
					EthAddr:   l1CoordinatorTx.FromEthAddr,
					BJJ:       l1CoordinatorTx.FromBJJ,
					Signature: l1CoordinatorTxAuth,
				})
			}

			// fmt.Println("DGB l1coordtx")
		}

		// Insert the slice of account creation auth
		// only if the node run as a coordinator
		if s.l2DB != nil && len(l1TxsAuth) > 0 {
			err = s.l2DB.AddManyAccountCreationAuth(l1TxsAuth)
			if err != nil {
				return nil, tracerr.Wrap(err)
			}
		}

		// Insert all the txs forged in this batch (l1UserTxs,
		// L1CoordinatorTxs, PoolL2Txs) into stateDB so that they are
		// processed.

		// Set TxType to the forged L2Txs
		for i := range forgeBatchArgs.L2TxsData {
			if err := forgeBatchArgs.L2TxsData[i].SetType(); err != nil {
				return nil, tracerr.Wrap(err)
			}
		}

		// Transform L2 txs to PoolL2Txs
		// NOTE: This is a big ugly, find a better way
		poolL2Txs := common.L2TxsToPoolL2Txs(forgeBatchArgs.L2TxsData)

		if int(forgeBatchArgs.VerifierIdx) >= len(s.consts.Rollup.Verifiers) {
			return nil, tracerr.Wrap(fmt.Errorf("forgeBatchArgs.VerifierIdx (%v) >= "+
				" len(s.consts.Rollup.Verifiers) (%v)",
				forgeBatchArgs.VerifierIdx, len(s.consts.Rollup.Verifiers)))
		}
		tpc := txprocessor.Config{
			NLevels:  uint32(s.consts.Rollup.Verifiers[forgeBatchArgs.VerifierIdx].NLevels),
			MaxTx:    uint32(s.consts.Rollup.Verifiers[forgeBatchArgs.VerifierIdx].MaxTx),
			ChainID:  s.cfg.ChainID,
			MaxFeeTx: common.RollupConstMaxFeeIdxCoordinator,
			MaxL1Tx:  common.RollupConstMaxL1Tx,
		}
		tp := txprocessor.NewTxProcessor(s.stateDB, tpc)

		// ProcessTxs updates poolL2Txs adding: Nonce (and also TokenID, but we don't use it).
		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))
		}
		if s.stateDB.MT.Root().BigInt().Cmp(forgeBatchArgs.NewStRoot) != 0 {
			return nil, tracerr.Wrap(fmt.Errorf("stateDB.MTRoot (%v) != "+
				"forgeBatchArgs.NewStRoot (%v)",
				s.stateDB.MT.Root().BigInt(), forgeBatchArgs.NewStRoot))
		}

		// Transform processed PoolL2 txs to L2 and store in BatchData
		l2Txs, err := common.PoolL2TxsToL2Txs(poolL2Txs) // NOTE: This is a big uggly, find a better way
		if err != nil {
			return nil, tracerr.Wrap(err)
		}

		// Set TxID, BlockNum, BatchNum and Position to the forged L2Txs
		for i := range l2Txs {
			if err := l2Txs[i].SetID(); err != nil {
				return nil, tracerr.Wrap(err)
			}
			l2Txs[i].EthBlockNum = blockNum
			l2Txs[i].BatchNum = batchNum
			l2Txs[i].Position = position
			position++
		}
		batchData.L2Txs = l2Txs

		// Set the BatchNum in the forged L1UserTxs
		for i := range l1UserTxs {
			l1UserTxs[i].BatchNum = &batchNum
		}
		batchData.L1UserTxs = l1UserTxs

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

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

		batchData.UpdatedAccounts = make([]common.AccountUpdate, 0,
			len(processTxsOut.UpdatedAccounts))
		for _, acc := range processTxsOut.UpdatedAccounts {
			batchData.UpdatedAccounts = append(batchData.UpdatedAccounts,
				common.AccountUpdate{
					EthBlockNum: blockNum,
					BatchNum:    batchNum,
					Idx:         acc.Idx,
					Nonce:       acc.Nonce,
					Balance:     acc.Balance,
				})
		}

		slotNum := int64(0)
		if ethBlock.Num >= s.consts.Auction.GenesisBlockNum {
			slotNum = (ethBlock.Num - s.consts.Auction.GenesisBlockNum) /
				int64(s.consts.Auction.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)
	}

	for _, evt := range rollupEvents.UpdateBucketWithdraw {
		rollupData.UpdateBucketWithdraw = append(rollupData.UpdateBucketWithdraw,
			common.BucketUpdate{
				EthBlockNum: blockNum,
				NumBucket:   evt.NumBucket,
				BlockStamp:  evt.BlockStamp,
				Withdrawals: evt.Withdrawals,
			})
	}

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

	for _, evt := range rollupEvents.UpdateTokenExchange {
		if len(evt.AddressArray) != len(evt.ValueArray) {
			return nil, tracerr.Wrap(fmt.Errorf("in RollupEventUpdateTokenExchange "+
				"len(AddressArray) != len(ValueArray) (%v != %v)",
				len(evt.AddressArray), len(evt.ValueArray)))
		}
		for i := range evt.AddressArray {
			rollupData.TokenExchanges = append(rollupData.TokenExchanges,
				common.TokenExchange{
					EthBlockNum: blockNum,
					Address:     evt.AddressArray[i],
					ValueUSD:    int64(evt.ValueArray[i]),
				})
		}
	}

	varsUpdate := false

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

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

	for _, evt := range rollupEvents.UpdateWithdrawalDelay {
		s.vars.Rollup.WithdrawalDelay = evt.NewWithdrawalDelay
		varsUpdate = true
	}

	// NOTE: We skip the event rollupEvents.SafeMode because the
	// implementation RollupEventsByBlock already inserts a non-existing
	// RollupEventUpdateBucketsParameters into UpdateBucketsParameters with
	// all the bucket values at 0 and SafeMode = true

	for _, evt := range rollupEvents.UpdateBucketsParameters {
		for i, bucket := range evt.ArrayBuckets {
			s.vars.Rollup.Buckets[i] = common.BucketParams{
				CeilUSD:             bucket.CeilUSD,
				Withdrawals:         bucket.Withdrawals,
				BlockWithdrawalRate: bucket.BlockWithdrawalRate,
				MaxWithdrawals:      bucket.MaxWithdrawals,
			}
		}
		s.vars.Rollup.SafeMode = evt.SafeMode
		varsUpdate = true
	}

	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.Num
	var auctionData = common.NewAuctionData()

	// Get auction events in the block
	auctionEvents, err := s.ethClient.AuctionEventsByBlock(blockNum, &ethBlock.Hash)
	if err != nil && err.Error() == errStrUnknownBlock {
		return nil, tracerr.Wrap(ErrUnknownBlock)
	} else if err != nil {
		return nil, tracerr.Wrap(fmt.Errorf("AuctionEventsByBlock: %w", err))
	}
	// No events in this block
	if auctionEvents == nil {
		return &auctionData, nil
	}

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

	// Get Coordinators
	for _, evt := range auctionEvents.SetCoordinator {
		coordinator := common.Coordinator{
			Bidder:      evt.BidderAddress,
			Forger:      evt.ForgerAddress,
			URL:         evt.CoordinatorURL,
			EthBlockNum: blockNum,
		}
		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
		s.vars.Auction.BootCoordinatorURL = evt.NewBootCoordinatorURL
		varsUpdate = true
		// Add new boot coordinator
		auctionData.Coordinators = append(auctionData.Coordinators, common.Coordinator{
			Forger:      evt.NewBootCoordinator,
			URL:         evt.NewBootCoordinatorURL,
			EthBlockNum: blockNum,
		})
	}
	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, tracerr.Wrap(fmt.Errorf("unexpected SlotSet in "+
				"auctionEvents.NewDefaultSlotSetBid: %v", evt.SlotSet))
		}
		s.vars.Auction.DefaultSlotSetBid[evt.SlotSet] = evt.NewInitialMinBid
		s.vars.Auction.DefaultSlotSetBidSlotNum = s.consts.Auction.SlotNum(blockNum) +
			int64(s.vars.Auction.ClosedAuctionSlots)
		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.Num
	wDelayerData := common.NewWDelayerData()

	// Get wDelayer events in the block
	wDelayerEvents, err := s.ethClient.WDelayerEventsByBlock(blockNum, &ethBlock.Hash)
	if err != nil && err.Error() == errStrUnknownBlock {
		return nil, tracerr.Wrap(ErrUnknownBlock)
	} else if err != nil {
		return nil, tracerr.Wrap(fmt.Errorf("WDelayerEventsByBlock: %w", err))
	}
	// No events in this block
	if wDelayerEvents == nil {
		return &wDelayerData, nil
	}

	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] =
			append(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,
		})
	}
	for _, evt := range wDelayerEvents.EscapeHatchWithdrawal {
		wDelayerData.EscapeHatchWithdrawals = append(wDelayerData.EscapeHatchWithdrawals,
			common.WDelayerEscapeHatchWithdrawal{
				EthBlockNum: blockNum,
				Who:         evt.Who,
				To:          evt.To,
				TokenAddr:   evt.Token,
				Amount:      evt.Amount,
			})
	}

	varsUpdate := false

	for range wDelayerEvents.EmergencyModeEnabled {
		s.vars.WDelayer.EmergencyMode = true
		s.vars.WDelayer.EmergencyModeStartingBlock = blockNum
		varsUpdate = true
	}
	for _, evt := range wDelayerEvents.NewWithdrawalDelay {
		s.vars.WDelayer.WithdrawalDelay = evt.WithdrawalDelay
		varsUpdate = true
	}
	for _, evt := range wDelayerEvents.NewEmergencyCouncil {
		s.vars.WDelayer.EmergencyCouncilAddress = evt.NewEmergencyCouncil
		varsUpdate = true
	}
	for _, evt := range wDelayerEvents.NewHermezGovernanceAddress {
		s.vars.WDelayer.HermezGovernanceAddress = evt.NewHermezGovernanceAddress
		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, tracerr.Wrap(err)
		}
		l1Txs[i] = *l1Tx
	}
	return l1Txs, nil
}