Calculate ForgeBatch gasLimit with parametrized formula

Add the following config parameters at `Coordinator.EthClient.ForgeBatchGasCost`: - `Fixed` - `L1UserTx` - `L1CoordTx` - `L2Tx` Which are the costs associated to a ForgeBatch transaction, split into different parts to be used in the formula to compute the gasLimit.
Reorg l2db before starting pipeline
2026-02-07 11:26:44 +01:00 · 2021-02-25 15:30:50 +01:00 · 2021-02-25 15:30:38 +01:00 · 2021-02-25 15:30:26 +01:00
32 changed files with 841 additions and 1628 deletions
--- a/api/api.go
+++ b/api/api.go
@@ -2,19 +2,39 @@ package api

 import (
 	"errors"
+	"sync"

 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/gin-gonic/gin"
+	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
 	"github.com/hermeznetwork/tracerr"
 )

+// TODO: Add correct values to constants
+const (
+	createAccountExtraFeePercentage         float64 = 2
+	createAccountInternalExtraFeePercentage float64 = 2.5
+)
+
+// Status define status of the network
+type Status struct {
+	sync.RWMutex
+	Network           Network                       `json:"network"`
+	Metrics           historydb.Metrics             `json:"metrics"`
+	Rollup            historydb.RollupVariablesAPI  `json:"rollup"`
+	Auction           historydb.AuctionVariablesAPI `json:"auction"`
+	WithdrawalDelayer common.WDelayerVariables      `json:"withdrawalDelayer"`
+	RecommendedFee    common.RecommendedFee         `json:"recommendedFee"`
+}
+
 // API serves HTTP requests to allow external interaction with the Hermez node
 type API struct {
 	h             *historydb.HistoryDB
 	cg            *configAPI
 	l2            *l2db.L2DB
+	status        Status
 	chainID       uint16
 	hermezAddress ethCommon.Address
 }
@@ -25,6 +45,7 @@ func NewAPI(
 	server *gin.Engine,
 	hdb *historydb.HistoryDB,
 	l2db *l2db.L2DB,
+	config *Config,
 ) (*API, error) {
 	// Check input
 	// TODO: is stateDB only needed for explorer endpoints or for both?
@@ -34,20 +55,18 @@ func NewAPI(
 	if explorerEndpoints && hdb == nil {
 		return nil, tracerr.Wrap(errors.New("cannot serve Explorer endpoints without HistoryDB"))
 	}
-	ni, err := hdb.GetNodeInfo()
-	if err != nil {
-		return nil, err
-	}
+
 	a := &API{
 		h: hdb,
 		cg: &configAPI{
-			RollupConstants:   *newRollupConstants(ni.Constants.RollupConstants),
-			AuctionConstants:  ni.Constants.AuctionConstants,
-			WDelayerConstants: ni.Constants.WDelayerConstants,
+			RollupConstants:   *newRollupConstants(config.RollupConstants),
+			AuctionConstants:  config.AuctionConstants,
+			WDelayerConstants: config.WDelayerConstants,
 		},
 		l2:            l2db,
-		chainID:       ni.Constants.ChainID,
-		hermezAddress: ni.Constants.HermezAddress,
+		status:        Status{},
+		chainID:       config.ChainID,
+		hermezAddress: config.HermezAddress,
 	}

 	// Add coordinator endpoints
--- a/api/api_test.go
+++ b/api/api_test.go
@@ -180,7 +180,7 @@ type testCommon struct {
 	auctionVars      common.AuctionVariables
 	rollupVars       common.RollupVariables
 	wdelayerVars     common.WDelayerVariables
-	nextForgers      []historydb.NextForgerAPI
+	nextForgers      []NextForger
 }

 var tc testCommon
@@ -206,6 +206,16 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
+	// StateDB
+	dir, err := ioutil.TempDir("", "tmpdb")
+	if err != nil {
+		panic(err)
+	}
+	defer func() {
+		if err := os.RemoveAll(dir); err != nil {
+			panic(err)
+		}
+	}()
 	// L2DB
 	l2DB := l2db.NewL2DB(database, database, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB()) // this will clean HistoryDB and L2DB
@@ -220,26 +230,15 @@ func TestMain(m *testing.M) {

 	// API
 	apiGin := gin.Default()
-	// Reset DB
-	test.WipeDB(hdb.DB())
-	if err := hdb.SetInitialNodeInfo(10, 0.0, &historydb.Constants{
-		RollupConstants:   _config.RollupConstants,
-		AuctionConstants:  _config.AuctionConstants,
-		WDelayerConstants: _config.WDelayerConstants,
-		ChainID:           chainID,
-		HermezAddress:     _config.HermezAddress,
-	}); err != nil {
-		panic(err)
-	}
 	api, err = NewAPI(
 		true,
 		true,
 		apiGin,
 		hdb,
 		l2DB,
+		&_config,
 	)
 	if err != nil {
-		log.Error(err)
 		panic(err)
 	}
 	// Start server
@@ -255,6 +254,9 @@ func TestMain(m *testing.M) {
 		}
 	}()

+	// Reset DB
+	test.WipeDB(api.h.DB())
+
 	// Genratre blockchain data with til
 	tcc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
 	tilCfgExtra := til.ConfigExtra{
@@ -455,19 +457,19 @@ func TestMain(m *testing.M) {
 	if err = api.h.AddBids(bids); err != nil {
 		panic(err)
 	}
-	bootForger := historydb.NextForgerAPI{
+	bootForger := NextForger{
 		Coordinator: historydb.CoordinatorAPI{
 			Forger: auctionVars.BootCoordinator,
 			URL:    auctionVars.BootCoordinatorURL,
 		},
 	}
 	// Set next forgers: set all as boot coordinator then replace the non boot coordinators
-	nextForgers := []historydb.NextForgerAPI{}
+	nextForgers := []NextForger{}
 	var initBlock int64 = 140
 	var deltaBlocks int64 = 40
 	for i := 1; i < int(auctionVars.ClosedAuctionSlots)+2; i++ {
 		fromBlock := initBlock + deltaBlocks*int64(i-1)
-		bootForger.Period = historydb.Period{
+		bootForger.Period = Period{
 			SlotNum:   int64(i),
 			FromBlock: fromBlock,
 			ToBlock:   fromBlock + deltaBlocks - 1,
@@ -584,12 +586,15 @@ func TestMain(m *testing.M) {
 	if err := database.Close(); err != nil {
 		panic(err)
 	}
+	if err := os.RemoveAll(dir); err != nil {
+		panic(err)
+	}
 	os.Exit(result)
 }

 func TestTimeout(t *testing.T) {
 	pass := os.Getenv("POSTGRES_PASS")
-	databaseTO, err := db.ConnectSQLDB(5432, "localhost", "hermez", pass, "hermez")
+	databaseTO, err := db.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	apiConnConTO := db.NewAPICnnectionController(1, 100*time.Millisecond)
 	hdbTO := historydb.NewHistoryDB(databaseTO, databaseTO, apiConnConTO)
@@ -619,12 +624,14 @@ func TestTimeout(t *testing.T) {
 			require.NoError(t, err)
 		}
 	}()
+	_config := getConfigTest(0)
 	_, err = NewAPI(
 		true,
 		true,
 		apiGinTO,
 		hdbTO,
 		l2DBTO,
+		&_config,
 	)
 	require.NoError(t, err)

--- a/api/slots_test.go
+++ b/api/slots_test.go
@@ -99,14 +99,12 @@ func TestGetSlot(t *testing.T) {
 			nil, &fetchedSlot,
 		),
 	)
-	ni, err := api.h.GetNodeInfoAPI()
-	assert.NoError(t, err)
-	emptySlot := api.getEmptyTestSlot(slotNum, ni.APIState.Network.LastSyncBlock, tc.auctionVars)
+	emptySlot := api.getEmptyTestSlot(slotNum, api.status.Network.LastSyncBlock, tc.auctionVars)
 	assertSlot(t, emptySlot, fetchedSlot)

 	// Invalid slotNum
 	path := endpoint + strconv.Itoa(-2)
-	err = doBadReq("GET", path, nil, 400)
+	err := doBadReq("GET", path, nil, 400)
 	assert.NoError(t, err)
 }

@@ -129,10 +127,8 @@ func TestGetSlots(t *testing.T) {
 	err := doGoodReqPaginated(path, historydb.OrderAsc, &testSlotsResponse{}, appendIter)
 	assert.NoError(t, err)
 	allSlots := tc.slots
-	ni, err := api.h.GetNodeInfoAPI()
-	assert.NoError(t, err)
 	for i := tc.slots[len(tc.slots)-1].SlotNum; i < maxSlotNum; i++ {
-		emptySlot := api.getEmptyTestSlot(i+1, ni.APIState.Network.LastSyncBlock, tc.auctionVars)
+		emptySlot := api.getEmptyTestSlot(i+1, api.status.Network.LastSyncBlock, tc.auctionVars)
 		allSlots = append(allSlots, emptySlot)
 	}
 	assertSlots(t, allSlots, fetchedSlots)
--- a/api/state.go
+++ b/api/state.go
@@ -2,122 +2,313 @@ package api

 import (
 	"database/sql"
+	"fmt"
+	"math"
+	"math/big"
 	"net/http"
+	"time"

 	"github.com/gin-gonic/gin"
+	"github.com/hermeznetwork/hermez-node/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/tracerr"
 )

+// Network define status of the network
+type Network struct {
+	LastEthBlock  int64               `json:"lastEthereumBlock"`
+	LastSyncBlock int64               `json:"lastSynchedBlock"`
+	LastBatch     *historydb.BatchAPI `json:"lastBatch"`
+	CurrentSlot   int64               `json:"currentSlot"`
+	NextForgers   []NextForger        `json:"nextForgers"`
+}
+
+// NextForger  is a representation of the information of a coordinator and the period will forge
+type NextForger struct {
+	Coordinator historydb.CoordinatorAPI `json:"coordinator"`
+	Period      Period                   `json:"period"`
+}
+
+// Period is a representation of a period
+type Period struct {
+	SlotNum       int64     `json:"slotNum"`
+	FromBlock     int64     `json:"fromBlock"`
+	ToBlock       int64     `json:"toBlock"`
+	FromTimestamp time.Time `json:"fromTimestamp"`
+	ToTimestamp   time.Time `json:"toTimestamp"`
+}
+
 func (a *API) getState(c *gin.Context) {
-	stateAPI, err := a.h.GetStateAPI()
-	if err != nil {
-		retBadReq(err, c)
-		return
-	}
-	c.JSON(http.StatusOK, stateAPI)
+	// TODO: There are no events for the buckets information, so now this information will be 0
+	a.status.RLock()
+	status := a.status //nolint
+	a.status.RUnlock()
+	c.JSON(http.StatusOK, status) //nolint
 }

-type APIStateUpdater struct {
-	hdb    *historydb.HistoryDB
-	state  historydb.StateAPI
-	config historydb.NodeConfig
-	vars   common.SCVariablesPtr
-	consts historydb.Constants
+// SC Vars
+
+// SetRollupVariables set Status.Rollup variables
+func (a *API) SetRollupVariables(rollupVariables common.RollupVariables) {
+	a.status.Lock()
+	var rollupVAPI historydb.RollupVariablesAPI
+	rollupVAPI.EthBlockNum = rollupVariables.EthBlockNum
+	rollupVAPI.FeeAddToken = apitypes.NewBigIntStr(rollupVariables.FeeAddToken)
+	rollupVAPI.ForgeL1L2BatchTimeout = rollupVariables.ForgeL1L2BatchTimeout
+	rollupVAPI.WithdrawalDelay = rollupVariables.WithdrawalDelay
+
+	for i, bucket := range rollupVariables.Buckets {
+		var apiBucket historydb.BucketParamsAPI
+		apiBucket.CeilUSD = apitypes.NewBigIntStr(bucket.CeilUSD)
+		apiBucket.Withdrawals = apitypes.NewBigIntStr(bucket.Withdrawals)
+		apiBucket.BlockWithdrawalRate = apitypes.NewBigIntStr(bucket.BlockWithdrawalRate)
+		apiBucket.MaxWithdrawals = apitypes.NewBigIntStr(bucket.MaxWithdrawals)
+		rollupVAPI.Buckets[i] = apiBucket
+	}
+
+	rollupVAPI.SafeMode = rollupVariables.SafeMode
+	a.status.Rollup = rollupVAPI
+	a.status.Unlock()
 }

-func NewAPIStateUpdater(hdb *historydb.HistoryDB, config *historydb.NodeConfig, vars *common.SCVariables,
-	consts *historydb.Constants) *APIStateUpdater {
-	u := APIStateUpdater{
-		hdb:    hdb,
-		config: *config,
-		consts: *consts,
-	}
-	u.SetSCVars(&common.SCVariablesPtr{&vars.Rollup, &vars.Auction, &vars.WDelayer})
-	return &u
+// SetWDelayerVariables set Status.WithdrawalDelayer variables
+func (a *API) SetWDelayerVariables(wDelayerVariables common.WDelayerVariables) {
+	a.status.Lock()
+	a.status.WithdrawalDelayer = wDelayerVariables
+	a.status.Unlock()
 }

-func (u *APIStateUpdater) Store() error {
-	return tracerr.Wrap(u.hdb.SetAPIState(&u.state))
+// SetAuctionVariables set Status.Auction variables
+func (a *API) SetAuctionVariables(auctionVariables common.AuctionVariables) {
+	a.status.Lock()
+	var auctionAPI historydb.AuctionVariablesAPI
+
+	auctionAPI.EthBlockNum = auctionVariables.EthBlockNum
+	auctionAPI.DonationAddress = auctionVariables.DonationAddress
+	auctionAPI.BootCoordinator = auctionVariables.BootCoordinator
+	auctionAPI.BootCoordinatorURL = auctionVariables.BootCoordinatorURL
+	auctionAPI.DefaultSlotSetBidSlotNum = auctionVariables.DefaultSlotSetBidSlotNum
+	auctionAPI.ClosedAuctionSlots = auctionVariables.ClosedAuctionSlots
+	auctionAPI.OpenAuctionSlots = auctionVariables.OpenAuctionSlots
+	auctionAPI.Outbidding = auctionVariables.Outbidding
+	auctionAPI.SlotDeadline = auctionVariables.SlotDeadline
+
+	for i, slot := range auctionVariables.DefaultSlotSetBid {
+		auctionAPI.DefaultSlotSetBid[i] = apitypes.NewBigIntStr(slot)
+	}
+
+	for i, ratio := range auctionVariables.AllocationRatio {
+		auctionAPI.AllocationRatio[i] = ratio
+	}
+
+	a.status.Auction = auctionAPI
+	a.status.Unlock()
 }

-func (u *APIStateUpdater) SetSCVars(vars *common.SCVariablesPtr) {
-	if vars.Rollup != nil {
-		u.vars.Rollup = vars.Rollup
-		rollupVars := historydb.NewRollupVariablesAPI(u.vars.Rollup)
-		u.state.Rollup = *rollupVars
-	}
-	if vars.Auction != nil {
-		u.vars.Auction = vars.Auction
-		auctionVars := historydb.NewAuctionVariablesAPI(u.vars.Auction)
-		u.state.Auction = *auctionVars
-	}
-	if vars.WDelayer != nil {
-		u.vars.WDelayer = vars.WDelayer
-		u.state.WithdrawalDelayer = *u.vars.WDelayer
-	}
+// Network
+
+// UpdateNetworkInfoBlock update Status.Network block related information
+func (a *API) UpdateNetworkInfoBlock(
+	lastEthBlock, lastSyncBlock common.Block,
+) {
+	a.status.Network.LastSyncBlock = lastSyncBlock.Num
+	a.status.Network.LastEthBlock = lastEthBlock.Num
 }

-func (u *APIStateUpdater) UpdateMetrics() error {
-	if u.state.Network.LastBatch == nil {
-		return nil
-	}
-	lastBatchNum := u.state.Network.LastBatch.BatchNum
-	metrics, err := u.hdb.GetMetricsInternalAPI(lastBatchNum)
-	if err != nil {
-		return tracerr.Wrap(err)
-	}
-	u.state.Metrics = *metrics
-	return nil
-}
-
-func (u *APIStateUpdater) UpdateNetworkInfoBlock(lastEthBlock, lastSyncBlock common.Block) {
-	u.state.Network.LastSyncBlock = lastSyncBlock.Num
-	u.state.Network.LastEthBlock = lastEthBlock.Num
-}
-
-func (u *APIStateUpdater) UpdateNetworkInfo(
+// UpdateNetworkInfo update Status.Network information
+func (a *API) UpdateNetworkInfo(
 	lastEthBlock, lastSyncBlock common.Block,
 	lastBatchNum common.BatchNum, currentSlot int64,
 ) error {
-	// Get last batch in API format
-	lastBatch, err := u.hdb.GetBatchInternalAPI(lastBatchNum)
+	lastBatch, err := a.h.GetBatchAPI(lastBatchNum)
 	if tracerr.Unwrap(err) == sql.ErrNoRows {
 		lastBatch = nil
 	} else if err != nil {
 		return tracerr.Wrap(err)
 	}
-	// Get next forgers
-	lastClosedSlot := currentSlot + int64(u.state.Auction.ClosedAuctionSlots)
-	nextForgers, err := u.hdb.GetNextForgersInternalAPI(u.vars.Auction, &u.consts.Auction,
-		lastSyncBlock, currentSlot, lastClosedSlot)
+	lastClosedSlot := currentSlot + int64(a.status.Auction.ClosedAuctionSlots)
+	nextForgers, err := a.getNextForgers(lastSyncBlock, currentSlot, lastClosedSlot)
 	if tracerr.Unwrap(err) == sql.ErrNoRows {
 		nextForgers = nil
 	} else if err != nil {
 		return tracerr.Wrap(err)
 	}
+	a.status.Lock()
+	a.status.Network.LastSyncBlock = lastSyncBlock.Num
+	a.status.Network.LastEthBlock = lastEthBlock.Num
+	a.status.Network.LastBatch = lastBatch
+	a.status.Network.CurrentSlot = currentSlot
+	a.status.Network.NextForgers = nextForgers

-	bucketUpdates, err := u.hdb.GetBucketUpdatesInternalAPI()
-	if err == sql.ErrNoRows {
-		bucketUpdates = nil
+	// Update buckets withdrawals
+	bucketsUpdate, err := a.h.GetBucketUpdatesAPI()
+	if tracerr.Unwrap(err) == sql.ErrNoRows {
+		bucketsUpdate = nil
 	} else if err != nil {
 		return tracerr.Wrap(err)
 	}
-	// Update NodeInfo struct
-	for i, bucketParams := range u.state.Rollup.Buckets {
-		for _, bucketUpdate := range bucketUpdates {
+
+	for i, bucketParams := range a.status.Rollup.Buckets {
+		for _, bucketUpdate := range bucketsUpdate {
 			if bucketUpdate.NumBucket == i {
 				bucketParams.Withdrawals = bucketUpdate.Withdrawals
-				u.state.Rollup.Buckets[i] = bucketParams
+				a.status.Rollup.Buckets[i] = bucketParams
 				break
 			}
 		}
 	}
-	u.state.Network.LastSyncBlock = lastSyncBlock.Num
-	u.state.Network.LastEthBlock = lastEthBlock.Num
-	u.state.Network.LastBatch = lastBatch
-	u.state.Network.CurrentSlot = currentSlot
-	u.state.Network.NextForgers = nextForgers
+	a.status.Unlock()
+	return nil
+}
+
+// apiSlotToBigInts converts from [6]*apitypes.BigIntStr to [6]*big.Int
+func apiSlotToBigInts(defaultSlotSetBid [6]*apitypes.BigIntStr) ([6]*big.Int, error) {
+	var slots [6]*big.Int
+
+	for i, slot := range defaultSlotSetBid {
+		bigInt, ok := new(big.Int).SetString(string(*slot), 10)
+		if !ok {
+			return slots, tracerr.Wrap(fmt.Errorf("can't convert %T into big.Int", slot))
+		}
+		slots[i] = bigInt
+	}
+
+	return slots, nil
+}
+
+// getNextForgers returns next forgers
+func (a *API) getNextForgers(lastBlock common.Block, currentSlot, lastClosedSlot int64) ([]NextForger, error) {
+	secondsPerBlock := int64(15) //nolint:gomnd
+	// currentSlot and lastClosedSlot included
+	limit := uint(lastClosedSlot - currentSlot + 1)
+	bids, _, err := a.h.GetBestBidsAPI(&currentSlot, &lastClosedSlot, nil, &limit, "ASC")
+	if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
+		return nil, tracerr.Wrap(err)
+	}
+	nextForgers := []NextForger{}
+	// Get min bid info
+	var minBidInfo []historydb.MinBidInfo
+	if currentSlot >= a.status.Auction.DefaultSlotSetBidSlotNum {
+		// All min bids can be calculated with the last update of AuctionVariables
+		bigIntSlots, err := apiSlotToBigInts(a.status.Auction.DefaultSlotSetBid)
+		if err != nil {
+			return nil, tracerr.Wrap(err)
+		}
+
+		minBidInfo = []historydb.MinBidInfo{{
+			DefaultSlotSetBid:        bigIntSlots,
+			DefaultSlotSetBidSlotNum: a.status.Auction.DefaultSlotSetBidSlotNum,
+		}}
+	} else {
+		// Get all the relevant updates from the DB
+		minBidInfo, err = a.h.GetAuctionVarsUntilSetSlotNumAPI(lastClosedSlot, int(lastClosedSlot-currentSlot)+1)
+		if err != nil {
+			return nil, tracerr.Wrap(err)
+		}
+	}
+	// Create nextForger for each slot
+	for i := currentSlot; i <= lastClosedSlot; i++ {
+		fromBlock := i*int64(a.cg.AuctionConstants.BlocksPerSlot) + a.cg.AuctionConstants.GenesisBlockNum
+		toBlock := (i+1)*int64(a.cg.AuctionConstants.BlocksPerSlot) + a.cg.AuctionConstants.GenesisBlockNum - 1
+		nextForger := NextForger{
+			Period: Period{
+				SlotNum:       i,
+				FromBlock:     fromBlock,
+				ToBlock:       toBlock,
+				FromTimestamp: lastBlock.Timestamp.Add(time.Second * time.Duration(secondsPerBlock*(fromBlock-lastBlock.Num))),
+				ToTimestamp:   lastBlock.Timestamp.Add(time.Second * time.Duration(secondsPerBlock*(toBlock-lastBlock.Num))),
+			},
+		}
+		foundForger := false
+		// If there is a bid for a slot, get forger (coordinator)
+		for j := range bids {
+			slotNum := bids[j].SlotNum
+			if slotNum == i {
+				// There's a bid for the slot
+				// Check if the bid is greater than the minimum required
+				for i := 0; i < len(minBidInfo); i++ {
+					// Find the most recent update
+					if slotNum >= minBidInfo[i].DefaultSlotSetBidSlotNum {
+						// Get min bid
+						minBidSelector := slotNum % int64(len(a.status.Auction.DefaultSlotSetBid))
+						minBid := minBidInfo[i].DefaultSlotSetBid[minBidSelector]
+						// Check if the bid has beaten the minimum
+						bid, ok := new(big.Int).SetString(string(bids[j].BidValue), 10)
+						if !ok {
+							return nil, tracerr.New("Wrong bid value, error parsing it as big.Int")
+						}
+						if minBid.Cmp(bid) == 1 {
+							// Min bid is greater than bid, the slot will be forged by boot coordinator
+							break
+						}
+						foundForger = true
+						break
+					}
+				}
+				if !foundForger { // There is no bid or it's smaller than the minimum
+					break
+				}
+				coordinator, err := a.h.GetCoordinatorAPI(bids[j].Bidder)
+				if err != nil {
+					return nil, tracerr.Wrap(err)
+				}
+				nextForger.Coordinator = *coordinator
+				break
+			}
+		}
+		// If there is no bid, the coordinator that will forge is boot coordinator
+		if !foundForger {
+			nextForger.Coordinator = historydb.CoordinatorAPI{
+				Forger: a.status.Auction.BootCoordinator,
+				URL:    a.status.Auction.BootCoordinatorURL,
+			}
+		}
+		nextForgers = append(nextForgers, nextForger)
+	}
+	return nextForgers, nil
+}
+
+// Metrics
+
+// UpdateMetrics update Status.Metrics information
+func (a *API) UpdateMetrics() error {
+	a.status.RLock()
+	if a.status.Network.LastBatch == nil {
+		a.status.RUnlock()
+		return nil
+	}
+	batchNum := a.status.Network.LastBatch.BatchNum
+	a.status.RUnlock()
+	metrics, err := a.h.GetMetricsAPI(batchNum)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	a.status.Lock()
+	a.status.Metrics = *metrics
+	a.status.Unlock()
+	return nil
+}
+
+// Recommended fee
+
+// UpdateRecommendedFee update Status.RecommendedFee information
+func (a *API) UpdateRecommendedFee() error {
+	feeExistingAccount, err := a.h.GetAvgTxFeeAPI()
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	var minFeeUSD float64
+	if a.l2 != nil {
+		minFeeUSD = a.l2.MinFeeUSD()
+	}
+	a.status.Lock()
+	a.status.RecommendedFee.ExistingAccount =
+		math.Max(feeExistingAccount, minFeeUSD)
+	a.status.RecommendedFee.CreatesAccount =
+		math.Max(createAccountExtraFeePercentage*feeExistingAccount, minFeeUSD)
+	a.status.RecommendedFee.CreatesAccountAndRegister =
+		math.Max(createAccountInternalExtraFeePercentage*feeExistingAccount, minFeeUSD)
+	a.status.Unlock()
 	return nil
 }
--- a/api/state_test.go
+++ b/api/state_test.go
@@ -13,7 +13,7 @@ import (

 type testStatus struct {
 	Network           testNetwork                   `json:"network"`
-	Metrics           historydb.MetricsAPI          `json:"metrics"`
+	Metrics           historydb.Metrics             `json:"metrics"`
 	Rollup            historydb.RollupVariablesAPI  `json:"rollup"`
 	Auction           historydb.AuctionVariablesAPI `json:"auction"`
 	WithdrawalDelayer common.WDelayerVariables      `json:"withdrawalDelayer"`
@@ -21,18 +21,18 @@ type testStatus struct {
 }

 type testNetwork struct {
-	LastEthBlock  int64                     `json:"lastEthereumBlock"`
-	LastSyncBlock int64                     `json:"lastSynchedBlock"`
-	LastBatch     testBatch                 `json:"lastBatch"`
-	CurrentSlot   int64                     `json:"currentSlot"`
-	NextForgers   []historydb.NextForgerAPI `json:"nextForgers"`
+	LastEthBlock  int64        `json:"lastEthereumBlock"`
+	LastSyncBlock int64        `json:"lastSynchedBlock"`
+	LastBatch     testBatch    `json:"lastBatch"`
+	CurrentSlot   int64        `json:"currentSlot"`
+	NextForgers   []NextForger `json:"nextForgers"`
 }

 func TestSetRollupVariables(t *testing.T) {
-	api.h.SetRollupVariables(&tc.rollupVars)
-	ni, err := api.h.GetNodeInfoAPI()
-	assert.NoError(t, err)
-	assertEqualRollupVariables(t, tc.rollupVars, ni.APIState.Rollup, true)
+	rollupVars := &common.RollupVariables{}
+	assertEqualRollupVariables(t, *rollupVars, api.status.Rollup, true)
+	api.SetRollupVariables(tc.rollupVars)
+	assertEqualRollupVariables(t, tc.rollupVars, api.status.Rollup, true)
 }

 func assertEqualRollupVariables(t *testing.T, rollupVariables common.RollupVariables, apiVariables historydb.RollupVariablesAPI, checkBuckets bool) {
@@ -51,17 +51,17 @@ func assertEqualRollupVariables(t *testing.T, rollupVariables common.RollupVaria
 }

 func TestSetWDelayerVariables(t *testing.T) {
-	api.h.SetWDelayerVariables(&tc.wdelayerVars)
-	ni, err := api.h.GetNodeInfoAPI()
-	assert.NoError(t, err)
-	assert.Equal(t, tc.wdelayerVars, ni.APIState.WithdrawalDelayer)
+	wdelayerVars := &common.WDelayerVariables{}
+	assert.Equal(t, *wdelayerVars, api.status.WithdrawalDelayer)
+	api.SetWDelayerVariables(tc.wdelayerVars)
+	assert.Equal(t, tc.wdelayerVars, api.status.WithdrawalDelayer)
 }

 func TestSetAuctionVariables(t *testing.T) {
-	api.h.SetAuctionVariables(&tc.auctionVars)
-	ni, err := api.h.GetNodeInfoAPI()
-	assert.NoError(t, err)
-	assertEqualAuctionVariables(t, tc.auctionVars, ni.APIState.Auction)
+	auctionVars := &common.AuctionVariables{}
+	assertEqualAuctionVariables(t, *auctionVars, api.status.Auction)
+	api.SetAuctionVariables(tc.auctionVars)
+	assertEqualAuctionVariables(t, tc.auctionVars, api.status.Auction)
 }

 func assertEqualAuctionVariables(t *testing.T, auctionVariables common.AuctionVariables, apiVariables historydb.AuctionVariablesAPI) {
@@ -85,6 +85,11 @@ func assertEqualAuctionVariables(t *testing.T, auctionVariables common.AuctionVa
 }

 func TestUpdateNetworkInfo(t *testing.T) {
+	status := &Network{}
+	assert.Equal(t, status.LastSyncBlock, api.status.Network.LastSyncBlock)
+	assert.Equal(t, status.LastBatch, api.status.Network.LastBatch)
+	assert.Equal(t, status.CurrentSlot, api.status.Network.CurrentSlot)
+	assert.Equal(t, status.NextForgers, api.status.Network.NextForgers)
 	lastBlock := tc.blocks[3]
 	lastBatchNum := common.BatchNum(3)
 	currentSlotNum := int64(1)
@@ -113,16 +118,14 @@ func TestUpdateNetworkInfo(t *testing.T) {
 	err := api.h.AddBucketUpdatesTest(api.h.DB(), bucketUpdates)
 	require.NoError(t, err)

-	err = api.h.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
+	err = api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
 	assert.NoError(t, err)
-	ni, err := api.h.GetNodeInfoAPI()
-	assert.NoError(t, err)
-	assert.Equal(t, lastBlock.Num, ni.APIState.Network.LastSyncBlock)
-	assert.Equal(t, lastBatchNum, ni.APIState.Network.LastBatch.BatchNum)
-	assert.Equal(t, currentSlotNum, ni.APIState.Network.CurrentSlot)
-	assert.Equal(t, int(ni.APIState.Auction.ClosedAuctionSlots)+1, len(ni.APIState.Network.NextForgers))
-	assert.Equal(t, ni.APIState.Rollup.Buckets[0].Withdrawals, apitypes.NewBigIntStr(big.NewInt(123)))
-	assert.Equal(t, ni.APIState.Rollup.Buckets[2].Withdrawals, apitypes.NewBigIntStr(big.NewInt(43)))
+	assert.Equal(t, lastBlock.Num, api.status.Network.LastSyncBlock)
+	assert.Equal(t, lastBatchNum, api.status.Network.LastBatch.BatchNum)
+	assert.Equal(t, currentSlotNum, api.status.Network.CurrentSlot)
+	assert.Equal(t, int(api.status.Auction.ClosedAuctionSlots)+1, len(api.status.Network.NextForgers))
+	assert.Equal(t, api.status.Rollup.Buckets[0].Withdrawals, apitypes.NewBigIntStr(big.NewInt(123)))
+	assert.Equal(t, api.status.Rollup.Buckets[2].Withdrawals, apitypes.NewBigIntStr(big.NewInt(43)))
 }

 func TestUpdateMetrics(t *testing.T) {
@@ -130,49 +133,45 @@ func TestUpdateMetrics(t *testing.T) {
 	lastBlock := tc.blocks[3]
 	lastBatchNum := common.BatchNum(12)
 	currentSlotNum := int64(1)
-	err := api.h.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
+	err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
 	assert.NoError(t, err)

-	err = api.h.UpdateMetrics()
+	err = api.UpdateMetrics()
 	assert.NoError(t, err)
-	ni, err := api.h.GetNodeInfoAPI()
-	assert.NoError(t, err)
-	assert.Greater(t, ni.APIState.Metrics.TransactionsPerBatch, float64(0))
-	assert.Greater(t, ni.APIState.Metrics.BatchFrequency, float64(0))
-	assert.Greater(t, ni.APIState.Metrics.TransactionsPerSecond, float64(0))
-	assert.Greater(t, ni.APIState.Metrics.TotalAccounts, int64(0))
-	assert.Greater(t, ni.APIState.Metrics.TotalBJJs, int64(0))
-	assert.Greater(t, ni.APIState.Metrics.AvgTransactionFee, float64(0))
+	assert.Greater(t, api.status.Metrics.TransactionsPerBatch, float64(0))
+	assert.Greater(t, api.status.Metrics.BatchFrequency, float64(0))
+	assert.Greater(t, api.status.Metrics.TransactionsPerSecond, float64(0))
+	assert.Greater(t, api.status.Metrics.TotalAccounts, int64(0))
+	assert.Greater(t, api.status.Metrics.TotalBJJs, int64(0))
+	assert.Greater(t, api.status.Metrics.AvgTransactionFee, float64(0))
 }

 func TestUpdateRecommendedFee(t *testing.T) {
-	err := api.h.UpdateRecommendedFee()
+	err := api.UpdateRecommendedFee()
 	assert.NoError(t, err)
 	var minFeeUSD float64
 	if api.l2 != nil {
 		minFeeUSD = api.l2.MinFeeUSD()
 	}
-	ni, err := api.h.GetNodeInfoAPI()
-	assert.NoError(t, err)
-	assert.Greater(t, ni.APIState.RecommendedFee.ExistingAccount, minFeeUSD)
-	// assert.Equal(t, ni.StateAPI.RecommendedFee.CreatesAccount,
-	// 	ni.StateAPI.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
-	// assert.Equal(t, ni.StateAPI.RecommendedFee.CreatesAccountAndRegister,
-	// 	ni.StateAPI.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
+	assert.Greater(t, api.status.RecommendedFee.ExistingAccount, minFeeUSD)
+	assert.Equal(t, api.status.RecommendedFee.CreatesAccount,
+		api.status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
+	assert.Equal(t, api.status.RecommendedFee.CreatesAccountAndRegister,
+		api.status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
 }

 func TestGetState(t *testing.T) {
 	lastBlock := tc.blocks[3]
 	lastBatchNum := common.BatchNum(12)
 	currentSlotNum := int64(1)
-	api.h.SetRollupVariables(&tc.rollupVars)
-	api.h.SetWDelayerVariables(&tc.wdelayerVars)
-	api.h.SetAuctionVariables(&tc.auctionVars)
-	err := api.h.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
+	api.SetRollupVariables(tc.rollupVars)
+	api.SetWDelayerVariables(tc.wdelayerVars)
+	api.SetAuctionVariables(tc.auctionVars)
+	err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
 	assert.NoError(t, err)
-	err = api.h.UpdateMetrics()
+	err = api.UpdateMetrics()
 	assert.NoError(t, err)
-	err = api.h.UpdateRecommendedFee()
+	err = api.UpdateRecommendedFee()
 	assert.NoError(t, err)

 	endpoint := apiURL + "state"
@@ -205,13 +204,13 @@ func TestGetState(t *testing.T) {
 	// Recommended fee
 	// TODO: perform real asserts (not just greater than 0)
 	assert.Greater(t, status.RecommendedFee.ExistingAccount, float64(0))
-	// assert.Equal(t, status.RecommendedFee.CreatesAccount,
-	// 	status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
-	// assert.Equal(t, status.RecommendedFee.CreatesAccountAndRegister,
-	// 	status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
+	assert.Equal(t, status.RecommendedFee.CreatesAccount,
+		status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
+	assert.Equal(t, status.RecommendedFee.CreatesAccountAndRegister,
+		status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
 }

-func assertNextForgers(t *testing.T, expected, actual []historydb.NextForgerAPI) {
+func assertNextForgers(t *testing.T, expected, actual []NextForger) {
 	assert.Equal(t, len(expected), len(actual))
 	for i := range expected {
 		// ignore timestamps and other metadata
--- a/api/swagger.yml
+++ b/api/swagger.yml
@@ -1329,6 +1329,13 @@ components:
          type: string
          description: Moment in which the transaction was added to the pool.
          format: date-time
+        batchNum:
+          type: integer
+          description: Identifier of a batch. Every new forged batch increases by one the batchNum, starting at 0.
+          minimum: 0
+          maximum: 4294967295
+          nullable: true
+          example: null
        requestFromAccountIndex:
          type: string
          description: >-
@@ -1383,6 +1390,7 @@ components:
          $ref: '#/components/schemas/Token'
      example:
        amount: '100000000000000'
+        batchNum: 
        fee: 0
        fromAccountIndex: hez:SCC:256
        fromBJJ: hez:r_trOasVEk0zNaalOoS9aLedu6mO7jI5XTIPu_zGXoyn
@@ -1430,6 +1438,7 @@ components:
        - info
        - signature
        - timestamp
+        - batchNum
        - requestFromAccountIndex
        - requestToAccountIndex
        - requestToHezEthereumAddress
@@ -2569,21 +2578,6 @@ components:
      description: List of next coordinators to forge.
      items: 
        $ref: '#/components/schemas/NextForger'
-    NodeConfig:
-      type: object
-      description: Configuration of the coordinator node. Note that this is specific for each coordinator.
-      properties:
-        forgeDelay:
-          type: number
-          description: |
-            Delay in seconds after which a batch is forged if the slot is
-            already committed. If set to 0s, the coordinator will continuously
-            forge at the maximum rate. Note that this is a configuration parameter of a node,
-            so each coordinator may have a different value.
-          example: 193.4
-      additionalProperties: false
-      required: 
-        - forgeDelay
    State:
      type: object
      description: Gobal variables of the network
@@ -2600,8 +2594,6 @@ components:
          $ref: '#/components/schemas/StateWithdrawDelayer'
        recommendedFee:
          $ref: '#/components/schemas/RecommendedFee'
-        nodeConfig:
-          $ref: '#/components/schemas/NodeConfig'
      additionalProperties: false
      required: 
        - network
@@ -2610,7 +2602,6 @@ components:
        - auction
        - withdrawalDelayer
        - recommendedFee
-        - nodeConfig
    StateNetwork:
      type: object
      description: Gobal statistics of the network
@@ -2821,10 +2812,6 @@ components:
          type: number
          description: Average fee percentage paid for L2 transactions in the last 24 hours.
          example: 1.54
-        estimatedTimeToForgeL1:
-          type: number
-          description: Estimated time needed to forge a L1 transaction, from the time it's added on the smart contract, until it's actualy forged. In seconds.
-          example: 193.4
      additionalProperties: false
      required:
        - transactionsPerBatch
@@ -2833,7 +2820,6 @@ components:
        - totalAccounts
        - totalBJJs
        - avgTransactionFee
-        - estimatedTimeToForgeL1
    PendingItems:
      type: integer
      description: Amount of items that will be returned in subsequent calls to the endpoint, as long as they are done with same filters. When the value is 0 it means that all items have been sent.
--- a/cli/node/cfg.buidler.toml
+++ b/cli/node/cfg.buidler.toml
@@ -14,7 +14,6 @@ Type = "bitfinexV2"
 [Debug]
 APIAddress = "localhost:12345"
 MeddlerLogs = true
-GinDebugMode = true

 [StateDB]
 Path = "/tmp/iden3-test/hermez/statedb"
@@ -51,7 +50,6 @@ ForgerAddress = "0x05c23b938a85ab26A36E6314a0D02080E9ca6BeD" # Non-Boot Coordina
 # ForgerAddressPrivateKey = "0x30f5fddb34cd4166adb2c6003fa6b18f380fd2341376be42cf1c7937004ac7a3"
 # ForgerAddress = "0xb4124ceb3451635dacedd11767f004d8a28c6ee7" # Boot Coordinator
 # ForgerAddressPrivateKey = "0xa8a54b2d8197bc0b19bb8a084031be71835580a01e70a45a13babd16c9bc1563"
-MinimumForgeAddressBalance = 0
 ConfirmBlocks = 10
 L1BatchTimeoutPerc = 0.6
 StartSlotBlocksDelay = 2
--- a/cli/node/main.go
+++ b/cli/node/main.go
@@ -143,47 +143,6 @@ func cmdRun(c *cli.Context) error {
 	return nil
 }

-func cmdServeAPI(c *cli.Context) error {
-	cfgPath := c.String(flagCfg)
-	cfg, err := config.LoadAPIServer(cfgPath)
-	if err != nil {
-		if err := cli.ShowAppHelp(c); err != nil {
-			panic(err)
-		}
-		return tracerr.Wrap(fmt.Errorf("error parsing flags and config: %w", err))
-	}
-
-	node, err := node.NewNode(cfg.mode, cfg.node)
-	if err != nil {
-		return tracerr.Wrap(fmt.Errorf("error starting node: %w", err))
-	}
-	node.Start()
-
-	stopCh := make(chan interface{})
-
-	// catch ^C to send the stop signal
-	ossig := make(chan os.Signal, 1)
-	signal.Notify(ossig, os.Interrupt)
-	const forceStopCount = 3
-	go func() {
-		n := 0
-		for sig := range ossig {
-			if sig == os.Interrupt {
-				log.Info("Received Interrupt Signal")
-				stopCh <- nil
-				n++
-				if n == forceStopCount {
-					log.Fatalf("Received %v Interrupt Signals", forceStopCount)
-				}
-			}
-		}
-	}()
-	<-stopCh
-	node.Stop()
-
-	return nil
-}
-
 func cmdDiscard(c *cli.Context) error {
 	_cfg, err := parseCli(c)
 	if err != nil {
@@ -266,6 +225,9 @@ func getConfig(c *cli.Context) (*Config, error) {
 	var cfg Config
 	mode := c.String(flagMode)
 	nodeCfgPath := c.String(flagCfg)
+	if nodeCfgPath == "" {
+		return nil, tracerr.Wrap(fmt.Errorf("required flag \"%v\" not set", flagCfg))
+	}
 	var err error
 	switch mode {
 	case modeSync:
@@ -342,12 +304,6 @@ func main() {
 			Usage:   "Run the hermez-node in the indicated mode",
 			Action:  cmdRun,
 		},
-		{
-			Name:    "serveapi",
-			Aliases: []string{},
-			Usage:   "Serve the API only",
-			Action:  cmdServeAPI,
-		},
 		{
 			Name:    "discard",
 			Aliases: []string{},
--- a/common/accountcreationauths.go
+++ b/common/accountcreationauths.go
@@ -1,25 +1,21 @@
 package common

 import (
+	"encoding/binary"
+	"strconv"
 	"time"

 	ethCommon "github.com/ethereum/go-ethereum/common"
-	ethMath "github.com/ethereum/go-ethereum/common/math"
 	ethCrypto "github.com/ethereum/go-ethereum/crypto"
-	ethSigner "github.com/ethereum/go-ethereum/signer/core"
-	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 )

 // AccountCreationAuthMsg is the message that is signed to authorize a Hermez
 // account creation
-const AccountCreationAuthMsg = "Account creation"
+const AccountCreationAuthMsg = "I authorize this babyjubjub key for hermez rollup account creation"

-// EIP712Version is the used version of the EIP-712
-const EIP712Version = "1"
-
-// EIP712Provider defines the Provider for the EIP-712
-const EIP712Provider = "Hermez Network"
+// EthMsgPrefix is the prefix for message signing at the Ethereum ecosystem
+const EthMsgPrefix = "\x19Ethereum Signed Message:\n"

 var (
 	// EmptyEthSignature is an ethereum signature of all zeroes
@@ -35,64 +31,27 @@ type AccountCreationAuth struct {
 	Timestamp time.Time             `meddler:"timestamp,utctime"`
 }

-// toHash returns a byte array to be hashed from the AccountCreationAuth, which
-// follows the EIP-712 encoding
 func (a *AccountCreationAuth) toHash(chainID uint16,
-	hermezContractAddr ethCommon.Address) ([]byte, error) {
-	chainIDFormatted := ethMath.NewHexOrDecimal256(int64(chainID))
+	hermezContractAddr ethCommon.Address) []byte {
+	var chainIDBytes [2]byte
+	binary.BigEndian.PutUint16(chainIDBytes[:], chainID)
+	// [EthPrefix | AccountCreationAuthMsg | compressedBJJ | chainID | hermezContractAddr]
+	var b []byte
+	b = append(b, []byte(AccountCreationAuthMsg)...)
+	b = append(b, SwapEndianness(a.BJJ[:])...) // for js implementation compatibility
+	b = append(b, chainIDBytes[:]...)
+	b = append(b, hermezContractAddr[:]...)

-	signerData := ethSigner.TypedData{
-		Types: ethSigner.Types{
-			"EIP712Domain": []ethSigner.Type{
-				{Name: "name", Type: "string"},
-				{Name: "version", Type: "string"},
-				{Name: "chainId", Type: "uint256"},
-				{Name: "verifyingContract", Type: "address"},
-			},
-			"Authorise": []ethSigner.Type{
-				{Name: "Provider", Type: "string"},
-				{Name: "Authorisation", Type: "string"},
-				{Name: "BJJKey", Type: "bytes32"},
-			},
-		},
-		PrimaryType: "Authorise",
-		Domain: ethSigner.TypedDataDomain{
-			Name:              EIP712Provider,
-			Version:           EIP712Version,
-			ChainId:           chainIDFormatted,
-			VerifyingContract: hermezContractAddr.Hex(),
-		},
-		Message: ethSigner.TypedDataMessage{
-			"Provider":      EIP712Provider,
-			"Authorisation": AccountCreationAuthMsg,
-			"BJJKey":        SwapEndianness(a.BJJ[:]),
-		},
-	}
-
-	domainSeparator, err := signerData.HashStruct("EIP712Domain", signerData.Domain.Map())
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	typedDataHash, err := signerData.HashStruct(signerData.PrimaryType, signerData.Message)
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-
-	rawData := []byte{0x19, 0x01} // "\x19\x01"
-	rawData = append(rawData, domainSeparator...)
-	rawData = append(rawData, typedDataHash...)
-	return rawData, nil
+	ethPrefix := EthMsgPrefix + strconv.Itoa(len(b))
+	return append([]byte(ethPrefix), b...)
 }

 // HashToSign returns the hash to be signed by the Etherum address to authorize
-// the account creation, which follows the EIP-712 encoding
+// the account creation
 func (a *AccountCreationAuth) HashToSign(chainID uint16,
 	hermezContractAddr ethCommon.Address) ([]byte, error) {
-	b, err := a.toHash(chainID, hermezContractAddr)
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	return ethCrypto.Keccak256(b), nil
+	b := a.toHash(chainID, hermezContractAddr)
+	return ethCrypto.Keccak256Hash(b).Bytes(), nil
 }

 // Sign signs the account creation authorization message using the provided
@@ -100,17 +59,16 @@ func (a *AccountCreationAuth) HashToSign(chainID uint16,
 // should do an ethereum signature using the account corresponding to
 // `a.EthAddr`.  The `signHash` function is used to make signig flexible: in
 // tests we sign directly using the private key, outside tests we sign using
-// the keystore (which never exposes the private key). Sign follows the EIP-712
-// encoding.
+// the keystore (which never exposes the private key).
 func (a *AccountCreationAuth) Sign(signHash func(hash []byte) ([]byte, error),
 	chainID uint16, hermezContractAddr ethCommon.Address) error {
 	hash, err := a.HashToSign(chainID, hermezContractAddr)
 	if err != nil {
-		return tracerr.Wrap(err)
+		return err
 	}
 	sig, err := signHash(hash)
 	if err != nil {
-		return tracerr.Wrap(err)
+		return err
 	}
 	sig[64] += 27
 	a.Signature = sig
@@ -119,8 +77,7 @@ func (a *AccountCreationAuth) Sign(signHash func(hash []byte) ([]byte, error),
 }

 // VerifySignature ensures that the Signature is done with the EthAddr, for the
-// chainID and hermezContractAddress passed by parameter. VerifySignature
-// follows the EIP-712 encoding.
+// chainID and hermezContractAddress passed by parameter
 func (a *AccountCreationAuth) VerifySignature(chainID uint16,
 	hermezContractAddr ethCommon.Address) bool {
 	// Calculate hash to be signed
--- a/common/accountcreationauths_test.go
+++ b/common/accountcreationauths_test.go
@@ -39,7 +39,7 @@ func TestAccountCreationAuthSignVerify(t *testing.T) {
 	// Hash and sign manually and compare the generated signature
 	hash, err := a.HashToSign(chainID, hermezContractAddr)
 	require.NoError(t, err)
-	assert.Equal(t, "9414667457e658dd31949b82996b75c65a055512244c3bbfd22ff56add02ba65",
+	assert.Equal(t, "4f8df75e96fdce1ac90bb2f8d81c42047600f85bfcef80ce3b91c2a2afc58c1e",
 		hex.EncodeToString(hash))
 	sig, err := ethCrypto.Sign(hash, ethSk)
 	require.NoError(t, err)
@@ -75,9 +75,9 @@ func TestAccountCreationAuthJSComp(t *testing.T) {
 		pkCompStr:          "21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7",
 		chainID:            uint16(4),
 		hermezContractAddr: "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
-		toHashExpected:     "190189658bba487e11c7da602676ee32bc90b77d3f32a305b147e4f3c3b35f19672e5d84ccc38d0ab245c469b719549d837113465c2abf9972c49403ca6fd10ed3dc",
-		hashExpected:       "c56eba41e511df100c804c5c09288f35887efea4f033be956481af335df3bea2",
-		sigExpected:        "dbedcc5ce02db8f48afbdb2feba9a3a31848eaa8fca5f312ce37b01db45d2199208335330d4445bd2f51d1db68dbc0d0bf3585c4a07504b4efbe46a69eaae5a21b",
+		toHashExpected:     "19457468657265756d205369676e6564204d6573736167653a0a3132304920617574686f72697a65207468697320626162796a75626a7562206b657920666f72206865726d657a20726f6c6c7570206163636f756e74206372656174696f6e21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d700047e5f4552091a69125d5dfcb7b8c2659029395bdf",
+		hashExpected:       "39afea52d843a4de905b6b5ebb0ee8c678141f711d96d9b429c4aec10ef9911f",
+		sigExpected:        "73d10d6ecf06ee8a5f60ac90f06b78bef9c650f414ba3ac73e176dc32e896159147457e9c86f0b4bd60fdaf2c0b2aec890a7df993d69a4805e242a6b845ebf231c",
 	}
 	tv1 := testVector{
 		ethSk:              "0000000000000000000000000000000000000000000000000000000000000002",
@@ -85,9 +85,9 @@ func TestAccountCreationAuthJSComp(t *testing.T) {
 		pkCompStr:          "093985b1993d9f743f9d7d943ed56f38601cb8b196db025f79650c4007c3054d",
 		chainID:            uint16(0),
 		hermezContractAddr: "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
-		toHashExpected:     "1901dafbc253dedf90d6421dc6e25d5d9efc6985133cb2a8d363d0a081a0e3eddddc65f603a88de36aaeabd3b4cf586538c7f3fd50c94780530a3707c8c14ad9fd11",
-		hashExpected:       "deb9afa479282cf27b442ce8ba86b19448aa87eacef691521a33db5d0feb9959",
-		sigExpected:        "6a0da90ba2d2b1be679a28ebe54ee03082d44b836087391cd7d2607c1e4dafe04476e6e88dccb8707c68312512f16c947524b35c80f26c642d23953e9bb84c701c",
+		toHashExpected:     "19457468657265756d205369676e6564204d6573736167653a0a3132304920617574686f72697a65207468697320626162796a75626a7562206b657920666f72206865726d657a20726f6c6c7570206163636f756e74206372656174696f6e093985b1993d9f743f9d7d943ed56f38601cb8b196db025f79650c4007c3054d00002b5ad5c4795c026514f8317c7a215e218dccd6cf",
+		hashExpected:       "89a3895993a4736232212e59566294feb3da227af44375daf3307dcad5451d5d",
+		sigExpected:        "bb4156156c705494ad5f99030342c64657e51e2994750f92125717c40bf56ad632044aa6bd00979feea92c417b552401e65fe5f531f15010d9d1c278da8be1df1b",
 	}
 	tv2 := testVector{
 		ethSk:              "c5e8f61d1ab959b397eecc0a37a6517b8e67a0e7cf1f4bce5591f3ed80199122",
@@ -95,9 +95,9 @@ func TestAccountCreationAuthJSComp(t *testing.T) {
 		pkCompStr:          "22870c1bcc451396202d62f566026eab8e438c6c91decf8ddf63a6c162619b52",
 		chainID:            uint16(31337), // =0x7a69
 		hermezContractAddr: "0xf4e77E5Da47AC3125140c470c71cBca77B5c638c",
-		toHashExpected:     "190167617949b934d7e01add4009cd3d47415a26727b7d6288e5dce33fb3721d5a1a9ce511b19b694c9aaf8183f4987ed752f24884c54c003d11daa2e98c7547a79e",
-		hashExpected:       "157b570c597e615b8356ce008ac39f43bc9b6d50080bc07d968031b9378acbbb",
-		sigExpected:        "a0766181102428b5672e523dc4b905c10ddf025c10dbd0b3534ef864632a14652737610041c670b302fc7dca28edd5d6eac42b72d69ce58da8ce21287b244e381b",
+		toHashExpected:     "19457468657265756d205369676e6564204d6573736167653a0a3132304920617574686f72697a65207468697320626162796a75626a7562206b657920666f72206865726d657a20726f6c6c7570206163636f756e74206372656174696f6e22870c1bcc451396202d62f566026eab8e438c6c91decf8ddf63a6c162619b527a69f4e77e5da47ac3125140c470c71cbca77b5c638c",
+		hashExpected:       "4f6ead01278ba4597d4720e37482f585a713497cea994a95209f4c57a963b4a7",
+		sigExpected:        "43b5818802a137a72a190c1d8d767ca507f7a4804b1b69b5e055abf31f4f2b476c80bb1ba63260d95610f6f831420d32130e7f22fec5d76e16644ddfcedd0d441c",
 	}
 	tvs = append(tvs, tv0)
 	tvs = append(tvs, tv1)
@@ -122,10 +122,10 @@ func TestAccountCreationAuthJSComp(t *testing.T) {
 			BJJ:     pkComp,
 		}

-		toHash, err := a.toHash(chainID, hermezContractAddr)
-		require.NoError(t, err)
+		toHash := a.toHash(chainID, hermezContractAddr)
 		assert.Equal(t, tv.toHashExpected,
 			hex.EncodeToString(toHash))
+		assert.Equal(t, 120+len(EthMsgPrefix)+len([]byte("120")), len(toHash))

 		msg, err := a.HashToSign(chainID, hermezContractAddr)
 		require.NoError(t, err)
--- a/common/eth.go
+++ b/common/eth.go
@@ -1,31 +0,0 @@
-package common
-
-// SCVariables joins all the smart contract variables in a single struct
-type SCVariables struct {
-	Rollup   RollupVariables   `validate:"required"`
-	Auction  AuctionVariables  `validate:"required"`
-	WDelayer WDelayerVariables `validate:"required"`
-}
-
-func (v *SCVariables) AsPtr() *SCVariablesPtr {
-	return &SCVariablesPtr{
-		Rollup:   &v.Rollup,
-		Auction:  &v.Auction,
-		WDelayer: &v.WDelayer,
-	}
-}
-
-// SCVariablesPtr joins all the smart contract variables as pointers in a single
-// struct
-type SCVariablesPtr struct {
-	Rollup   *RollupVariables   `validate:"required"`
-	Auction  *AuctionVariables  `validate:"required"`
-	WDelayer *WDelayerVariables `validate:"required"`
-}
-
-// SCConsts joins all the smart contract constants in a single struct
-type SCConsts struct {
-	Rollup   RollupConstants
-	Auction  AuctionConstants
-	WDelayer WDelayerConstants
-}
--- a/common/l1tx.go
+++ b/common/l1tx.go
@@ -368,12 +368,19 @@ func L1UserTxFromBytes(b []byte) (*L1Tx, error) {
 	return tx, nil
 }

+func signHash(data []byte) []byte {
+	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data)
+	return ethCrypto.Keccak256([]byte(msg))
+}
+
 // L1CoordinatorTxFromBytes decodes a L1Tx from []byte
 func L1CoordinatorTxFromBytes(b []byte, chainID *big.Int, hermezAddress ethCommon.Address) (*L1Tx, error) {
 	if len(b) != RollupConstL1CoordinatorTotalBytes {
 		return nil, tracerr.Wrap(fmt.Errorf("Can not parse L1CoordinatorTx bytes, expected length %d, current: %d", 101, len(b)))
 	}

+	bytesMessage := []byte("I authorize this babyjubjub key for hermez rollup account creation")
+
 	tx := &L1Tx{
 		UserOrigin: false,
 	}
@@ -394,20 +401,18 @@ func L1CoordinatorTxFromBytes(b []byte, chainID *big.Int, hermezAddress ethCommo
 		// L1CoordinatorTX ETH
 		// Ethereum adds 27 to v
 		v = b[0] - byte(27) //nolint:gomnd
+		chainIDBytes := ethCommon.LeftPadBytes(chainID.Bytes(), 2)
+		var data []byte
+		data = append(data, bytesMessage...)
+		data = append(data, pkCompB...)
+		data = append(data, chainIDBytes[:]...)
+		data = append(data, hermezAddress.Bytes()...)
 		var signature []byte
 		signature = append(signature, r[:]...)
 		signature = append(signature, s[:]...)
 		signature = append(signature, v)
-
-		accCreationAuth := AccountCreationAuth{
-			BJJ: tx.FromBJJ,
-		}
-		h, err := accCreationAuth.HashToSign(uint16(chainID.Uint64()), hermezAddress)
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-
-		pubKeyBytes, err := ethCrypto.Ecrecover(h, signature)
+		hash := signHash(data)
+		pubKeyBytes, err := ethCrypto.Ecrecover(hash, signature)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
--- a/common/l1tx_test.go
+++ b/common/l1tx_test.go
@@ -227,6 +227,7 @@ func TestL1TxByteParsersCompatibility(t *testing.T) {
 func TestL1CoordinatorTxByteParsers(t *testing.T) {
 	hermezAddress := ethCommon.HexToAddress("0xD6C850aeBFDC46D7F4c207e445cC0d6B0919BDBe")
 	chainID := big.NewInt(1337)
+	chainIDBytes := ethCommon.LeftPadBytes(chainID.Bytes(), 2)

 	privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
 	require.NoError(t, err)
@@ -244,16 +245,18 @@ func TestL1CoordinatorTxByteParsers(t *testing.T) {
 	pkCompL := []byte("56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c")
 	err = pkComp.UnmarshalText(pkCompL)
 	require.NoError(t, err)
+	bytesMessage1 := []byte("\x19Ethereum Signed Message:\n120")
+	bytesMessage2 := []byte("I authorize this babyjubjub key for hermez rollup account creation")

-	accCreationAuth := AccountCreationAuth{
-		EthAddr: fromEthAddr,
-		BJJ:     pkComp,
-	}
-
-	h, err := accCreationAuth.HashToSign(uint16(chainID.Uint64()), hermezAddress)
-	require.NoError(t, err)
-
-	signature, err := crypto.Sign(h, privateKey)
+	babyjubB := SwapEndianness(pkComp[:])
+	var data []byte
+	data = append(data, bytesMessage1...)
+	data = append(data, bytesMessage2...)
+	data = append(data, babyjubB[:]...)
+	data = append(data, chainIDBytes...)
+	data = append(data, hermezAddress.Bytes()...)
+	hash := crypto.Keccak256Hash(data)
+	signature, err := crypto.Sign(hash.Bytes(), privateKey)
 	require.NoError(t, err)
 	// Ethereum adds 27 to v
 	v := int(signature[64])
--- a/common/pooll2tx.go
+++ b/common/pooll2tx.go
@@ -73,7 +73,7 @@ func NewPoolL2Tx(tx *PoolL2Tx) (*PoolL2Tx, error) {
 	// If original Type doesn't match the correct one, return error
 	if txTypeOld != "" && txTypeOld != tx.Type {
 		return nil, tracerr.Wrap(fmt.Errorf("L2Tx.Type: %s, should be: %s",
-			txTypeOld, tx.Type))
+			tx.Type, txTypeOld))
 	}

 	txIDOld := tx.TxID
@@ -83,7 +83,7 @@ func NewPoolL2Tx(tx *PoolL2Tx) (*PoolL2Tx, error) {
 	// If original TxID doesn't match the correct one, return error
 	if txIDOld != (TxID{}) && txIDOld != tx.TxID {
 		return tx, tracerr.Wrap(fmt.Errorf("PoolL2Tx.TxID: %s, should be: %s",
-			txIDOld.String(), tx.TxID.String()))
+			tx.TxID.String(), txIDOld.String()))
 	}

 	return tx, nil
--- a/config/config.go
+++ b/config/config.go
@@ -44,21 +44,10 @@ type ForgeBatchGasCost struct {
 	L2Tx      uint64 `validate:"required"`
 }

-// CoordinatorAPI specifies the configuration parameters of the API in mode
-// coordinator
-type CoordinatorAPI struct {
-	// Coordinator enables the coordinator API endpoints
-	Coordinator bool
-}
-
 // Coordinator is the coordinator specific configuration.
 type Coordinator struct {
 	// ForgerAddress is the address under which this coordinator is forging
 	ForgerAddress ethCommon.Address `validate:"required"`
-	// MinimumForgeAddressBalance is the minimum balance the forger address
-	// needs to start the coordinator in wei. Of set to 0, the coordinator
-	// will not check the balance before starting.
-	MinimumForgeAddressBalance *big.Int
 	// FeeAccount is the Hermez account that the coordinator uses to receive fees
 	FeeAccount struct {
 		// Address is the ethereum address of the account to receive fees
@@ -204,7 +193,10 @@ type Coordinator struct {
 		// ForgeBatch transaction.
 		ForgeBatchGasCost ForgeBatchGasCost `validate:"required"`
 	} `validate:"required"`
-	API   CoordinatorAPI `validate:"required"`
+	API struct {
+		// Coordinator enables the coordinator API endpoints
+		Coordinator bool
+	} `validate:"required"`
 	Debug struct {
 		// BatchPath if set, specifies the path where batchInfo is stored
 		// in JSON in every step/update of the pipeline
@@ -219,64 +211,6 @@ type Coordinator struct {
 	}
 }

-// NodeAPI specifies the configuration parameters of the API
-type NodeAPI struct {
-	// Address where the API will listen if set
-	Address string
-	// Explorer enables the Explorer API endpoints
-	Explorer bool
-	// UpdateMetricsInterval is the interval between updates of the
-	// API metrics
-	UpdateMetricsInterval Duration
-	// UpdateRecommendedFeeInterval is the interval between updates of the
-	// recommended fees
-	UpdateRecommendedFeeInterval Duration
-	// Maximum concurrent connections allowed between API and SQL
-	MaxSQLConnections int `validate:"required"`
-	// SQLConnectionTimeout is the maximum amount of time that an API request
-	// can wait to stablish a SQL connection
-	SQLConnectionTimeout Duration
-}
-
-// It's possible to use diferentiated SQL connections for read/write.
-// If the read configuration is not provided, the write one it's going to be used
-// for both reads and writes
-type PostgreSQL struct {
-	// Port of the PostgreSQL write server
-	PortWrite int `validate:"required"`
-	// Host of the PostgreSQL write server
-	HostWrite string `validate:"required"`
-	// User of the PostgreSQL write server
-	UserWrite string `validate:"required"`
-	// Password of the PostgreSQL write server
-	PasswordWrite string `validate:"required"`
-	// Name of the PostgreSQL write server database
-	NameWrite string `validate:"required"`
-	// Port of the PostgreSQL read server
-	PortRead int
-	// Host of the PostgreSQL read server
-	HostRead string
-	// User of the PostgreSQL read server
-	UserRead string
-	// Password of the PostgreSQL read server
-	PasswordRead string
-	// Name of the PostgreSQL read server database
-	NameRead string
-}
-
-// NodeDebug specifies debug configuration parameters
-type NodeDebug struct {
-	// APIAddress is the address where the debugAPI will listen if
-	// set
-	APIAddress string
-	// MeddlerLogs enables meddler debug mode, where unused columns and struct
-	// fields will be logged
-	MeddlerLogs bool
-	// GinDebugMode sets Gin-Gonic (the web framework) to run in
-	// debug mode
-	GinDebugMode bool
-}
-
 // Node is the hermez node configuration.
 type Node struct {
 	PriceUpdater struct {
@@ -293,8 +227,32 @@ type Node struct {
 		// Keep is the number of checkpoints to keep
 		Keep int `validate:"required"`
 	} `validate:"required"`
-	PostgreSQL PostgreSQL `validate:"required"`
-	Web3       struct {
+	// It's possible to use diferentiated SQL connections for read/write.
+	// If the read configuration is not provided, the write one it's going to be used
+	// for both reads and writes
+	PostgreSQL struct {
+		// Port of the PostgreSQL write server
+		PortWrite int `validate:"required"`
+		// Host of the PostgreSQL write server
+		HostWrite string `validate:"required"`
+		// User of the PostgreSQL write server
+		UserWrite string `validate:"required"`
+		// Password of the PostgreSQL write server
+		PasswordWrite string `validate:"required"`
+		// Name of the PostgreSQL write server database
+		NameWrite string `validate:"required"`
+		// Port of the PostgreSQL read server
+		PortRead int
+		// Host of the PostgreSQL read server
+		HostRead string
+		// User of the PostgreSQL read server
+		UserRead string
+		// Password of the PostgreSQL read server
+		PasswordRead string
+		// Name of the PostgreSQL read server database
+		NameRead string
+	} `validate:"required"`
+	Web3 struct {
 		// URL is the URL of the web3 ethereum-node RPC server
 		URL string `validate:"required"`
 	} `validate:"required"`
@@ -324,34 +282,34 @@ type Node struct {
 		// TokenHEZ address
 		TokenHEZName string `validate:"required"`
 	} `validate:"required"`
-	API         NodeAPI     `validate:"required"`
-	Debug       NodeDebug   `validate:"required"`
+	API struct {
+		// Address where the API will listen if set
+		Address string
+		// Explorer enables the Explorer API endpoints
+		Explorer bool
+		// UpdateMetricsInterval is the interval between updates of the
+		// API metrics
+		UpdateMetricsInterval Duration
+		// UpdateRecommendedFeeInterval is the interval between updates of the
+		// recommended fees
+		UpdateRecommendedFeeInterval Duration
+		// Maximum concurrent connections allowed between API and SQL
+		MaxSQLConnections int `validate:"required"`
+		// SQLConnectionTimeout is the maximum amount of time that an API request
+		// can wait to stablish a SQL connection
+		SQLConnectionTimeout Duration
+	} `validate:"required"`
+	Debug struct {
+		// APIAddress is the address where the debugAPI will listen if
+		// set
+		APIAddress string
+		// MeddlerLogs enables meddler debug mode, where unused columns and struct
+		// fields will be logged
+		MeddlerLogs bool
+	}
 	Coordinator Coordinator `validate:"-"`
 }

-type APIServer struct {
-	API         NodeAPI    `validate:"required"`
-	PostgreSQL  PostgreSQL `validate:"required"`
-	Coordinator struct {
-		API struct {
-			// Coordinator enables the coordinator API endpoints
-			Coordinator bool
-		} `validate:"required"`
-	} `validate:"required"`
-	L2DB struct {
-		// MaxTxs is the maximum number of pending L2Txs that can be
-		// stored in the pool.  Once this number of pending L2Txs is
-		// reached, inserts to the pool will be denied until some of
-		// the pending txs are forged.
-		MaxTxs uint32 `validate:"required"`
-		// MinFeeUSD is the minimum fee in USD that a tx must pay in
-		// order to be accepted into the pool.  Txs with lower than
-		// minimum fee will be rejected at the API level.
-		MinFeeUSD float64
-	} `validate:"required"`
-	Debug NodeDebug `validate:"required"`
-}
-
 // Load loads a generic config.
 func Load(path string, cfg interface{}) error {
 	bs, err := ioutil.ReadFile(path) //nolint:gosec
@@ -393,16 +351,3 @@ func LoadNode(path string) (*Node, error) {
 	}
 	return &cfg, nil
 }
-
-// LoadAPIServer loads the APIServer configuration from path.
-func LoadAPIServer(path string) (*APIServer, error) {
-	var cfg APIServer
-	if err := Load(path, &cfg); err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("error loading apiServer configuration file: %w", err))
-	}
-	validate := validator.New()
-	if err := validate.Struct(cfg); err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("error validating configuration file: %w", err))
-	}
-	return &cfg, nil
-}
--- a/coordinator/coordinator.go
+++ b/coordinator/coordinator.go
@@ -185,8 +185,8 @@ func NewCoordinator(cfg Config,
 	batchBuilder *batchbuilder.BatchBuilder,
 	serverProofs []prover.Client,
 	ethClient eth.ClientInterface,
-	scConsts *common.SCConsts,
-	initSCVars *common.SCVariables,
+	scConsts *synchronizer.SCConsts,
+	initSCVars *synchronizer.SCVariables,
 ) (*Coordinator, error) {
 	// nolint reason: hardcoded `1.0`, by design the percentage can't be over 100%
 	if cfg.L1BatchTimeoutPerc >= 1.0 { //nolint:gomnd
--- a/coordinator/coordinator_test.go
+++ b/coordinator/coordinator_test.go
@@ -517,7 +517,7 @@ func TestCoordinatorStress(t *testing.T) {
 	wg.Add(1)
 	go func() {
 		for {
-			blockData, _, err := syn.Sync(ctx, nil)
+			blockData, _, err := syn.Sync2(ctx, nil)
 			if ctx.Err() != nil {
 				wg.Done()
 				return
--- a/coordinator/pipeline_test.go
+++ b/coordinator/pipeline_test.go
@@ -148,7 +148,7 @@ func preloadSync(t *testing.T, ethClient *test.Client, sync *synchronizer.Synchr

 	ctx := context.Background()
 	for {
-		syncBlock, discards, err := sync.Sync(ctx, nil)
+		syncBlock, discards, err := sync.Sync2(ctx, nil)
 		require.NoError(t, err)
 		require.Nil(t, discards)
 		if syncBlock == nil {
--- a/db/historydb/apiqueries.go
+++ b/db/historydb/apiqueries.go
@@ -1,11 +1,8 @@
 package historydb

 import (
-	"database/sql"
 	"errors"
 	"fmt"
-	"math/big"
-	"time"

 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/hermeznetwork/hermez-node/common"
@@ -35,18 +32,9 @@ func (hdb *HistoryDB) GetBatchAPI(batchNum common.BatchNum) (*BatchAPI, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	defer hdb.apiConnCon.Release()
-	return hdb.getBatchAPI(hdb.dbRead, batchNum)
-}
-
-// GetBatchAPI return the batch with the given batchNum
-func (hdb *HistoryDB) GetBatchInternalAPI(batchNum common.BatchNum) (*BatchAPI, error) {
-	return hdb.getBatchAPI(hdb.dbRead, batchNum)
-}
-
-func (hdb *HistoryDB) getBatchAPI(d meddler.DB, batchNum common.BatchNum) (*BatchAPI, error) {
 	batch := &BatchAPI{}
 	return batch, tracerr.Wrap(meddler.QueryRow(
-		d, batch,
+		hdb.dbRead, batch,
 		`SELECT batch.item_id, batch.batch_num, batch.eth_block_num,
 		batch.forger_addr, batch.fees_collected, batch.total_fees_usd, batch.state_root,
 		batch.num_accounts, batch.exit_root, batch.forge_l1_txs_num, batch.slot_num,
@@ -192,14 +180,6 @@ func (hdb *HistoryDB) GetBestBidsAPI(
 		return nil, 0, tracerr.Wrap(err)
 	}
 	defer hdb.apiConnCon.Release()
-	return hdb.getBestBidsAPI(hdb.dbRead, minSlotNum, maxSlotNum, bidderAddr, limit, order)
-}
-func (hdb *HistoryDB) getBestBidsAPI(
-	d meddler.DB,
-	minSlotNum, maxSlotNum *int64,
-	bidderAddr *ethCommon.Address,
-	limit *uint, order string,
-) ([]BidAPI, uint64, error) {
 	var query string
 	var args []interface{}
 	// JOIN the best bid of each slot with the latest update of each coordinator
@@ -234,7 +214,7 @@ func (hdb *HistoryDB) getBestBidsAPI(
 	}
 	query = hdb.dbRead.Rebind(queryStr)
 	bidPtrs := []*BidAPI{}
-	if err := meddler.QueryAll(d, &bidPtrs, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.dbRead, &bidPtrs, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	// log.Debug(query)
@@ -717,6 +697,25 @@ func (hdb *HistoryDB) GetExitsAPI(
 	return db.SlicePtrsToSlice(exits).([]ExitAPI), exits[0].TotalItems - uint64(len(exits)), nil
 }

+// GetBucketUpdatesAPI retrieves latest values for each bucket
+func (hdb *HistoryDB) GetBucketUpdatesAPI() ([]BucketUpdateAPI, error) {
+	cancel, err := hdb.apiConnCon.Acquire()
+	defer cancel()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	defer hdb.apiConnCon.Release()
+	var bucketUpdates []*BucketUpdateAPI
+	err = meddler.QueryAll(
+		hdb.dbRead, &bucketUpdates,
+		`SELECT num_bucket, withdrawals FROM bucket_update 
+		WHERE item_id in(SELECT max(item_id) FROM bucket_update 
+		group by num_bucket) 
+		ORDER BY num_bucket ASC;`,
+	)
+	return db.SlicePtrsToSlice(bucketUpdates).([]BucketUpdateAPI), tracerr.Wrap(err)
+}
+
 // GetCoordinatorsAPI returns a list of coordinators from the DB and pagination info
 func (hdb *HistoryDB) GetCoordinatorsAPI(
 	bidderAddr, forgerAddr *ethCommon.Address,
@@ -801,6 +800,29 @@ func (hdb *HistoryDB) GetAuctionVarsAPI() (*common.AuctionVariables, error) {
 	return auctionVars, tracerr.Wrap(err)
 }

+// GetAuctionVarsUntilSetSlotNumAPI returns all the updates of the auction vars
+// from the last entry in which DefaultSlotSetBidSlotNum <= slotNum
+func (hdb *HistoryDB) GetAuctionVarsUntilSetSlotNumAPI(slotNum int64, maxItems int) ([]MinBidInfo, error) {
+	cancel, err := hdb.apiConnCon.Acquire()
+	defer cancel()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	defer hdb.apiConnCon.Release()
+	auctionVars := []*MinBidInfo{}
+	query := `
+		SELECT DISTINCT default_slot_set_bid, default_slot_set_bid_slot_num FROM auction_vars
+		WHERE default_slot_set_bid_slot_num < $1
+		ORDER BY default_slot_set_bid_slot_num DESC
+		LIMIT $2;
+	`
+	err = meddler.QueryAll(hdb.dbRead, &auctionVars, query, slotNum, maxItems)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	return db.SlicePtrsToSlice(auctionVars).([]MinBidInfo), nil
+}
+
 // GetAccountAPI returns an account by its index
 func (hdb *HistoryDB) GetAccountAPI(idx common.Idx) (*AccountAPI, error) {
 	cancel, err := hdb.apiConnCon.Acquire()
@@ -919,6 +941,112 @@ func (hdb *HistoryDB) GetAccountsAPI(
 		accounts[0].TotalItems - uint64(len(accounts)), nil
 }

+// GetMetricsAPI returns metrics
+func (hdb *HistoryDB) GetMetricsAPI(lastBatchNum common.BatchNum) (*Metrics, error) {
+	cancel, err := hdb.apiConnCon.Acquire()
+	defer cancel()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	defer hdb.apiConnCon.Release()
+	metricsTotals := &MetricsTotals{}
+	metrics := &Metrics{}
+	err = meddler.QueryRow(
+		hdb.dbRead, metricsTotals, `SELECT
+		COALESCE (MIN(batch.batch_num), 0) as batch_num,
+		COALESCE (MIN(block.timestamp), NOW()) AS min_timestamp, 
+		COALESCE (MAX(block.timestamp), NOW()) AS max_timestamp
+		FROM batch INNER JOIN block ON batch.eth_block_num = block.eth_block_num
+		WHERE block.timestamp >= NOW() - INTERVAL '24 HOURS' and batch.batch_num <= $1;`, lastBatchNum)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+
+	err = meddler.QueryRow(
+		hdb.dbRead, metricsTotals, `SELECT COUNT(*) as total_txs
+		FROM tx	WHERE tx.batch_num between $1 AND $2;`, metricsTotals.FirstBatchNum, lastBatchNum)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+
+	seconds := metricsTotals.MaxTimestamp.Sub(metricsTotals.MinTimestamp).Seconds()
+	// Avoid dividing by 0
+	if seconds == 0 {
+		seconds++
+	}
+
+	metrics.TransactionsPerSecond = float64(metricsTotals.TotalTransactions) / seconds
+
+	if (lastBatchNum - metricsTotals.FirstBatchNum) > 0 {
+		metrics.TransactionsPerBatch = float64(metricsTotals.TotalTransactions) /
+			float64(lastBatchNum-metricsTotals.FirstBatchNum+1)
+	} else {
+		metrics.TransactionsPerBatch = float64(0)
+	}
+
+	err = meddler.QueryRow(
+		hdb.dbRead, metricsTotals, `SELECT COUNT(*) AS total_batches, 
+		COALESCE (SUM(total_fees_usd), 0) AS total_fees FROM batch 
+		WHERE batch_num between $1 and $2;`, metricsTotals.FirstBatchNum, lastBatchNum)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+
+	if metricsTotals.TotalBatches > 0 {
+		metrics.BatchFrequency = seconds / float64(metricsTotals.TotalBatches)
+	} else {
+		metrics.BatchFrequency = 0
+	}
+	if metricsTotals.TotalTransactions > 0 {
+		metrics.AvgTransactionFee = metricsTotals.TotalFeesUSD / float64(metricsTotals.TotalTransactions)
+	} else {
+		metrics.AvgTransactionFee = 0
+	}
+	err = meddler.QueryRow(
+		hdb.dbRead, metrics,
+		`SELECT COUNT(*) AS total_bjjs, COUNT(DISTINCT(bjj)) AS total_accounts FROM account;`)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+
+	return metrics, nil
+}
+
+// GetAvgTxFeeAPI returns average transaction fee of the last 1h
+func (hdb *HistoryDB) GetAvgTxFeeAPI() (float64, error) {
+	cancel, err := hdb.apiConnCon.Acquire()
+	defer cancel()
+	if err != nil {
+		return 0, tracerr.Wrap(err)
+	}
+	defer hdb.apiConnCon.Release()
+	metricsTotals := &MetricsTotals{}
+	err = meddler.QueryRow(
+		hdb.dbRead, metricsTotals, `SELECT COUNT(tx.*) as total_txs, 
+		COALESCE (MIN(tx.batch_num), 0) as batch_num 
+		FROM tx INNER JOIN block ON tx.eth_block_num = block.eth_block_num
+		WHERE block.timestamp >= NOW() - INTERVAL '1 HOURS';`)
+	if err != nil {
+		return 0, tracerr.Wrap(err)
+	}
+	err = meddler.QueryRow(
+		hdb.dbRead, metricsTotals, `SELECT COUNT(*) AS total_batches, 
+		COALESCE (SUM(total_fees_usd), 0) AS total_fees FROM batch 
+		WHERE batch_num > $1;`, metricsTotals.FirstBatchNum)
+	if err != nil {
+		return 0, tracerr.Wrap(err)
+	}
+
+	var avgTransactionFee float64
+	if metricsTotals.TotalTransactions > 0 {
+		avgTransactionFee = metricsTotals.TotalFeesUSD / float64(metricsTotals.TotalTransactions)
+	} else {
+		avgTransactionFee = 0
+	}
+
+	return avgTransactionFee, nil
+}
+
 // GetCommonAccountAPI returns the account associated to an account idx
 func (hdb *HistoryDB) GetCommonAccountAPI(idx common.Idx) (*common.Account, error) {
 	cancel, err := hdb.apiConnCon.Acquire()
@@ -933,250 +1061,3 @@ func (hdb *HistoryDB) GetCommonAccountAPI(idx common.Idx) (*common.Account, erro
 	)
 	return account, tracerr.Wrap(err)
 }
-
-// GetCoordinatorAPI returns a coordinator by its bidderAddr
-func (hdb *HistoryDB) GetCoordinatorAPI(bidderAddr ethCommon.Address) (*CoordinatorAPI, error) {
-	cancel, err := hdb.apiConnCon.Acquire()
-	defer cancel()
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	defer hdb.apiConnCon.Release()
-	return hdb.getCoordinatorAPI(hdb.dbRead, bidderAddr)
-}
-func (hdb *HistoryDB) getCoordinatorAPI(d meddler.DB, bidderAddr ethCommon.Address) (*CoordinatorAPI, error) {
-	coordinator := &CoordinatorAPI{}
-	err := meddler.QueryRow(
-		d, coordinator,
-		"SELECT * FROM coordinator WHERE bidder_addr = $1 ORDER BY item_id DESC LIMIT 1;",
-		bidderAddr,
-	)
-	return coordinator, tracerr.Wrap(err)
-}
-
-func (hdb *HistoryDB) GetNodeInfoAPI() (*NodeInfo, error) {
-	cancel, err := hdb.apiConnCon.Acquire()
-	defer cancel()
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	defer hdb.apiConnCon.Release()
-	return hdb.GetNodeInfo()
-}
-
-func (hdb *HistoryDB) GetBucketUpdatesInternalAPI() ([]BucketUpdateAPI, error) {
-	var bucketUpdates []*BucketUpdateAPI
-	// var bucketUpdates []*common.BucketUpdate
-	err := meddler.QueryAll(
-		hdb.dbRead, &bucketUpdates,
-		`SELECT num_bucket, withdrawals FROM bucket_update 
-			WHERE item_id in(SELECT max(item_id) FROM bucket_update 
-			group by num_bucket) 
-			ORDER BY num_bucket ASC;`,
-	)
-	return db.SlicePtrsToSlice(bucketUpdates).([]BucketUpdateAPI), tracerr.Wrap(err)
-}
-
-// getNextForgers returns next forgers
-func (hdb *HistoryDB) GetNextForgersInternalAPI(auctionVars *common.AuctionVariables,
-	auctionConsts *common.AuctionConstants,
-	lastBlock common.Block, currentSlot, lastClosedSlot int64) ([]NextForgerAPI, error) {
-	secondsPerBlock := int64(15) //nolint:gomnd
-	// currentSlot and lastClosedSlot included
-	limit := uint(lastClosedSlot - currentSlot + 1)
-	bids, _, err := hdb.getBestBidsAPI(hdb.dbRead, &currentSlot, &lastClosedSlot, nil, &limit, "ASC")
-	if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
-		return nil, tracerr.Wrap(err)
-	}
-	nextForgers := []NextForgerAPI{}
-	// Get min bid info
-	var minBidInfo []MinBidInfo
-	if currentSlot >= auctionVars.DefaultSlotSetBidSlotNum {
-		// All min bids can be calculated with the last update of AuctionVariables
-
-		minBidInfo = []MinBidInfo{{
-			DefaultSlotSetBid:        auctionVars.DefaultSlotSetBid,
-			DefaultSlotSetBidSlotNum: auctionVars.DefaultSlotSetBidSlotNum,
-		}}
-	} else {
-		// Get all the relevant updates from the DB
-		minBidInfo, err = hdb.getMinBidInfo(hdb.dbRead, currentSlot, lastClosedSlot)
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-	}
-	// Create nextForger for each slot
-	for i := currentSlot; i <= lastClosedSlot; i++ {
-		fromBlock := i*int64(auctionConsts.BlocksPerSlot) +
-			auctionConsts.GenesisBlockNum
-		toBlock := (i+1)*int64(auctionConsts.BlocksPerSlot) +
-			auctionConsts.GenesisBlockNum - 1
-		nextForger := NextForgerAPI{
-			Period: Period{
-				SlotNum:   i,
-				FromBlock: fromBlock,
-				ToBlock:   toBlock,
-				FromTimestamp: lastBlock.Timestamp.Add(time.Second *
-					time.Duration(secondsPerBlock*(fromBlock-lastBlock.Num))),
-				ToTimestamp: lastBlock.Timestamp.Add(time.Second *
-					time.Duration(secondsPerBlock*(toBlock-lastBlock.Num))),
-			},
-		}
-		foundForger := false
-		// If there is a bid for a slot, get forger (coordinator)
-		for j := range bids {
-			slotNum := bids[j].SlotNum
-			if slotNum == i {
-				// There's a bid for the slot
-				// Check if the bid is greater than the minimum required
-				for i := 0; i < len(minBidInfo); i++ {
-					// Find the most recent update
-					if slotNum >= minBidInfo[i].DefaultSlotSetBidSlotNum {
-						// Get min bid
-						minBidSelector := slotNum % int64(len(auctionVars.DefaultSlotSetBid))
-						minBid := minBidInfo[i].DefaultSlotSetBid[minBidSelector]
-						// Check if the bid has beaten the minimum
-						bid, ok := new(big.Int).SetString(string(bids[j].BidValue), 10)
-						if !ok {
-							return nil, tracerr.New("Wrong bid value, error parsing it as big.Int")
-						}
-						if minBid.Cmp(bid) == 1 {
-							// Min bid is greater than bid, the slot will be forged by boot coordinator
-							break
-						}
-						foundForger = true
-						break
-					}
-				}
-				if !foundForger { // There is no bid or it's smaller than the minimum
-					break
-				}
-				coordinator, err := hdb.getCoordinatorAPI(hdb.dbRead, bids[j].Bidder)
-				if err != nil {
-					return nil, tracerr.Wrap(err)
-				}
-				nextForger.Coordinator = *coordinator
-				break
-			}
-		}
-		// If there is no bid, the coordinator that will forge is boot coordinator
-		if !foundForger {
-			nextForger.Coordinator = CoordinatorAPI{
-				Forger: auctionVars.BootCoordinator,
-				URL:    auctionVars.BootCoordinatorURL,
-			}
-		}
-		nextForgers = append(nextForgers, nextForger)
-	}
-	return nextForgers, nil
-}
-
-// UpdateMetrics update Status.Metrics information
-func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (*MetricsAPI, error) {
-	var metrics MetricsAPI
-	// Get the first and last batch of the last 24h and their timestamps
-	// if u.state.Network.LastBatch == nil {
-	// 	return &metrics, nil
-	// }
-	type period struct {
-		FromBatchNum  common.BatchNum `meddler:"from_batch_num"`
-		FromTimestamp time.Time       `meddler:"from_timestamp"`
-		ToBatchNum    common.BatchNum `meddler:"-"`
-		ToTimestamp   time.Time       `meddler:"to_timestamp"`
-	}
-	p := &period{
-		ToBatchNum: lastBatchNum,
-	}
-	if err := meddler.QueryRow(
-		hdb.dbRead, p, `SELECT
-			COALESCE (MIN(batch.batch_num), 0) as from_batch_num,
-			COALESCE (MIN(block.timestamp), NOW()) AS from_timestamp, 
-			COALESCE (MAX(block.timestamp), NOW()) AS to_timestamp
-			FROM batch INNER JOIN block ON batch.eth_block_num = block.eth_block_num
-			WHERE block.timestamp >= NOW() - INTERVAL '24 HOURS';`,
-	); err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	// Get the amount of txs of that period
-	row := hdb.dbRead.QueryRow(
-		`SELECT COUNT(*) as total_txs FROM tx WHERE tx.batch_num between $1 AND $2;`,
-		p.FromBatchNum, p.ToBatchNum,
-	)
-	var nTxs int
-	if err := row.Scan(&nTxs); err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	// Set txs/s
-	seconds := p.ToTimestamp.Sub(p.FromTimestamp).Seconds()
-	if seconds == 0 { // Avoid dividing by 0
-		seconds++
-	}
-	metrics.TransactionsPerSecond = float64(nTxs) / seconds
-	// Set txs/batch
-	nBatches := p.ToBatchNum - p.FromBatchNum + 1
-	if nBatches == 0 { // Avoid dividing by 0
-		nBatches++
-	}
-	if (p.ToBatchNum - p.FromBatchNum) > 0 {
-		fmt.Printf("DBG ntxs: %v, nBatches: %v\n", nTxs, nBatches)
-		metrics.TransactionsPerBatch = float64(nTxs) /
-			float64(nBatches)
-	} else {
-		metrics.TransactionsPerBatch = 0
-	}
-	// Get total fee of that period
-	row = hdb.dbRead.QueryRow(
-		`SELECT COALESCE (SUM(total_fees_usd), 0) FROM batch WHERE batch_num between $1 AND $2;`,
-		p.FromBatchNum, p.ToBatchNum,
-	)
-	var totalFee float64
-	if err := row.Scan(&totalFee); err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	// Set batch frequency
-	metrics.BatchFrequency = seconds / float64(nBatches)
-	if nTxs > 0 {
-		metrics.AvgTransactionFee = totalFee / float64(nTxs)
-	} else {
-		metrics.AvgTransactionFee = 0
-	}
-	// Get and set amount of registered accounts
-	type registeredAccounts struct {
-		TotalIdx int64 `meddler:"total_idx"`
-		TotalBJJ int64 `meddler:"total_bjj"`
-	}
-	ra := &registeredAccounts{}
-	if err := meddler.QueryRow(
-		hdb.dbRead, ra,
-		`SELECT COUNT(*) AS total_bjj, COUNT(DISTINCT(bjj)) AS total_idx FROM account;`,
-	); err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	metrics.TotalAccounts = ra.TotalIdx
-	metrics.TotalBJJs = ra.TotalBJJ
-	// Get and set estimated time to forge L1 tx
-	row = hdb.dbRead.QueryRow(
-		`SELECT COALESCE (AVG(EXTRACT(EPOCH FROM (forged.timestamp - added.timestamp))), 0) FROM tx
-			INNER JOIN block AS added ON tx.eth_block_num = added.eth_block_num
-			INNER JOIN batch AS forged_batch ON tx.batch_num = forged_batch.batch_num
-			INNER JOIN block AS forged ON forged_batch.eth_block_num = forged.eth_block_num
-			WHERE tx.batch_num between $1 and $2 AND tx.is_l1 AND tx.user_origin;`,
-		p.FromBatchNum, p.ToBatchNum,
-	)
-	var timeToForgeL1 float64
-	if err := row.Scan(&timeToForgeL1); err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	metrics.EstimatedTimeToForgeL1 = timeToForgeL1
-	return &metrics, nil
-}
-
-func (hdb *HistoryDB) GetStateAPI() (*StateAPI, error) {
-	cancel, err := hdb.apiConnCon.Acquire()
-	defer cancel()
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	defer hdb.apiConnCon.Release()
-	return hdb.getStateAPI(hdb.dbRead)
-}
--- a/db/historydb/historydb.go
+++ b/db/historydb/historydb.go
@@ -841,18 +841,6 @@ func (hdb *HistoryDB) GetAllBucketUpdates() ([]common.BucketUpdate, error) {
 	return db.SlicePtrsToSlice(bucketUpdates).([]common.BucketUpdate), tracerr.Wrap(err)
 }

-func (hdb *HistoryDB) getMinBidInfo(d meddler.DB,
-	currentSlot, lastClosedSlot int64) ([]MinBidInfo, error) {
-	minBidInfo := []*MinBidInfo{}
-	query := `
-		SELECT DISTINCT default_slot_set_bid, default_slot_set_bid_slot_num FROM auction_vars
-		WHERE default_slot_set_bid_slot_num < $1
-		ORDER BY default_slot_set_bid_slot_num DESC
-		LIMIT $2;`
-	err := meddler.QueryAll(d, &minBidInfo, query, lastClosedSlot, int(lastClosedSlot-currentSlot)+1)
-	return db.SlicePtrsToSlice(minBidInfo).([]MinBidInfo), tracerr.Wrap(err)
-}
-
 func (hdb *HistoryDB) addTokenExchanges(d meddler.DB, tokenExchanges []common.TokenExchange) error {
 	if len(tokenExchanges) == 0 {
 		return nil
@@ -1151,6 +1139,17 @@ func (hdb *HistoryDB) AddBlockSCData(blockData *common.BlockData) (err error) {
 	return tracerr.Wrap(txn.Commit())
 }

+// GetCoordinatorAPI returns a coordinator by its bidderAddr
+func (hdb *HistoryDB) GetCoordinatorAPI(bidderAddr ethCommon.Address) (*CoordinatorAPI, error) {
+	coordinator := &CoordinatorAPI{}
+	err := meddler.QueryRow(
+		hdb.dbRead, coordinator,
+		"SELECT * FROM coordinator WHERE bidder_addr = $1 ORDER BY item_id DESC LIMIT 1;",
+		bidderAddr,
+	)
+	return coordinator, tracerr.Wrap(err)
+}
+
 // AddAuctionVars insert auction vars into the DB
 func (hdb *HistoryDB) AddAuctionVars(auctionVars *common.AuctionVariables) error {
 	return tracerr.Wrap(meddler.Insert(hdb.dbWrite, "auction_vars", auctionVars))
@@ -1170,49 +1169,3 @@ func (hdb *HistoryDB) GetTokensTest() ([]TokenWithUSD, error) {
 	}
 	return db.SlicePtrsToSlice(tokens).([]TokenWithUSD), nil
 }
-
-// UpdateRecommendedFee update Status.RecommendedFee information
-func (hdb *HistoryDB) GetRecommendedFee(minFeeUSD float64) (*common.RecommendedFee, error) {
-	var recommendedFee common.RecommendedFee
-	// Get total txs and the batch of the first selected tx of the last hour
-	type totalTxsSinceBatchNum struct {
-		TotalTxs      int             `meddler:"total_txs"`
-		FirstBatchNum common.BatchNum `meddler:"batch_num"`
-	}
-	ttsbn := &totalTxsSinceBatchNum{}
-	if err := meddler.QueryRow(
-		hdb.dbRead, ttsbn, `SELECT COUNT(tx.*) as total_txs, 
-			COALESCE (MIN(tx.batch_num), 0) as batch_num 
-			FROM tx INNER JOIN block ON tx.eth_block_num = block.eth_block_num
-			WHERE block.timestamp >= NOW() - INTERVAL '1 HOURS';`,
-	); err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	// Get the amount of batches and acumulated fees for the last hour
-	type totalBatchesAndFee struct {
-		TotalBatches int     `meddler:"total_batches"`
-		TotalFees    float64 `meddler:"total_fees"`
-	}
-	tbf := &totalBatchesAndFee{}
-	if err := meddler.QueryRow(
-		hdb.dbRead, tbf, `SELECT COUNT(*) AS total_batches, 
-			COALESCE (SUM(total_fees_usd), 0) AS total_fees FROM batch 
-			WHERE batch_num > $1;`, ttsbn.FirstBatchNum,
-	); err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	// Update NodeInfo struct
-	var avgTransactionFee float64
-	if ttsbn.TotalTxs > 0 {
-		avgTransactionFee = tbf.TotalFees / float64(ttsbn.TotalTxs)
-	} else {
-		avgTransactionFee = 0
-	}
-	recommendedFee.ExistingAccount =
-		math.Max(avgTransactionFee, minFeeUSD)
-	recommendedFee.CreatesAccount =
-		math.Max(createAccountExtraFeePercentage*avgTransactionFee, minFeeUSD)
-	recommendedFee.CreatesAccountAndRegister =
-		math.Max(createAccountInternalExtraFeePercentage*avgTransactionFee, minFeeUSD)
-	return &recommendedFee, nil
-}
--- a/db/historydb/historydb_test.go
+++ b/db/historydb/historydb_test.go
@@ -1172,16 +1172,7 @@ func TestGetMetricsAPI(t *testing.T) {
 		assert.NoError(t, err)
 	}

-	// clientSetupExample := test.NewClientSetupExample()
-	// apiStateUpdater := NewAPIStateUpdater(historyDB, &NodeConfig{1000, 0.5},
-	// 	&Constants{
-	// 		RollupConstants:   *clientSetupExample.RollupConstants,
-	// 		AuctionConstants:  *clientSetupExample.AuctionConstants,
-	// 		WDelayerConstants: *clientSetupExample.WDelayerConstants,
-	// 		ChainID:           uint16(clientSetupExample.ChainID.Int64()),
-	// 		HermezAddress:     clientSetupExample.AuctionConstants.HermezRollup,
-	// 	})
-	res, err := historyDB.GetMetricsInternalAPI(common.BatchNum(numBatches))
+	res, err := historyDBWithACC.GetMetricsAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)

 	assert.Equal(t, float64(numTx)/float64(numBatches), res.TransactionsPerBatch)
@@ -1259,7 +1250,7 @@ func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {
 		assert.NoError(t, err)
 	}

-	res, err := historyDBWithACC.GetMetricsInternalAPI(common.BatchNum(numBatches))
+	res, err := historyDBWithACC.GetMetricsAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)

 	assert.InEpsilon(t, 1.0, res.TransactionsPerBatch, 0.1)
@@ -1274,7 +1265,13 @@ func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {

 func TestGetMetricsAPIEmpty(t *testing.T) {
 	test.WipeDB(historyDB.DB())
-	_, err := historyDBWithACC.GetMetricsInternalAPI(0)
+	_, err := historyDBWithACC.GetMetricsAPI(0)
+	assert.NoError(t, err)
+}
+
+func TestGetAvgTxFeeEmpty(t *testing.T) {
+	test.WipeDB(historyDB.DB())
+	_, err := historyDBWithACC.GetAvgTxFeeAPI()
 	assert.NoError(t, err)
 }

@@ -1463,65 +1460,3 @@ func setTestBlocks(from, to int64) []common.Block {
 	}
 	return blocks
 }
-
-func TestNodeInfo(t *testing.T) {
-	test.WipeDB(historyDB.DB())
-
-	err := historyDB.SetAPIState(&StateAPI{})
-	require.NoError(t, err)
-
-	clientSetup := test.NewClientSetupExample()
-	constants := &Constants{
-		SCConsts: common.SCConsts{
-			Rollup:   *clientSetup.RollupConstants,
-			Auction:  *clientSetup.AuctionConstants,
-			WDelayer: *clientSetup.WDelayerConstants,
-		},
-		ChainID:       42,
-		HermezAddress: clientSetup.AuctionConstants.HermezRollup,
-	}
-	err = historyDB.SetConstants(constants)
-	require.NoError(t, err)
-
-	// Test parameters
-	stateAPI := &StateAPI{
-		NodePublicConfig: NodePublicConfig{
-			ForgeDelay: 3.1,
-		},
-		Network: NetworkAPI{
-			LastEthBlock:  12,
-			LastSyncBlock: 34,
-		},
-		Metrics: MetricsAPI{
-			TransactionsPerBatch: 1.1,
-			TotalAccounts:        42,
-		},
-		Rollup:            *NewRollupVariablesAPI(clientSetup.RollupVariables),
-		Auction:           *NewAuctionVariablesAPI(clientSetup.AuctionVariables),
-		WithdrawalDelayer: *clientSetup.WDelayerVariables,
-		RecommendedFee: common.RecommendedFee{
-			ExistingAccount: 0.15,
-		},
-	}
-	err = historyDB.SetAPIState(stateAPI)
-	require.NoError(t, err)
-
-	nodeConfig := &NodeConfig{
-		MaxPoolTxs: 123,
-		MinFeeUSD:  0.5,
-	}
-	err = historyDB.SetNodeConfig(nodeConfig)
-	require.NoError(t, err)
-
-	dbConstants, err := historyDB.GetConstants()
-	require.NoError(t, err)
-	assert.Equal(t, constants, dbConstants)
-
-	dbNodeConfig, err := historyDB.GetNodeConfig()
-	require.NoError(t, err)
-	assert.Equal(t, nodeConfig, dbNodeConfig)
-
-	dbStateAPI, err := historyDB.GetStateAPI()
-	require.NoError(t, err)
-	assert.Equal(t, stateAPI, dbStateAPI)
-}
--- a/db/historydb/nodeinfo.go
+++ b/db/historydb/nodeinfo.go
@@ -1,215 +0,0 @@
-package historydb
-
-import (
-	"time"
-
-	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/hermeznetwork/hermez-node/common"
-	"github.com/hermeznetwork/tracerr"
-	"github.com/russross/meddler"
-)
-
-const (
-	createAccountExtraFeePercentage         float64 = 2
-	createAccountInternalExtraFeePercentage float64 = 2.5
-)
-
-type Period struct {
-	SlotNum       int64     `json:"slotNum"`
-	FromBlock     int64     `json:"fromBlock"`
-	ToBlock       int64     `json:"toBlock"`
-	FromTimestamp time.Time `json:"fromTimestamp"`
-	ToTimestamp   time.Time `json:"toTimestamp"`
-}
-
-type NextForgerAPI struct {
-	Coordinator CoordinatorAPI `json:"coordinator"`
-	Period      Period         `json:"period"`
-}
-
-type NetworkAPI struct {
-	LastEthBlock  int64           `json:"lastEthereumBlock"`
-	LastSyncBlock int64           `json:"lastSynchedBlock"`
-	LastBatch     *BatchAPI       `json:"lastBatch"`
-	CurrentSlot   int64           `json:"currentSlot"`
-	NextForgers   []NextForgerAPI `json:"nextForgers"`
-}
-
-// NodePublicConfig is the configuration of the node that is exposed via API
-type NodePublicConfig struct {
-	// ForgeDelay in seconds
-	ForgeDelay float64 `json:"forgeDelay"`
-}
-
-type StateAPI struct {
-	// NodePublicConfig is the configuration of the node that is exposed via API
-	NodePublicConfig  NodePublicConfig         `json:"nodeConfig"`
-	Network           NetworkAPI               `json:"network"`
-	Metrics           MetricsAPI               `json:"metrics"`
-	Rollup            RollupVariablesAPI       `json:"rollup"`
-	Auction           AuctionVariablesAPI      `json:"auction"`
-	WithdrawalDelayer common.WDelayerVariables `json:"withdrawalDelayer"`
-	RecommendedFee    common.RecommendedFee    `json:"recommendedFee"`
-}
-
-type Constants struct {
-	// RollupConstants   common.RollupConstants
-	// AuctionConstants  common.AuctionConstants
-	// WDelayerConstants common.WDelayerConstants
-	common.SCConsts
-	ChainID       uint16
-	HermezAddress ethCommon.Address
-}
-
-type NodeConfig struct {
-	MaxPoolTxs uint32  `meddler:"max_pool_txs"`
-	MinFeeUSD  float64 `meddler:"min_fee"`
-}
-
-type NodeInfo struct {
-	ItemID     int         `meddler:"item_id,pk"`
-	APIState   *StateAPI   `meddler:"state,json"`
-	NodeConfig *NodeConfig `meddler:"config,json"`
-	Constants  *Constants  `meddler:"constants,json"`
-}
-
-func (hdb *HistoryDB) GetNodeInfo() (*NodeInfo, error) {
-	ni := &NodeInfo{}
-	err := meddler.QueryRow(
-		hdb.dbRead, ni, `SELECT * FROM node_info WHERE item_id = 1;`,
-	)
-	return ni, tracerr.Wrap(err)
-}
-
-func (hdb *HistoryDB) GetConstants() (*Constants, error) {
-	var nodeInfo NodeInfo
-	err := meddler.QueryRow(
-		hdb.dbRead, &nodeInfo,
-		"SELECT constants FROM node_info WHERE item_id = 1;",
-	)
-	return nodeInfo.Constants, tracerr.Wrap(err)
-}
-
-func (hdb *HistoryDB) SetConstants(constants *Constants) error {
-	_constants := struct {
-		Constants *Constants `meddler:"constants,json"`
-	}{constants}
-	values, err := meddler.Default.Values(&_constants, false)
-	if err != nil {
-		return tracerr.Wrap(err)
-	}
-	_, err = hdb.dbWrite.Exec(
-		"UPDATE node_info SET constants = $1 WHERE item_id = 1;",
-		values[0],
-	)
-	return tracerr.Wrap(err)
-}
-
-func (hdb *HistoryDB) GetStateInternalAPI() (*StateAPI, error) {
-	return hdb.getStateAPI(hdb.dbRead)
-}
-
-func (hdb *HistoryDB) getStateAPI(d meddler.DB) (*StateAPI, error) {
-	var nodeInfo NodeInfo
-	err := meddler.QueryRow(
-		d, &nodeInfo,
-		"SELECT state FROM node_info WHERE item_id = 1;",
-	)
-	return nodeInfo.APIState, tracerr.Wrap(err)
-}
-
-func (hdb *HistoryDB) SetAPIState(apiState *StateAPI) error {
-	_apiState := struct {
-		APIState *StateAPI `meddler:"state,json"`
-	}{apiState}
-	values, err := meddler.Default.Values(&_apiState, false)
-	if err != nil {
-		return tracerr.Wrap(err)
-	}
-	_, err = hdb.dbWrite.Exec(
-		"UPDATE node_info SET state = $1 WHERE item_id = 1;",
-		values[0],
-	)
-	return tracerr.Wrap(err)
-}
-
-func (hdb *HistoryDB) GetNodeConfig() (*NodeConfig, error) {
-	var nodeInfo NodeInfo
-	err := meddler.QueryRow(
-		hdb.dbRead, &nodeInfo,
-		"SELECT config FROM node_info WHERE item_id = 1;",
-	)
-	return nodeInfo.NodeConfig, tracerr.Wrap(err)
-}
-
-func (hdb *HistoryDB) SetNodeConfig(nodeConfig *NodeConfig) error {
-	_nodeConfig := struct {
-		NodeConfig *NodeConfig `meddler:"config,json"`
-	}{nodeConfig}
-	values, err := meddler.Default.Values(&_nodeConfig, false)
-	if err != nil {
-		return tracerr.Wrap(err)
-	}
-	_, err = hdb.dbWrite.Exec(
-		"UPDATE config SET state = $1 WHERE item_id = 1;",
-		values[0],
-	)
-	return tracerr.Wrap(err)
-}
-
-// func (hdb *HistoryDB) SetInitialNodeInfo(maxPoolTxs uint32, minFeeUSD float64, constants *Constants) error {
-// 	ni := &NodeInfo{
-// 		MaxPoolTxs: &maxPoolTxs,
-// 		MinFeeUSD:  &minFeeUSD,
-// 		Constants:  constants,
-// 	}
-// 	return tracerr.Wrap(meddler.Insert(hdb.dbWrite, "node_info", ni))
-// }
-
-// apiSlotToBigInts converts from [6]*apitypes.BigIntStr to [6]*big.Int
-// func apiSlotToBigInts(defaultSlotSetBid [6]*apitypes.BigIntStr) ([6]*big.Int, error) {
-// 	var slots [6]*big.Int
-//
-// 	for i, slot := range defaultSlotSetBid {
-// 		bigInt, ok := new(big.Int).SetString(string(*slot), 10)
-// 		if !ok {
-// 			return slots, tracerr.Wrap(fmt.Errorf("can't convert %T into big.Int", slot))
-// 		}
-// 		slots[i] = bigInt
-// 	}
-//
-// 	return slots, nil
-// }
-
-// func (hdb *HistoryDB) updateNodeInfo(setUpdatedNodeInfo func(*sqlx.Tx, *NodeInfo) error) error {
-// 	// Create a SQL transaction or read and update atomicaly
-// 	txn, err := hdb.dbWrite.Beginx()
-// 	if err != nil {
-// 		return tracerr.Wrap(err)
-// 	}
-// 	defer func() {
-// 		if err != nil {
-// 			db.Rollback(txn)
-// 		}
-// 	}()
-// 	// Read current node info
-// 	ni := &NodeInfo{}
-// 	if err := meddler.QueryRow(
-// 		txn, ni, "SELECT * FROM node_info;",
-// 	); err != nil {
-// 		return tracerr.Wrap(err)
-// 	}
-// 	// Update NodeInfo struct
-// 	if err := setUpdatedNodeInfo(txn, ni); err != nil {
-// 		return tracerr.Wrap(err)
-// 	}
-// 	// Update NodeInfo at DB
-// 	if _, err := txn.Exec("DELETE FROM node_info;"); err != nil {
-// 		return tracerr.Wrap(err)
-// 	}
-// 	if err := meddler.Insert(txn, "node_info", ni); err != nil {
-// 		return tracerr.Wrap(err)
-// 	}
-// 	// Commit NodeInfo update
-// 	return tracerr.Wrap(txn.Commit())
-// }
--- a/db/historydb/views.go
+++ b/db/historydb/views.go
@@ -302,15 +302,25 @@ type BatchAPI struct {
 	LastItem      uint64                 `json:"-" meddler:"last_item"`
 }

-// MetricsAPI define metrics of the network
-type MetricsAPI struct {
-	TransactionsPerBatch   float64 `json:"transactionsPerBatch"`
-	BatchFrequency         float64 `json:"batchFrequency"`
-	TransactionsPerSecond  float64 `json:"transactionsPerSecond"`
-	TotalAccounts          int64   `json:"totalAccounts" meddler:"total_accounts"`
-	TotalBJJs              int64   `json:"totalBJJs" meddler:"total_bjjs"`
-	AvgTransactionFee      float64 `json:"avgTransactionFee"`
-	EstimatedTimeToForgeL1 float64 `json:"estimatedTimeToForgeL1" meddler:"estimatedTimeToForgeL1"`
+// Metrics define metrics of the network
+type Metrics struct {
+	TransactionsPerBatch  float64 `json:"transactionsPerBatch"`
+	BatchFrequency        float64 `json:"batchFrequency"`
+	TransactionsPerSecond float64 `json:"transactionsPerSecond"`
+	TotalAccounts         int64   `json:"totalAccounts" meddler:"total_accounts"`
+	TotalBJJs             int64   `json:"totalBJJs" meddler:"total_bjjs"`
+	AvgTransactionFee     float64 `json:"avgTransactionFee"`
+}
+
+// MetricsTotals is used to get temporal information from HistoryDB
+// to calculate data to be stored into the Metrics struct
+type MetricsTotals struct {
+	TotalTransactions uint64          `meddler:"total_txs"`
+	FirstBatchNum     common.BatchNum `meddler:"batch_num"`
+	TotalBatches      int64           `meddler:"total_batches"`
+	TotalFeesUSD      float64         `meddler:"total_fees"`
+	MinTimestamp      time.Time       `meddler:"min_timestamp,utctime"`
+	MaxTimestamp      time.Time       `meddler:"max_timestamp,utctime"`
 }

 // BidAPI is a representation of a bid with additional information
@@ -363,27 +373,6 @@ type RollupVariablesAPI struct {
 	SafeMode              bool                                          `json:"safeMode" meddler:"safe_mode"`
 }

-// NewRollupVariablesAPI creates a RollupVariablesAPI from common.RollupVariables
-func NewRollupVariablesAPI(rollupVariables *common.RollupVariables) *RollupVariablesAPI {
-	rollupVars := RollupVariablesAPI{
-		EthBlockNum:           rollupVariables.EthBlockNum,
-		FeeAddToken:           apitypes.NewBigIntStr(rollupVariables.FeeAddToken),
-		ForgeL1L2BatchTimeout: rollupVariables.ForgeL1L2BatchTimeout,
-		WithdrawalDelay:       rollupVariables.WithdrawalDelay,
-		SafeMode:              rollupVariables.SafeMode,
-	}
-
-	for i, bucket := range rollupVariables.Buckets {
-		rollupVars.Buckets[i] = BucketParamsAPI{
-			CeilUSD:             apitypes.NewBigIntStr(bucket.CeilUSD),
-			Withdrawals:         apitypes.NewBigIntStr(bucket.Withdrawals),
-			BlockWithdrawalRate: apitypes.NewBigIntStr(bucket.BlockWithdrawalRate),
-			MaxWithdrawals:      apitypes.NewBigIntStr(bucket.MaxWithdrawals),
-		}
-	}
-	return &rollupVars
-}
-
 // AuctionVariablesAPI are the variables of the Auction Smart Contract
 type AuctionVariablesAPI struct {
 	EthBlockNum int64 `json:"ethereumBlockNum" meddler:"eth_block_num"`
@@ -408,28 +397,3 @@ type AuctionVariablesAPI struct {
 	// SlotDeadline Number of blocks at the end of a slot in which any coordinator can forge if the winner has not forged one before
 	SlotDeadline uint8 `json:"slotDeadline" meddler:"slot_deadline" validate:"required"`
 }
-
-// NewAuctionVariablesAPI creates a AuctionVariablesAPI from common.AuctionVariables
-func NewAuctionVariablesAPI(auctionVariables *common.AuctionVariables) *AuctionVariablesAPI {
-	auctionVars := AuctionVariablesAPI{
-		EthBlockNum:              auctionVariables.EthBlockNum,
-		DonationAddress:          auctionVariables.DonationAddress,
-		BootCoordinator:          auctionVariables.BootCoordinator,
-		BootCoordinatorURL:       auctionVariables.BootCoordinatorURL,
-		DefaultSlotSetBidSlotNum: auctionVariables.DefaultSlotSetBidSlotNum,
-		ClosedAuctionSlots:       auctionVariables.ClosedAuctionSlots,
-		OpenAuctionSlots:         auctionVariables.OpenAuctionSlots,
-		Outbidding:               auctionVariables.Outbidding,
-		SlotDeadline:             auctionVariables.SlotDeadline,
-	}
-
-	for i, slot := range auctionVariables.DefaultSlotSetBid {
-		auctionVars.DefaultSlotSetBid[i] = apitypes.NewBigIntStr(slot)
-	}
-
-	for i, ratio := range auctionVariables.AllocationRatio {
-		auctionVars.AllocationRatio[i] = ratio
-	}
-
-	return &auctionVars
-}
--- a/db/l2db/apiqueries.go
+++ b/db/l2db/apiqueries.go
@@ -50,7 +50,7 @@ func (l2db *L2DB) AddTxAPI(tx *PoolL2TxWrite) error {
 	defer l2db.apiConnCon.Release()

 	row := l2db.dbRead.QueryRow(`SELECT
-		($1::NUMERIC * COALESCE(token.usd, 0) * fee_percentage($2::NUMERIC)) /
+		($1::NUMERIC * token.usd * fee_percentage($2::NUMERIC)) /
 			(10.0 ^ token.decimals::NUMERIC)
 		FROM token WHERE token.token_id = $3;`,
 		tx.AmountFloat, tx.Fee, tx.TokenID)
--- a/db/l2db/views.go
+++ b/db/l2db/views.go
@@ -95,6 +95,7 @@ func (tx PoolTxAPI) MarshalJSON() ([]byte, error) {
 		"info":                        tx.Info,
 		"signature":                   tx.Signature,
 		"timestamp":                   tx.Timestamp,
+		"batchNum":                    tx.BatchNum,
 		"requestFromAccountIndex":     tx.RqFromIdx,
 		"requestToAccountIndex":       tx.RqToIdx,
 		"requestToHezEthereumAddress": tx.RqToEthAddr,
--- a/db/migrations/0001.sql
+++ b/db/migrations/0001.sql
@@ -661,16 +661,6 @@ CREATE TABLE account_creation_auth (
    timestamp TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT timezone('utc', now())
 );

-CREATE TABLE node_info (
-    item_id SERIAL PRIMARY KEY,
-    state BYTEA,            -- object returned by GET /state
-    config BYTEA,           -- Node config
-    -- max_pool_txs BIGINT,    -- L2DB config
-    -- min_fee NUMERIC,        -- L2DB config
-    constants BYTEA         -- info of the network that is constant
-);
-INSERT INTO node_info(item_id) VALUES (1); -- Always have a single row that we will update
-
 -- +migrate Down
 -- triggers
 DROP TRIGGER IF EXISTS trigger_token_usd_update ON token;
@@ -685,7 +675,6 @@ DROP FUNCTION IF EXISTS set_tx;
 DROP FUNCTION IF EXISTS forge_l1_user_txs;
 DROP FUNCTION IF EXISTS set_pool_tx;
 -- drop tables IF EXISTS
-DROP TABLE IF EXISTS node_info;
 DROP TABLE IF EXISTS account_creation_auth;
 DROP TABLE IF EXISTS tx_pool;
 DROP TABLE IF EXISTS auction_vars;
--- a/node/node.go
+++ b/node/node.go
@@ -53,10 +53,9 @@ const (

 // Node is the Hermez Node
 type Node struct {
-	nodeAPI         *NodeAPI
-	apiStateUpdater *api.APIStateUpdater
-	debugAPI        *debugapi.DebugAPI
-	priceUpdater    *priceupdater.PriceUpdater
+	nodeAPI      *NodeAPI
+	debugAPI     *debugapi.DebugAPI
+	priceUpdater *priceupdater.PriceUpdater
 	// Coordinator
 	coord *coordinator.Coordinator

@@ -68,7 +67,6 @@ type Node struct {
 	mode         Mode
 	sqlConnRead  *sqlx.DB
 	sqlConnWrite *sqlx.DB
-	historyDB    *historydb.HistoryDB
 	ctx          context.Context
 	wg           sync.WaitGroup
 	cancel       context.CancelFunc
@@ -139,23 +137,6 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 		keyStore = ethKeystore.NewKeyStore(cfg.Coordinator.EthClient.Keystore.Path,
 			scryptN, scryptP)

-		balance, err := ethClient.BalanceAt(context.TODO(), cfg.Coordinator.ForgerAddress, nil)
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-
-		minForgeBalance := cfg.Coordinator.MinimumForgeAddressBalance
-		if minForgeBalance != nil && balance.Cmp(minForgeBalance) == -1 {
-			return nil, tracerr.Wrap(fmt.Errorf(
-				"forger account balance is less than cfg.Coordinator.MinimumForgeAddressBalance: %v < %v",
-				balance.Int64(), minForgeBalance))
-		}
-		log.Infow("forger ethereum account balance",
-			"addr", cfg.Coordinator.ForgerAddress,
-			"balance", balance.Int64(),
-			"minForgeBalance", minForgeBalance.Int64(),
-		)
-
 		// Unlock Coordinator ForgerAddr in the keystore to make calls
 		// to ForgeBatch in the smart contract
 		if !keyStore.HasAddress(cfg.Coordinator.ForgerAddress) {
@@ -231,34 +212,12 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	}
 	initSCVars := sync.SCVars()

-	scConsts := common.SCConsts{
+	scConsts := synchronizer.SCConsts{
 		Rollup:   *sync.RollupConstants(),
 		Auction:  *sync.AuctionConstants(),
 		WDelayer: *sync.WDelayerConstants(),
 	}

-	hdbNodeCfg := historydb.NodeConfig{
-		MaxPoolTxs: cfg.Coordinator.L2DB.MaxTxs,
-		MinFeeUSD:  cfg.Coordinator.L2DB.MinFeeUSD,
-	}
-	if err := historyDB.SetNodeConfig(&hdbNodeCfg); err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	hdbConsts := historydb.Constants{
-		SCConsts: common.SCConsts{
-			Rollup:   scConsts.Rollup,
-			Auction:  scConsts.Auction,
-			WDelayer: scConsts.WDelayer,
-		},
-		ChainID:       chainIDU16,
-		HermezAddress: cfg.SmartContracts.Rollup,
-	}
-	if err := historyDB.SetConstants(&hdbConsts); err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-
-	apiStateUpdater := api.NewAPIStateUpdater(historyDB, &hdbNodeCfg, initSCVars, &hdbConsts)
-
 	var coord *coordinator.Coordinator
 	var l2DB *l2db.L2DB
 	if mode == ModeCoordinator {
@@ -388,7 +347,11 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 			serverProofs,
 			client,
 			&scConsts,
-			initSCVars,
+			&synchronizer.SCVariables{
+				Rollup:   *initSCVars.Rollup,
+				Auction:  *initSCVars.Auction,
+				WDelayer: *initSCVars.WDelayer,
+			},
 		)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
@@ -396,11 +359,6 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	}
 	var nodeAPI *NodeAPI
 	if cfg.API.Address != "" {
-		if cfg.Debug.GinDebugMode {
-			gin.SetMode(gin.DebugMode)
-		} else {
-			gin.SetMode(gin.ReleaseMode)
-		}
 		if cfg.API.UpdateMetricsInterval.Duration == 0 {
 			return nil, tracerr.Wrap(fmt.Errorf("invalid cfg.API.UpdateMetricsInterval: %v",
 				cfg.API.UpdateMetricsInterval.Duration))
@@ -420,11 +378,22 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 			coord, cfg.API.Explorer,
 			server,
 			historyDB,
+			stateDB,
 			l2DB,
+			&api.Config{
+				RollupConstants:   scConsts.Rollup,
+				AuctionConstants:  scConsts.Auction,
+				WDelayerConstants: scConsts.WDelayer,
+				ChainID:           chainIDU16,
+				HermezAddress:     cfg.SmartContracts.Rollup,
+			},
 		)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
+		nodeAPI.api.SetRollupVariables(*initSCVars.Rollup)
+		nodeAPI.api.SetAuctionVariables(*initSCVars.Auction)
+		nodeAPI.api.SetWDelayerVariables(*initSCVars.WDelayer)
 	}
 	var debugAPI *debugapi.DebugAPI
 	if cfg.Debug.APIAddress != "" {
@@ -437,118 +406,20 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	}
 	ctx, cancel := context.WithCancel(context.Background())
 	return &Node{
-		apiStateUpdater: apiStateUpdater,
-		nodeAPI:         nodeAPI,
-		debugAPI:        debugAPI,
-		priceUpdater:    priceUpdater,
-		coord:           coord,
-		sync:            sync,
-		cfg:             cfg,
-		mode:            mode,
-		sqlConnRead:     dbRead,
-		sqlConnWrite:    dbWrite,
-		historyDB:       historyDB,
-		ctx:             ctx,
-		cancel:          cancel,
+		nodeAPI:      nodeAPI,
+		debugAPI:     debugAPI,
+		priceUpdater: priceUpdater,
+		coord:        coord,
+		sync:         sync,
+		cfg:          cfg,
+		mode:         mode,
+		sqlConnRead:  dbRead,
+		sqlConnWrite: dbWrite,
+		ctx:          ctx,
+		cancel:       cancel,
 	}, nil
 }

-// APIServer is a server that only runs the API
-type APIServer struct {
-	nodeAPI *NodeAPI
-}
-
-func NewAPIServer(mode Mode, cfg *config.APIServer) (*APIServer, error) {
-	// NOTE: I just copied some parts of NewNode related to starting the
-	// API, but it still cotains many parameters that are not available
-	meddler.Debug = cfg.Debug.MeddlerLogs
-	// Stablish DB connection
-	dbWrite, err := dbUtils.InitSQLDB(
-		cfg.PostgreSQL.PortWrite,
-		cfg.PostgreSQL.HostWrite,
-		cfg.PostgreSQL.UserWrite,
-		cfg.PostgreSQL.PasswordWrite,
-		cfg.PostgreSQL.NameWrite,
-	)
-	if err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("dbUtils.InitSQLDB: %w", err))
-	}
-	var dbRead *sqlx.DB
-	if cfg.PostgreSQL.HostRead == "" {
-		dbRead = dbWrite
-	} else if cfg.PostgreSQL.HostRead == cfg.PostgreSQL.HostWrite {
-		return nil, tracerr.Wrap(fmt.Errorf(
-			"PostgreSQL.HostRead and PostgreSQL.HostWrite must be different",
-		))
-	} else {
-		dbRead, err = dbUtils.InitSQLDB(
-			cfg.PostgreSQL.PortRead,
-			cfg.PostgreSQL.HostRead,
-			cfg.PostgreSQL.UserRead,
-			cfg.PostgreSQL.PasswordRead,
-			cfg.PostgreSQL.NameRead,
-		)
-		if err != nil {
-			return nil, tracerr.Wrap(fmt.Errorf("dbUtils.InitSQLDB: %w", err))
-		}
-	}
-	var apiConnCon *dbUtils.APIConnectionController
-	if cfg.API.Explorer || mode == ModeCoordinator {
-		apiConnCon = dbUtils.NewAPICnnectionController(
-			cfg.API.MaxSQLConnections,
-			cfg.API.SQLConnectionTimeout.Duration,
-		)
-	}
-
-	historyDB := historydb.NewHistoryDB(dbRead, dbWrite, apiConnCon)
-
-	var l2DB *l2db.L2DB
-	if mode == ModeCoordinator {
-		l2DB = l2db.NewL2DB(
-			dbRead, dbWrite,
-			cfg.Coordinator.L2DB.SafetyPeriod,
-			cfg.Coordinator.L2DB.MaxTxs,
-			cfg.Coordinator.L2DB.MinFeeUSD,
-			cfg.Coordinator.L2DB.TTL.Duration,
-			apiConnCon,
-		)
-	}
-
-	var nodeAPI *NodeAPI
-	if cfg.API.Address != "" {
-		if cfg.Debug.GinDebugMode {
-			gin.SetMode(gin.DebugMode)
-		} else {
-			gin.SetMode(gin.ReleaseMode)
-		}
-		if cfg.API.UpdateMetricsInterval.Duration == 0 {
-			return nil, tracerr.Wrap(fmt.Errorf("invalid cfg.API.UpdateMetricsInterval: %v",
-				cfg.API.UpdateMetricsInterval.Duration))
-		}
-		if cfg.API.UpdateRecommendedFeeInterval.Duration == 0 {
-			return nil, tracerr.Wrap(fmt.Errorf("invalid cfg.API.UpdateRecommendedFeeInterval: %v",
-				cfg.API.UpdateRecommendedFeeInterval.Duration))
-		}
-		server := gin.Default()
-		coord := false
-		if mode == ModeCoordinator {
-			coord = cfg.Coordinator.API.Coordinator
-		}
-		var err error
-		nodeAPI, err = NewNodeAPI(
-			cfg.API.Address,
-			coord, cfg.API.Explorer,
-			server,
-			historyDB,
-			l2DB,
-		)
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-	}
-	// ETC...
-}
-
 // NodeAPI holds the node http API
 type NodeAPI struct { //nolint:golint
 	api    *api.API
@@ -568,7 +439,9 @@ func NewNodeAPI(
 	coordinatorEndpoints, explorerEndpoints bool,
 	server *gin.Engine,
 	hdb *historydb.HistoryDB,
+	sdb *statedb.StateDB,
 	l2db *l2db.L2DB,
+	config *api.Config,
 ) (*NodeAPI, error) {
 	engine := gin.Default()
 	engine.NoRoute(handleNoRoute)
@@ -578,6 +451,7 @@ func NewNodeAPI(
 		engine,
 		hdb,
 		l2db,
+		config,
 	)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -622,8 +496,8 @@ func (a *NodeAPI) Run(ctx context.Context) error {
 	return nil
 }

-func (n *Node) handleNewBlock(ctx context.Context, stats *synchronizer.Stats, vars *common.SCVariablesPtr,
-	batches []common.BatchData) error {
+func (n *Node) handleNewBlock(ctx context.Context, stats *synchronizer.Stats, vars synchronizer.SCVariablesPtr,
+	batches []common.BatchData) {
 	if n.mode == ModeCoordinator {
 		n.coord.SendMsg(ctx, coordinator.MsgSyncBlock{
 			Stats:   *stats,
@@ -631,48 +505,55 @@ func (n *Node) handleNewBlock(ctx context.Context, stats *synchronizer.Stats, va
 			Batches: batches,
 		})
 	}
-	n.apiStateUpdater.SetSCVars(vars)
-	if stats.Synced() {
-		if err := n.apiStateUpdater.UpdateNetworkInfo(
-			stats.Eth.LastBlock, stats.Sync.LastBlock,
-			common.BatchNum(stats.Eth.LastBatchNum),
-			stats.Sync.Auction.CurrentSlot.SlotNum,
-		); err != nil {
-			log.Errorw("ApiStateUpdater.UpdateNetworkInfo", "err", err)
+	if n.nodeAPI != nil {
+		if vars.Rollup != nil {
+			n.nodeAPI.api.SetRollupVariables(*vars.Rollup)
+		}
+		if vars.Auction != nil {
+			n.nodeAPI.api.SetAuctionVariables(*vars.Auction)
+		}
+		if vars.WDelayer != nil {
+			n.nodeAPI.api.SetWDelayerVariables(*vars.WDelayer)
+		}
+
+		if stats.Synced() {
+			if err := n.nodeAPI.api.UpdateNetworkInfo(
+				stats.Eth.LastBlock, stats.Sync.LastBlock,
+				common.BatchNum(stats.Eth.LastBatchNum),
+				stats.Sync.Auction.CurrentSlot.SlotNum,
+			); err != nil {
+				log.Errorw("API.UpdateNetworkInfo", "err", err)
+			}
+		} else {
+			n.nodeAPI.api.UpdateNetworkInfoBlock(
+				stats.Eth.LastBlock, stats.Sync.LastBlock,
+			)
 		}
-	} else {
-		n.apiStateUpdater.UpdateNetworkInfoBlock(
-			stats.Eth.LastBlock, stats.Sync.LastBlock,
-		)
 	}
-	if err := n.apiStateUpdater.Store(); err != nil {
-		return tracerr.Wrap(err)
-	}
-	return nil
 }

-func (n *Node) handleReorg(ctx context.Context, stats *synchronizer.Stats,
-	vars *common.SCVariables) error {
+func (n *Node) handleReorg(ctx context.Context, stats *synchronizer.Stats, vars synchronizer.SCVariablesPtr) {
 	if n.mode == ModeCoordinator {
 		n.coord.SendMsg(ctx, coordinator.MsgSyncReorg{
 			Stats: *stats,
 			Vars:  vars,
 		})
 	}
-	n.apiStateUpdater.SetSCVars(vars.AsPtr())
-	n.apiStateUpdater.UpdateNetworkInfoBlock(
-		stats.Eth.LastBlock, stats.Sync.LastBlock,
-	)
-	if err := n.apiStateUpdater.Store(); err != nil {
-		return tracerr.Wrap(err)
+	if n.nodeAPI != nil {
+		vars := n.sync.SCVars()
+		n.nodeAPI.api.SetRollupVariables(*vars.Rollup)
+		n.nodeAPI.api.SetAuctionVariables(*vars.Auction)
+		n.nodeAPI.api.SetWDelayerVariables(*vars.WDelayer)
+		n.nodeAPI.api.UpdateNetworkInfoBlock(
+			stats.Eth.LastBlock, stats.Sync.LastBlock,
+		)
 	}
-	return nil
 }

 // TODO(Edu): Consider keeping the `lastBlock` inside synchronizer so that we
 // don't have to pass it around.
 func (n *Node) syncLoopFn(ctx context.Context, lastBlock *common.Block) (*common.Block, time.Duration, error) {
-	blockData, discarded, err := n.sync.Sync(ctx, lastBlock)
+	blockData, discarded, err := n.sync.Sync2(ctx, lastBlock)
 	stats := n.sync.Stats()
 	if err != nil {
 		// case: error
@@ -681,20 +562,16 @@ func (n *Node) syncLoopFn(ctx context.Context, lastBlock *common.Block) (*common
 		// case: reorg
 		log.Infow("Synchronizer.Sync reorg", "discarded", *discarded)
 		vars := n.sync.SCVars()
-		if err := n.handleReorg(ctx, stats, vars); err != nil {
-			return nil, time.Duration(0), tracerr.Wrap(err)
-		}
+		n.handleReorg(ctx, stats, vars)
 		return nil, time.Duration(0), nil
 	} else if blockData != nil {
 		// case: new block
-		vars := common.SCVariablesPtr{
+		vars := synchronizer.SCVariablesPtr{
 			Rollup:   blockData.Rollup.Vars,
 			Auction:  blockData.Auction.Vars,
 			WDelayer: blockData.WDelayer.Vars,
 		}
-		if err := n.handleNewBlock(ctx, stats, &vars, blockData.Rollup.Batches); err != nil {
-			return nil, time.Duration(0), tracerr.Wrap(err)
-		}
+		n.handleNewBlock(ctx, stats, vars, blockData.Rollup.Batches)
 		return &blockData.Block, time.Duration(0), nil
 	} else {
 		// case: no block
@@ -713,7 +590,7 @@ func (n *Node) StartSynchronizer() {
 	// the last synced one) is synchronized
 	stats := n.sync.Stats()
 	vars := n.sync.SCVars()
-	n.handleNewBlock(n.ctx, stats, vars.AsPtr(), []common.BatchData{})
+	n.handleNewBlock(n.ctx, stats, vars, []common.BatchData{})

 	n.wg.Add(1)
 	go func() {
@@ -800,11 +677,8 @@ func (n *Node) StartNodeAPI() {
 	n.wg.Add(1)
 	go func() {
 		// Do an initial update on startup
-		if err := n.apiStateUpdater.UpdateMetrics(); err != nil {
-			log.Errorw("ApiStateUpdater.UpdateMetrics", "err", err)
-		}
-		if err := n.apiStateUpdater.Store(); err != nil {
-			log.Errorw("ApiStateUpdater.Store", "err", err)
+		if err := n.nodeAPI.api.UpdateMetrics(); err != nil {
+			log.Errorw("API.UpdateMetrics", "err", err)
 		}
 		for {
 			select {
@@ -813,12 +687,8 @@ func (n *Node) StartNodeAPI() {
 				n.wg.Done()
 				return
 			case <-time.After(n.cfg.API.UpdateMetricsInterval.Duration):
-				if err := n.apiStateUpdater.UpdateMetrics(); err != nil {
-					log.Errorw("ApiStateUpdater.UpdateMetrics", "err", err)
-					continue
-				}
-				if err := n.apiStateUpdater.Store(); err != nil {
-					log.Errorw("ApiStateUpdater.Store", "err", err)
+				if err := n.nodeAPI.api.UpdateMetrics(); err != nil {
+					log.Errorw("API.UpdateMetrics", "err", err)
 				}
 			}
 		}
@@ -827,7 +697,7 @@ func (n *Node) StartNodeAPI() {
 	n.wg.Add(1)
 	go func() {
 		// Do an initial update on startup
-		if err := n.historyDB.UpdateRecommendedFee(); err != nil {
+		if err := n.nodeAPI.api.UpdateRecommendedFee(); err != nil {
 			log.Errorw("API.UpdateRecommendedFee", "err", err)
 		}
 		for {
@@ -837,7 +707,7 @@ func (n *Node) StartNodeAPI() {
 				n.wg.Done()
 				return
 			case <-time.After(n.cfg.API.UpdateRecommendedFeeInterval.Duration):
-				if err := n.historyDB.UpdateRecommendedFee(); err != nil {
+				if err := n.nodeAPI.api.UpdateRecommendedFee(); err != nil {
 					log.Errorw("API.UpdateRecommendedFee", "err", err)
 				}
 			}
--- a/synchronizer/synchronizer.go
+++ b/synchronizer/synchronizer.go
@@ -183,26 +183,26 @@ type StartBlockNums struct {
 }

 // 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"`
-// }
-//
-// // SCVariablesPtr joins all the smart contract variables as pointers in a single
-// // struct
-// type SCVariablesPtr struct {
-// 	Rollup   *common.RollupVariables   `validate:"required"`
-// 	Auction  *common.AuctionVariables  `validate:"required"`
-// 	WDelayer *common.WDelayerVariables `validate:"required"`
-// }
-//
-// // SCConsts joins all the smart contract constants in a single struct
-// type SCConsts struct {
-// 	Rollup   common.RollupConstants
-// 	Auction  common.AuctionConstants
-// 	WDelayer common.WDelayerConstants
-// }
+type SCVariables struct {
+	Rollup   common.RollupVariables   `validate:"required"`
+	Auction  common.AuctionVariables  `validate:"required"`
+	WDelayer common.WDelayerVariables `validate:"required"`
+}
+
+// SCVariablesPtr joins all the smart contract variables as pointers in a single
+// struct
+type SCVariablesPtr struct {
+	Rollup   *common.RollupVariables   `validate:"required"`
+	Auction  *common.AuctionVariables  `validate:"required"`
+	WDelayer *common.WDelayerVariables `validate:"required"`
+}
+
+// SCConsts joins all the smart contract constants in a single struct
+type SCConsts struct {
+	Rollup   common.RollupConstants
+	Auction  common.AuctionConstants
+	WDelayer common.WDelayerConstants
+}

 // Config is the Synchronizer configuration
 type Config struct {
@@ -213,13 +213,13 @@ type Config struct {
 // Synchronizer implements the Synchronizer type
 type Synchronizer struct {
 	ethClient        eth.ClientInterface
-	consts           common.SCConsts
+	consts           SCConsts
 	historyDB        *historydb.HistoryDB
 	stateDB          *statedb.StateDB
 	cfg              Config
-	initVars         common.SCVariables
+	initVars         SCVariables
 	startBlockNum    int64
-	vars             common.SCVariables
+	vars             SCVariables
 	stats            *StatsHolder
 	resetStateFailed bool
 }
@@ -242,7 +242,7 @@ func NewSynchronizer(ethClient eth.ClientInterface, historyDB *historydb.History
 		return nil, tracerr.Wrap(fmt.Errorf("NewSynchronizer ethClient.WDelayerConstants(): %w",
 			err))
 	}
-	consts := common.SCConsts{
+	consts := SCConsts{
 		Rollup:   *rollupConstants,
 		Auction:  *auctionConstants,
 		WDelayer: *wDelayerConstants,
@@ -307,11 +307,11 @@ func (s *Synchronizer) WDelayerConstants() *common.WDelayerConstants {
 }

 // 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(),
+func (s *Synchronizer) SCVars() SCVariablesPtr {
+	return SCVariablesPtr{
+		Rollup:   s.vars.Rollup.Copy(),
+		Auction:  s.vars.Auction.Copy(),
+		WDelayer: s.vars.WDelayer.Copy(),
 	}
 }

@@ -503,13 +503,13 @@ func (s *Synchronizer) resetIntermediateState() error {
 	return nil
 }

-// Sync attems to synchronize an ethereum block starting from lastSavedBlock.
+// 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) Sync(ctx context.Context,
+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 {
@@ -724,7 +724,7 @@ func (s *Synchronizer) reorg(uncleBlock *common.Block) (int64, error) {
 }

 func getInitialVariables(ethClient eth.ClientInterface,
-	consts *common.SCConsts) (*common.SCVariables, *StartBlockNums, error) {
+	consts *SCConsts) (*SCVariables, *StartBlockNums, error) {
 	rollupInit, rollupInitBlock, err := ethClient.RollupEventInit()
 	if err != nil {
 		return nil, nil, tracerr.Wrap(fmt.Errorf("RollupEventInit: %w", err))
@@ -740,7 +740,7 @@ func getInitialVariables(ethClient eth.ClientInterface,
 	rollupVars := rollupInit.RollupVariables()
 	auctionVars := auctionInit.AuctionVariables(consts.Auction.InitialMinimalBidding)
 	wDelayerVars := wDelayerInit.WDelayerVariables()
-	return &common.SCVariables{
+	return &SCVariables{
 			Rollup:   *rollupVars,
 			Auction:  *auctionVars,
 			WDelayer: *wDelayerVars,
--- a/synchronizer/synchronizer_test.go
+++ b/synchronizer/synchronizer_test.go
@@ -359,7 +359,7 @@ func TestSyncGeneral(t *testing.T) {
 	assert.Equal(t, false, stats.Synced())

 	// Test Sync for rollup genesis block
-	syncBlock, discards, err := s.Sync(ctx, nil)
+	syncBlock, discards, err := s.Sync2(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.NotNil(t, syncBlock)
@@ -382,7 +382,7 @@ func TestSyncGeneral(t *testing.T) {
 	assert.Equal(t, int64(1), dbBlocks[1].Num)

 	// Sync again and expect no new blocks
-	syncBlock, discards, err = s.Sync(ctx, nil)
+	syncBlock, discards, err = s.Sync2(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.Nil(t, syncBlock)
@@ -479,7 +479,7 @@ func TestSyncGeneral(t *testing.T) {

 	// Block 2

-	syncBlock, discards, err = s.Sync(ctx, nil)
+	syncBlock, discards, err = s.Sync2(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.NotNil(t, syncBlock)
@@ -496,7 +496,7 @@ func TestSyncGeneral(t *testing.T) {

 	// Block 3

-	syncBlock, discards, err = s.Sync(ctx, nil)
+	syncBlock, discards, err = s.Sync2(ctx, nil)
 	assert.NoError(t, err)
 	require.NoError(t, err)
 	require.Nil(t, discards)
@@ -520,7 +520,7 @@ func TestSyncGeneral(t *testing.T) {
 	require.NoError(t, err)
 	client.CtlMineBlock()

-	syncBlock, discards, err = s.Sync(ctx, nil)
+	syncBlock, discards, err = s.Sync2(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.NotNil(t, syncBlock)
@@ -571,7 +571,7 @@ func TestSyncGeneral(t *testing.T) {

 	client.CtlMineBlock()

-	syncBlock, discards, err = s.Sync(ctx, nil)
+	syncBlock, discards, err = s.Sync2(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.NotNil(t, syncBlock)
@@ -656,7 +656,7 @@ func TestSyncGeneral(t *testing.T) {
 	require.NoError(t, err)

 	// First sync detects the reorg and discards 4 blocks
-	syncBlock, discards, err = s.Sync(ctx, nil)
+	syncBlock, discards, err = s.Sync2(ctx, nil)
 	require.NoError(t, err)
 	expetedDiscards := int64(4)
 	require.Equal(t, &expetedDiscards, discards)
@@ -684,7 +684,7 @@ func TestSyncGeneral(t *testing.T) {

 	// Sync blocks 2-6
 	for i := 0; i < 5; i++ {
-		syncBlock, discards, err = s.Sync(ctx, nil)
+		syncBlock, discards, err = s.Sync2(ctx, nil)
 		require.NoError(t, err)
 		require.Nil(t, discards)
 		require.NotNil(t, syncBlock)
@@ -807,7 +807,7 @@ func TestSyncForgerCommitment(t *testing.T) {

 	// be in sync
 	for {
-		syncBlock, discards, err := s.Sync(ctx, nil)
+		syncBlock, discards, err := s.Sync2(ctx, nil)
 		require.NoError(t, err)
 		require.Nil(t, discards)
 		if syncBlock == nil {
@@ -826,7 +826,7 @@ func TestSyncForgerCommitment(t *testing.T) {
 		err = client.CtlAddBlocks([]common.BlockData{block})
 		require.NoError(t, err)

-		syncBlock, discards, err := s.Sync(ctx, nil)
+		syncBlock, discards, err := s.Sync2(ctx, nil)
 		require.NoError(t, err)
 		require.Nil(t, discards)
 		if syncBlock == nil {
--- a/txprocessor/txprocessor.go
+++ b/txprocessor/txprocessor.go
@@ -1197,7 +1197,7 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 		exitAccount := &common.Account{
 			TokenID: acc.TokenID,
 			Nonce:   common.Nonce(0),
-			// as is a common.Tx, the tx.Amount is already an
+			// as is a common.Tx, the Amount is already an
 			// EffectiveAmount
 			Balance: tx.Amount,
 			BJJ:     acc.BJJ,
@@ -1212,9 +1212,9 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 				tp.zki.Sign2[tp.i] = big.NewInt(1)
 			}
 			tp.zki.Ay2[tp.i] = accBJJY
-			// Balance2 contains the ExitLeaf Balance before the
-			// leaf update, which is 0
-			tp.zki.Balance2[tp.i] = big.NewInt(0)
+			// as is a common.Tx, the Amount is already an
+			// EffectiveAmount
+			tp.zki.Balance2[tp.i] = tx.Amount
 			tp.zki.EthAddr2[tp.i] = common.EthAddrToBigInt(acc.EthAddr)
 			// as Leaf didn't exist in the ExitTree, set NewExit[i]=1
 			tp.zki.NewExit[tp.i] = big.NewInt(1)
@@ -1248,9 +1248,7 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 			tp.zki.Sign2[tp.i] = big.NewInt(1)
 		}
 		tp.zki.Ay2[tp.i] = accBJJY
-		// Balance2 contains the ExitLeaf Balance before the leaf
-		// update
-		tp.zki.Balance2[tp.i] = exitAccount.Balance
+		tp.zki.Balance2[tp.i] = tx.Amount
 		tp.zki.EthAddr2[tp.i] = common.EthAddrToBigInt(acc.EthAddr)
 	}

@@ -1268,7 +1266,6 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 		}
 		tp.zki.OldKey2[tp.i] = p.OldKey.BigInt()
 		tp.zki.OldValue2[tp.i] = p.OldValue.BigInt()
-		tp.zki.ISExitRoot[tp.i] = exitTree.Root().BigInt()
 	}

 	return exitAccount, false, nil
--- a/txprocessor/txprocessor_test.go
+++ b/txprocessor/txprocessor_test.go
@@ -795,8 +795,7 @@ func TestMultipleCoordIdxForTokenID(t *testing.T) {
 	checkBalanceByIdx(t, tp.s, 259, "0")   // Coord0
 }

-func testTwoExits(t *testing.T, stateDBType statedb.TypeStateDB) ([]*ProcessTxOutput,
-	[]*ProcessTxOutput, []*ProcessTxOutput) {
+func TestTwoExits(t *testing.T) {
 	// In the first part we generate a batch with two force exits for the
 	// same account of 20 each.  The txprocessor output should be a single
 	// exitInfo with balance of 40.
@@ -804,9 +803,8 @@ func testTwoExits(t *testing.T, stateDBType statedb.TypeStateDB) ([]*ProcessTxOu
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))

-	nLevels := 16
 	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
-		Type: stateDBType, NLevels: nLevels})
+		Type: statedb.TypeSynchronizer, NLevels: 32})
 	assert.NoError(t, err)

 	chainID := uint16(1)
@@ -842,10 +840,10 @@ func testTwoExits(t *testing.T, stateDBType statedb.TypeStateDB) ([]*ProcessTxOu
 	require.Equal(t, 2, len(blocks[0].Rollup.Batches[3].L1UserTxs))

 	config := Config{
-		NLevels:  uint32(nLevels),
-		MaxTx:    3,
-		MaxL1Tx:  2,
-		MaxFeeTx: 2,
+		NLevels:  32,
+		MaxFeeTx: 64,
+		MaxTx:    512,
+		MaxL1Tx:  16,
 		ChainID:  chainID,
 	}
 	tp := NewTxProcessor(sdb, config)
@@ -858,6 +856,8 @@ func testTwoExits(t *testing.T, stateDBType statedb.TypeStateDB) ([]*ProcessTxOu
 		}
 	}

+	assert.Equal(t, 1, len(ptOuts[3].ExitInfos))
+	assert.Equal(t, big.NewInt(40), ptOuts[3].ExitInfos[0].Balance)
 	acc, err := sdb.GetAccount(256)
 	require.NoError(t, err)
 	assert.Equal(t, big.NewInt(60), acc.Balance)
@@ -872,7 +872,7 @@ func testTwoExits(t *testing.T, stateDBType statedb.TypeStateDB) ([]*ProcessTxOu
 	defer assert.NoError(t, os.RemoveAll(dir2))

 	sdb2, err := statedb.NewStateDB(statedb.Config{Path: dir2, Keep: 128,
-		Type: stateDBType, NLevels: nLevels})
+		Type: statedb.TypeSynchronizer, NLevels: 32})
 	assert.NoError(t, err)

 	tc = til.NewContext(chainID, common.RollupConstMaxL1UserTx)
@@ -910,68 +910,7 @@ func testTwoExits(t *testing.T, stateDBType statedb.TypeStateDB) ([]*ProcessTxOu
 		}
 	}

-	// In the third part we start a fresh statedb and generate a batch with
-	// two force exit for the same account as before but where the 1st Exit
-	// is with all the amount, and the 2nd Exit is with more amount than
-	// the available balance.  The txprocessor output should be a single
-	// exitInfo with balance of 40, and the exit merkle tree proof should
-	// be equal to the previous ones.
-
-	dir3, err := ioutil.TempDir("", "tmpdb")
-	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir3))
-
-	sdb3, err := statedb.NewStateDB(statedb.Config{Path: dir3, Keep: 128,
-		Type: stateDBType, NLevels: nLevels})
-	assert.NoError(t, err)
-
-	tc = til.NewContext(chainID, common.RollupConstMaxL1UserTx)
-
-	// Single exit with balance of both exits in previous set.  The exit
-	// root should match.
-	set3 := `
-		Type: Blockchain
-
-		CreateAccountDeposit(0) A: 100
-
-		> batchL1 // freeze L1User{1}
-		> batchL1 // forge L1User{1}
-
-		ForceExit(0) A: 40
-		ForceExit(0) A: 100
-
-		> batchL1 // freeze L1User{2}
-		> batchL1 // forge L1User{2}
-		> block
-	`
-	blocks, err = tc.GenerateBlocks(set3)
-	require.NoError(t, err)
-	err = tc.FillBlocksExtra(blocks, &til.ConfigExtra{})
-	require.NoError(t, err)
-	err = tc.FillBlocksForgedL1UserTxs(blocks)
-	require.NoError(t, err)
-
-	tp = NewTxProcessor(sdb3, config)
-	ptOuts3 := []*ProcessTxOutput{}
-	for _, block := range blocks {
-		for _, batch := range block.Rollup.Batches {
-			ptOut, err := tp.ProcessTxs(nil, batch.L1UserTxs, nil, nil)
-			require.NoError(t, err)
-			ptOuts3 = append(ptOuts3, ptOut)
-		}
-	}
-
-	return ptOuts, ptOuts2, ptOuts3
-}
-
-func TestTwoExitsSynchronizer(t *testing.T) {
-	ptOuts, ptOuts2, ptOuts3 := testTwoExits(t, statedb.TypeSynchronizer)
-
-	assert.Equal(t, 1, len(ptOuts[3].ExitInfos))
-	assert.Equal(t, big.NewInt(40), ptOuts[3].ExitInfos[0].Balance)
-
 	assert.Equal(t, ptOuts[3].ExitInfos[0].MerkleProof, ptOuts2[3].ExitInfos[0].MerkleProof)
-	assert.Equal(t, ptOuts[3].ExitInfos[0].MerkleProof, ptOuts3[3].ExitInfos[0].MerkleProof)
 }

 func TestExitOf0Amount(t *testing.T) {
--- a/txprocessor/zkinputsgen_test.go
+++ b/txprocessor/zkinputsgen_test.go