WIP

Avoid SQL error when checking value of token without usd on tx insert

README.md

@@ -15,7 +15,7 @@ start PostgreSQL with docker easily this way (where `yourpasswordhere` should
 be your password):
 
 ```
-POSTGRES_PASS=yourpasswordhere sudo docker run --rm --name hermez-db-test -p 5432:5432 -e POSTGRES_DB=hermez -e POSTGRES_USER=hermez -e POSTGRES_PASSWORD="$POSTGRES_PASS" -d postgres
+POSTGRES_PASS=yourpasswordhere; sudo docker run --rm --name hermez-db-test -p 5432:5432 -e POSTGRES_DB=hermez -e POSTGRES_USER=hermez -e POSTGRES_PASSWORD="$POSTGRES_PASS" -d postgres
 ```
 
 Afterwards, run the tests with the password as env var:

api/account.go

@@ -4,10 +4,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/hermeznetwork/hermez-node/apitypes"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
-	"github.com/hermeznetwork/hermez-node/db/statedb"
-	"github.com/hermeznetwork/tracerr"
 )
 
 func (a *API) getAccount(c *gin.Context) {
@@ -23,16 +20,6 @@ func (a *API) getAccount(c *gin.Context) {
 		return
 	}
 
-	// Get balance from stateDB
-	account, err := a.s.LastGetAccount(*idx)
-	if err != nil {
-		retSQLErr(err, c)
-		return
-	}
-
-	apiAccount.Balance = apitypes.NewBigIntStr(account.Balance)
-	apiAccount.Nonce = account.Nonce
-
 	c.JSON(http.StatusOK, apiAccount)
 }
 
@@ -57,26 +44,6 @@ func (a *API) getAccounts(c *gin.Context) {
 		return
 	}
 
-	// Get balances from stateDB
-	if err := a.s.LastRead(func(sdb *statedb.Last) error {
-		for x, apiAccount := range apiAccounts {
-			idx, err := stringToIdx(string(apiAccount.Idx), "Account Idx")
-			if err != nil {
-				return tracerr.Wrap(err)
-			}
-			account, err := sdb.GetAccount(*idx)
-			if err != nil {
-				return tracerr.Wrap(err)
-			}
-			apiAccounts[x].Balance = apitypes.NewBigIntStr(account.Balance)
-			apiAccounts[x].Nonce = account.Nonce
-		}
-		return nil
-	}); err != nil {
-		retSQLErr(err, c)
-		return
-	}
-
 	// Build succesfull response
 	type accountResponse struct {
 		Accounts     []historydb.AccountAPI `json:"accounts"`

api/api.go

@@ -2,41 +2,19 @@ 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/hermez-node/db/statedb"
 	"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
-	s             *statedb.StateDB
 	l2            *l2db.L2DB
-	status        Status
 	chainID       uint16
 	hermezAddress ethCommon.Address
 }
@@ -46,9 +24,7 @@ func NewAPI(
 	coordinatorEndpoints, explorerEndpoints bool,
 	server *gin.Engine,
 	hdb *historydb.HistoryDB,
-	sdb *statedb.StateDB,
 	l2db *l2db.L2DB,
-	config *Config,
 ) (*API, error) {
 	// Check input
 	// TODO: is stateDB only needed for explorer endpoints or for both?
@@ -58,19 +34,20 @@ func NewAPI(
 	if explorerEndpoints && hdb == nil {
 		return nil, tracerr.Wrap(errors.New("cannot serve Explorer endpoints without HistoryDB"))
 	}
-
+	consts, err := hdb.GetConstants()
+	if err != nil {
+		return nil, err
+	}
 	a := &API{
 		h: hdb,
 		cg: &configAPI{
-			RollupConstants:   *newRollupConstants(config.RollupConstants),
+			RollupConstants:   *newRollupConstants(consts.Rollup),
-			AuctionConstants:  config.AuctionConstants,
+			AuctionConstants:  consts.Auction,
-			WDelayerConstants: config.WDelayerConstants,
+			WDelayerConstants: consts.WDelayer,
 		},
-		s:             sdb,
 		l2:            l2db,
-		status:        Status{},
+		chainID:       consts.ChainID,
-		chainID:       config.ChainID,
+		hermezAddress: consts.HermezAddress,
-		hermezAddress: config.HermezAddress,
 	}
 
 	// Add coordinator endpoints

api/api_test.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"io/ioutil"
 	"math/big"
+	"net"
 	"net/http"
 	"os"
 	"strconv"
@@ -22,7 +23,6 @@ import (
 	"github.com/hermeznetwork/hermez-node/db"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
-	"github.com/hermeznetwork/hermez-node/db/statedb"
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/hermez-node/test"
 	"github.com/hermeznetwork/hermez-node/test/til"
@@ -39,8 +39,8 @@ type Pendinger interface {
 	New() Pendinger
 }
 
-const apiPort = ":4010"
+const apiAddr = ":4010"
-const apiURL = "http://localhost" + apiPort + "/"
+const apiURL = "http://localhost" + apiAddr + "/"
 
 var SetBlockchain = `
 	Type: Blockchain
@@ -180,12 +180,13 @@ type testCommon struct {
 	auctionVars      common.AuctionVariables
 	rollupVars       common.RollupVariables
 	wdelayerVars     common.WDelayerVariables
-	nextForgers      []NextForger
+	nextForgers      []historydb.NextForgerAPI
 }
 
 var tc testCommon
 var config configAPI
 var api *API
+var stateAPIUpdater *StateAPIUpdater
 
 // TestMain initializes the API server, and fill HistoryDB and StateDB with fake data,
 // emulating the task of the synchronizer in order to have data to be returned
@@ -202,26 +203,12 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 	apiConnCon := db.NewAPICnnectionController(1, time.Second)
-	hdb := historydb.NewHistoryDB(database, apiConnCon)
+	hdb := historydb.NewHistoryDB(database, database, apiConnCon)
-	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)
-		}
-	}()
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128, Type: statedb.TypeTxSelector, NLevels: 0})
 	if err != nil {
 		panic(err)
 	}
 	// L2DB
-	l2DB := l2db.NewL2DB(database, 10, 1000, 24*time.Hour, apiConnCon)
+	l2DB := l2db.NewL2DB(database, database, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB()) // this will clean HistoryDB and L2DB
 	// Config (smart contract constants)
 	chainID := uint16(0)
@@ -234,29 +221,53 @@ func TestMain(m *testing.M) {
 
 	// API
 	apiGin := gin.Default()
+	// Reset DB
+	test.WipeDB(hdb.DB())
+
+	constants := &historydb.Constants{
+		SCConsts: common.SCConsts{
+			Rollup:   _config.RollupConstants,
+			Auction:  _config.AuctionConstants,
+			WDelayer: _config.WDelayerConstants,
+		},
+		ChainID:       chainID,
+		HermezAddress: _config.HermezAddress,
+	}
+	if err := hdb.SetConstants(constants); err != nil {
+		panic(err)
+	}
+	nodeConfig := &historydb.NodeConfig{
+		MaxPoolTxs: 10,
+		MinFeeUSD:  0,
+	}
+	if err := hdb.SetNodeConfig(nodeConfig); err != nil {
+		panic(err)
+	}
+
 	api, err = NewAPI(
 		true,
 		true,
 		apiGin,
 		hdb,
-		sdb,
 		l2DB,
-		&_config,
 	)
 	if err != nil {
+		log.Error(err)
 		panic(err)
 	}
 	// Start server
-	server := &http.Server{Addr: apiPort, Handler: apiGin}
+	listener, err := net.Listen("tcp", apiAddr) //nolint:gosec
+	if err != nil {
+		panic(err)
+	}
+	server := &http.Server{Handler: apiGin}
 	go func() {
-		if err := server.ListenAndServe(); err != nil && tracerr.Unwrap(err) != http.ErrServerClosed {
+		if err := server.Serve(listener); err != nil &&
+			tracerr.Unwrap(err) != http.ErrServerClosed {
 			panic(err)
 		}
 	}()
 
-	// Reset DB
-	test.WipeDB(api.h.DB())
-
 	// Genratre blockchain data with til
 	tcc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
 	tilCfgExtra := til.ConfigExtra{
@@ -350,19 +361,6 @@ func TestMain(m *testing.M) {
 		}
 	}
 
-	// lastBlockNum2 := blocksData[len(blocksData)-1].Block.EthBlockNum
-
-	// Add accounts to StateDB
-	for i := 0; i < len(commonAccounts); i++ {
-		if _, err := api.s.CreateAccount(commonAccounts[i].Idx, &commonAccounts[i]); err != nil {
-			panic(err)
-		}
-	}
-	// Make a checkpoint to make the accounts available in Last
-	if err := api.s.MakeCheckpoint(); err != nil {
-		panic(err)
-	}
-
 	// Generate Coordinators and add them to HistoryDB
 	const nCoords = 10
 	commonCoords := test.GenCoordinators(nCoords, commonBlocks)
@@ -470,19 +468,19 @@ func TestMain(m *testing.M) {
 	if err = api.h.AddBids(bids); err != nil {
 		panic(err)
 	}
-	bootForger := NextForger{
+	bootForger := historydb.NextForgerAPI{
 		Coordinator: historydb.CoordinatorAPI{
 			Forger: auctionVars.BootCoordinator,
 			URL:    auctionVars.BootCoordinatorURL,
 		},
 	}
 	// Set next forgers: set all as boot coordinator then replace the non boot coordinators
-	nextForgers := []NextForger{}
+	nextForgers := []historydb.NextForgerAPI{}
 	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 = Period{
+		bootForger.Period = historydb.Period{
 			SlotNum:   int64(i),
 			FromBlock: fromBlock,
 			ToBlock:   fromBlock + deltaBlocks - 1,
@@ -522,6 +520,12 @@ func TestMain(m *testing.M) {
 		WithdrawalDelay: uint64(3000),
 	}
 
+	stateAPIUpdater = NewStateAPIUpdater(hdb, nodeConfig, &common.SCVariables{
+		Rollup:   rollupVars,
+		Auction:  auctionVars,
+		WDelayer: wdelayerVars,
+	}, constants)
+
 	// Generate test data, as expected to be received/sended from/to the API
 	testCoords := genTestCoordinators(commonCoords)
 	testBids := genTestBids(commonBlocks, testCoords, bids)
@@ -529,13 +533,41 @@ func TestMain(m *testing.M) {
 	testTxs := genTestTxs(commonL1Txs, commonL2Txs, commonAccounts, testTokens, commonBlocks)
 	testBatches, testFullBatches := genTestBatches(commonBlocks, commonBatches, testTxs)
 	poolTxsToSend, poolTxsToReceive := genTestPoolTxs(commonPoolTxs, testTokens, commonAccounts)
+	// Add balance and nonce to historyDB
+	accounts := genTestAccounts(commonAccounts, testTokens)
+	accUpdates := []common.AccountUpdate{}
+	for i := 0; i < len(accounts); i++ {
+		balance := new(big.Int)
+		balance.SetString(string(*accounts[i].Balance), 10)
+		idx, err := stringToIdx(string(accounts[i].Idx), "foo")
+		if err != nil {
+			panic(err)
+		}
+		accUpdates = append(accUpdates, common.AccountUpdate{
+			EthBlockNum: 0,
+			BatchNum:    1,
+			Idx:         *idx,
+			Nonce:       0,
+			Balance:     balance,
+		})
+		accUpdates = append(accUpdates, common.AccountUpdate{
+			EthBlockNum: 0,
+			BatchNum:    1,
+			Idx:         *idx,
+			Nonce:       accounts[i].Nonce,
+			Balance:     balance,
+		})
+	}
+	if err := api.h.AddAccountUpdates(accUpdates); err != nil {
+		panic(err)
+	}
 	tc = testCommon{
 		blocks:           commonBlocks,
 		tokens:           testTokens,
 		batches:          testBatches,
 		fullBatches:      testFullBatches,
 		coordinators:     testCoords,
-		accounts:         genTestAccounts(commonAccounts, testTokens),
+		accounts:         accounts,
 		txs:              testTxs,
 		exits:            testExits,
 		poolTxsToSend:    poolTxsToSend,
@@ -571,21 +603,18 @@ 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.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
+	databaseTO, err := db.ConnectSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	apiConnConTO := db.NewAPICnnectionController(1, 100*time.Millisecond)
-	hdbTO := historydb.NewHistoryDB(databaseTO, apiConnConTO)
+	hdbTO := historydb.NewHistoryDB(databaseTO, databaseTO, apiConnConTO)
 	require.NoError(t, err)
 	// L2DB
-	l2DBTO := l2db.NewL2DB(databaseTO, 10, 1000, 24*time.Hour, apiConnConTO)
+	l2DBTO := l2db.NewL2DB(databaseTO, databaseTO, 10, 1000, 1.0, 24*time.Hour, apiConnConTO)
 
 	// API
 	apiGinTO := gin.Default()
@@ -600,21 +629,21 @@ func TestTimeout(t *testing.T) {
 		<-finishWait
 	})
 	// Start server
-	serverTO := &http.Server{Addr: ":4444", Handler: apiGinTO}
+	serverTO := &http.Server{Handler: apiGinTO}
+	listener, err := net.Listen("tcp", ":4444") //nolint:gosec
+	require.NoError(t, err)
 	go func() {
-		if err := serverTO.ListenAndServe(); err != nil && tracerr.Unwrap(err) != http.ErrServerClosed {
+		if err := serverTO.Serve(listener); err != nil &&
+			tracerr.Unwrap(err) != http.ErrServerClosed {
 			require.NoError(t, err)
 		}
 	}()
-	_config := getConfigTest(0)
 	_, err = NewAPI(
 		true,
 		true,
 		apiGinTO,
 		hdbTO,
-		nil,
 		l2DBTO,
-		&_config,
 	)
 	require.NoError(t, err)
 

api/handlers.go

@@ -10,6 +10,7 @@ import (
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/lib/pq"
+	"github.com/russross/meddler"
 )
 
 const (
@@ -46,24 +47,33 @@ var (
 func retSQLErr(err error, c *gin.Context) {
 	log.Warnw("HTTP API SQL request error", "err", err)
 	errMsg := tracerr.Unwrap(err).Error()
+	retDupKey := func(errCode pq.ErrorCode) {
+		// https://www.postgresql.org/docs/current/errcodes-appendix.html
+		if errCode == "23505" {
+			c.JSON(http.StatusInternalServerError, errorMsg{
+				Message: errDuplicatedKey,
+			})
+		} else {
+			c.JSON(http.StatusInternalServerError, errorMsg{
+				Message: errMsg,
+			})
+		}
+	}
 	if errMsg == errCtxTimeout {
 		c.JSON(http.StatusServiceUnavailable, errorMsg{
 			Message: errSQLTimeout,
 		})
 	} else if sqlErr, ok := tracerr.Unwrap(err).(*pq.Error); ok {
-		// https://www.postgresql.org/docs/current/errcodes-appendix.html
+		retDupKey(sqlErr.Code)
-		if sqlErr.Code == "23505" {
+	} else if sqlErr, ok := meddler.DriverErr(tracerr.Unwrap(err)); ok {
-			c.JSON(http.StatusInternalServerError, errorMsg{
+		retDupKey(sqlErr.(*pq.Error).Code)
-				Message: errDuplicatedKey,
-			})
-		}
 	} else if tracerr.Unwrap(err) == sql.ErrNoRows {
 		c.JSON(http.StatusNotFound, errorMsg{
-			Message: err.Error(),
+			Message: errMsg,
 		})
 	} else {
 		c.JSON(http.StatusInternalServerError, errorMsg{
-			Message: err.Error(),
+			Message: errMsg,
 		})
 	}
 }

api/slots_test.go

@@ -99,7 +99,9 @@ func TestGetSlot(t *testing.T) {
 			nil, &fetchedSlot,
 		),
 	)
-	emptySlot := api.getEmptyTestSlot(slotNum, api.status.Network.LastSyncBlock, tc.auctionVars)
+	// ni, err := api.h.GetNodeInfoAPI()
+	// assert.NoError(t, err)
+	emptySlot := api.getEmptyTestSlot(slotNum, 0, tc.auctionVars)
 	assertSlot(t, emptySlot, fetchedSlot)
 
 	// Invalid slotNum
@@ -127,8 +129,10 @@ 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, api.status.Network.LastSyncBlock, tc.auctionVars)
+		emptySlot := api.getEmptyTestSlot(i+1, 0, tc.auctionVars)
 		allSlots = append(allSlots, emptySlot)
 	}
 	assertSlots(t, allSlots, fetchedSlots)

api/state.go

@@ -2,305 +2,160 @@ package api
 
 import (
 	"database/sql"
-	"fmt"
-	"math/big"
 	"net/http"
-	"time"
+	"sync"
 
 	"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) {
-	// TODO: There are no events for the buckets information, so now this information will be 0
+	stateAPI, err := a.h.GetStateAPI()
-	a.status.RLock()
+	if err != nil {
-	status := a.status //nolint
+		retBadReq(err, c)
-	a.status.RUnlock()
+		return
-	c.JSON(http.StatusOK, status) //nolint
-}
-
-// 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
 	}
-
+	c.JSON(http.StatusOK, stateAPI)
-	rollupVAPI.SafeMode = rollupVariables.SafeMode
-	a.status.Rollup = rollupVAPI
-	a.status.Unlock()
 }
 
-// SetWDelayerVariables set Status.WithdrawalDelayer variables
+// StateAPIUpdater is an utility object to facilitate updating the StateAPI
-func (a *API) SetWDelayerVariables(wDelayerVariables common.WDelayerVariables) {
+type StateAPIUpdater struct {
-	a.status.Lock()
+	hdb    *historydb.HistoryDB
-	a.status.WithdrawalDelayer = wDelayerVariables
+	state  historydb.StateAPI
-	a.status.Unlock()
+	config historydb.NodeConfig
+	vars   common.SCVariablesPtr
+	consts historydb.Constants
+	rw     sync.RWMutex
 }
 
-// SetAuctionVariables set Status.Auction variables
+// NewStateAPIUpdater creates a new StateAPIUpdater
-func (a *API) SetAuctionVariables(auctionVariables common.AuctionVariables) {
+func NewStateAPIUpdater(hdb *historydb.HistoryDB, config *historydb.NodeConfig, vars *common.SCVariables,
-	a.status.Lock()
+	consts *historydb.Constants) *StateAPIUpdater {
-	var auctionAPI historydb.AuctionVariablesAPI
+	u := StateAPIUpdater{
-
+		hdb:    hdb,
-	auctionAPI.EthBlockNum = auctionVariables.EthBlockNum
+		config: *config,
-	auctionAPI.DonationAddress = auctionVariables.DonationAddress
+		consts: *consts,
-	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)
 	}
-
+	u.SetSCVars(vars.AsPtr())
-	for i, ratio := range auctionVariables.AllocationRatio {
+	return &u
-		auctionAPI.AllocationRatio[i] = ratio
-	}
-
-	a.status.Auction = auctionAPI
-	a.status.Unlock()
 }
 
-// Network
+// Store the State in the HistoryDB
+func (u *StateAPIUpdater) Store() error {
+	u.rw.RLock()
+	defer u.rw.RUnlock()
+	return tracerr.Wrap(u.hdb.SetStateInternalAPI(&u.state))
+}
+
+// SetSCVars sets the smart contract vars (ony updates those that are not nil)
+func (u *StateAPIUpdater) SetSCVars(vars *common.SCVariablesPtr) {
+	u.rw.Lock()
+	defer u.rw.Unlock()
+	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
+	}
+}
+
+// UpdateRecommendedFee update Status.RecommendedFee information
+func (u *StateAPIUpdater) UpdateRecommendedFee() error {
+	recommendedFee, err := u.hdb.GetRecommendedFee(u.config.MinFeeUSD)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	u.rw.Lock()
+	u.state.RecommendedFee = *recommendedFee
+	u.rw.Unlock()
+	return nil
+}
+
+// UpdateMetrics update Status.Metrics information
+func (u *StateAPIUpdater) UpdateMetrics() error {
+	u.rw.RLock()
+	lastBatch := u.state.Network.LastBatch
+	u.rw.RUnlock()
+	if lastBatch == nil {
+		return nil
+	}
+	lastBatchNum := lastBatch.BatchNum
+	metrics, err := u.hdb.GetMetricsInternalAPI(lastBatchNum)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	u.rw.Lock()
+	u.state.Metrics = *metrics
+	u.rw.Unlock()
+	return nil
+}
 
 // UpdateNetworkInfoBlock update Status.Network block related information
-func (a *API) UpdateNetworkInfoBlock(
+func (u *StateAPIUpdater) UpdateNetworkInfoBlock(lastEthBlock, lastSyncBlock common.Block) {
-	lastEthBlock, lastSyncBlock common.Block,
+	u.rw.Lock()
-) {
+	u.state.Network.LastSyncBlock = lastSyncBlock.Num
-	a.status.Network.LastSyncBlock = lastSyncBlock.Num
+	u.state.Network.LastEthBlock = lastEthBlock.Num
-	a.status.Network.LastEthBlock = lastEthBlock.Num
+	u.rw.Unlock()
 }
 
 // UpdateNetworkInfo update Status.Network information
-func (a *API) UpdateNetworkInfo(
+func (u *StateAPIUpdater) UpdateNetworkInfo(
 	lastEthBlock, lastSyncBlock common.Block,
 	lastBatchNum common.BatchNum, currentSlot int64,
 ) error {
-	lastBatch, err := a.h.GetBatchAPI(lastBatchNum)
+	// Get last batch in API format
+	lastBatch, err := u.hdb.GetBatchInternalAPI(lastBatchNum)
 	if tracerr.Unwrap(err) == sql.ErrNoRows {
 		lastBatch = nil
 	} else if err != nil {
 		return tracerr.Wrap(err)
 	}
-	lastClosedSlot := currentSlot + int64(a.status.Auction.ClosedAuctionSlots)
+	u.rw.RLock()
-	nextForgers, err := a.getNextForgers(lastSyncBlock, currentSlot, lastClosedSlot)
+	auctionVars := u.vars.Auction
+	u.rw.RUnlock()
+	// Get next forgers
+	lastClosedSlot := currentSlot + int64(auctionVars.ClosedAuctionSlots)
+	nextForgers, err := u.hdb.GetNextForgersInternalAPI(auctionVars, &u.consts.Auction,
+		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
 
-	// Update buckets withdrawals
+	bucketUpdates, err := u.hdb.GetBucketUpdatesInternalAPI()
-	bucketsUpdate, err := a.h.GetBucketUpdatesAPI()
+	if err == sql.ErrNoRows {
-	if tracerr.Unwrap(err) == sql.ErrNoRows {
+		bucketUpdates = nil
-		bucketsUpdate = nil
 	} else if err != nil {
 		return tracerr.Wrap(err)
 	}
 
-	for i, bucketParams := range a.status.Rollup.Buckets {
+	u.rw.Lock()
-		for _, bucketUpdate := range bucketsUpdate {
+	// Update NodeInfo struct
+	for i, bucketParams := range u.state.Rollup.Buckets {
+		for _, bucketUpdate := range bucketUpdates {
 			if bucketUpdate.NumBucket == i {
 				bucketParams.Withdrawals = bucketUpdate.Withdrawals
-				a.status.Rollup.Buckets[i] = bucketParams
+				u.state.Rollup.Buckets[i] = bucketParams
 				break
 			}
 		}
 	}
-	a.status.Unlock()
+	u.state.Network.LastSyncBlock = lastSyncBlock.Num
-	return nil
+	u.state.Network.LastEthBlock = lastEthBlock.Num
-}
+	u.state.Network.LastBatch = lastBatch
-
+	u.state.Network.CurrentSlot = currentSlot
-// apiSlotToBigInts converts from [6]*apitypes.BigIntStr to [6]*big.Int
+	u.state.Network.NextForgers = nextForgers
-func apiSlotToBigInts(defaultSlotSetBid [6]*apitypes.BigIntStr) ([6]*big.Int, error) {
+	u.rw.Unlock()
-	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)
-	}
-	a.status.Lock()
-	a.status.RecommendedFee.ExistingAccount = feeExistingAccount
-	a.status.RecommendedFee.CreatesAccount = createAccountExtraFeePercentage * feeExistingAccount
-	a.status.RecommendedFee.CreatesAccountAndRegister = createAccountInternalExtraFeePercentage * feeExistingAccount
-	a.status.Unlock()
 	return nil
 }

api/state_test.go

@@ -13,7 +13,7 @@ import (
 
 type testStatus struct {
 	Network           testNetwork                   `json:"network"`
-	Metrics           historydb.Metrics             `json:"metrics"`
+	Metrics           historydb.MetricsAPI          `json:"metrics"`
 	Rollup            historydb.RollupVariablesAPI  `json:"rollup"`
 	Auction           historydb.AuctionVariablesAPI `json:"auction"`
 	WithdrawalDelayer common.WDelayerVariables      `json:"withdrawalDelayer"`
@@ -21,18 +21,19 @@ type testStatus struct {
 }
 
 type testNetwork struct {
-	LastEthBlock  int64        `json:"lastEthereumBlock"`
+	LastEthBlock  int64                     `json:"lastEthereumBlock"`
-	LastSyncBlock int64        `json:"lastSynchedBlock"`
+	LastSyncBlock int64                     `json:"lastSynchedBlock"`
-	LastBatch     testBatch    `json:"lastBatch"`
+	LastBatch     testBatch                 `json:"lastBatch"`
-	CurrentSlot   int64        `json:"currentSlot"`
+	CurrentSlot   int64                     `json:"currentSlot"`
-	NextForgers   []NextForger `json:"nextForgers"`
+	NextForgers   []historydb.NextForgerAPI `json:"nextForgers"`
 }
 
 func TestSetRollupVariables(t *testing.T) {
-	rollupVars := &common.RollupVariables{}
+	stateAPIUpdater.SetSCVars(&common.SCVariablesPtr{Rollup: &tc.rollupVars})
-	assertEqualRollupVariables(t, *rollupVars, api.status.Rollup, true)
+	require.NoError(t, stateAPIUpdater.Store())
-	api.SetRollupVariables(tc.rollupVars)
+	ni, err := api.h.GetNodeInfoAPI()
-	assertEqualRollupVariables(t, tc.rollupVars, api.status.Rollup, true)
+	require.NoError(t, err)
+	assertEqualRollupVariables(t, tc.rollupVars, ni.StateAPI.Rollup, true)
 }
 
 func assertEqualRollupVariables(t *testing.T, rollupVariables common.RollupVariables, apiVariables historydb.RollupVariablesAPI, checkBuckets bool) {
@@ -51,17 +52,19 @@ func assertEqualRollupVariables(t *testing.T, rollupVariables common.RollupVaria
 }
 
 func TestSetWDelayerVariables(t *testing.T) {
-	wdelayerVars := &common.WDelayerVariables{}
+	stateAPIUpdater.SetSCVars(&common.SCVariablesPtr{WDelayer: &tc.wdelayerVars})
-	assert.Equal(t, *wdelayerVars, api.status.WithdrawalDelayer)
+	require.NoError(t, stateAPIUpdater.Store())
-	api.SetWDelayerVariables(tc.wdelayerVars)
+	ni, err := api.h.GetNodeInfoAPI()
-	assert.Equal(t, tc.wdelayerVars, api.status.WithdrawalDelayer)
+	require.NoError(t, err)
+	assert.Equal(t, tc.wdelayerVars, ni.StateAPI.WithdrawalDelayer)
 }
 
 func TestSetAuctionVariables(t *testing.T) {
-	auctionVars := &common.AuctionVariables{}
+	stateAPIUpdater.SetSCVars(&common.SCVariablesPtr{Auction: &tc.auctionVars})
-	assertEqualAuctionVariables(t, *auctionVars, api.status.Auction)
+	require.NoError(t, stateAPIUpdater.Store())
-	api.SetAuctionVariables(tc.auctionVars)
+	ni, err := api.h.GetNodeInfoAPI()
-	assertEqualAuctionVariables(t, tc.auctionVars, api.status.Auction)
+	require.NoError(t, err)
+	assertEqualAuctionVariables(t, tc.auctionVars, ni.StateAPI.Auction)
 }
 
 func assertEqualAuctionVariables(t *testing.T, auctionVariables common.AuctionVariables, apiVariables historydb.AuctionVariablesAPI) {
@@ -85,11 +88,6 @@ 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)
@@ -118,62 +116,79 @@ func TestUpdateNetworkInfo(t *testing.T) {
 	err := api.h.AddBucketUpdatesTest(api.h.DB(), bucketUpdates)
 	require.NoError(t, err)
 
-	err = api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
+	// stateAPIUpdater := NewStateAPIUpdater(hdb)
-	assert.NoError(t, err)
+	err = stateAPIUpdater.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
-	assert.Equal(t, lastBlock.Num, api.status.Network.LastSyncBlock)
+	require.NoError(t, err)
-	assert.Equal(t, lastBatchNum, api.status.Network.LastBatch.BatchNum)
+	require.NoError(t, stateAPIUpdater.Store())
-	assert.Equal(t, currentSlotNum, api.status.Network.CurrentSlot)
+	ni, err := api.h.GetNodeInfoAPI()
-	assert.Equal(t, int(api.status.Auction.ClosedAuctionSlots)+1, len(api.status.Network.NextForgers))
+	require.NoError(t, err)
-	assert.Equal(t, api.status.Rollup.Buckets[0].Withdrawals, apitypes.NewBigIntStr(big.NewInt(123)))
+	assert.Equal(t, lastBlock.Num, ni.StateAPI.Network.LastSyncBlock)
-	assert.Equal(t, api.status.Rollup.Buckets[2].Withdrawals, apitypes.NewBigIntStr(big.NewInt(43)))
+	assert.Equal(t, lastBatchNum, ni.StateAPI.Network.LastBatch.BatchNum)
+	assert.Equal(t, currentSlotNum, ni.StateAPI.Network.CurrentSlot)
+	assert.Equal(t, int(ni.StateAPI.Auction.ClosedAuctionSlots)+1, len(ni.StateAPI.Network.NextForgers))
+	assert.Equal(t, ni.StateAPI.Rollup.Buckets[0].Withdrawals, apitypes.NewBigIntStr(big.NewInt(123)))
+	assert.Equal(t, ni.StateAPI.Rollup.Buckets[2].Withdrawals, apitypes.NewBigIntStr(big.NewInt(43)))
 }
 
 func TestUpdateMetrics(t *testing.T) {
 	// Update Metrics needs api.status.Network.LastBatch.BatchNum to be updated
 	lastBlock := tc.blocks[3]
-	lastBatchNum := common.BatchNum(3)
+	lastBatchNum := common.BatchNum(12)
 	currentSlotNum := int64(1)
-	err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
+	err := stateAPIUpdater.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
-	err = api.UpdateMetrics()
+	err = stateAPIUpdater.UpdateMetrics()
-	assert.NoError(t, err)
+	require.NoError(t, err)
-	assert.Greater(t, api.status.Metrics.TransactionsPerBatch, float64(0))
+	require.NoError(t, stateAPIUpdater.Store())
-	assert.Greater(t, api.status.Metrics.BatchFrequency, float64(0))
+	ni, err := api.h.GetNodeInfoAPI()
-	assert.Greater(t, api.status.Metrics.TransactionsPerSecond, float64(0))
+	require.NoError(t, err)
-	assert.Greater(t, api.status.Metrics.TotalAccounts, int64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.TransactionsPerBatch, float64(0))
-	assert.Greater(t, api.status.Metrics.TotalBJJs, int64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.BatchFrequency, float64(0))
-	assert.Greater(t, api.status.Metrics.AvgTransactionFee, float64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.TransactionsPerSecond, float64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.TotalAccounts, int64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.TotalBJJs, int64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.AvgTransactionFee, float64(0))
 }
 
 func TestUpdateRecommendedFee(t *testing.T) {
-	err := api.UpdateRecommendedFee()
+	err := stateAPIUpdater.UpdateRecommendedFee()
-	assert.NoError(t, err)
+	require.NoError(t, err)
-	assert.Greater(t, api.status.RecommendedFee.ExistingAccount, float64(0))
+	require.NoError(t, stateAPIUpdater.Store())
-	assert.Equal(t, api.status.RecommendedFee.CreatesAccount,
+	var minFeeUSD float64
-		api.status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
+	if api.l2 != nil {
-	assert.Equal(t, api.status.RecommendedFee.CreatesAccountAndRegister,
+		minFeeUSD = api.l2.MinFeeUSD()
-		api.status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
+	}
+	ni, err := api.h.GetNodeInfoAPI()
+	require.NoError(t, err)
+	assert.Greater(t, ni.StateAPI.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)
 }
 
 func TestGetState(t *testing.T) {
 	lastBlock := tc.blocks[3]
-	lastBatchNum := common.BatchNum(3)
+	lastBatchNum := common.BatchNum(12)
 	currentSlotNum := int64(1)
-	api.SetRollupVariables(tc.rollupVars)
+	stateAPIUpdater.SetSCVars(&common.SCVariablesPtr{
-	api.SetWDelayerVariables(tc.wdelayerVars)
+		Rollup:   &tc.rollupVars,
-	api.SetAuctionVariables(tc.auctionVars)
+		Auction:  &tc.auctionVars,
-	err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
+		WDelayer: &tc.wdelayerVars,
-	assert.NoError(t, err)
+	})
-	err = api.UpdateMetrics()
+	err := stateAPIUpdater.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
-	err = api.UpdateRecommendedFee()
+	err = stateAPIUpdater.UpdateMetrics()
-	assert.NoError(t, err)
+	require.NoError(t, err)
+	err = stateAPIUpdater.UpdateRecommendedFee()
+	require.NoError(t, err)
+	require.NoError(t, stateAPIUpdater.Store())
 
 	endpoint := apiURL + "state"
 	var status testStatus
 
-	assert.NoError(t, doGoodReq("GET", endpoint, nil, &status))
+	require.NoError(t, doGoodReq("GET", endpoint, nil, &status))
 
 	// SC vars
 	// UpdateNetworkInfo will overwrite buckets withdrawal values
@@ -200,13 +215,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,
+	// assert.Equal(t, status.RecommendedFee.CreatesAccount,
-		status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
+	// 	status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
-	assert.Equal(t, status.RecommendedFee.CreatesAccountAndRegister,
+	// assert.Equal(t, status.RecommendedFee.CreatesAccountAndRegister,
-		status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
+	// 	status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
 }
 
-func assertNextForgers(t *testing.T, expected, actual []NextForger) {
+func assertNextForgers(t *testing.T, expected, actual []historydb.NextForgerAPI) {
 	assert.Equal(t, len(expected), len(actual))
 	for i := range expected {
 		// ignore timestamps and other metadata

api/swagger.yml

@@ -1329,13 +1329,6 @@ 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: >-
@@ -1390,7 +1383,6 @@ components:
           $ref: '#/components/schemas/Token'
       example:
         amount: '100000000000000'
-        batchNum: 
         fee: 0
         fromAccountIndex: hez:SCC:256
         fromBJJ: hez:r_trOasVEk0zNaalOoS9aLedu6mO7jI5XTIPu_zGXoyn
@@ -1438,7 +1430,6 @@ components:
         - info
         - signature
         - timestamp
-        - batchNum
         - requestFromAccountIndex
         - requestToAccountIndex
         - requestToHezEthereumAddress
@@ -2578,6 +2569,21 @@ 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
@@ -2594,6 +2600,8 @@ components:
           $ref: '#/components/schemas/StateWithdrawDelayer'
         recommendedFee:
           $ref: '#/components/schemas/RecommendedFee'
+        nodeConfig:
+          $ref: '#/components/schemas/NodeConfig'
       additionalProperties: false
       required: 
         - network
@@ -2602,6 +2610,7 @@ components:
         - auction
         - withdrawalDelayer
         - recommendedFee
+        - nodeConfig
     StateNetwork:
       type: object
       description: Gobal statistics of the network
@@ -2812,6 +2821,10 @@ 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
@@ -2820,6 +2833,7 @@ 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.

api/txspool.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"errors"
+	"fmt"
 	"math/big"
 	"net/http"
 
@@ -27,6 +28,7 @@ func (a *API) postPoolTx(c *gin.Context) {
 		retBadReq(err, c)
 		return
 	}
+	writeTx.ClientIP = c.ClientIP()
 	// Insert to DB
 	if err := a.l2.AddTxAPI(writeTx); err != nil {
 		retSQLErr(err, c)
@@ -169,16 +171,21 @@ func (a *API) verifyPoolL2TxWrite(txw *l2db.PoolL2TxWrite) error {
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	// Get public key
-	account, err := a.s.LastGetAccount(poolTx.FromIdx)
-	if err != nil {
-		return tracerr.Wrap(err)
-	}
 	// Validate feeAmount
 	_, err = common.CalcFeeAmount(poolTx.Amount, poolTx.Fee)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
+	// Get public key
+	account, err := a.h.GetCommonAccountAPI(poolTx.FromIdx)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	// Validate TokenID
+	if poolTx.TokenID != account.TokenID {
+		return tracerr.Wrap(fmt.Errorf("tx.TokenID (%v) != account.TokenID (%v)",
+			poolTx.TokenID, account.TokenID))
+	}
 	// Check signature
 	if !poolTx.VerifySignature(a.chainID, account.BJJ) {
 		return tracerr.Wrap(errors.New("wrong signature"))

api/txspool_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // testPoolTxReceive is a struct to be used to assert the response
@@ -170,9 +171,9 @@ func TestPoolTxs(t *testing.T) {
 	fetchedTxID := common.TxID{}
 	for _, tx := range tc.poolTxsToSend {
 		jsonTxBytes, err := json.Marshal(tx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		jsonTxReader := bytes.NewReader(jsonTxBytes)
-		assert.NoError(
+		require.NoError(
 			t, doGoodReq(
 				"POST",
 				endpoint,
@@ -187,42 +188,42 @@ func TestPoolTxs(t *testing.T) {
 	badTx.Amount = "99950000000000000"
 	badTx.Fee = 255
 	jsonTxBytes, err := json.Marshal(badTx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	jsonTxReader := bytes.NewReader(jsonTxBytes)
 	err = doBadReq("POST", endpoint, jsonTxReader, 400)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Wrong signature
 	badTx = tc.poolTxsToSend[0]
 	badTx.FromIdx = "hez:foo:1000"
 	jsonTxBytes, err = json.Marshal(badTx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	jsonTxReader = bytes.NewReader(jsonTxBytes)
 	err = doBadReq("POST", endpoint, jsonTxReader, 400)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Wrong to
 	badTx = tc.poolTxsToSend[0]
 	ethAddr := "hez:0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
 	badTx.ToEthAddr = &ethAddr
 	badTx.ToIdx = nil
 	jsonTxBytes, err = json.Marshal(badTx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	jsonTxReader = bytes.NewReader(jsonTxBytes)
 	err = doBadReq("POST", endpoint, jsonTxReader, 400)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Wrong rq
 	badTx = tc.poolTxsToSend[0]
 	rqFromIdx := "hez:foo:30"
 	badTx.RqFromIdx = &rqFromIdx
 	jsonTxBytes, err = json.Marshal(badTx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	jsonTxReader = bytes.NewReader(jsonTxBytes)
 	err = doBadReq("POST", endpoint, jsonTxReader, 400)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// GET
 	endpoint += "/"
 	for _, tx := range tc.poolTxsToReceive {
 		fetchedTx := testPoolTxReceive{}
-		assert.NoError(
+		require.NoError(
 			t, doGoodReq(
 				"GET",
 				endpoint+tx.TxID.String(),
@@ -233,10 +234,10 @@ func TestPoolTxs(t *testing.T) {
 	}
 	// 400, due invalid TxID
 	err = doBadReq("GET", endpoint+"0xG2241b6f2b1dd772dba391f4a1a3407c7c21f598d86e2585a14e616fb4a255f823", nil, 400)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// 404, due inexistent TxID in DB
 	err = doBadReq("GET", endpoint+"0x02241b6f2b1dd772dba391f4a1a3407c7c21f598d86e2585a14e616fb4a255f823", nil, 404)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func assertPoolTx(t *testing.T, expected, actual testPoolTxReceive) {

batchbuilder/batchbuilder.go

@@ -64,7 +64,10 @@ func (bb *BatchBuilder) BuildBatch(coordIdxs []common.Idx, configBatch *ConfigBa
 	tp := txprocessor.NewTxProcessor(bbStateDB, configBatch.TxProcessorConfig)
 
 	ptOut, err := tp.ProcessTxs(coordIdxs, l1usertxs, l1coordinatortxs, pooll2txs)
-	return ptOut.ZKInputs, tracerr.Wrap(err)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	return ptOut.ZKInputs, nil
 }
 
 // LocalStateDB returns the underlying LocalStateDB

cli/node/.gitignore

@@ -1,2 +1,3 @@
 cfg.example.secret.toml
 cfg.toml
+node

cli/node/cfg.buidler.toml

@@ -14,17 +14,23 @@ Type = "bitfinexV2"
 [Debug]
 APIAddress = "localhost:12345"
 MeddlerLogs = true
+GinDebugMode = true
 
 [StateDB]
 Path = "/tmp/iden3-test/hermez/statedb"
 Keep = 256
 
 [PostgreSQL]
-Port     = 5432
+PortWrite     = 5432
-Host     = "localhost"
+HostWrite     = "localhost"
-User     = "hermez"
+UserWrite     = "hermez"
-Password = "yourpasswordhere"
+PasswordWrite = "yourpasswordhere"
-Name     = "hermez"
+NameWrite     = "hermez"
+# PortRead     = 5432
+# HostRead     = "localhost"
+# UserRead     = "hermez"
+# PasswordRead = "yourpasswordhere"
+# NameRead     = "hermez"
 
 [Web3]
 URL = "http://localhost:8545"
@@ -45,6 +51,7 @@ ForgerAddress = "0x05c23b938a85ab26A36E6314a0D02080E9ca6BeD" # Non-Boot Coordina
 # ForgerAddressPrivateKey = "0x30f5fddb34cd4166adb2c6003fa6b18f380fd2341376be42cf1c7937004ac7a3"
 # ForgerAddress = "0xb4124ceb3451635dacedd11767f004d8a28c6ee7" # Boot Coordinator
 # ForgerAddressPrivateKey = "0xa8a54b2d8197bc0b19bb8a084031be71835580a01e70a45a13babd16c9bc1563"
+MinimumForgeAddressBalance = 0
 ConfirmBlocks = 10
 L1BatchTimeoutPerc = 0.6
 StartSlotBlocksDelay = 2
@@ -55,6 +62,7 @@ ForgeRetryInterval = "500ms"
 SyncRetryInterval = "1s"
 ForgeDelay = "10s"
 ForgeNoTxsDelay = "0s"
+PurgeByExtDelInterval = "1m"
 
 [Coordinator.FeeAccount]
 Address = "0x56232B1c5B10038125Bc7345664B4AFD745bcF8E"
@@ -65,6 +73,7 @@ BJJ = "0x1b176232f78ba0d388ecc5f4896eca2d3b3d4f272092469f559247297f5c0c13"
 [Coordinator.L2DB]
 SafetyPeriod = 10
 MaxTxs       = 512
+MinFeeUSD    = 0.0
 TTL          = "24h"
 PurgeBatchDelay = 10
 InvalidateBatchDelay = 20
@@ -97,6 +106,12 @@ GasPriceIncPerc = 10
 Path = "/tmp/iden3-test/hermez/ethkeystore"
 Password = "yourpasswordhere"
 
+[Coordinator.EthClient.ForgeBatchGasCost]
+Fixed = 500000
+L1UserTx = 8000
+L1CoordTx = 9000
+L2Tx = 1
+
 [Coordinator.API]
 Coordinator = true
 

cli/node/main.go

@@ -17,6 +17,7 @@ import (
 	"github.com/hermeznetwork/hermez-node/node"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-iden3-crypto/babyjub"
+	"github.com/jmoiron/sqlx"
 	"github.com/urfave/cli/v2"
 )
 
@@ -90,11 +91,11 @@ func cmdWipeSQL(c *cli.Context) error {
 		}
 	}
 	db, err := dbUtils.ConnectSQLDB(
-		cfg.PostgreSQL.Port,
+		cfg.PostgreSQL.PortWrite,
-		cfg.PostgreSQL.Host,
+		cfg.PostgreSQL.HostWrite,
-		cfg.PostgreSQL.User,
+		cfg.PostgreSQL.UserWrite,
-		cfg.PostgreSQL.Password,
+		cfg.PostgreSQL.PasswordWrite,
-		cfg.PostgreSQL.Name,
+		cfg.PostgreSQL.NameWrite,
 	)
 	if err != nil {
 		return tracerr.Wrap(err)
@@ -106,17 +107,7 @@ func cmdWipeSQL(c *cli.Context) error {
 	return nil
 }
 
-func cmdRun(c *cli.Context) error {
+func waitSigInt() {
-	cfg, err := parseCli(c)
-	if err != nil {
-		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
@@ -137,11 +128,40 @@ func cmdRun(c *cli.Context) error {
 		}
 	}()
 	<-stopCh
+}
+
+func cmdRun(c *cli.Context) error {
+	cfg, err := parseCli(c)
+	if err != nil {
+		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()
+	waitSigInt()
 	node.Stop()
 
 	return nil
 }
 
+func cmdServeAPI(c *cli.Context) error {
+	cfg, err := parseCliAPIServer(c)
+	if err != nil {
+		return tracerr.Wrap(fmt.Errorf("error parsing flags and config: %w", err))
+	}
+	srv, err := node.NewAPIServer(cfg.mode, cfg.server)
+	if err != nil {
+		return tracerr.Wrap(fmt.Errorf("error starting api server: %w", err))
+	}
+	srv.Start()
+	waitSigInt()
+	srv.Stop()
+
+	return nil
+}
+
 func cmdDiscard(c *cli.Context) error {
 	_cfg, err := parseCli(c)
 	if err != nil {
@@ -151,17 +171,36 @@ func cmdDiscard(c *cli.Context) error {
 	blockNum := c.Int64(flagBlock)
 	log.Infof("Discarding all blocks up to block %v...", blockNum)
 
-	db, err := dbUtils.InitSQLDB(
+	dbWrite, err := dbUtils.InitSQLDB(
-		cfg.PostgreSQL.Port,
+		cfg.PostgreSQL.PortWrite,
-		cfg.PostgreSQL.Host,
+		cfg.PostgreSQL.HostWrite,
-		cfg.PostgreSQL.User,
+		cfg.PostgreSQL.UserWrite,
-		cfg.PostgreSQL.Password,
+		cfg.PostgreSQL.PasswordWrite,
-		cfg.PostgreSQL.Name,
+		cfg.PostgreSQL.NameWrite,
 	)
 	if err != nil {
 		return tracerr.Wrap(fmt.Errorf("dbUtils.InitSQLDB: %w", err))
 	}
-	historyDB := historydb.NewHistoryDB(db, nil)
+	var dbRead *sqlx.DB
+	if cfg.PostgreSQL.HostRead == "" {
+		dbRead = dbWrite
+	} else if cfg.PostgreSQL.HostRead == cfg.PostgreSQL.HostWrite {
+		return 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 tracerr.Wrap(fmt.Errorf("dbUtils.InitSQLDB: %w", err))
+		}
+	}
+	historyDB := historydb.NewHistoryDB(dbRead, dbWrite, nil)
 	if err := historyDB.Reorg(blockNum); err != nil {
 		return tracerr.Wrap(fmt.Errorf("historyDB.Reorg: %w", err))
 	}
@@ -170,9 +209,10 @@ func cmdDiscard(c *cli.Context) error {
 		return tracerr.Wrap(fmt.Errorf("historyDB.GetLastBatchNum: %w", err))
 	}
 	l2DB := l2db.NewL2DB(
-		db,
+		dbRead, dbWrite,
 		cfg.Coordinator.L2DB.SafetyPeriod,
 		cfg.Coordinator.L2DB.MaxTxs,
+		cfg.Coordinator.L2DB.MinFeeUSD,
 		cfg.Coordinator.L2DB.TTL.Duration,
 		nil,
 	)
@@ -204,20 +244,59 @@ 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:
 		cfg.mode = node.ModeSynchronizer
-		cfg.node, err = config.LoadNode(nodeCfgPath)
+		cfg.node, err = config.LoadNode(nodeCfgPath, false)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
 	case modeCoord:
 		cfg.mode = node.ModeCoordinator
-		cfg.node, err = config.LoadCoordinator(nodeCfgPath)
+		cfg.node, err = config.LoadNode(nodeCfgPath, true)
+		if err != nil {
+			return nil, tracerr.Wrap(err)
+		}
+	default:
+		return nil, tracerr.Wrap(fmt.Errorf("invalid mode \"%v\"", mode))
+	}
+
+	return &cfg, nil
+}
+
+// ConfigAPIServer is the configuration of the api server execution
+type ConfigAPIServer struct {
+	mode   node.Mode
+	server *config.APIServer
+}
+
+func parseCliAPIServer(c *cli.Context) (*ConfigAPIServer, error) {
+	cfg, err := getConfigAPIServer(c)
+	if err != nil {
+		if err := cli.ShowAppHelp(c); err != nil {
+			panic(err)
+		}
+		return nil, tracerr.Wrap(err)
+	}
+	return cfg, nil
+}
+
+func getConfigAPIServer(c *cli.Context) (*ConfigAPIServer, error) {
+	var cfg ConfigAPIServer
+	mode := c.String(flagMode)
+	nodeCfgPath := c.String(flagCfg)
+	var err error
+	switch mode {
+	case modeSync:
+		cfg.mode = node.ModeSynchronizer
+		cfg.server, err = config.LoadAPIServer(nodeCfgPath, false)
+		if err != nil {
+			return nil, tracerr.Wrap(err)
+		}
+	case modeCoord:
+		cfg.mode = node.ModeCoordinator
+		cfg.server, err = config.LoadAPIServer(nodeCfgPath, true)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
@@ -283,6 +362,12 @@ 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{},

common/account.go

@@ -263,3 +263,13 @@ type IdxNonce struct {
 	Idx   Idx   `db:"idx"`
 	Nonce Nonce `db:"nonce"`
 }
+
+// AccountUpdate represents an account balance and/or nonce update after a
+// processed batch
+type AccountUpdate struct {
+	EthBlockNum int64    `meddler:"eth_block_num"`
+	BatchNum    BatchNum `meddler:"batch_num"`
+	Idx         Idx      `meddler:"idx"`
+	Nonce       Nonce    `meddler:"nonce"`
+	Balance     *big.Int `meddler:"balance,bigint"`
+}

common/accountcreationauths.go

@@ -1,21 +1,25 @@
 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 = "I authorize this babyjubjub key for hermez rollup account creation"
+const AccountCreationAuthMsg = "Account creation"
 
-// EthMsgPrefix is the prefix for message signing at the Ethereum ecosystem
+// EIP712Version is the used version of the EIP-712
-const EthMsgPrefix = "\x19Ethereum Signed Message:\n"
+const EIP712Version = "1"
+
+// EIP712Provider defines the Provider for the EIP-712
+const EIP712Provider = "Hermez Network"
 
 var (
 	// EmptyEthSignature is an ethereum signature of all zeroes
@@ -31,27 +35,64 @@ 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 {
+	hermezContractAddr ethCommon.Address) ([]byte, error) {
-	var chainIDBytes [2]byte
+	chainIDFormatted := ethMath.NewHexOrDecimal256(int64(chainID))
-	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[:]...)
 
-	ethPrefix := EthMsgPrefix + strconv.Itoa(len(b))
+	signerData := ethSigner.TypedData{
-	return append([]byte(ethPrefix), b...)
+		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
 }
 
 // HashToSign returns the hash to be signed by the Etherum address to authorize
-// the account creation
+// the account creation, which follows the EIP-712 encoding
 func (a *AccountCreationAuth) HashToSign(chainID uint16,
 	hermezContractAddr ethCommon.Address) ([]byte, error) {
-	b := a.toHash(chainID, hermezContractAddr)
+	b, err := a.toHash(chainID, hermezContractAddr)
-	return ethCrypto.Keccak256Hash(b).Bytes(), nil
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	return ethCrypto.Keccak256(b), nil
 }
 
 // Sign signs the account creation authorization message using the provided
@@ -59,16 +100,17 @@ 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).
+// the keystore (which never exposes the private key). Sign follows the EIP-712
+// encoding.
 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 err
+		return tracerr.Wrap(err)
 	}
 	sig, err := signHash(hash)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	sig[64] += 27
 	a.Signature = sig
@@ -77,7 +119,8 @@ 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
+// chainID and hermezContractAddress passed by parameter. VerifySignature
+// follows the EIP-712 encoding.
 func (a *AccountCreationAuth) VerifySignature(chainID uint16,
 	hermezContractAddr ethCommon.Address) bool {
 	// Calculate hash to be signed

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, "4f8df75e96fdce1ac90bb2f8d81c42047600f85bfcef80ce3b91c2a2afc58c1e",
+	assert.Equal(t, "9414667457e658dd31949b82996b75c65a055512244c3bbfd22ff56add02ba65",
 		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:     "19457468657265756d205369676e6564204d6573736167653a0a3132304920617574686f72697a65207468697320626162796a75626a7562206b657920666f72206865726d657a20726f6c6c7570206163636f756e74206372656174696f6e21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d700047e5f4552091a69125d5dfcb7b8c2659029395bdf",
+		toHashExpected:     "190189658bba487e11c7da602676ee32bc90b77d3f32a305b147e4f3c3b35f19672e5d84ccc38d0ab245c469b719549d837113465c2abf9972c49403ca6fd10ed3dc",
-		hashExpected:       "39afea52d843a4de905b6b5ebb0ee8c678141f711d96d9b429c4aec10ef9911f",
+		hashExpected:       "c56eba41e511df100c804c5c09288f35887efea4f033be956481af335df3bea2",
-		sigExpected:        "73d10d6ecf06ee8a5f60ac90f06b78bef9c650f414ba3ac73e176dc32e896159147457e9c86f0b4bd60fdaf2c0b2aec890a7df993d69a4805e242a6b845ebf231c",
+		sigExpected:        "dbedcc5ce02db8f48afbdb2feba9a3a31848eaa8fca5f312ce37b01db45d2199208335330d4445bd2f51d1db68dbc0d0bf3585c4a07504b4efbe46a69eaae5a21b",
 	}
 	tv1 := testVector{
 		ethSk:              "0000000000000000000000000000000000000000000000000000000000000002",
@@ -85,9 +85,9 @@ func TestAccountCreationAuthJSComp(t *testing.T) {
 		pkCompStr:          "093985b1993d9f743f9d7d943ed56f38601cb8b196db025f79650c4007c3054d",
 		chainID:            uint16(0),
 		hermezContractAddr: "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
-		toHashExpected:     "19457468657265756d205369676e6564204d6573736167653a0a3132304920617574686f72697a65207468697320626162796a75626a7562206b657920666f72206865726d657a20726f6c6c7570206163636f756e74206372656174696f6e093985b1993d9f743f9d7d943ed56f38601cb8b196db025f79650c4007c3054d00002b5ad5c4795c026514f8317c7a215e218dccd6cf",
+		toHashExpected:     "1901dafbc253dedf90d6421dc6e25d5d9efc6985133cb2a8d363d0a081a0e3eddddc65f603a88de36aaeabd3b4cf586538c7f3fd50c94780530a3707c8c14ad9fd11",
-		hashExpected:       "89a3895993a4736232212e59566294feb3da227af44375daf3307dcad5451d5d",
+		hashExpected:       "deb9afa479282cf27b442ce8ba86b19448aa87eacef691521a33db5d0feb9959",
-		sigExpected:        "bb4156156c705494ad5f99030342c64657e51e2994750f92125717c40bf56ad632044aa6bd00979feea92c417b552401e65fe5f531f15010d9d1c278da8be1df1b",
+		sigExpected:        "6a0da90ba2d2b1be679a28ebe54ee03082d44b836087391cd7d2607c1e4dafe04476e6e88dccb8707c68312512f16c947524b35c80f26c642d23953e9bb84c701c",
 	}
 	tv2 := testVector{
 		ethSk:              "c5e8f61d1ab959b397eecc0a37a6517b8e67a0e7cf1f4bce5591f3ed80199122",
@@ -95,9 +95,9 @@ func TestAccountCreationAuthJSComp(t *testing.T) {
 		pkCompStr:          "22870c1bcc451396202d62f566026eab8e438c6c91decf8ddf63a6c162619b52",
 		chainID:            uint16(31337), // =0x7a69
 		hermezContractAddr: "0xf4e77E5Da47AC3125140c470c71cBca77B5c638c",
-		toHashExpected:     "19457468657265756d205369676e6564204d6573736167653a0a3132304920617574686f72697a65207468697320626162796a75626a7562206b657920666f72206865726d657a20726f6c6c7570206163636f756e74206372656174696f6e22870c1bcc451396202d62f566026eab8e438c6c91decf8ddf63a6c162619b527a69f4e77e5da47ac3125140c470c71cbca77b5c638c",
+		toHashExpected:     "190167617949b934d7e01add4009cd3d47415a26727b7d6288e5dce33fb3721d5a1a9ce511b19b694c9aaf8183f4987ed752f24884c54c003d11daa2e98c7547a79e",
-		hashExpected:       "4f6ead01278ba4597d4720e37482f585a713497cea994a95209f4c57a963b4a7",
+		hashExpected:       "157b570c597e615b8356ce008ac39f43bc9b6d50080bc07d968031b9378acbbb",
-		sigExpected:        "43b5818802a137a72a190c1d8d767ca507f7a4804b1b69b5e055abf31f4f2b476c80bb1ba63260d95610f6f831420d32130e7f22fec5d76e16644ddfcedd0d441c",
+		sigExpected:        "a0766181102428b5672e523dc4b905c10ddf025c10dbd0b3534ef864632a14652737610041c670b302fc7dca28edd5d6eac42b72d69ce58da8ce21287b244e381b",
 	}
 	tvs = append(tvs, tv0)
 	tvs = append(tvs, tv1)
@@ -122,10 +122,10 @@ func TestAccountCreationAuthJSComp(t *testing.T) {
 			BJJ:     pkComp,
 		}
 
-		toHash := a.toHash(chainID, hermezContractAddr)
+		toHash, err := a.toHash(chainID, hermezContractAddr)
+		require.NoError(t, err)
 		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)

common/batch.go

@@ -77,6 +77,7 @@ type BatchData struct {
 	L1CoordinatorTxs []L1Tx
 	L2Txs            []L2Tx
 	CreatedAccounts  []Account
+	UpdatedAccounts  []AccountUpdate
 	ExitTree         []ExitInfo
 	Batch            Batch
 }

common/eth.go

@@ -0,0 +1,33 @@
+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"`
+}
+
+// AsPtr returns the SCVariables as a SCVariablesPtr using pointers to the
+// original SCVariables
+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
+}

common/l1tx.go

@@ -368,19 +368,12 @@ 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,
 	}
@@ -401,18 +394,20 @@ 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)
-		hash := signHash(data)
+
-		pubKeyBytes, err := ethCrypto.Ecrecover(hash, signature)
+		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)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}

common/l1tx_test.go

@@ -227,7 +227,6 @@ 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)
@@ -245,18 +244,16 @@ 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")
 
-	babyjubB := SwapEndianness(pkComp[:])
+	accCreationAuth := AccountCreationAuth{
-	var data []byte
+		EthAddr: fromEthAddr,
-	data = append(data, bytesMessage1...)
+		BJJ:     pkComp,
-	data = append(data, bytesMessage2...)
+	}
-	data = append(data, babyjubB[:]...)
+
-	data = append(data, chainIDBytes...)
+	h, err := accCreationAuth.HashToSign(uint16(chainID.Uint64()), hermezAddress)
-	data = append(data, hermezAddress.Bytes()...)
+	require.NoError(t, err)
-	hash := crypto.Keccak256Hash(data)
+
-	signature, err := crypto.Sign(hash.Bytes(), privateKey)
+	signature, err := crypto.Sign(h, privateKey)
 	require.NoError(t, err)
 	// Ethereum adds 27 to v
 	v := int(signature[64])

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",
-			tx.Type, txTypeOld))
+			txTypeOld, tx.Type))
 	}
 
 	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",
-			tx.TxID.String(), txIDOld.String()))
+			txIDOld.String(), tx.TxID.String()))
 	}
 
 	return tx, nil

common/utils.go

@@ -62,3 +62,17 @@ func RmEndingZeroes(siblings []*merkletree.Hash) []*merkletree.Hash {
 	}
 	return siblings[:pos]
 }
+
+// TokensToUSD is a helper function to calculate the USD value of a certain
+// amount of tokens considering the normalized token price (which is the price
+// commonly reported by exhanges)
+func TokensToUSD(amount *big.Int, decimals uint64, valueUSD float64) float64 {
+	amountF := new(big.Float).SetInt(amount)
+	// Divide by 10^decimals to normalize the amount
+	baseF := new(big.Float).SetInt(new(big.Int).Exp(
+		big.NewInt(10), big.NewInt(int64(decimals)), nil)) //nolint:gomnd
+	amountF.Mul(amountF, big.NewFloat(valueUSD))
+	amountF.Quo(amountF, baseF)
+	amountUSD, _ := amountF.Float64()
+	return amountUSD
+}

config/config.go

@@ -35,10 +35,30 @@ type ServerProof struct {
 	URL string `validate:"required"`
 }
 
+// ForgeBatchGasCost is the costs associated to a ForgeBatch transaction, split
+// into different parts to be used in a formula.
+type ForgeBatchGasCost struct {
+	Fixed     uint64 `validate:"required"`
+	L1UserTx  uint64 `validate:"required"`
+	L1CoordTx uint64 `validate:"required"`
+	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
@@ -91,6 +111,10 @@ type Coordinator struct {
 	// SyncRetryInterval is the waiting interval between calls to the main
 	// handler of a synced block after an error
 	SyncRetryInterval Duration `validate:"required"`
+	// PurgeByExtDelInterval is the waiting interval between calls
+	// to the PurgeByExternalDelete function of the l2db which deletes
+	// pending txs externally marked by the column `external_delete`
+	PurgeByExtDelInterval Duration `validate:"required"`
 	// L2DB is the DB that holds the pool of L2Txs
 	L2DB struct {
 		// SafetyPeriod is the number of batches after which
@@ -101,6 +125,10 @@ type Coordinator struct {
 		// 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
 		// TTL is the Time To Live for L2Txs in the pool.  Once MaxTxs
 		// L2Txs is reached, L2Txs older than TTL will be deleted.
 		TTL Duration `validate:"required"`
@@ -172,11 +200,11 @@ type Coordinator struct {
 			// Password used to decrypt the keys in the keystore
 			Password string `validate:"required"`
 		} `validate:"required"`
+		// ForgeBatchGasCost contains the cost of each action in the
+		// ForgeBatch transaction.
+		ForgeBatchGasCost ForgeBatchGasCost `validate:"required"`
 	} `validate:"required"`
-	API struct {
+	API   CoordinatorAPI `validate:"required"`
-		// 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
@@ -191,6 +219,45 @@ type Coordinator struct {
 	}
 }
 
+// PostgreSQL is the postgreSQL configuration parameters.  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 {
@@ -207,19 +274,8 @@ type Node struct {
 		// Keep is the number of checkpoints to keep
 		Keep int `validate:"required"`
 	} `validate:"required"`
-	PostgreSQL struct {
+	PostgreSQL PostgreSQL `validate:"required"`
-		// Port of the PostgreSQL server
+	Web3       struct {
-		Port int `validate:"required"`
-		// Host of the PostgreSQL server
-		Host string `validate:"required"`
-		// User of the PostgreSQL server
-		User string `validate:"required"`
-		// Password of the PostgreSQL server
-		Password string `validate:"required"`
-		// Name of the PostgreSQL server database
-		Name string `validate:"required"`
-	} `validate:"required"`
-	Web3 struct {
 		// URL is the URL of the web3 ethereum-node RPC server
 		URL string `validate:"required"`
 	} `validate:"required"`
@@ -249,6 +305,7 @@ type Node struct {
 		// TokenHEZ address
 		TokenHEZName string `validate:"required"`
 	} `validate:"required"`
+	// API specifies the configuration parameters of the API
 	API struct {
 		// Address where the API will listen if set
 		Address string
@@ -266,17 +323,45 @@ type Node struct {
 		// can wait to stablish a SQL connection
 		SQLConnectionTimeout Duration
 	} `validate:"required"`
-	Debug struct {
+	Debug       NodeDebug   `validate:"required"`
-		// 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:"-"`
 }
 
+// APIServer is the api server configuration parameters
+type APIServer struct {
+	// NodeAPI specifies the configuration parameters of the API
+	API struct {
+		// Address where the API will listen if set
+		Address string `validate:"required"`
+		// Explorer enables the Explorer API endpoints
+		Explorer bool
+		// 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"`
+	PostgreSQL  PostgreSQL `validate:"required"`
+	Coordinator struct {
+		API struct {
+			// Coordinator enables the coordinator API endpoints
+			Coordinator bool
+		} `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
@@ -290,8 +375,8 @@ func Load(path string, cfg interface{}) error {
 	return nil
 }
 
-// LoadCoordinator loads the Coordinator configuration from path.
+// LoadNode loads the Node configuration from path.
-func LoadCoordinator(path string) (*Node, error) {
+func LoadNode(path string, coordinator bool) (*Node, error) {
 	var cfg Node
 	if err := Load(path, &cfg); err != nil {
 		return nil, tracerr.Wrap(fmt.Errorf("error loading node configuration file: %w", err))
@@ -300,21 +385,28 @@ func LoadCoordinator(path string) (*Node, error) {
 	if err := validate.Struct(cfg); err != nil {
 		return nil, tracerr.Wrap(fmt.Errorf("error validating configuration file: %w", err))
 	}
-	if err := validate.Struct(cfg.Coordinator); err != nil {
+	if coordinator {
-		return nil, tracerr.Wrap(fmt.Errorf("error validating configuration file: %w", err))
+		if err := validate.Struct(cfg.Coordinator); err != nil {
+			return nil, tracerr.Wrap(fmt.Errorf("error validating configuration file: %w", err))
+		}
 	}
 	return &cfg, nil
 }
 
-// LoadNode loads the Node configuration from path.
+// LoadAPIServer loads the APIServer configuration from path.
-func LoadNode(path string) (*Node, error) {
+func LoadAPIServer(path string, coordinator bool) (*APIServer, error) {
-	var cfg Node
+	var cfg APIServer
 	if err := Load(path, &cfg); err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("error loading node configuration file: %w", err))
+		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))
 	}
+	if coordinator {
+		if err := validate.Struct(cfg.Coordinator); err != nil {
+			return nil, tracerr.Wrap(fmt.Errorf("error validating configuration file: %w", err))
+		}
+	}
 	return &cfg, nil
 }

coordinator/coordinator.go

@@ -11,6 +11,7 @@ import (
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/hermeznetwork/hermez-node/batchbuilder"
 	"github.com/hermeznetwork/hermez-node/common"
+	"github.com/hermeznetwork/hermez-node/config"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
 	"github.com/hermeznetwork/hermez-node/eth"
@@ -85,6 +86,10 @@ type Config struct {
 	// SyncRetryInterval is the waiting interval between calls to the main
 	// handler of a synced block after an error
 	SyncRetryInterval time.Duration
+	// PurgeByExtDelInterval is the waiting interval between calls
+	// to the PurgeByExternalDelete function of the l2db which deletes
+	// pending txs externally marked by the column `external_delete`
+	PurgeByExtDelInterval time.Duration
 	// EthClientAttemptsDelay is delay between attempts do do an eth client
 	// RPC call
 	EthClientAttemptsDelay time.Duration
@@ -111,7 +116,10 @@ type Config struct {
 	Purger         PurgerCfg
 	// VerifierIdx is the index of the verifier contract registered in the
 	// smart contract
-	VerifierIdx       uint8
+	VerifierIdx uint8
+	// ForgeBatchGasCost contains the cost of each action in the
+	// ForgeBatch transaction.
+	ForgeBatchGasCost config.ForgeBatchGasCost
 	TxProcessorConfig txprocessor.Config
 }
 
@@ -136,8 +144,8 @@ type Coordinator struct {
 	pipelineNum       int       // Pipeline sequential number.  The first pipeline is 1
 	pipelineFromBatch fromBatch // batch from which we started the pipeline
 	provers           []prover.Client
-	consts            synchronizer.SCConsts
+	consts            common.SCConsts
-	vars              synchronizer.SCVariables
+	vars              common.SCVariables
 	stats             synchronizer.Stats
 	started           bool
 
@@ -153,6 +161,15 @@ type Coordinator struct {
 	wg     sync.WaitGroup
 	cancel context.CancelFunc
 
+	// mutexL2DBUpdateDelete protects updates to the L2DB so that
+	// these two processes always happen exclusively:
+	// - Pipeline taking pending txs, running through the TxProcessor and
+	//   marking selected txs as forging
+	// - Coordinator deleting pending txs that have been marked with
+	//   `external_delete`.
+	// Without this mutex, the coordinator could delete a pending txs that
+	// has just been selected by the TxProcessor in the pipeline.
+	mutexL2DBUpdateDelete sync.Mutex
 	pipeline              *Pipeline
 	lastNonFailedBatchNum common.BatchNum
 
@@ -168,8 +185,8 @@ func NewCoordinator(cfg Config,
 	batchBuilder *batchbuilder.BatchBuilder,
 	serverProofs []prover.Client,
 	ethClient eth.ClientInterface,
-	scConsts *synchronizer.SCConsts,
+	scConsts *common.SCConsts,
-	initSCVars *synchronizer.SCVariables,
+	initSCVars *common.SCVariables,
 ) (*Coordinator, error) {
 	// nolint reason: hardcoded `1.0`, by design the percentage can't be over 100%
 	if cfg.L1BatchTimeoutPerc >= 1.0 { //nolint:gomnd
@@ -248,7 +265,8 @@ func (c *Coordinator) BatchBuilder() *batchbuilder.BatchBuilder {
 func (c *Coordinator) newPipeline(ctx context.Context) (*Pipeline, error) {
 	c.pipelineNum++
 	return NewPipeline(ctx, c.cfg, c.pipelineNum, c.historyDB, c.l2DB, c.txSelector,
-		c.batchBuilder, c.purger, c, c.txManager, c.provers, &c.consts)
+		c.batchBuilder, &c.mutexL2DBUpdateDelete, c.purger, c, c.txManager,
+		c.provers, &c.consts)
 }
 
 // MsgSyncBlock indicates an update to the Synchronizer stats
@@ -257,13 +275,13 @@ type MsgSyncBlock struct {
 	Batches []common.BatchData
 	// Vars contains each Smart Contract variables if they are updated, or
 	// nil if they haven't changed.
-	Vars synchronizer.SCVariablesPtr
+	Vars common.SCVariablesPtr
 }
 
 // MsgSyncReorg indicates a reorg
 type MsgSyncReorg struct {
 	Stats synchronizer.Stats
-	Vars  synchronizer.SCVariablesPtr
+	Vars  common.SCVariablesPtr
 }
 
 // MsgStopPipeline indicates a signal to reset the pipeline
@@ -282,7 +300,7 @@ func (c *Coordinator) SendMsg(ctx context.Context, msg interface{}) {
 	}
 }
 
-func updateSCVars(vars *synchronizer.SCVariables, update synchronizer.SCVariablesPtr) {
+func updateSCVars(vars *common.SCVariables, update common.SCVariablesPtr) {
 	if update.Rollup != nil {
 		vars.Rollup = *update.Rollup
 	}
@@ -294,7 +312,7 @@ func updateSCVars(vars *synchronizer.SCVariables, update synchronizer.SCVariable
 	}
 }
 
-func (c *Coordinator) syncSCVars(vars synchronizer.SCVariablesPtr) {
+func (c *Coordinator) syncSCVars(vars common.SCVariablesPtr) {
 	updateSCVars(&c.vars, vars)
 }
 
@@ -369,11 +387,23 @@ func (c *Coordinator) syncStats(ctx context.Context, stats *synchronizer.Stats)
 				fromBatch.ForgerAddr = c.cfg.ForgerAddress
 				fromBatch.StateRoot = big.NewInt(0)
 			}
+			// Before starting the pipeline make sure we reset any
+			// l2tx from the pool that was forged in a batch that
+			// didn't end up being mined.  We are already doing
+			// this in handleStopPipeline, but we do it again as a
+			// failsafe in case the last synced batchnum is
+			// different than in the previous call to l2DB.Reorg,
+			// or in case the node was restarted when there was a
+			// started batch that included l2txs but was not mined.
+			if err := c.l2DB.Reorg(fromBatch.BatchNum); err != nil {
+				return tracerr.Wrap(err)
+			}
 			var err error
 			if c.pipeline, err = c.newPipeline(ctx); err != nil {
 				return tracerr.Wrap(err)
 			}
 			c.pipelineFromBatch = fromBatch
+			// Start the pipeline
 			if err := c.pipeline.Start(fromBatch.BatchNum, stats, &c.vars); err != nil {
 				c.pipeline = nil
 				return tracerr.Wrap(err)
@@ -494,7 +524,7 @@ func (c *Coordinator) Start() {
 
 	c.wg.Add(1)
 	go func() {
-		waitCh := time.After(longWaitDuration)
+		timer := time.NewTimer(longWaitDuration)
 		for {
 			select {
 			case <-c.ctx.Done():
@@ -506,24 +536,45 @@ func (c *Coordinator) Start() {
 					continue
 				} else if err != nil {
 					log.Errorw("Coordinator.handleMsg", "err", err)
-					waitCh = time.After(c.cfg.SyncRetryInterval)
+					if !timer.Stop() {
+						<-timer.C
+					}
+					timer.Reset(c.cfg.SyncRetryInterval)
 					continue
 				}
-				waitCh = time.After(longWaitDuration)
+			case <-timer.C:
-			case <-waitCh:
+				timer.Reset(longWaitDuration)
 				if !c.stats.Synced() {
-					waitCh = time.After(longWaitDuration)
 					continue
 				}
 				if err := c.syncStats(c.ctx, &c.stats); c.ctx.Err() != nil {
-					waitCh = time.After(longWaitDuration)
 					continue
 				} else if err != nil {
 					log.Errorw("Coordinator.syncStats", "err", err)
-					waitCh = time.After(c.cfg.SyncRetryInterval)
+					if !timer.Stop() {
+						<-timer.C
+					}
+					timer.Reset(c.cfg.SyncRetryInterval)
 					continue
 				}
-				waitCh = time.After(longWaitDuration)
+			}
+		}
+	}()
+
+	c.wg.Add(1)
+	go func() {
+		for {
+			select {
+			case <-c.ctx.Done():
+				log.Info("Coordinator L2DB.PurgeByExternalDelete loop done")
+				c.wg.Done()
+				return
+			case <-time.After(c.cfg.PurgeByExtDelInterval):
+				c.mutexL2DBUpdateDelete.Lock()
+				if err := c.l2DB.PurgeByExternalDelete(); err != nil {
+					log.Errorw("L2DB.PurgeByExternalDelete", "err", err)
+				}
+				c.mutexL2DBUpdateDelete.Unlock()
 			}
 		}
 	}()

coordinator/coordinator_test.go

@@ -105,8 +105,8 @@ func newTestModules(t *testing.T) modules {
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	test.WipeDB(db)
-	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
-	historyDB := historydb.NewHistoryDB(db, nil)
+	historyDB := historydb.NewHistoryDB(db, db, nil)
 
 	txSelDBPath, err = ioutil.TempDir("", "tmpTxSelDB")
 	require.NoError(t, err)
@@ -187,12 +187,12 @@ func newTestCoordinator(t *testing.T, forgerAddr ethCommon.Address, ethClient *t
 		&prover.MockClient{Delay: 400 * time.Millisecond},
 	}
 
-	scConsts := &synchronizer.SCConsts{
+	scConsts := &common.SCConsts{
 		Rollup:   *ethClientSetup.RollupConstants,
 		Auction:  *ethClientSetup.AuctionConstants,
 		WDelayer: *ethClientSetup.WDelayerConstants,
 	}
-	initSCVars := &synchronizer.SCVariables{
+	initSCVars := &common.SCVariables{
 		Rollup:   *ethClientSetup.RollupVariables,
 		Auction:  *ethClientSetup.AuctionVariables,
 		WDelayer: *ethClientSetup.WDelayerVariables,
@@ -517,7 +517,7 @@ func TestCoordinatorStress(t *testing.T) {
 	wg.Add(1)
 	go func() {
 		for {
-			blockData, _, err := syn.Sync2(ctx, nil)
+			blockData, _, err := syn.Sync(ctx, nil)
 			if ctx.Err() != nil {
 				wg.Done()
 				return
@@ -528,7 +528,7 @@ func TestCoordinatorStress(t *testing.T) {
 				coord.SendMsg(ctx, MsgSyncBlock{
 					Stats:   *stats,
 					Batches: blockData.Rollup.Batches,
-					Vars: synchronizer.SCVariablesPtr{
+					Vars: common.SCVariablesPtr{
 						Rollup:   blockData.Rollup.Vars,
 						Auction:  blockData.Auction.Vars,
 						WDelayer: blockData.WDelayer.Vars,

coordinator/pipeline.go

@@ -22,7 +22,7 @@ import (
 
 type statsVars struct {
 	Stats synchronizer.Stats
-	Vars  synchronizer.SCVariablesPtr
+	Vars  common.SCVariablesPtr
 }
 
 type state struct {
@@ -36,7 +36,7 @@ type state struct {
 type Pipeline struct {
 	num    int
 	cfg    Config
-	consts synchronizer.SCConsts
+	consts common.SCConsts
 
 	// state
 	state         state
@@ -45,18 +45,19 @@ type Pipeline struct {
 	errAtBatchNum common.BatchNum
 	lastForgeTime time.Time
 
-	proversPool  *ProversPool
+	proversPool           *ProversPool
-	provers      []prover.Client
+	provers               []prover.Client
-	coord        *Coordinator
+	coord                 *Coordinator
-	txManager    *TxManager
+	txManager             *TxManager
-	historyDB    *historydb.HistoryDB
+	historyDB             *historydb.HistoryDB
-	l2DB         *l2db.L2DB
+	l2DB                  *l2db.L2DB
-	txSelector   *txselector.TxSelector
+	txSelector            *txselector.TxSelector
-	batchBuilder *batchbuilder.BatchBuilder
+	batchBuilder          *batchbuilder.BatchBuilder
-	purger       *Purger
+	mutexL2DBUpdateDelete *sync.Mutex
+	purger                *Purger
 
 	stats       synchronizer.Stats
-	vars        synchronizer.SCVariables
+	vars        common.SCVariables
 	statsVarsCh chan statsVars
 
 	ctx    context.Context
@@ -84,11 +85,12 @@ func NewPipeline(ctx context.Context,
 	l2DB *l2db.L2DB,
 	txSelector *txselector.TxSelector,
 	batchBuilder *batchbuilder.BatchBuilder,
+	mutexL2DBUpdateDelete *sync.Mutex,
 	purger *Purger,
 	coord *Coordinator,
 	txManager *TxManager,
 	provers []prover.Client,
-	scConsts *synchronizer.SCConsts,
+	scConsts *common.SCConsts,
 ) (*Pipeline, error) {
 	proversPool := NewProversPool(len(provers))
 	proversPoolSize := 0
@@ -104,24 +106,25 @@ func NewPipeline(ctx context.Context,
 		return nil, tracerr.Wrap(fmt.Errorf("no provers in the pool"))
 	}
 	return &Pipeline{
-		num:          num,
+		num:                   num,
-		cfg:          cfg,
+		cfg:                   cfg,
-		historyDB:    historyDB,
+		historyDB:             historyDB,
-		l2DB:         l2DB,
+		l2DB:                  l2DB,
-		txSelector:   txSelector,
+		txSelector:            txSelector,
-		batchBuilder: batchBuilder,
+		batchBuilder:          batchBuilder,
-		provers:      provers,
+		provers:               provers,
-		proversPool:  proversPool,
+		proversPool:           proversPool,
-		purger:       purger,
+		mutexL2DBUpdateDelete: mutexL2DBUpdateDelete,
-		coord:        coord,
+		purger:                purger,
-		txManager:    txManager,
+		coord:                 coord,
-		consts:       *scConsts,
+		txManager:             txManager,
-		statsVarsCh:  make(chan statsVars, queueLen),
+		consts:                *scConsts,
+		statsVarsCh:           make(chan statsVars, queueLen),
 	}, nil
 }
 
 // SetSyncStatsVars is a thread safe method to sets the synchronizer Stats
-func (p *Pipeline) SetSyncStatsVars(ctx context.Context, stats *synchronizer.Stats, vars *synchronizer.SCVariablesPtr) {
+func (p *Pipeline) SetSyncStatsVars(ctx context.Context, stats *synchronizer.Stats, vars *common.SCVariablesPtr) {
 	select {
 	case p.statsVarsCh <- statsVars{Stats: *stats, Vars: *vars}:
 	case <-ctx.Done():
@@ -130,7 +133,7 @@ func (p *Pipeline) SetSyncStatsVars(ctx context.Context, stats *synchronizer.Sta
 
 // reset pipeline state
 func (p *Pipeline) reset(batchNum common.BatchNum,
-	stats *synchronizer.Stats, vars *synchronizer.SCVariables) error {
+	stats *synchronizer.Stats, vars *common.SCVariables) error {
 	p.state = state{
 		batchNum:                     batchNum,
 		lastForgeL1TxsNum:            stats.Sync.LastForgeL1TxsNum,
@@ -191,15 +194,38 @@ func (p *Pipeline) reset(batchNum common.BatchNum,
 	return nil
 }
 
-func (p *Pipeline) syncSCVars(vars synchronizer.SCVariablesPtr) {
+func (p *Pipeline) syncSCVars(vars common.SCVariablesPtr) {
 	updateSCVars(&p.vars, vars)
 }
 
-// handleForgeBatch calls p.forgeBatch to forge the batch and get the zkInputs,
+// handleForgeBatch waits for an available proof server, calls p.forgeBatch to
-// and then waits for an available proof server and sends the zkInputs to it so
+// forge the batch and get the zkInputs, and then  sends the zkInputs to the
-// that the proof computation begins.
+// selected proof server so that the proof computation begins.
-func (p *Pipeline) handleForgeBatch(ctx context.Context, batchNum common.BatchNum) (*BatchInfo, error) {
+func (p *Pipeline) handleForgeBatch(ctx context.Context,
-	batchInfo, err := p.forgeBatch(batchNum)
+	batchNum common.BatchNum) (batchInfo *BatchInfo, err error) {
+	// 1. Wait for an available serverProof (blocking call)
+	serverProof, err := p.proversPool.Get(ctx)
+	if ctx.Err() != nil {
+		return nil, ctx.Err()
+	} else if err != nil {
+		log.Errorw("proversPool.Get", "err", err)
+		return nil, err
+	}
+	defer func() {
+		// If we encounter any error (notice that this function returns
+		// errors to notify that a batch is not forged not only because
+		// of unexpected errors but also due to benign causes), add the
+		// serverProof back to the pool
+		if err != nil {
+			p.proversPool.Add(ctx, serverProof)
+		}
+	}()
+
+	// 2. Forge the batch internally (make a selection of txs and prepare
+	// all the smart contract arguments)
+	p.mutexL2DBUpdateDelete.Lock()
+	batchInfo, err = p.forgeBatch(batchNum)
+	p.mutexL2DBUpdateDelete.Unlock()
 	if ctx.Err() != nil {
 		return nil, ctx.Err()
 	} else if err != nil {
@@ -215,21 +241,13 @@ func (p *Pipeline) handleForgeBatch(ctx context.Context, batchNum common.BatchNu
 		}
 		return nil, err
 	}
-	// 6. Wait for an available server proof (blocking call)
+
-	serverProof, err := p.proversPool.Get(ctx)
+	// 3. Send the ZKInputs to the proof server
-	if ctx.Err() != nil {
-		return nil, ctx.Err()
-	} else if err != nil {
-		log.Errorw("proversPool.Get", "err", err)
-		return nil, err
-	}
 	batchInfo.ServerProof = serverProof
 	if err := p.sendServerProof(ctx, batchInfo); ctx.Err() != nil {
 		return nil, ctx.Err()
 	} else if err != nil {
 		log.Errorw("sendServerProof", "err", err)
-		batchInfo.ServerProof = nil
-		p.proversPool.Add(ctx, serverProof)
 		return nil, err
 	}
 	return batchInfo, nil
@@ -237,7 +255,7 @@ func (p *Pipeline) handleForgeBatch(ctx context.Context, batchNum common.BatchNu
 
 // Start the forging pipeline
 func (p *Pipeline) Start(batchNum common.BatchNum,
-	stats *synchronizer.Stats, vars *synchronizer.SCVariables) error {
+	stats *synchronizer.Stats, vars *common.SCVariables) error {
 	if p.started {
 		log.Fatal("Pipeline already started")
 	}
@@ -253,7 +271,7 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 
 	p.wg.Add(1)
 	go func() {
-		waitCh := time.After(zeroDuration)
+		timer := time.NewTimer(zeroDuration)
 		for {
 			select {
 			case <-p.ctx.Done():
@@ -263,23 +281,21 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 			case statsVars := <-p.statsVarsCh:
 				p.stats = statsVars.Stats
 				p.syncSCVars(statsVars.Vars)
-			case <-waitCh:
+			case <-timer.C:
+				timer.Reset(p.cfg.ForgeRetryInterval)
 				// Once errAtBatchNum != 0, we stop forging
 				// batches because there's been an error and we
 				// wait for the pipeline to be stopped.
 				if p.getErrAtBatchNum() != 0 {
-					waitCh = time.After(p.cfg.ForgeRetryInterval)
 					continue
 				}
 				batchNum = p.state.batchNum + 1
 				batchInfo, err := p.handleForgeBatch(p.ctx, batchNum)
 				if p.ctx.Err() != nil {
-					waitCh = time.After(p.cfg.ForgeRetryInterval)
 					continue
 				} else if tracerr.Unwrap(err) == errLastL1BatchNotSynced ||
 					tracerr.Unwrap(err) == errForgeNoTxsBeforeDelay ||
 					tracerr.Unwrap(err) == errForgeBeforeDelay {
-					waitCh = time.After(p.cfg.ForgeRetryInterval)
 					continue
 				} else if err != nil {
 					p.setErrAtBatchNum(batchNum)
@@ -288,7 +304,6 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 							"Pipeline.handleForgBatch: %v", err),
 						FailedBatchNum: batchNum,
 					})
-					waitCh = time.After(p.cfg.ForgeRetryInterval)
 					continue
 				}
 				p.lastForgeTime = time.Now()
@@ -298,7 +313,10 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 				case batchChSentServerProof <- batchInfo:
 				case <-p.ctx.Done():
 				}
-				waitCh = time.After(zeroDuration)
+				if !timer.Stop() {
+					<-timer.C
+				}
+				timer.Reset(zeroDuration)
 			}
 		}
 	}()
@@ -333,7 +351,6 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 				}
 				// We are done with this serverProof, add it back to the pool
 				p.proversPool.Add(p.ctx, batchInfo.ServerProof)
-				// batchInfo.ServerProof = nil
 				p.txManager.AddBatch(p.ctx, batchInfo)
 			}
 		}

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.Sync2(ctx, nil)
+		syncBlock, discards, err := sync.Sync(ctx, nil)
 		require.NoError(t, err)
 		require.Nil(t, discards)
 		if syncBlock == nil {
@@ -206,11 +206,7 @@ PoolTransfer(0) User2-User3: 300 (126)
 		require.NoError(t, err)
 	}
 
-	err = pipeline.reset(batchNum, syncStats, &synchronizer.SCVariables{
+	err = pipeline.reset(batchNum, syncStats, syncSCVars)
-		Rollup:   *syncSCVars.Rollup,
-		Auction:  *syncSCVars.Auction,
-		WDelayer: *syncSCVars.WDelayer,
-	})
 	require.NoError(t, err)
 	// Sanity check
 	sdbAccounts, err := pipeline.txSelector.LocalAccountsDB().TestGetAccounts()

coordinator/purger_test.go

@@ -21,7 +21,7 @@ func newL2DB(t *testing.T) *l2db.L2DB {
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	test.WipeDB(db)
-	return l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
+	return l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
 }
 
 func newStateDB(t *testing.T) *statedb.LocalStateDB {

coordinator/txmanager.go

@@ -2,9 +2,9 @@ package coordinator
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"math/big"
+	"strings"
 	"time"
 
 	"github.com/ethereum/go-ethereum"
@@ -31,10 +31,10 @@ type TxManager struct {
 	batchCh   chan *BatchInfo
 	chainID   *big.Int
 	account   accounts.Account
-	consts    synchronizer.SCConsts
+	consts    common.SCConsts
 
 	stats       synchronizer.Stats
-	vars        synchronizer.SCVariables
+	vars        common.SCVariables
 	statsVarsCh chan statsVars
 
 	discardPipelineCh chan int // int refers to the pipelineNum
@@ -55,7 +55,7 @@ type TxManager struct {
 
 // NewTxManager creates a new TxManager
 func NewTxManager(ctx context.Context, cfg *Config, ethClient eth.ClientInterface, l2DB *l2db.L2DB,
-	coord *Coordinator, scConsts *synchronizer.SCConsts, initSCVars *synchronizer.SCVariables) (*TxManager, error) {
+	coord *Coordinator, scConsts *common.SCConsts, initSCVars *common.SCVariables) (*TxManager, error) {
 	chainID, err := ethClient.EthChainID()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -102,7 +102,7 @@ func (t *TxManager) AddBatch(ctx context.Context, batchInfo *BatchInfo) {
 }
 
 // SetSyncStatsVars is a thread safe method to sets the synchronizer Stats
-func (t *TxManager) SetSyncStatsVars(ctx context.Context, stats *synchronizer.Stats, vars *synchronizer.SCVariablesPtr) {
+func (t *TxManager) SetSyncStatsVars(ctx context.Context, stats *synchronizer.Stats, vars *common.SCVariablesPtr) {
 	select {
 	case t.statsVarsCh <- statsVars{Stats: *stats, Vars: *vars}:
 	case <-ctx.Done():
@@ -118,12 +118,12 @@ func (t *TxManager) DiscardPipeline(ctx context.Context, pipelineNum int) {
 	}
 }
 
-func (t *TxManager) syncSCVars(vars synchronizer.SCVariablesPtr) {
+func (t *TxManager) syncSCVars(vars common.SCVariablesPtr) {
 	updateSCVars(&t.vars, vars)
 }
 
 // NewAuth generates a new auth object for an ethereum transaction
-func (t *TxManager) NewAuth(ctx context.Context) (*bind.TransactOpts, error) {
+func (t *TxManager) NewAuth(ctx context.Context, batchInfo *BatchInfo) (*bind.TransactOpts, error) {
 	gasPrice, err := t.ethClient.EthSuggestGasPrice(ctx)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -143,15 +143,12 @@ func (t *TxManager) NewAuth(ctx context.Context) (*bind.TransactOpts, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	auth.Value = big.NewInt(0) // in wei
-	// TODO: Calculate GasLimit based on the contents of the ForgeBatchArgs
+
-	// This requires a function that estimates the gas usage of the
+	gasLimit := t.cfg.ForgeBatchGasCost.Fixed +
-	// forgeBatch call based on the contents of the ForgeBatch args:
+		uint64(len(batchInfo.L1UserTxsExtra))*t.cfg.ForgeBatchGasCost.L1UserTx +
-	// - length of l2txs
+		uint64(len(batchInfo.L1CoordTxs))*t.cfg.ForgeBatchGasCost.L1CoordTx +
-	// - length of l1Usertxs
+		uint64(len(batchInfo.L2Txs))*t.cfg.ForgeBatchGasCost.L2Tx
-	// - length of l1CoordTxs with authorization signature
+	auth.GasLimit = gasLimit
-	// - length of l1CoordTxs without authoriation signature
-	// - etc.
-	auth.GasLimit = 1000000
 	auth.GasPrice = gasPrice
 	auth.Nonce = nil
 
@@ -191,7 +188,7 @@ func addPerc(v *big.Int, p int64) *big.Int {
 func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchInfo, resend bool) error {
 	var ethTx *types.Transaction
 	var err error
-	auth, err := t.NewAuth(ctx)
+	auth, err := t.NewAuth(ctx, batchInfo)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -206,32 +203,35 @@ func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchIn
 		}
 		// RollupForgeBatch() calls ethclient.SendTransaction()
 		ethTx, err = t.ethClient.RollupForgeBatch(batchInfo.ForgeBatchArgs, auth)
-		if errors.Is(err, core.ErrNonceTooLow) {
+		// We check the errors via strings because we match the
+		// definition of the error from geth, with the string returned
+		// via RPC obtained by the client.
+		if err == nil {
+			break
+		} else if strings.Contains(err.Error(), core.ErrNonceTooLow.Error()) {
 			log.Warnw("TxManager ethClient.RollupForgeBatch incrementing nonce",
 				"err", err, "nonce", auth.Nonce, "batchNum", batchInfo.BatchNum)
 			auth.Nonce.Add(auth.Nonce, big.NewInt(1))
 			attempt--
-		} else if errors.Is(err, core.ErrNonceTooHigh) {
+		} else if strings.Contains(err.Error(), core.ErrNonceTooHigh.Error()) {
 			log.Warnw("TxManager ethClient.RollupForgeBatch decrementing nonce",
 				"err", err, "nonce", auth.Nonce, "batchNum", batchInfo.BatchNum)
 			auth.Nonce.Sub(auth.Nonce, big.NewInt(1))
 			attempt--
-		} else if errors.Is(err, core.ErrUnderpriced) {
+		} else if strings.Contains(err.Error(), core.ErrReplaceUnderpriced.Error()) {
 			log.Warnw("TxManager ethClient.RollupForgeBatch incrementing gasPrice",
 				"err", err, "gasPrice", auth.GasPrice, "batchNum", batchInfo.BatchNum)
 			auth.GasPrice = addPerc(auth.GasPrice, 10)
 			attempt--
-		} else if errors.Is(err, core.ErrReplaceUnderpriced) {
+		} else if strings.Contains(err.Error(), core.ErrUnderpriced.Error()) {
 			log.Warnw("TxManager ethClient.RollupForgeBatch incrementing gasPrice",
 				"err", err, "gasPrice", auth.GasPrice, "batchNum", batchInfo.BatchNum)
 			auth.GasPrice = addPerc(auth.GasPrice, 10)
 			attempt--
-		} else if err != nil {
+		} else {
 			log.Errorw("TxManager ethClient.RollupForgeBatch",
 				"attempt", attempt, "err", err, "block", t.stats.Eth.LastBlock.Num+1,
 				"batchNum", batchInfo.BatchNum)
-		} else {
-			break
 		}
 		select {
 		case <-ctx.Done():
@@ -416,8 +416,6 @@ func (q *Queue) Push(batchInfo *BatchInfo) {
 
 // Run the TxManager
 func (t *TxManager) Run(ctx context.Context) {
-	waitCh := time.After(longWaitDuration)
-
 	var statsVars statsVars
 	select {
 	case statsVars = <-t.statsVarsCh:
@@ -428,6 +426,7 @@ func (t *TxManager) Run(ctx context.Context) {
 	log.Infow("TxManager: received initial statsVars",
 		"block", t.stats.Eth.LastBlock.Num, "batch", t.stats.Eth.LastBatchNum)
 
+	timer := time.NewTimer(longWaitDuration)
 	for {
 		select {
 		case <-ctx.Done():
@@ -471,13 +470,17 @@ func (t *TxManager) Run(ctx context.Context) {
 				continue
 			}
 			t.queue.Push(batchInfo)
-			waitCh = time.After(t.cfg.TxManagerCheckInterval)
+			if !timer.Stop() {
-		case <-waitCh:
+				<-timer.C
+			}
+			timer.Reset(t.cfg.TxManagerCheckInterval)
+		case <-timer.C:
 			queuePosition, batchInfo := t.queue.Next()
 			if batchInfo == nil {
-				waitCh = time.After(longWaitDuration)
+				timer.Reset(longWaitDuration)
 				continue
 			}
+			timer.Reset(t.cfg.TxManagerCheckInterval)
 			if err := t.checkEthTransactionReceipt(ctx, batchInfo); ctx.Err() != nil {
 				continue
 			} else if err != nil { //nolint:staticcheck

db/historydb/apiqueries.go

@@ -1,8 +1,11 @@
 package historydb
 
 import (
+	"database/sql"
 	"errors"
 	"fmt"
+	"math/big"
+	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/hermeznetwork/hermez-node/common"
@@ -32,9 +35,18 @@ func (hdb *HistoryDB) GetBatchAPI(batchNum common.BatchNum) (*BatchAPI, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	defer hdb.apiConnCon.Release()
+	return hdb.getBatchAPI(hdb.dbRead, batchNum)
+}
+
+// GetBatchInternalAPI 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(
-		hdb.db, batch,
+		d, 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,
@@ -133,10 +145,10 @@ func (hdb *HistoryDB) GetBatchesAPI(
 		queryStr += " DESC "
 	}
 	queryStr += fmt.Sprintf("LIMIT %d;", *limit)
-	query = hdb.db.Rebind(queryStr)
+	query = hdb.dbRead.Rebind(queryStr)
 	// log.Debug(query)
 	batchPtrs := []*BatchAPI{}
-	if err := meddler.QueryAll(hdb.db, &batchPtrs, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.dbRead, &batchPtrs, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	batches := db.SlicePtrsToSlice(batchPtrs).([]BatchAPI)
@@ -156,7 +168,7 @@ func (hdb *HistoryDB) GetBestBidAPI(slotNum *int64) (BidAPI, error) {
 	}
 	defer hdb.apiConnCon.Release()
 	err = meddler.QueryRow(
-		hdb.db, bid, `SELECT bid.*, block.timestamp, coordinator.forger_addr, coordinator.url 
+		hdb.dbRead, bid, `SELECT bid.*, block.timestamp, coordinator.forger_addr, coordinator.url 
 		FROM bid INNER JOIN block ON bid.eth_block_num = block.eth_block_num
 		INNER JOIN (
 			SELECT bidder_addr, MAX(item_id) AS item_id FROM coordinator
@@ -180,6 +192,14 @@ 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
@@ -212,9 +232,9 @@ func (hdb *HistoryDB) GetBestBidsAPI(
 	if limit != nil {
 		queryStr += fmt.Sprintf("LIMIT %d;", *limit)
 	}
-	query = hdb.db.Rebind(queryStr)
+	query = hdb.dbRead.Rebind(queryStr)
 	bidPtrs := []*BidAPI{}
-	if err := meddler.QueryAll(hdb.db, &bidPtrs, query, args...); err != nil {
+	if err := meddler.QueryAll(d, &bidPtrs, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	// log.Debug(query)
@@ -296,9 +316,9 @@ func (hdb *HistoryDB) GetBidsAPI(
 	if err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
-	query = hdb.db.Rebind(query)
+	query = hdb.dbRead.Rebind(query)
 	bids := []*BidAPI{}
-	if err := meddler.QueryAll(hdb.db, &bids, query, argsQ...); err != nil {
+	if err := meddler.QueryAll(hdb.dbRead, &bids, query, argsQ...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(bids) == 0 {
@@ -384,9 +404,9 @@ func (hdb *HistoryDB) GetTokensAPI(
 	if err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
-	query = hdb.db.Rebind(query)
+	query = hdb.dbRead.Rebind(query)
 	tokens := []*TokenWithUSD{}
-	if err := meddler.QueryAll(hdb.db, &tokens, query, argsQ...); err != nil {
+	if err := meddler.QueryAll(hdb.dbRead, &tokens, query, argsQ...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(tokens) == 0 {
@@ -408,7 +428,7 @@ func (hdb *HistoryDB) GetTxAPI(txID common.TxID) (*TxAPI, error) {
 	defer hdb.apiConnCon.Release()
 	tx := &TxAPI{}
 	err = meddler.QueryRow(
-		hdb.db, tx, `SELECT tx.item_id, tx.is_l1, tx.id, tx.type, tx.position, 
+		hdb.dbRead, tx, `SELECT tx.item_id, tx.is_l1, tx.id, tx.type, tx.position, 
 		hez_idx(tx.effective_from_idx, token.symbol) AS from_idx, tx.from_eth_addr, tx.from_bjj,
 		hez_idx(tx.to_idx, token.symbol) AS to_idx, tx.to_eth_addr, tx.to_bjj,
 		tx.amount, tx.amount_success, tx.token_id, tx.amount_usd, 
@@ -541,10 +561,10 @@ func (hdb *HistoryDB) GetTxsAPI(
 		queryStr += " DESC "
 	}
 	queryStr += fmt.Sprintf("LIMIT %d;", *limit)
-	query = hdb.db.Rebind(queryStr)
+	query = hdb.dbRead.Rebind(queryStr)
 	// log.Debug(query)
 	txsPtrs := []*TxAPI{}
-	if err := meddler.QueryAll(hdb.db, &txsPtrs, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.dbRead, &txsPtrs, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	txs := db.SlicePtrsToSlice(txsPtrs).([]TxAPI)
@@ -564,7 +584,7 @@ func (hdb *HistoryDB) GetExitAPI(batchNum *uint, idx *common.Idx) (*ExitAPI, err
 	defer hdb.apiConnCon.Release()
 	exit := &ExitAPI{}
 	err = meddler.QueryRow(
-		hdb.db, exit, `SELECT exit_tree.item_id, exit_tree.batch_num,
+		hdb.dbRead, exit, `SELECT exit_tree.item_id, exit_tree.batch_num,
 		hez_idx(exit_tree.account_idx, token.symbol) AS account_idx,
 		account.bjj, account.eth_addr,
 		exit_tree.merkle_proof, exit_tree.balance, exit_tree.instant_withdrawn,
@@ -685,10 +705,10 @@ func (hdb *HistoryDB) GetExitsAPI(
 		queryStr += " DESC "
 	}
 	queryStr += fmt.Sprintf("LIMIT %d;", *limit)
-	query = hdb.db.Rebind(queryStr)
+	query = hdb.dbRead.Rebind(queryStr)
 	// log.Debug(query)
 	exits := []*ExitAPI{}
-	if err := meddler.QueryAll(hdb.db, &exits, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.dbRead, &exits, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(exits) == 0 {
@@ -697,25 +717,6 @@ 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.db, &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,
@@ -772,10 +773,10 @@ func (hdb *HistoryDB) GetCoordinatorsAPI(
 		queryStr += " DESC "
 	}
 	queryStr += fmt.Sprintf("LIMIT %d;", *limit)
-	query = hdb.db.Rebind(queryStr)
+	query = hdb.dbRead.Rebind(queryStr)
 
 	coordinators := []*CoordinatorAPI{}
-	if err := meddler.QueryAll(hdb.db, &coordinators, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.dbRead, &coordinators, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(coordinators) == 0 {
@@ -795,34 +796,11 @@ func (hdb *HistoryDB) GetAuctionVarsAPI() (*common.AuctionVariables, error) {
 	defer hdb.apiConnCon.Release()
 	auctionVars := &common.AuctionVariables{}
 	err = meddler.QueryRow(
-		hdb.db, auctionVars, `SELECT * FROM auction_vars;`,
+		hdb.dbRead, auctionVars, `SELECT * FROM auction_vars;`,
 	)
 	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.db, &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()
@@ -832,11 +810,19 @@ func (hdb *HistoryDB) GetAccountAPI(idx common.Idx) (*AccountAPI, error) {
 	}
 	defer hdb.apiConnCon.Release()
 	account := &AccountAPI{}
-	err = meddler.QueryRow(hdb.db, account, `SELECT account.item_id, hez_idx(account.idx, 
+	err = meddler.QueryRow(hdb.dbRead, account, `SELECT account.item_id, hez_idx(account.idx, 
-	token.symbol) as idx, account.batch_num, account.bjj, account.eth_addr,
+		token.symbol) as idx, account.batch_num, account.bjj, account.eth_addr,
-	token.token_id, token.item_id AS token_item_id, token.eth_block_num AS token_block,
+		token.token_id, token.item_id AS token_item_id, token.eth_block_num AS token_block,
-	token.eth_addr as token_eth_addr, token.name, token.symbol, token.decimals, token.usd, token.usd_update 
+		token.eth_addr as token_eth_addr, token.name, token.symbol, token.decimals, token.usd,
-	FROM account INNER JOIN token ON account.token_id = token.token_id WHERE idx = $1;`, idx)
+		token.usd_update, account_update.nonce, account_update.balance 
+		FROM account inner JOIN (
+			SELECT idx, nonce, balance 
+			FROM account_update
+			WHERE idx = $1
+			ORDER BY item_id DESC LIMIT 1
+		) AS account_update ON account_update.idx = account.idx 
+		INNER JOIN token ON account.token_id = token.token_id
+		WHERE account.idx = $1;`, idx)
 
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -864,8 +850,13 @@ func (hdb *HistoryDB) GetAccountsAPI(
 	queryStr := `SELECT account.item_id, hez_idx(account.idx, token.symbol) as idx, account.batch_num, 
 	account.bjj, account.eth_addr, token.token_id, token.item_id AS token_item_id, token.eth_block_num AS token_block,
 	token.eth_addr as token_eth_addr, token.name, token.symbol, token.decimals, token.usd, token.usd_update, 
-	COUNT(*) OVER() AS total_items
+	account_update.nonce, account_update.balance, COUNT(*) OVER() AS total_items
-	FROM account INNER JOIN token ON account.token_id = token.token_id `
+	FROM account inner JOIN (
+		SELECT DISTINCT idx,
+		first_value(nonce) over(partition by idx ORDER BY item_id DESC) as nonce,
+		first_value(balance) over(partition by idx ORDER BY item_id DESC) as balance
+		FROM account_update
+	) AS account_update ON account_update.idx = account.idx INNER JOIN token ON account.token_id = token.token_id `
 	// Apply filters
 	nextIsAnd := false
 	// ethAddr filter
@@ -914,10 +905,10 @@ func (hdb *HistoryDB) GetAccountsAPI(
 	if err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
-	query = hdb.db.Rebind(query)
+	query = hdb.dbRead.Rebind(query)
 
 	accounts := []*AccountAPI{}
-	if err := meddler.QueryAll(hdb.db, &accounts, query, argsQ...); err != nil {
+	if err := meddler.QueryAll(hdb.dbRead, &accounts, query, argsQ...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(accounts) == 0 {
@@ -928,99 +919,267 @@ func (hdb *HistoryDB) GetAccountsAPI(
 		accounts[0].TotalItems - uint64(len(accounts)), nil
 }
 
-// GetMetricsAPI returns metrics
+// GetCommonAccountAPI returns the account associated to an account idx
-func (hdb *HistoryDB) GetMetricsAPI(lastBatchNum common.BatchNum) (*Metrics, error) {
+func (hdb *HistoryDB) GetCommonAccountAPI(idx common.Idx) (*common.Account, error) {
 	cancel, err := hdb.apiConnCon.Acquire()
 	defer cancel()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
 	defer hdb.apiConnCon.Release()
-	metricsTotals := &MetricsTotals{}
+	account := &common.Account{}
-	metrics := &Metrics{}
 	err = meddler.QueryRow(
-		hdb.db, metricsTotals, `SELECT COUNT(tx.*) as total_txs,
+		hdb.dbRead, account, `SELECT * FROM account WHERE idx = $1;`, idx,
-		COALESCE (MIN(tx.batch_num), 0) as batch_num, COALESCE (MIN(block.timestamp), 
+	)
-		NOW()) AS min_timestamp, COALESCE (MAX(block.timestamp), NOW()) AS max_timestamp
+	return account, tracerr.Wrap(err)
-		FROM tx INNER JOIN block ON tx.eth_block_num = block.eth_block_num
+}
-		WHERE block.timestamp >= NOW() - INTERVAL '24 HOURS';`)
+
+// 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)
+}
 
-	seconds := metricsTotals.MaxTimestamp.Sub(metricsTotals.MinTimestamp).Seconds()
+func (hdb *HistoryDB) getCoordinatorAPI(d meddler.DB, bidderAddr ethCommon.Address) (*CoordinatorAPI, error) {
-	// Avoid dividing by 0
+	coordinator := &CoordinatorAPI{}
-	if seconds == 0 {
+	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)
+}
+
+// GetNodeInfoAPI retusnt he NodeInfo
+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()
+}
+
+// GetBucketUpdatesInternalAPI returns the latest bucket updates
+func (hdb *HistoryDB) GetBucketUpdatesInternalAPI() ([]BucketUpdateAPI, error) {
+	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)
+}
+
+// GetNextForgersInternalAPI 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
+}
+
+// GetMetricsInternalAPI returns the MetricsAPI
+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
-	metrics.TransactionsPerSecond = float64(metricsTotals.TotalTransactions) / seconds
+	// Set txs/batch
-
+	nBatches := p.ToBatchNum - p.FromBatchNum + 1
-	if (lastBatchNum - metricsTotals.FirstBatchNum) > 0 {
+	if nBatches == 0 { // Avoid dividing by 0
-		metrics.TransactionsPerBatch = float64(metricsTotals.TotalTransactions) /
+		nBatches++
-			float64(lastBatchNum-metricsTotals.FirstBatchNum+1)
-	} else {
-		metrics.TransactionsPerBatch = float64(0)
 	}
-
+	if (p.ToBatchNum - p.FromBatchNum) > 0 {
-	err = meddler.QueryRow(
+		fmt.Printf("DBG ntxs: %v, nBatches: %v\n", nTxs, nBatches)
-		hdb.db, metricsTotals, `SELECT COUNT(*) AS total_batches, 
+		metrics.TransactionsPerBatch = float64(nTxs) /
-		COALESCE (SUM(total_fees_usd), 0) AS total_fees FROM batch 
+			float64(nBatches)
-		WHERE batch_num > $1;`, metricsTotals.FirstBatchNum)
+	} else {
-	if err != nil {
+		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)
 	}
-	if metricsTotals.TotalBatches > 0 {
+	// Set batch frequency
-		metrics.BatchFrequency = seconds / float64(metricsTotals.TotalBatches)
+	metrics.BatchFrequency = seconds / float64(nBatches)
-	} else {
+	if nTxs > 0 {
-		metrics.BatchFrequency = 0
+		metrics.AvgTransactionFee = totalFee / float64(nTxs)
-	}
-	if metricsTotals.TotalTransactions > 0 {
-		metrics.AvgTransactionFee = metricsTotals.TotalFeesUSD / float64(metricsTotals.TotalTransactions)
 	} else {
 		metrics.AvgTransactionFee = 0
 	}
-	err = meddler.QueryRow(
+	// Get and set amount of registered accounts
-		hdb.db, metrics,
+	type registeredAccounts struct {
-		`SELECT COUNT(*) AS total_bjjs, COUNT(DISTINCT(bjj)) AS total_accounts FROM account;`)
+		TotalIdx int64 `meddler:"total_idx"`
-	if err != nil {
+		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
-	return metrics, nil
+	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
 }
 
-// GetAvgTxFeeAPI returns average transaction fee of the last 1h
+// GetStateAPI returns the StateAPI
-func (hdb *HistoryDB) GetAvgTxFeeAPI() (float64, error) {
+func (hdb *HistoryDB) GetStateAPI() (*StateAPI, error) {
 	cancel, err := hdb.apiConnCon.Acquire()
 	defer cancel()
 	if err != nil {
-		return 0, tracerr.Wrap(err)
+		return nil, tracerr.Wrap(err)
 	}
 	defer hdb.apiConnCon.Release()
-	metricsTotals := &MetricsTotals{}
+	return hdb.getStateAPI(hdb.dbRead)
-	err = meddler.QueryRow(
-		hdb.db, 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.db, 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
 }

db/historydb/historydb.go

@@ -27,30 +27,35 @@ const (
 
 // HistoryDB persist the historic of the rollup
 type HistoryDB struct {
-	db         *sqlx.DB
+	dbRead     *sqlx.DB
+	dbWrite    *sqlx.DB
 	apiConnCon *db.APIConnectionController
 }
 
 // NewHistoryDB initialize the DB
-func NewHistoryDB(db *sqlx.DB, apiConnCon *db.APIConnectionController) *HistoryDB {
+func NewHistoryDB(dbRead, dbWrite *sqlx.DB, apiConnCon *db.APIConnectionController) *HistoryDB {
-	return &HistoryDB{db: db, apiConnCon: apiConnCon}
+	return &HistoryDB{
+		dbRead:     dbRead,
+		dbWrite:    dbWrite,
+		apiConnCon: apiConnCon,
+	}
 }
 
 // DB returns a pointer to the L2DB.db. This method should be used only for
 // internal testing purposes.
 func (hdb *HistoryDB) DB() *sqlx.DB {
-	return hdb.db
+	return hdb.dbWrite
 }
 
 // AddBlock insert a block into the DB
-func (hdb *HistoryDB) AddBlock(block *common.Block) error { return hdb.addBlock(hdb.db, block) }
+func (hdb *HistoryDB) AddBlock(block *common.Block) error { return hdb.addBlock(hdb.dbWrite, block) }
 func (hdb *HistoryDB) addBlock(d meddler.DB, block *common.Block) error {
 	return tracerr.Wrap(meddler.Insert(d, "block", block))
 }
 
 // AddBlocks inserts blocks into the DB
 func (hdb *HistoryDB) AddBlocks(blocks []common.Block) error {
-	return tracerr.Wrap(hdb.addBlocks(hdb.db, blocks))
+	return tracerr.Wrap(hdb.addBlocks(hdb.dbWrite, blocks))
 }
 
 func (hdb *HistoryDB) addBlocks(d meddler.DB, blocks []common.Block) error {
@@ -61,7 +66,7 @@ func (hdb *HistoryDB) addBlocks(d meddler.DB, blocks []common.Block) error {
 			timestamp,
 			hash
 		) VALUES %s;`,
-		blocks[:],
+		blocks,
 	))
 }
 
@@ -69,7 +74,7 @@ func (hdb *HistoryDB) addBlocks(d meddler.DB, blocks []common.Block) error {
 func (hdb *HistoryDB) GetBlock(blockNum int64) (*common.Block, error) {
 	block := &common.Block{}
 	err := meddler.QueryRow(
-		hdb.db, block,
+		hdb.dbRead, block,
 		"SELECT * FROM block WHERE eth_block_num = $1;", blockNum,
 	)
 	return block, tracerr.Wrap(err)
@@ -79,7 +84,7 @@ func (hdb *HistoryDB) GetBlock(blockNum int64) (*common.Block, error) {
 func (hdb *HistoryDB) GetAllBlocks() ([]common.Block, error) {
 	var blocks []*common.Block
 	err := meddler.QueryAll(
-		hdb.db, &blocks,
+		hdb.dbRead, &blocks,
 		"SELECT * FROM block ORDER BY eth_block_num;",
 	)
 	return db.SlicePtrsToSlice(blocks).([]common.Block), tracerr.Wrap(err)
@@ -89,7 +94,7 @@ func (hdb *HistoryDB) GetAllBlocks() ([]common.Block, error) {
 func (hdb *HistoryDB) getBlocks(from, to int64) ([]common.Block, error) {
 	var blocks []*common.Block
 	err := meddler.QueryAll(
-		hdb.db, &blocks,
+		hdb.dbRead, &blocks,
 		"SELECT * FROM block WHERE $1 <= eth_block_num AND eth_block_num < $2 ORDER BY eth_block_num;",
 		from, to,
 	)
@@ -100,13 +105,13 @@ func (hdb *HistoryDB) getBlocks(from, to int64) ([]common.Block, error) {
 func (hdb *HistoryDB) GetLastBlock() (*common.Block, error) {
 	block := &common.Block{}
 	err := meddler.QueryRow(
-		hdb.db, block, "SELECT * FROM block ORDER BY eth_block_num DESC LIMIT 1;",
+		hdb.dbRead, block, "SELECT * FROM block ORDER BY eth_block_num DESC LIMIT 1;",
 	)
 	return block, tracerr.Wrap(err)
 }
 
 // AddBatch insert a Batch into the DB
-func (hdb *HistoryDB) AddBatch(batch *common.Batch) error { return hdb.addBatch(hdb.db, batch) }
+func (hdb *HistoryDB) AddBatch(batch *common.Batch) error { return hdb.addBatch(hdb.dbWrite, batch) }
 func (hdb *HistoryDB) addBatch(d meddler.DB, batch *common.Batch) error {
 	// Calculate total collected fees in USD
 	// Get IDs of collected tokens for fees
@@ -129,9 +134,9 @@ func (hdb *HistoryDB) addBatch(d meddler.DB, batch *common.Batch) error {
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
-		query = hdb.db.Rebind(query)
+		query = hdb.dbWrite.Rebind(query)
 		if err := meddler.QueryAll(
-			hdb.db, &tokenPrices, query, args...,
+			hdb.dbWrite, &tokenPrices, query, args...,
 		); err != nil {
 			return tracerr.Wrap(err)
 		}
@@ -153,7 +158,7 @@ func (hdb *HistoryDB) addBatch(d meddler.DB, batch *common.Batch) error {
 
 // AddBatches insert Bids into the DB
 func (hdb *HistoryDB) AddBatches(batches []common.Batch) error {
-	return tracerr.Wrap(hdb.addBatches(hdb.db, batches))
+	return tracerr.Wrap(hdb.addBatches(hdb.dbWrite, batches))
 }
 func (hdb *HistoryDB) addBatches(d meddler.DB, batches []common.Batch) error {
 	for i := 0; i < len(batches); i++ {
@@ -168,7 +173,7 @@ func (hdb *HistoryDB) addBatches(d meddler.DB, batches []common.Batch) error {
 func (hdb *HistoryDB) GetBatch(batchNum common.BatchNum) (*common.Batch, error) {
 	var batch common.Batch
 	err := meddler.QueryRow(
-		hdb.db, &batch, `SELECT batch.batch_num, batch.eth_block_num, batch.forger_addr,
+		hdb.dbRead, &batch, `SELECT batch.batch_num, batch.eth_block_num, batch.forger_addr,
 		batch.fees_collected, batch.fee_idxs_coordinator, batch.state_root,
 		batch.num_accounts, batch.last_idx, batch.exit_root, batch.forge_l1_txs_num,
 		batch.slot_num, batch.total_fees_usd FROM batch WHERE batch_num = $1;`,
@@ -181,7 +186,7 @@ func (hdb *HistoryDB) GetBatch(batchNum common.BatchNum) (*common.Batch, error)
 func (hdb *HistoryDB) GetAllBatches() ([]common.Batch, error) {
 	var batches []*common.Batch
 	err := meddler.QueryAll(
-		hdb.db, &batches,
+		hdb.dbRead, &batches,
 		`SELECT batch.batch_num, batch.eth_block_num, batch.forger_addr, batch.fees_collected,
 		 batch.fee_idxs_coordinator, batch.state_root, batch.num_accounts, batch.last_idx, batch.exit_root,
 		 batch.forge_l1_txs_num, batch.slot_num, batch.total_fees_usd FROM batch
@@ -194,7 +199,7 @@ func (hdb *HistoryDB) GetAllBatches() ([]common.Batch, error) {
 func (hdb *HistoryDB) GetBatches(from, to common.BatchNum) ([]common.Batch, error) {
 	var batches []*common.Batch
 	err := meddler.QueryAll(
-		hdb.db, &batches,
+		hdb.dbRead, &batches,
 		`SELECT batch_num, eth_block_num, forger_addr, fees_collected, fee_idxs_coordinator, 
 		state_root, num_accounts, last_idx, exit_root, forge_l1_txs_num, slot_num, total_fees_usd 
 		FROM batch WHERE $1 <= batch_num AND batch_num < $2 ORDER BY batch_num;`,
@@ -206,7 +211,7 @@ func (hdb *HistoryDB) GetBatches(from, to common.BatchNum) ([]common.Batch, erro
 // GetFirstBatchBlockNumBySlot returns the ethereum block number of the first
 // batch within a slot
 func (hdb *HistoryDB) GetFirstBatchBlockNumBySlot(slotNum int64) (int64, error) {
-	row := hdb.db.QueryRow(
+	row := hdb.dbRead.QueryRow(
 		`SELECT eth_block_num FROM batch
 		WHERE slot_num = $1 ORDER BY batch_num ASC LIMIT 1;`, slotNum,
 	)
@@ -216,7 +221,7 @@ func (hdb *HistoryDB) GetFirstBatchBlockNumBySlot(slotNum int64) (int64, error)
 
 // GetLastBatchNum returns the BatchNum of the latest forged batch
 func (hdb *HistoryDB) GetLastBatchNum() (common.BatchNum, error) {
-	row := hdb.db.QueryRow("SELECT batch_num FROM batch ORDER BY batch_num DESC LIMIT 1;")
+	row := hdb.dbRead.QueryRow("SELECT batch_num FROM batch ORDER BY batch_num DESC LIMIT 1;")
 	var batchNum common.BatchNum
 	return batchNum, tracerr.Wrap(row.Scan(&batchNum))
 }
@@ -225,7 +230,7 @@ func (hdb *HistoryDB) GetLastBatchNum() (common.BatchNum, error) {
 func (hdb *HistoryDB) GetLastBatch() (*common.Batch, error) {
 	var batch common.Batch
 	err := meddler.QueryRow(
-		hdb.db, &batch, `SELECT batch.batch_num, batch.eth_block_num, batch.forger_addr,
+		hdb.dbRead, &batch, `SELECT batch.batch_num, batch.eth_block_num, batch.forger_addr,
 		batch.fees_collected, batch.fee_idxs_coordinator, batch.state_root,
 		batch.num_accounts, batch.last_idx, batch.exit_root, batch.forge_l1_txs_num,
 		batch.slot_num, batch.total_fees_usd FROM batch ORDER BY batch_num DESC LIMIT 1;`,
@@ -235,7 +240,7 @@ func (hdb *HistoryDB) GetLastBatch() (*common.Batch, error) {
 
 // GetLastL1BatchBlockNum returns the blockNum of the latest forged l1Batch
 func (hdb *HistoryDB) GetLastL1BatchBlockNum() (int64, error) {
-	row := hdb.db.QueryRow(`SELECT eth_block_num FROM batch
+	row := hdb.dbRead.QueryRow(`SELECT eth_block_num FROM batch
 		WHERE forge_l1_txs_num IS NOT NULL
 		ORDER BY batch_num DESC LIMIT 1;`)
 	var blockNum int64
@@ -245,7 +250,7 @@ func (hdb *HistoryDB) GetLastL1BatchBlockNum() (int64, error) {
 // GetLastL1TxsNum returns the greatest ForgeL1TxsNum in the DB from forged
 // batches.  If there's no batch in the DB (nil, nil) is returned.
 func (hdb *HistoryDB) GetLastL1TxsNum() (*int64, error) {
-	row := hdb.db.QueryRow("SELECT MAX(forge_l1_txs_num) FROM batch;")
+	row := hdb.dbRead.QueryRow("SELECT MAX(forge_l1_txs_num) FROM batch;")
 	lastL1TxsNum := new(int64)
 	return lastL1TxsNum, tracerr.Wrap(row.Scan(&lastL1TxsNum))
 }
@@ -256,15 +261,15 @@ func (hdb *HistoryDB) GetLastL1TxsNum() (*int64, error) {
 func (hdb *HistoryDB) Reorg(lastValidBlock int64) error {
 	var err error
 	if lastValidBlock < 0 {
-		_, err = hdb.db.Exec("DELETE FROM block;")
+		_, err = hdb.dbWrite.Exec("DELETE FROM block;")
 	} else {
-		_, err = hdb.db.Exec("DELETE FROM block WHERE eth_block_num > $1;", lastValidBlock)
+		_, err = hdb.dbWrite.Exec("DELETE FROM block WHERE eth_block_num > $1;", lastValidBlock)
 	}
 	return tracerr.Wrap(err)
 }
 
 // AddBids insert Bids into the DB
-func (hdb *HistoryDB) AddBids(bids []common.Bid) error { return hdb.addBids(hdb.db, bids) }
+func (hdb *HistoryDB) AddBids(bids []common.Bid) error { return hdb.addBids(hdb.dbWrite, bids) }
 func (hdb *HistoryDB) addBids(d meddler.DB, bids []common.Bid) error {
 	if len(bids) == 0 {
 		return nil
@@ -273,7 +278,7 @@ func (hdb *HistoryDB) addBids(d meddler.DB, bids []common.Bid) error {
 	return tracerr.Wrap(db.BulkInsert(
 		d,
 		"INSERT INTO bid (slot_num, bid_value, eth_block_num, bidder_addr) VALUES %s;",
-		bids[:],
+		bids,
 	))
 }
 
@@ -281,7 +286,7 @@ func (hdb *HistoryDB) addBids(d meddler.DB, bids []common.Bid) error {
 func (hdb *HistoryDB) GetAllBids() ([]common.Bid, error) {
 	var bids []*common.Bid
 	err := meddler.QueryAll(
-		hdb.db, &bids,
+		hdb.dbRead, &bids,
 		`SELECT bid.slot_num, bid.bid_value, bid.eth_block_num, bid.bidder_addr FROM bid
 		ORDER BY item_id;`,
 	)
@@ -292,7 +297,7 @@ func (hdb *HistoryDB) GetAllBids() ([]common.Bid, error) {
 func (hdb *HistoryDB) GetBestBidCoordinator(slotNum int64) (*common.BidCoordinator, error) {
 	bidCoord := &common.BidCoordinator{}
 	err := meddler.QueryRow(
-		hdb.db, bidCoord,
+		hdb.dbRead, bidCoord,
 		`SELECT (
 			SELECT default_slot_set_bid
 			FROM auction_vars
@@ -315,7 +320,7 @@ func (hdb *HistoryDB) GetBestBidCoordinator(slotNum int64) (*common.BidCoordinat
 
 // AddCoordinators insert Coordinators into the DB
 func (hdb *HistoryDB) AddCoordinators(coordinators []common.Coordinator) error {
-	return tracerr.Wrap(hdb.addCoordinators(hdb.db, coordinators))
+	return tracerr.Wrap(hdb.addCoordinators(hdb.dbWrite, coordinators))
 }
 func (hdb *HistoryDB) addCoordinators(d meddler.DB, coordinators []common.Coordinator) error {
 	if len(coordinators) == 0 {
@@ -324,13 +329,13 @@ func (hdb *HistoryDB) addCoordinators(d meddler.DB, coordinators []common.Coordi
 	return tracerr.Wrap(db.BulkInsert(
 		d,
 		"INSERT INTO coordinator (bidder_addr, forger_addr, eth_block_num, url) VALUES %s;",
-		coordinators[:],
+		coordinators,
 	))
 }
 
 // AddExitTree insert Exit tree into the DB
 func (hdb *HistoryDB) AddExitTree(exitTree []common.ExitInfo) error {
-	return tracerr.Wrap(hdb.addExitTree(hdb.db, exitTree))
+	return tracerr.Wrap(hdb.addExitTree(hdb.dbWrite, exitTree))
 }
 func (hdb *HistoryDB) addExitTree(d meddler.DB, exitTree []common.ExitInfo) error {
 	if len(exitTree) == 0 {
@@ -340,7 +345,7 @@ func (hdb *HistoryDB) addExitTree(d meddler.DB, exitTree []common.ExitInfo) erro
 		d,
 		"INSERT INTO exit_tree (batch_num, account_idx, merkle_proof, balance, "+
 			"instant_withdrawn, delayed_withdraw_request, delayed_withdrawn) VALUES %s;",
-		exitTree[:],
+		exitTree,
 	))
 }
 
@@ -418,11 +423,13 @@ func (hdb *HistoryDB) updateExitTree(d sqlx.Ext, blockNum int64,
 
 // AddToken insert a token into the DB
 func (hdb *HistoryDB) AddToken(token *common.Token) error {
-	return tracerr.Wrap(meddler.Insert(hdb.db, "token", token))
+	return tracerr.Wrap(meddler.Insert(hdb.dbWrite, "token", token))
 }
 
 // AddTokens insert tokens into the DB
-func (hdb *HistoryDB) AddTokens(tokens []common.Token) error { return hdb.addTokens(hdb.db, tokens) }
+func (hdb *HistoryDB) AddTokens(tokens []common.Token) error {
+	return hdb.addTokens(hdb.dbWrite, tokens)
+}
 func (hdb *HistoryDB) addTokens(d meddler.DB, tokens []common.Token) error {
 	if len(tokens) == 0 {
 		return nil
@@ -443,16 +450,17 @@ func (hdb *HistoryDB) addTokens(d meddler.DB, tokens []common.Token) error {
 			symbol,
 			decimals
 		) VALUES %s;`,
-		tokens[:],
+		tokens,
 	))
 }
 
-// UpdateTokenValue updates the USD value of a token
+// UpdateTokenValue updates the USD value of a token.  Value is the price in
+// USD of a normalized token (1 token = 10^decimals units)
 func (hdb *HistoryDB) UpdateTokenValue(tokenSymbol string, value float64) error {
 	// Sanitize symbol
 	tokenSymbol = strings.ToValidUTF8(tokenSymbol, " ")
 
-	_, err := hdb.db.Exec(
+	_, err := hdb.dbWrite.Exec(
 		"UPDATE token SET usd = $1 WHERE symbol = $2;",
 		value, tokenSymbol,
 	)
@@ -463,7 +471,7 @@ func (hdb *HistoryDB) UpdateTokenValue(tokenSymbol string, value float64) error
 func (hdb *HistoryDB) GetToken(tokenID common.TokenID) (*TokenWithUSD, error) {
 	token := &TokenWithUSD{}
 	err := meddler.QueryRow(
-		hdb.db, token, `SELECT * FROM token WHERE token_id = $1;`, tokenID,
+		hdb.dbRead, token, `SELECT * FROM token WHERE token_id = $1;`, tokenID,
 	)
 	return token, tracerr.Wrap(err)
 }
@@ -472,7 +480,7 @@ func (hdb *HistoryDB) GetToken(tokenID common.TokenID) (*TokenWithUSD, error) {
 func (hdb *HistoryDB) GetAllTokens() ([]TokenWithUSD, error) {
 	var tokens []*TokenWithUSD
 	err := meddler.QueryAll(
-		hdb.db, &tokens,
+		hdb.dbRead, &tokens,
 		"SELECT * FROM token ORDER BY token_id;",
 	)
 	return db.SlicePtrsToSlice(tokens).([]TokenWithUSD), tracerr.Wrap(err)
@@ -481,7 +489,7 @@ func (hdb *HistoryDB) GetAllTokens() ([]TokenWithUSD, error) {
 // GetTokenSymbols returns all the token symbols from the DB
 func (hdb *HistoryDB) GetTokenSymbols() ([]string, error) {
 	var tokenSymbols []string
-	rows, err := hdb.db.Query("SELECT symbol FROM token;")
+	rows, err := hdb.dbRead.Query("SELECT symbol FROM token;")
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -499,7 +507,7 @@ func (hdb *HistoryDB) GetTokenSymbols() ([]string, error) {
 
 // AddAccounts insert accounts into the DB
 func (hdb *HistoryDB) AddAccounts(accounts []common.Account) error {
-	return tracerr.Wrap(hdb.addAccounts(hdb.db, accounts))
+	return tracerr.Wrap(hdb.addAccounts(hdb.dbWrite, accounts))
 }
 func (hdb *HistoryDB) addAccounts(d meddler.DB, accounts []common.Account) error {
 	if len(accounts) == 0 {
@@ -514,7 +522,7 @@ func (hdb *HistoryDB) addAccounts(d meddler.DB, accounts []common.Account) error
 			bjj,
 			eth_addr
 		) VALUES %s;`,
-		accounts[:],
+		accounts,
 	))
 }
 
@@ -522,18 +530,49 @@ func (hdb *HistoryDB) addAccounts(d meddler.DB, accounts []common.Account) error
 func (hdb *HistoryDB) GetAllAccounts() ([]common.Account, error) {
 	var accs []*common.Account
 	err := meddler.QueryAll(
-		hdb.db, &accs,
+		hdb.dbRead, &accs,
 		"SELECT idx, token_id, batch_num, bjj, eth_addr FROM account ORDER BY idx;",
 	)
 	return db.SlicePtrsToSlice(accs).([]common.Account), tracerr.Wrap(err)
 }
 
+// AddAccountUpdates inserts accUpdates into the DB
+func (hdb *HistoryDB) AddAccountUpdates(accUpdates []common.AccountUpdate) error {
+	return tracerr.Wrap(hdb.addAccountUpdates(hdb.dbWrite, accUpdates))
+}
+func (hdb *HistoryDB) addAccountUpdates(d meddler.DB, accUpdates []common.AccountUpdate) error {
+	if len(accUpdates) == 0 {
+		return nil
+	}
+	return tracerr.Wrap(db.BulkInsert(
+		d,
+		`INSERT INTO account_update (
+			eth_block_num,
+			batch_num,
+			idx,
+			nonce,
+			balance
+		) VALUES %s;`,
+		accUpdates,
+	))
+}
+
+// GetAllAccountUpdates returns all the AccountUpdate from the DB
+func (hdb *HistoryDB) GetAllAccountUpdates() ([]common.AccountUpdate, error) {
+	var accUpdates []*common.AccountUpdate
+	err := meddler.QueryAll(
+		hdb.dbRead, &accUpdates,
+		"SELECT eth_block_num, batch_num, idx, nonce, balance FROM account_update ORDER BY idx;",
+	)
+	return db.SlicePtrsToSlice(accUpdates).([]common.AccountUpdate), tracerr.Wrap(err)
+}
+
 // AddL1Txs inserts L1 txs to the DB. USD and DepositAmountUSD will be set automatically before storing the tx.
 // If the tx is originated by a coordinator, BatchNum must be provided. If it's originated by a user,
 // BatchNum should be null, and the value will be setted by a trigger when a batch forges the tx.
 // EffectiveAmount and EffectiveDepositAmount are seted with default values by the DB.
 func (hdb *HistoryDB) AddL1Txs(l1txs []common.L1Tx) error {
-	return tracerr.Wrap(hdb.addL1Txs(hdb.db, l1txs))
+	return tracerr.Wrap(hdb.addL1Txs(hdb.dbWrite, l1txs))
 }
 
 // addL1Txs inserts L1 txs to the DB. USD and DepositAmountUSD will be set automatically before storing the tx.
@@ -587,7 +626,7 @@ func (hdb *HistoryDB) addL1Txs(d meddler.DB, l1txs []common.L1Tx) error {
 
 // AddL2Txs inserts L2 txs to the DB. TokenID, USD and FeeUSD will be set automatically before storing the tx.
 func (hdb *HistoryDB) AddL2Txs(l2txs []common.L2Tx) error {
-	return tracerr.Wrap(hdb.addL2Txs(hdb.db, l2txs))
+	return tracerr.Wrap(hdb.addL2Txs(hdb.dbWrite, l2txs))
 }
 
 // addL2Txs inserts L2 txs to the DB. TokenID, USD and FeeUSD will be set automatically before storing the tx.
@@ -646,7 +685,7 @@ func (hdb *HistoryDB) addTxs(d meddler.DB, txs []txWrite) error {
 			fee,
 			nonce
 		) VALUES %s;`,
-		txs[:],
+		txs,
 	))
 }
 
@@ -654,7 +693,7 @@ func (hdb *HistoryDB) addTxs(d meddler.DB, txs []txWrite) error {
 func (hdb *HistoryDB) GetAllExits() ([]common.ExitInfo, error) {
 	var exits []*common.ExitInfo
 	err := meddler.QueryAll(
-		hdb.db, &exits,
+		hdb.dbRead, &exits,
 		`SELECT exit_tree.batch_num, exit_tree.account_idx, exit_tree.merkle_proof,
 		exit_tree.balance, exit_tree.instant_withdrawn, exit_tree.delayed_withdraw_request,
 		exit_tree.delayed_withdrawn FROM exit_tree ORDER BY item_id;`,
@@ -666,7 +705,7 @@ func (hdb *HistoryDB) GetAllExits() ([]common.ExitInfo, error) {
 func (hdb *HistoryDB) GetAllL1UserTxs() ([]common.L1Tx, error) {
 	var txs []*common.L1Tx
 	err := meddler.QueryAll(
-		hdb.db, &txs, // Note that '\x' gets parsed as a big.Int with value = 0
+		hdb.dbRead, &txs, // Note that '\x' gets parsed as a big.Int with value = 0
 		`SELECT tx.id, tx.to_forge_l1_txs_num, tx.position, tx.user_origin,
 		tx.from_idx, tx.effective_from_idx, tx.from_eth_addr, tx.from_bjj, tx.to_idx, tx.token_id,
 		tx.amount, (CASE WHEN tx.batch_num IS NULL THEN NULL WHEN tx.amount_success THEN tx.amount ELSE '\x' END) AS effective_amount,
@@ -683,7 +722,7 @@ func (hdb *HistoryDB) GetAllL1CoordinatorTxs() ([]common.L1Tx, error) {
 	// Since the query specifies that only coordinator txs are returned, it's safe to assume
 	// that returned txs will always have effective amounts
 	err := meddler.QueryAll(
-		hdb.db, &txs,
+		hdb.dbRead, &txs,
 		`SELECT tx.id, tx.to_forge_l1_txs_num, tx.position, tx.user_origin,
 		tx.from_idx, tx.effective_from_idx, tx.from_eth_addr, tx.from_bjj, tx.to_idx, tx.token_id,
 		tx.amount, tx.amount AS effective_amount,
@@ -698,7 +737,7 @@ func (hdb *HistoryDB) GetAllL1CoordinatorTxs() ([]common.L1Tx, error) {
 func (hdb *HistoryDB) GetAllL2Txs() ([]common.L2Tx, error) {
 	var txs []*common.L2Tx
 	err := meddler.QueryAll(
-		hdb.db, &txs,
+		hdb.dbRead, &txs,
 		`SELECT tx.id, tx.batch_num, tx.position,
 		tx.from_idx, tx.to_idx, tx.amount, tx.token_id,
 		tx.fee, tx.nonce, tx.type, tx.eth_block_num
@@ -711,7 +750,7 @@ func (hdb *HistoryDB) GetAllL2Txs() ([]common.L2Tx, error) {
 func (hdb *HistoryDB) GetUnforgedL1UserTxs(toForgeL1TxsNum int64) ([]common.L1Tx, error) {
 	var txs []*common.L1Tx
 	err := meddler.QueryAll(
-		hdb.db, &txs, // only L1 user txs can have batch_num set to null
+		hdb.dbRead, &txs, // only L1 user txs can have batch_num set to null
 		`SELECT tx.id, tx.to_forge_l1_txs_num, tx.position, tx.user_origin,
 		tx.from_idx, tx.from_eth_addr, tx.from_bjj, tx.to_idx, tx.token_id,
 		tx.amount, NULL AS effective_amount,
@@ -728,7 +767,7 @@ func (hdb *HistoryDB) GetUnforgedL1UserTxs(toForgeL1TxsNum int64) ([]common.L1Tx
 
 // GetLastTxsPosition for a given to_forge_l1_txs_num
 func (hdb *HistoryDB) GetLastTxsPosition(toForgeL1TxsNum int64) (int, error) {
-	row := hdb.db.QueryRow(
+	row := hdb.dbRead.QueryRow(
 		"SELECT position FROM tx WHERE to_forge_l1_txs_num = $1 ORDER BY position DESC;",
 		toForgeL1TxsNum,
 	)
@@ -742,15 +781,15 @@ func (hdb *HistoryDB) GetSCVars() (*common.RollupVariables, *common.AuctionVaria
 	var rollup common.RollupVariables
 	var auction common.AuctionVariables
 	var wDelayer common.WDelayerVariables
-	if err := meddler.QueryRow(hdb.db, &rollup,
+	if err := meddler.QueryRow(hdb.dbRead, &rollup,
 		"SELECT * FROM rollup_vars ORDER BY eth_block_num DESC LIMIT 1;"); err != nil {
 		return nil, nil, nil, tracerr.Wrap(err)
 	}
-	if err := meddler.QueryRow(hdb.db, &auction,
+	if err := meddler.QueryRow(hdb.dbRead, &auction,
 		"SELECT * FROM auction_vars ORDER BY eth_block_num DESC LIMIT 1;"); err != nil {
 		return nil, nil, nil, tracerr.Wrap(err)
 	}
-	if err := meddler.QueryRow(hdb.db, &wDelayer,
+	if err := meddler.QueryRow(hdb.dbRead, &wDelayer,
 		"SELECT * FROM wdelayer_vars ORDER BY eth_block_num DESC LIMIT 1;"); err != nil {
 		return nil, nil, nil, tracerr.Wrap(err)
 	}
@@ -781,7 +820,7 @@ func (hdb *HistoryDB) addBucketUpdates(d meddler.DB, bucketUpdates []common.Buck
 		 	block_stamp,
 		 	withdrawals
 		) VALUES %s;`,
-		bucketUpdates[:],
+		bucketUpdates,
 	))
 }
 
@@ -795,13 +834,25 @@ func (hdb *HistoryDB) AddBucketUpdatesTest(d meddler.DB, bucketUpdates []common.
 func (hdb *HistoryDB) GetAllBucketUpdates() ([]common.BucketUpdate, error) {
 	var bucketUpdates []*common.BucketUpdate
 	err := meddler.QueryAll(
-		hdb.db, &bucketUpdates,
+		hdb.dbRead, &bucketUpdates,
 		`SELECT eth_block_num, num_bucket, block_stamp, withdrawals  
 		FROM bucket_update ORDER BY item_id;`,
 	)
 	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
@@ -813,7 +864,7 @@ func (hdb *HistoryDB) addTokenExchanges(d meddler.DB, tokenExchanges []common.To
     			eth_addr,
     			value_usd
 		) VALUES %s;`,
-		tokenExchanges[:],
+		tokenExchanges,
 	))
 }
 
@@ -821,7 +872,7 @@ func (hdb *HistoryDB) addTokenExchanges(d meddler.DB, tokenExchanges []common.To
 func (hdb *HistoryDB) GetAllTokenExchanges() ([]common.TokenExchange, error) {
 	var tokenExchanges []*common.TokenExchange
 	err := meddler.QueryAll(
-		hdb.db, &tokenExchanges,
+		hdb.dbRead, &tokenExchanges,
 		"SELECT eth_block_num, eth_addr, value_usd FROM token_exchange ORDER BY item_id;",
 	)
 	return db.SlicePtrsToSlice(tokenExchanges).([]common.TokenExchange), tracerr.Wrap(err)
@@ -841,7 +892,7 @@ func (hdb *HistoryDB) addEscapeHatchWithdrawals(d meddler.DB,
 			token_addr,
 			amount
 		) VALUES %s;`,
-		escapeHatchWithdrawals[:],
+		escapeHatchWithdrawals,
 	))
 }
 
@@ -849,7 +900,7 @@ func (hdb *HistoryDB) addEscapeHatchWithdrawals(d meddler.DB,
 func (hdb *HistoryDB) GetAllEscapeHatchWithdrawals() ([]common.WDelayerEscapeHatchWithdrawal, error) {
 	var escapeHatchWithdrawals []*common.WDelayerEscapeHatchWithdrawal
 	err := meddler.QueryAll(
-		hdb.db, &escapeHatchWithdrawals,
+		hdb.dbRead, &escapeHatchWithdrawals,
 		"SELECT eth_block_num, who_addr, to_addr, token_addr, amount FROM escape_hatch_withdrawal ORDER BY item_id;",
 	)
 	return db.SlicePtrsToSlice(escapeHatchWithdrawals).([]common.WDelayerEscapeHatchWithdrawal),
@@ -862,7 +913,7 @@ func (hdb *HistoryDB) GetAllEscapeHatchWithdrawals() ([]common.WDelayerEscapeHat
 // exist in the smart contracts.
 func (hdb *HistoryDB) SetInitialSCVars(rollup *common.RollupVariables,
 	auction *common.AuctionVariables, wDelayer *common.WDelayerVariables) error {
-	txn, err := hdb.db.Beginx()
+	txn, err := hdb.dbWrite.Beginx()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -946,7 +997,7 @@ func (hdb *HistoryDB) setExtraInfoForgedL1UserTxs(d sqlx.Ext, txs []common.L1Tx)
 // the pagination system of the API/DB depends on this.  Within blocks, all
 // items should also be in the correct order (Accounts, Tokens, Txs, etc.)
 func (hdb *HistoryDB) AddBlockSCData(blockData *common.BlockData) (err error) {
-	txn, err := hdb.db.Beginx()
+	txn, err := hdb.dbWrite.Beginx()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1018,6 +1069,11 @@ func (hdb *HistoryDB) AddBlockSCData(blockData *common.BlockData) (err error) {
 			return tracerr.Wrap(err)
 		}
 
+		// Add accountBalances if it exists
+		if err := hdb.addAccountUpdates(txn, batch.UpdatedAccounts); err != nil {
+			return tracerr.Wrap(err)
+		}
+
 		// Set the EffectiveAmount and EffectiveDepositAmount of all the
 		// L1UserTxs that have been forged in this batch
 		if err = hdb.setExtraInfoForgedL1UserTxs(txn, batch.L1UserTxs); err != nil {
@@ -1095,27 +1151,16 @@ 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.db, 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.db, "auction_vars", auctionVars))
+	return tracerr.Wrap(meddler.Insert(hdb.dbWrite, "auction_vars", auctionVars))
 }
 
 // GetTokensTest used to get tokens in a testing context
 func (hdb *HistoryDB) GetTokensTest() ([]TokenWithUSD, error) {
 	tokens := []*TokenWithUSD{}
 	if err := meddler.QueryAll(
-		hdb.db, &tokens,
+		hdb.dbRead, &tokens,
 		"SELECT * FROM TOKEN",
 	); err != nil {
 		return nil, tracerr.Wrap(err)
@@ -1125,3 +1170,49 @@ func (hdb *HistoryDB) GetTokensTest() ([]TokenWithUSD, error) {
 	}
 	return db.SlicePtrsToSlice(tokens).([]TokenWithUSD), nil
 }
+
+// GetRecommendedFee returns the 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
+}

db/historydb/historydb_test.go

@@ -39,12 +39,12 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
-	historyDB = NewHistoryDB(db, nil)
+	historyDB = NewHistoryDB(db, db, nil)
 	if err != nil {
 		panic(err)
 	}
 	apiConnCon := dbUtils.NewAPICnnectionController(1, time.Second)
-	historyDBWithACC = NewHistoryDB(db, apiConnCon)
+	historyDBWithACC = NewHistoryDB(db, db, apiConnCon)
 	// Run tests
 	result := m.Run()
 	// Close DB
@@ -377,6 +377,22 @@ func TestAccounts(t *testing.T) {
 		accs[i].Balance = nil
 		assert.Equal(t, accs[i], acc)
 	}
+	// Test AccountBalances
+	accUpdates := make([]common.AccountUpdate, len(accs))
+	for i, acc := range accs {
+		accUpdates[i] = common.AccountUpdate{
+			EthBlockNum: batches[acc.BatchNum-1].EthBlockNum,
+			BatchNum:    acc.BatchNum,
+			Idx:         acc.Idx,
+			Nonce:       common.Nonce(i),
+			Balance:     big.NewInt(int64(i)),
+		}
+	}
+	err = historyDB.AddAccountUpdates(accUpdates)
+	require.NoError(t, err)
+	fetchedAccBalances, err := historyDB.GetAllAccountUpdates()
+	require.NoError(t, err)
+	assert.Equal(t, accUpdates, fetchedAccBalances)
 }
 
 func TestTxs(t *testing.T) {
@@ -801,11 +817,11 @@ func TestSetExtraInfoForgedL1UserTxs(t *testing.T) {
 	}
 	// Add second batch to trigger the update of the batch_num,
 	// while avoiding the implicit call of setExtraInfoForgedL1UserTxs
-	err = historyDB.addBlock(historyDB.db, &blocks[1].Block)
+	err = historyDB.addBlock(historyDB.dbWrite, &blocks[1].Block)
 	require.NoError(t, err)
-	err = historyDB.addBatch(historyDB.db, &blocks[1].Rollup.Batches[0].Batch)
+	err = historyDB.addBatch(historyDB.dbWrite, &blocks[1].Rollup.Batches[0].Batch)
 	require.NoError(t, err)
-	err = historyDB.addAccounts(historyDB.db, blocks[1].Rollup.Batches[0].CreatedAccounts)
+	err = historyDB.addAccounts(historyDB.dbWrite, blocks[1].Rollup.Batches[0].CreatedAccounts)
 	require.NoError(t, err)
 
 	// Set the Effective{Amount,DepositAmount} of the L1UserTxs that are forged in the second block
@@ -815,7 +831,7 @@ func TestSetExtraInfoForgedL1UserTxs(t *testing.T) {
 	l1Txs[1].EffectiveAmount = big.NewInt(0)
 	l1Txs[2].EffectiveDepositAmount = big.NewInt(0)
 	l1Txs[2].EffectiveAmount = big.NewInt(0)
-	err = historyDB.setExtraInfoForgedL1UserTxs(historyDB.db, l1Txs)
+	err = historyDB.setExtraInfoForgedL1UserTxs(historyDB.dbWrite, l1Txs)
 	require.NoError(t, err)
 
 	dbL1Txs, err := historyDB.GetAllL1UserTxs()
@@ -902,10 +918,10 @@ func TestUpdateExitTree(t *testing.T) {
 		common.WithdrawInfo{Idx: 259, NumExitRoot: 3, InstantWithdraw: false,
 			Owner: tc.UsersByIdx[259].Addr, Token: tokenAddr},
 	)
-	err = historyDB.addBlock(historyDB.db, &block.Block)
+	err = historyDB.addBlock(historyDB.dbWrite, &block.Block)
 	require.NoError(t, err)
 
-	err = historyDB.updateExitTree(historyDB.db, block.Block.Num,
+	err = historyDB.updateExitTree(historyDB.dbWrite, block.Block.Num,
 		block.Rollup.Withdrawals, block.WDelayer.Withdrawals)
 	require.NoError(t, err)
 
@@ -935,10 +951,10 @@ func TestUpdateExitTree(t *testing.T) {
 			Token:  tokenAddr,
 			Amount: big.NewInt(80),
 		})
-	err = historyDB.addBlock(historyDB.db, &block.Block)
+	err = historyDB.addBlock(historyDB.dbWrite, &block.Block)
 	require.NoError(t, err)
 
-	err = historyDB.updateExitTree(historyDB.db, block.Block.Num,
+	err = historyDB.updateExitTree(historyDB.dbWrite, block.Block.Num,
 		block.Rollup.Withdrawals, block.WDelayer.Withdrawals)
 	require.NoError(t, err)
 
@@ -981,7 +997,7 @@ func TestGetBestBidCoordinator(t *testing.T) {
 			URL:         "bar",
 		},
 	}
-	err = historyDB.addCoordinators(historyDB.db, coords)
+	err = historyDB.addCoordinators(historyDB.dbWrite, coords)
 	require.NoError(t, err)
 
 	bids := []common.Bid{
@@ -999,7 +1015,7 @@ func TestGetBestBidCoordinator(t *testing.T) {
 		},
 	}
 
-	err = historyDB.addBids(historyDB.db, bids)
+	err = historyDB.addBids(historyDB.dbWrite, bids)
 	require.NoError(t, err)
 
 	forger10, err := historyDB.GetBestBidCoordinator(10)
@@ -1037,7 +1053,7 @@ func TestAddBucketUpdates(t *testing.T) {
 			Withdrawals: big.NewInt(42),
 		},
 	}
-	err := historyDB.addBucketUpdates(historyDB.db, bucketUpdates)
+	err := historyDB.addBucketUpdates(historyDB.dbWrite, bucketUpdates)
 	require.NoError(t, err)
 	dbBucketUpdates, err := historyDB.GetAllBucketUpdates()
 	require.NoError(t, err)
@@ -1062,7 +1078,7 @@ func TestAddTokenExchanges(t *testing.T) {
 			ValueUSD:    67890,
 		},
 	}
-	err := historyDB.addTokenExchanges(historyDB.db, tokenExchanges)
+	err := historyDB.addTokenExchanges(historyDB.dbWrite, tokenExchanges)
 	require.NoError(t, err)
 	dbTokenExchanges, err := historyDB.GetAllTokenExchanges()
 	require.NoError(t, err)
@@ -1091,7 +1107,7 @@ func TestAddEscapeHatchWithdrawals(t *testing.T) {
 			Amount:      big.NewInt(20003),
 		},
 	}
-	err := historyDB.addEscapeHatchWithdrawals(historyDB.db, escapeHatchWithdrawals)
+	err := historyDB.addEscapeHatchWithdrawals(historyDB.dbWrite, escapeHatchWithdrawals)
 	require.NoError(t, err)
 	dbEscapeHatchWithdrawals, err := historyDB.GetAllEscapeHatchWithdrawals()
 	require.NoError(t, err)
@@ -1156,19 +1172,15 @@ func TestGetMetricsAPI(t *testing.T) {
 		assert.NoError(t, err)
 	}
 
-	res, err := historyDBWithACC.GetMetricsAPI(common.BatchNum(numBatches))
+	res, err := historyDB.GetMetricsInternalAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
-	assert.Equal(t, float64(numTx)/float64(numBatches-1), res.TransactionsPerBatch)
+	assert.Equal(t, float64(numTx)/float64(numBatches), res.TransactionsPerBatch)
 
 	// Frequency is not exactly the desired one, some decimals may appear
-	assert.GreaterOrEqual(t, res.BatchFrequency, float64(frequency))
+	// There is a -2 as time for first and last batch is not taken into account
-	assert.Less(t, res.BatchFrequency, float64(frequency+1))
+	assert.InEpsilon(t, float64(frequency)*float64(numBatches-2)/float64(numBatches), res.BatchFrequency, 0.01)
-	// Truncate frecuency into an int to do an exact check
+	assert.InEpsilon(t, float64(numTx)/float64(frequency*blockNum-frequency), res.TransactionsPerSecond, 0.01)
-	assert.Equal(t, frequency, int(res.BatchFrequency))
-	// This may also be different in some decimals
-	// Truncate it to the third decimal to compare
-	assert.Equal(t, math.Trunc((float64(numTx)/float64(frequency*blockNum-frequency))/0.001)*0.001, math.Trunc(res.TransactionsPerSecond/0.001)*0.001)
 	assert.Equal(t, int64(3), res.TotalAccounts)
 	assert.Equal(t, int64(3), res.TotalBJJs)
 	// Til does not set fees
@@ -1195,7 +1207,8 @@ func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {
 	set = append(set, til.Instruction{Typ: til.TypeNewBlock})
 
 	// Transfers
-	for x := 0; x < 6000; x++ {
+	const numBlocks int = 30
+	for x := 0; x < numBlocks; x++ {
 		set = append(set, til.Instruction{
 			Typ:           common.TxTypeTransfer,
 			TokenID:       common.TokenID(0),
@@ -1219,36 +1232,31 @@ func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {
 	err = tc.FillBlocksExtra(blocks, &tilCfgExtra)
 	require.NoError(t, err)
 
-	const numBatches int = 6002
+	const numBatches int = 2 + numBlocks
-	const numTx int = 6003
+	const blockNum = 4 + numBlocks
-	const blockNum = 6005 - 1
 
 	// Sanity check
 	require.Equal(t, blockNum, len(blocks))
 
 	// Adding one batch per block
 	// batch frequency can be chosen
-	const frequency int = 15
+	const blockTime time.Duration = 3600 * time.Second
+	now := time.Now()
+	require.NoError(t, err)
 
 	for i := range blocks {
-		blocks[i].Block.Timestamp = time.Now().Add(-time.Second * time.Duration(frequency*(len(blocks)-i)))
+		blocks[i].Block.Timestamp = now.Add(-time.Duration(len(blocks)-1-i) * blockTime)
 		err = historyDB.AddBlockSCData(&blocks[i])
 		assert.NoError(t, err)
 	}
 
-	res, err := historyDBWithACC.GetMetricsAPI(common.BatchNum(numBatches))
+	res, err := historyDBWithACC.GetMetricsInternalAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
-	assert.Equal(t, math.Trunc((float64(numTx)/float64(numBatches-1))/0.001)*0.001, math.Trunc(res.TransactionsPerBatch/0.001)*0.001)
+	assert.InEpsilon(t, 1.0, res.TransactionsPerBatch, 0.1)
 
-	// Frequency is not exactly the desired one, some decimals may appear
+	assert.InEpsilon(t, res.BatchFrequency, float64(blockTime/time.Second), 0.1)
-	assert.GreaterOrEqual(t, res.BatchFrequency, float64(frequency))
+	assert.InEpsilon(t, 1.0/float64(blockTime/time.Second), res.TransactionsPerSecond, 0.1)
-	assert.Less(t, res.BatchFrequency, float64(frequency+1))
-	// Truncate frecuency into an int to do an exact check
-	assert.Equal(t, frequency, int(res.BatchFrequency))
-	// This may also be different in some decimals
-	// Truncate it to the third decimal to compare
-	assert.Equal(t, math.Trunc((float64(numTx)/float64(frequency*blockNum-frequency))/0.001)*0.001, math.Trunc(res.TransactionsPerSecond/0.001)*0.001)
 	assert.Equal(t, int64(3), res.TotalAccounts)
 	assert.Equal(t, int64(3), res.TotalBJJs)
 	// Til does not set fees
@@ -1257,13 +1265,7 @@ func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {
 
 func TestGetMetricsAPIEmpty(t *testing.T) {
 	test.WipeDB(historyDB.DB())
-	_, err := historyDBWithACC.GetMetricsAPI(0)
+	_, err := historyDBWithACC.GetMetricsInternalAPI(0)
-	assert.NoError(t, err)
-}
-
-func TestGetAvgTxFeeEmpty(t *testing.T) {
-	test.WipeDB(historyDB.DB())
-	_, err := historyDBWithACC.GetAvgTxFeeAPI()
 	assert.NoError(t, err)
 }
 
@@ -1452,3 +1454,65 @@ func setTestBlocks(from, to int64) []common.Block {
 	}
 	return blocks
 }
+
+func TestNodeInfo(t *testing.T) {
+	test.WipeDB(historyDB.DB())
+
+	err := historyDB.SetStateInternalAPI(&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.SetStateInternalAPI(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(historyDB.dbRead)
+	require.NoError(t, err)
+	assert.Equal(t, stateAPI, dbStateAPI)
+}

db/historydb/nodeinfo.go

@@ -0,0 +1,169 @@
+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
+)
+
+// Period represents a time period in ethereum
+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"`
+}
+
+// NextForgerAPI represents the next forger exposed via the API
+type NextForgerAPI struct {
+	Coordinator CoordinatorAPI `json:"coordinator"`
+	Period      Period         `json:"period"`
+}
+
+// NetworkAPI is the network state exposed via the API
+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"`
+}
+
+// StateAPI is an object representing the node and network state exposed via the API
+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"`
+}
+
+// Constants contains network constants
+type Constants struct {
+	common.SCConsts
+	ChainID       uint16
+	HermezAddress ethCommon.Address
+}
+
+// NodeConfig contains the node config exposed in the API
+type NodeConfig struct {
+	MaxPoolTxs uint32  `meddler:"max_pool_txs"`
+	MinFeeUSD  float64 `meddler:"min_fee"`
+}
+
+// NodeInfo contains information about he node used when serving the API
+type NodeInfo struct {
+	ItemID     int         `meddler:"item_id,pk"`
+	StateAPI   *StateAPI   `meddler:"state,json"`
+	NodeConfig *NodeConfig `meddler:"config,json"`
+	Constants  *Constants  `meddler:"constants,json"`
+}
+
+// GetNodeInfo returns the NodeInfo
+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)
+}
+
+// GetConstants returns the Constats
+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)
+}
+
+// SetConstants sets the Constants
+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)
+}
+
+// GetStateInternalAPI returns the StateAPI
+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.StateAPI, tracerr.Wrap(err)
+}
+
+// SetStateInternalAPI sets the StateAPI
+func (hdb *HistoryDB) SetStateInternalAPI(stateAPI *StateAPI) error {
+	_stateAPI := struct {
+		StateAPI *StateAPI `meddler:"state,json"`
+	}{stateAPI}
+	values, err := meddler.Default.Values(&_stateAPI, 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)
+}
+
+// GetNodeConfig returns the NodeConfig
+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)
+}
+
+// SetNodeConfig sets the NodeConfig
+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 node_info SET config = $1 WHERE item_id = 1;",
+		values[0],
+	)
+	return tracerr.Wrap(err)
+}

db/historydb/views.go

@@ -239,8 +239,8 @@ type AccountAPI struct {
 	BatchNum         common.BatchNum     `meddler:"batch_num"`
 	PublicKey        apitypes.HezBJJ     `meddler:"bjj"`
 	EthAddr          apitypes.HezEthAddr `meddler:"eth_addr"`
-	Nonce            common.Nonce        `meddler:"-"` // max of 40 bits used
+	Nonce            common.Nonce        `meddler:"nonce"`   // max of 40 bits used
-	Balance          *apitypes.BigIntStr `meddler:"-"` // max of 192 bits used
+	Balance          *apitypes.BigIntStr `meddler:"balance"` // max of 192 bits used
 	TotalItems       uint64              `meddler:"total_items"`
 	FirstItem        uint64              `meddler:"first_item"`
 	LastItem         uint64              `meddler:"last_item"`
@@ -302,25 +302,15 @@ type BatchAPI struct {
 	LastItem      uint64                 `json:"-" meddler:"last_item"`
 }
 
-// Metrics define metrics of the network
+// MetricsAPI define metrics of the network
-type Metrics struct {
+type MetricsAPI struct {
-	TransactionsPerBatch  float64 `json:"transactionsPerBatch"`
+	TransactionsPerBatch   float64 `json:"transactionsPerBatch"`
-	BatchFrequency        float64 `json:"batchFrequency"`
+	BatchFrequency         float64 `json:"batchFrequency"`
-	TransactionsPerSecond float64 `json:"transactionsPerSecond"`
+	TransactionsPerSecond  float64 `json:"transactionsPerSecond"`
-	TotalAccounts         int64   `json:"totalAccounts" meddler:"total_accounts"`
+	TotalAccounts          int64   `json:"totalAccounts" meddler:"total_accounts"`
-	TotalBJJs             int64   `json:"totalBJJs" meddler:"total_bjjs"`
+	TotalBJJs              int64   `json:"totalBJJs" meddler:"total_bjjs"`
-	AvgTransactionFee     float64 `json:"avgTransactionFee"`
+	AvgTransactionFee      float64 `json:"avgTransactionFee"`
-}
+	EstimatedTimeToForgeL1 float64 `json:"estimatedTimeToForgeL1" meddler:"estimatedTimeToForgeL1"`
-
-// 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
@@ -373,6 +363,27 @@ 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"`
@@ -397,3 +408,28 @@ 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
+}

db/l2db/apiqueries.go

@@ -1,12 +1,18 @@
 package l2db
 
 import (
+	"fmt"
+
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/russross/meddler"
 )
 
+var (
+	errPoolFull = fmt.Errorf("the pool is at full capacity. More transactions are not accepted currently")
+)
+
 // AddAccountCreationAuthAPI inserts an account creation authorization into the DB
 func (l2db *L2DB) AddAccountCreationAuthAPI(auth *common.AccountCreationAuth) error {
 	cancel, err := l2db.apiConnCon.Acquire()
@@ -28,7 +34,7 @@ func (l2db *L2DB) GetAccountCreationAuthAPI(addr ethCommon.Address) (*AccountCre
 	defer l2db.apiConnCon.Release()
 	auth := new(AccountCreationAuthAPI)
 	return auth, tracerr.Wrap(meddler.QueryRow(
-		l2db.db, auth,
+		l2db.dbRead, auth,
 		"SELECT * FROM account_creation_auth WHERE eth_addr = $1;",
 		addr,
 	))
@@ -42,20 +48,54 @@ func (l2db *L2DB) AddTxAPI(tx *PoolL2TxWrite) error {
 		return tracerr.Wrap(err)
 	}
 	defer l2db.apiConnCon.Release()
-	row := l2db.db.QueryRow(
+
-		"SELECT COUNT(*) FROM tx_pool WHERE state = $1;",
+	row := l2db.dbRead.QueryRow(`SELECT
-		common.PoolL2TxStatePending,
+		($1::NUMERIC * COALESCE(token.usd, 0) * fee_percentage($2::NUMERIC)) /
-	)
+			(10.0 ^ token.decimals::NUMERIC)
-	var totalTxs uint32
+		FROM token WHERE token.token_id = $3;`,
-	if err := row.Scan(&totalTxs); err != nil {
+		tx.AmountFloat, tx.Fee, tx.TokenID)
+	var feeUSD float64
+	if err := row.Scan(&feeUSD); err != nil {
 		return tracerr.Wrap(err)
 	}
-	if totalTxs >= l2db.maxTxs {
+	if feeUSD < l2db.minFeeUSD {
-		return tracerr.New(
+		return tracerr.Wrap(fmt.Errorf("tx.feeUSD (%v) < minFeeUSD (%v)",
-			"The pool is at full capacity. More transactions are not accepted currently",
+			feeUSD, l2db.minFeeUSD))
-		)
 	}
-	return tracerr.Wrap(meddler.Insert(l2db.db, "tx_pool", tx))
+
+	// Prepare insert SQL query argument parameters
+	namesPart, err := meddler.Default.ColumnsQuoted(tx, false)
+	if err != nil {
+		return err
+	}
+	valuesPart, err := meddler.Default.PlaceholdersString(tx, false)
+	if err != nil {
+		return err
+	}
+	values, err := meddler.Default.Values(tx, false)
+	if err != nil {
+		return err
+	}
+
+	q := fmt.Sprintf(
+		`INSERT INTO tx_pool (%s)
+		SELECT %s
+		WHERE (SELECT COUNT(*) FROM tx_pool WHERE state = $%v) < $%v;`,
+		namesPart, valuesPart,
+		len(values)+1, len(values)+2) //nolint:gomnd
+	values = append(values, common.PoolL2TxStatePending, l2db.maxTxs)
+	res, err := l2db.dbWrite.Exec(q, values...)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	rowsAffected, err := res.RowsAffected()
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	if rowsAffected == 0 {
+		return tracerr.Wrap(errPoolFull)
+	}
+	return nil
 }
 
 // selectPoolTxAPI select part of queries to get PoolL2TxRead
@@ -78,7 +118,7 @@ func (l2db *L2DB) GetTxAPI(txID common.TxID) (*PoolTxAPI, error) {
 	defer l2db.apiConnCon.Release()
 	tx := new(PoolTxAPI)
 	return tx, tracerr.Wrap(meddler.QueryRow(
-		l2db.db, tx,
+		l2db.dbRead, tx,
 		selectPoolTxAPI+"WHERE tx_id = $1;",
 		txID,
 	))

db/l2db/l2db.go

@@ -21,10 +21,12 @@ import (
 // L2DB stores L2 txs and authorization registers received by the coordinator and keeps them until they are no longer relevant
 // due to them being forged or invalid after a safety period
 type L2DB struct {
-	db           *sqlx.DB
+	dbRead       *sqlx.DB
+	dbWrite      *sqlx.DB
 	safetyPeriod common.BatchNum
 	ttl          time.Duration
 	maxTxs       uint32 // limit of txs that are accepted in the pool
+	minFeeUSD    float64
 	apiConnCon   *db.APIConnectionController
 }
 
@@ -32,17 +34,20 @@ type L2DB struct {
 // To create it, it's needed db connection, safety period expressed in batches,
 // maxTxs that the DB should have and TTL (time to live) for pending txs.
 func NewL2DB(
-	db *sqlx.DB,
+	dbRead, dbWrite *sqlx.DB,
 	safetyPeriod common.BatchNum,
 	maxTxs uint32,
+	minFeeUSD float64,
 	TTL time.Duration,
 	apiConnCon *db.APIConnectionController,
 ) *L2DB {
 	return &L2DB{
-		db:           db,
+		dbRead:       dbRead,
+		dbWrite:      dbWrite,
 		safetyPeriod: safetyPeriod,
 		ttl:          TTL,
 		maxTxs:       maxTxs,
+		minFeeUSD:    minFeeUSD,
 		apiConnCon:   apiConnCon,
 	}
 }
@@ -50,12 +55,18 @@ func NewL2DB(
 // DB returns a pointer to the L2DB.db. This method should be used only for
 // internal testing purposes.
 func (l2db *L2DB) DB() *sqlx.DB {
-	return l2db.db
+	return l2db.dbWrite
+}
+
+// MinFeeUSD returns the minimum fee in USD that is required to accept txs into
+// the pool
+func (l2db *L2DB) MinFeeUSD() float64 {
+	return l2db.minFeeUSD
 }
 
 // AddAccountCreationAuth inserts an account creation authorization into the DB
 func (l2db *L2DB) AddAccountCreationAuth(auth *common.AccountCreationAuth) error {
-	_, err := l2db.db.Exec(
+	_, err := l2db.dbWrite.Exec(
 		`INSERT INTO account_creation_auth (eth_addr, bjj, signature)
 		VALUES ($1, $2, $3);`,
 		auth.EthAddr, auth.BJJ, auth.Signature,
@@ -67,30 +78,12 @@ func (l2db *L2DB) AddAccountCreationAuth(auth *common.AccountCreationAuth) error
 func (l2db *L2DB) GetAccountCreationAuth(addr ethCommon.Address) (*common.AccountCreationAuth, error) {
 	auth := new(common.AccountCreationAuth)
 	return auth, tracerr.Wrap(meddler.QueryRow(
-		l2db.db, auth,
+		l2db.dbRead, auth,
 		"SELECT * FROM account_creation_auth WHERE eth_addr = $1;",
 		addr,
 	))
 }
 
-// AddTx inserts a tx to the pool
-func (l2db *L2DB) AddTx(tx *PoolL2TxWrite) error {
-	row := l2db.db.QueryRow(
-		"SELECT COUNT(*) FROM tx_pool WHERE state = $1;",
-		common.PoolL2TxStatePending,
-	)
-	var totalTxs uint32
-	if err := row.Scan(&totalTxs); err != nil {
-		return tracerr.Wrap(err)
-	}
-	if totalTxs >= l2db.maxTxs {
-		return tracerr.New(
-			"The pool is at full capacity. More transactions are not accepted currently",
-		)
-	}
-	return tracerr.Wrap(meddler.Insert(l2db.db, "tx_pool", tx))
-}
-
 // UpdateTxsInfo updates the parameter Info of the pool transactions
 func (l2db *L2DB) UpdateTxsInfo(txs []common.PoolL2Tx) error {
 	if len(txs) == 0 {
@@ -114,7 +107,7 @@ func (l2db *L2DB) UpdateTxsInfo(txs []common.PoolL2Tx) error {
 		WHERE tx_pool.tx_id = tx_update.id;
 	`
 	if len(txUpdates) > 0 {
-		if _, err := sqlx.NamedExec(l2db.db, query, txUpdates); err != nil {
+		if _, err := sqlx.NamedExec(l2db.dbWrite, query, txUpdates); err != nil {
 			return tracerr.Wrap(err)
 		}
 	}
@@ -122,9 +115,8 @@ func (l2db *L2DB) UpdateTxsInfo(txs []common.PoolL2Tx) error {
 	return nil
 }
 
-// AddTxTest inserts a tx into the L2DB. This is useful for test purposes,
+// NewPoolL2TxWriteFromPoolL2Tx creates a new PoolL2TxWrite from a PoolL2Tx
-// but in production txs will only be inserted through the API
+func NewPoolL2TxWriteFromPoolL2Tx(tx *common.PoolL2Tx) *PoolL2TxWrite {
-func (l2db *L2DB) AddTxTest(tx *common.PoolL2Tx) error {
 	// transform tx from *common.PoolL2Tx to PoolL2TxWrite
 	insertTx := &PoolL2TxWrite{
 		TxID:      tx.TxID,
@@ -166,8 +158,15 @@ func (l2db *L2DB) AddTxTest(tx *common.PoolL2Tx) error {
 	f := new(big.Float).SetInt(tx.Amount)
 	amountF, _ := f.Float64()
 	insertTx.AmountFloat = amountF
+	return insertTx
+}
+
+// AddTxTest inserts a tx into the L2DB. This is useful for test purposes,
+// but in production txs will only be inserted through the API
+func (l2db *L2DB) AddTxTest(tx *common.PoolL2Tx) error {
+	insertTx := NewPoolL2TxWriteFromPoolL2Tx(tx)
 	// insert tx
-	return tracerr.Wrap(meddler.Insert(l2db.db, "tx_pool", insertTx))
+	return tracerr.Wrap(meddler.Insert(l2db.dbWrite, "tx_pool", insertTx))
 }
 
 // selectPoolTxCommon select part of queries to get common.PoolL2Tx
@@ -176,14 +175,15 @@ tx_pool.to_bjj, tx_pool.token_id, tx_pool.amount, tx_pool.fee, tx_pool.nonce,
 tx_pool.state, tx_pool.info, tx_pool.signature, tx_pool.timestamp, rq_from_idx, 
 rq_to_idx, tx_pool.rq_to_eth_addr, tx_pool.rq_to_bjj, tx_pool.rq_token_id, tx_pool.rq_amount, 
 tx_pool.rq_fee, tx_pool.rq_nonce, tx_pool.tx_type, 
-fee_percentage(tx_pool.fee::NUMERIC) * token.usd * tx_pool.amount_f AS fee_usd, token.usd_update  
+(fee_percentage(tx_pool.fee::NUMERIC) * token.usd * tx_pool.amount_f) /
+	(10.0 ^ token.decimals::NUMERIC) AS fee_usd, token.usd_update
 FROM tx_pool INNER JOIN token ON tx_pool.token_id = token.token_id `
 
 // GetTx  return the specified Tx in common.PoolL2Tx format
 func (l2db *L2DB) GetTx(txID common.TxID) (*common.PoolL2Tx, error) {
 	tx := new(common.PoolL2Tx)
 	return tx, tracerr.Wrap(meddler.QueryRow(
-		l2db.db, tx,
+		l2db.dbRead, tx,
 		selectPoolTxCommon+"WHERE tx_id = $1;",
 		txID,
 	))
@@ -193,7 +193,7 @@ func (l2db *L2DB) GetTx(txID common.TxID) (*common.PoolL2Tx, error) {
 func (l2db *L2DB) GetPendingTxs() ([]common.PoolL2Tx, error) {
 	var txs []*common.PoolL2Tx
 	err := meddler.QueryAll(
-		l2db.db, &txs,
+		l2db.dbRead, &txs,
 		selectPoolTxCommon+"WHERE state = $1",
 		common.PoolL2TxStatePending,
 	)
@@ -218,8 +218,8 @@ func (l2db *L2DB) StartForging(txIDs []common.TxID, batchNum common.BatchNum) er
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	query = l2db.db.Rebind(query)
+	query = l2db.dbWrite.Rebind(query)
-	_, err = l2db.db.Exec(query, args...)
+	_, err = l2db.dbWrite.Exec(query, args...)
 	return tracerr.Wrap(err)
 }
 
@@ -241,8 +241,8 @@ func (l2db *L2DB) DoneForging(txIDs []common.TxID, batchNum common.BatchNum) err
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	query = l2db.db.Rebind(query)
+	query = l2db.dbWrite.Rebind(query)
-	_, err = l2db.db.Exec(query, args...)
+	_, err = l2db.dbWrite.Exec(query, args...)
 	return tracerr.Wrap(err)
 }
 
@@ -263,8 +263,8 @@ func (l2db *L2DB) InvalidateTxs(txIDs []common.TxID, batchNum common.BatchNum) e
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	query = l2db.db.Rebind(query)
+	query = l2db.dbWrite.Rebind(query)
-	_, err = l2db.db.Exec(query, args...)
+	_, err = l2db.dbWrite.Exec(query, args...)
 	return tracerr.Wrap(err)
 }
 
@@ -272,7 +272,7 @@ func (l2db *L2DB) InvalidateTxs(txIDs []common.TxID, batchNum common.BatchNum) e
 // of unique FromIdx
 func (l2db *L2DB) GetPendingUniqueFromIdxs() ([]common.Idx, error) {
 	var idxs []common.Idx
-	rows, err := l2db.db.Query(`SELECT DISTINCT from_idx FROM tx_pool
+	rows, err := l2db.dbRead.Query(`SELECT DISTINCT from_idx FROM tx_pool
 		WHERE state = $1;`, common.PoolL2TxStatePending)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -313,7 +313,7 @@ func (l2db *L2DB) InvalidateOldNonces(updatedAccounts []common.IdxNonce, batchNu
 	// named query which works with slices, and doens't handle an extra
 	// individual argument.
 	query := fmt.Sprintf(invalidateOldNoncesQuery, batchNum)
-	if _, err := sqlx.NamedExec(l2db.db, query, updatedAccounts); err != nil {
+	if _, err := sqlx.NamedExec(l2db.dbWrite, query, updatedAccounts); err != nil {
 		return tracerr.Wrap(err)
 	}
 	return nil
@@ -322,7 +322,7 @@ func (l2db *L2DB) InvalidateOldNonces(updatedAccounts []common.IdxNonce, batchNu
 // Reorg updates the state of txs that were updated in a batch that has been discarted due to a blockchain reorg.
 // The state of the affected txs can change form Forged -> Pending or from Invalid -> Pending
 func (l2db *L2DB) Reorg(lastValidBatch common.BatchNum) error {
-	_, err := l2db.db.Exec(
+	_, err := l2db.dbWrite.Exec(
 		`UPDATE tx_pool SET batch_num = NULL, state = $1
 		WHERE (state = $2 OR state = $3 OR state = $4) AND batch_num > $5`,
 		common.PoolL2TxStatePending,
@@ -338,7 +338,7 @@ func (l2db *L2DB) Reorg(lastValidBatch common.BatchNum) error {
 // it also deletes pending txs that have been in the L2DB for longer than the ttl if maxTxs has been exceeded
 func (l2db *L2DB) Purge(currentBatchNum common.BatchNum) (err error) {
 	now := time.Now().UTC().Unix()
-	_, err = l2db.db.Exec(
+	_, err = l2db.dbWrite.Exec(
 		`DELETE FROM tx_pool WHERE (
 			batch_num < $1 AND (state = $2 OR state = $3)
 		) OR (
@@ -354,3 +354,14 @@ func (l2db *L2DB) Purge(currentBatchNum common.BatchNum) (err error) {
 	)
 	return tracerr.Wrap(err)
 }
+
+// PurgeByExternalDelete deletes all pending transactions marked with true in
+// the `external_delete` column.  An external process can set this column to
+// true to instruct the coordinator to delete the tx when possible.
+func (l2db *L2DB) PurgeByExternalDelete() error {
+	_, err := l2db.dbWrite.Exec(
+		`DELETE from tx_pool WHERE (external_delete = true AND state = $1);`,
+		common.PoolL2TxStatePending,
+	)
+	return tracerr.Wrap(err)
+}

db/l2db/l2db_test.go

@@ -1,8 +1,8 @@
 package l2db
 
 import (
-	"math"
+	"database/sql"
-	"math/big"
+	"fmt"
 	"os"
 	"testing"
 	"time"
@@ -20,12 +20,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+var decimals = uint64(3)
+var tokenValue = 1.0 // The price update gives a value of 1.0 USD to the token
 var l2DB *L2DB
 var l2DBWithACC *L2DB
 var historyDB *historydb.HistoryDB
 var tc *til.Context
 var tokens map[common.TokenID]historydb.TokenWithUSD
-var tokensValue map[common.TokenID]float64
+
 var accs map[common.Idx]common.Account
 
 func TestMain(m *testing.M) {
@@ -35,11 +37,11 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
-	l2DB = NewL2DB(db, 10, 1000, 24*time.Hour, nil)
+	l2DB = NewL2DB(db, db, 10, 1000, 0.0, 24*time.Hour, nil)
 	apiConnCon := dbUtils.NewAPICnnectionController(1, time.Second)
-	l2DBWithACC = NewL2DB(db, 10, 1000, 24*time.Hour, apiConnCon)
+	l2DBWithACC = NewL2DB(db, db, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB())
-	historyDB = historydb.NewHistoryDB(db, nil)
+	historyDB = historydb.NewHistoryDB(db, db, nil)
 	// Run tests
 	result := m.Run()
 	// Close DB
@@ -58,10 +60,10 @@ func prepareHistoryDB(historyDB *historydb.HistoryDB) error {
 
 			AddToken(1)
 			AddToken(2)
-			CreateAccountDeposit(1) A: 2000
+			CreateAccountDeposit(1) A: 20000
-			CreateAccountDeposit(2) A: 2000
+			CreateAccountDeposit(2) A: 20000
-			CreateAccountDeposit(1) B: 1000
+			CreateAccountDeposit(1) B: 10000
-			CreateAccountDeposit(2) B: 1000
+			CreateAccountDeposit(2) B: 10000
 			> batchL1 
 			> batchL1
 			> block
@@ -82,15 +84,23 @@ func prepareHistoryDB(historyDB *historydb.HistoryDB) error {
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
+	for i := range blocks {
+		block := &blocks[i]
+		for j := range block.Rollup.AddedTokens {
+			token := &block.Rollup.AddedTokens[j]
+			token.Name = fmt.Sprintf("Token %d", token.TokenID)
+			token.Symbol = fmt.Sprintf("TK%d", token.TokenID)
+			token.Decimals = decimals
+		}
+	}
+
 	tokens = make(map[common.TokenID]historydb.TokenWithUSD)
-	tokensValue = make(map[common.TokenID]float64)
+	// tokensValue = make(map[common.TokenID]float64)
 	accs = make(map[common.Idx]common.Account)
-	value := 5 * 5.389329
 	now := time.Now().UTC()
 	// Add all blocks except for the last one
 	for i := range blocks[:len(blocks)-1] {
-		err = historyDB.AddBlockSCData(&blocks[i])
+		if err := historyDB.AddBlockSCData(&blocks[i]); err != nil {
-		if err != nil {
 			return tracerr.Wrap(err)
 		}
 		for _, batch := range blocks[i].Rollup.Batches {
@@ -106,39 +116,38 @@ func prepareHistoryDB(historyDB *historydb.HistoryDB) error {
 				Name:        token.Name,
 				Symbol:      token.Symbol,
 				Decimals:    token.Decimals,
+				USD:         &tokenValue,
+				USDUpdate:   &now,
 			}
-			tokensValue[token.TokenID] = value / math.Pow(10, float64(token.Decimals))
-			readToken.USDUpdate = &now
-			readToken.USD = &value
 			tokens[token.TokenID] = readToken
-		}
+			// Set value to the tokens
-		// Set value to the tokens (tokens have no symbol)
+			err := historyDB.UpdateTokenValue(readToken.Symbol, *readToken.USD)
-		tokenSymbol := ""
+			if err != nil {
-		err := historyDB.UpdateTokenValue(tokenSymbol, value)
+				return tracerr.Wrap(err)
-		if err != nil {
+			}
-			return tracerr.Wrap(err)
 		}
 	}
 	return nil
 }
 
 func generatePoolL2Txs() ([]common.PoolL2Tx, error) {
+	// Fee = 126 corresponds to ~10%
 	setPool := `
 			Type: PoolL2
-			PoolTransfer(1) A-B: 6 (4)
+			PoolTransfer(1) A-B: 6000 (126)
-			PoolTransfer(2) A-B: 3 (1)
+			PoolTransfer(2) A-B: 3000 (126)
-			PoolTransfer(1) B-A: 5 (2)
+			PoolTransfer(1) B-A: 5000 (126)
-			PoolTransfer(2) B-A: 10 (3)
+			PoolTransfer(2) B-A: 10000 (126)
-			PoolTransfer(1) A-B: 7 (2)
+			PoolTransfer(1) A-B: 7000 (126)
-			PoolTransfer(2) A-B: 2 (1)
+			PoolTransfer(2) A-B: 2000 (126)
-			PoolTransfer(1) B-A: 8 (2)
+			PoolTransfer(1) B-A: 8000 (126)
-			PoolTransfer(2) B-A: 1 (1)
+			PoolTransfer(2) B-A: 1000 (126)
-			PoolTransfer(1) A-B: 3 (1)
+			PoolTransfer(1) A-B: 3000 (126)
-			PoolTransferToEthAddr(2) B-A: 5 (2)
+			PoolTransferToEthAddr(2) B-A: 5000 (126)
-			PoolTransferToBJJ(2) B-A: 5 (2)
+			PoolTransferToBJJ(2) B-A: 5000 (126)
 
-			PoolExit(1) A: 5 (2)
+			PoolExit(1) A: 5000 (126)
-			PoolExit(2) B: 3 (1)
+			PoolExit(2) B: 3000 (126)
 		`
 	poolL2Txs, err := tc.GeneratePoolL2Txs(setPool)
 	if err != nil {
@@ -153,25 +162,74 @@ func TestAddTxTest(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		fetchedTx, err := l2DB.GetTx(poolL2Txs[i].TxID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assertTx(t, &poolL2Txs[i], fetchedTx)
 		nameZone, offset := fetchedTx.Timestamp.Zone()
 		assert.Equal(t, "UTC", nameZone)
 		assert.Equal(t, 0, offset)
 	}
 }
+
+func TestAddTxAPI(t *testing.T) {
+	err := prepareHistoryDB(historyDB)
+	if err != nil {
+		log.Error("Error prepare historyDB", err)
+	}
+
+	oldMaxTxs := l2DBWithACC.maxTxs
+	// set max number of pending txs that can be kept in the pool to 5
+	l2DBWithACC.maxTxs = 5
+
+	poolL2Txs, err := generatePoolL2Txs()
+	txs := make([]*PoolL2TxWrite, len(poolL2Txs))
+	for i := range poolL2Txs {
+		txs[i] = NewPoolL2TxWriteFromPoolL2Tx(&poolL2Txs[i])
+	}
+	require.NoError(t, err)
+	require.GreaterOrEqual(t, len(poolL2Txs), 8)
+	for i := range txs[:5] {
+		err := l2DBWithACC.AddTxAPI(txs[i])
+		require.NoError(t, err)
+		fetchedTx, err := l2DB.GetTx(poolL2Txs[i].TxID)
+		require.NoError(t, err)
+		assertTx(t, &poolL2Txs[i], fetchedTx)
+		nameZone, offset := fetchedTx.Timestamp.Zone()
+		assert.Equal(t, "UTC", nameZone)
+		assert.Equal(t, 0, offset)
+	}
+	err = l2DBWithACC.AddTxAPI(txs[5])
+	assert.Equal(t, errPoolFull, tracerr.Unwrap(err))
+	// reset maxTxs to original value
+	l2DBWithACC.maxTxs = oldMaxTxs
+
+	// set minFeeUSD to a high value than the tx feeUSD to test the error
+	// of inserting a tx with lower than min fee
+	oldMinFeeUSD := l2DBWithACC.minFeeUSD
+	tx := txs[5]
+	feeAmount, err := common.CalcFeeAmount(tx.Amount, tx.Fee)
+	require.NoError(t, err)
+	feeAmountUSD := common.TokensToUSD(feeAmount, decimals, tokenValue)
+	// set minFeeUSD higher than the tx fee to trigger the error
+	l2DBWithACC.minFeeUSD = feeAmountUSD + 1
+	err = l2DBWithACC.AddTxAPI(tx)
+	require.Error(t, err)
+	assert.Regexp(t, "tx.feeUSD (.*) < minFeeUSD (.*)", err.Error())
+	// reset minFeeUSD to original value
+	l2DBWithACC.minFeeUSD = oldMinFeeUSD
+}
+
 func TestUpdateTxsInfo(t *testing.T) {
 	err := prepareHistoryDB(historyDB)
 	if err != nil {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
 		require.NoError(t, err)
@@ -185,7 +243,7 @@ func TestUpdateTxsInfo(t *testing.T) {
 
 	for i := range poolL2Txs {
 		fetchedTx, err := l2DB.GetTx(poolL2Txs[i].TxID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "test", fetchedTx.Info)
 	}
 }
@@ -203,9 +261,8 @@ func assertTx(t *testing.T, expected, actual *common.PoolL2Tx) {
 		assert.Less(t, token.USDUpdate.Unix()-3, actual.AbsoluteFeeUpdate.Unix())
 		expected.AbsoluteFeeUpdate = actual.AbsoluteFeeUpdate
 		// Set expected fee
-		f := new(big.Float).SetInt(expected.Amount)
+		amountUSD := common.TokensToUSD(expected.Amount, token.Decimals, *token.USD)
-		amountF, _ := f.Float64()
+		expected.AbsoluteFee = amountUSD * expected.Fee.Percentage()
-		expected.AbsoluteFee = *token.USD * amountF * expected.Fee.Percentage()
 		test.AssertUSD(t, &expected.AbsoluteFee, &actual.AbsoluteFee)
 	}
 	assert.Equal(t, expected, actual)
@@ -230,19 +287,28 @@ func TestGetPending(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	var pendingTxs []*common.PoolL2Tx
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		pendingTxs = append(pendingTxs, &poolL2Txs[i])
 	}
 	fetchedTxs, err := l2DB.GetPendingTxs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, len(pendingTxs), len(fetchedTxs))
 	for i := range fetchedTxs {
 		assertTx(t, pendingTxs[i], &fetchedTxs[i])
 	}
+	// Check AbsoluteFee amount
+	for i := range fetchedTxs {
+		tx := &fetchedTxs[i]
+		feeAmount, err := common.CalcFeeAmount(tx.Amount, tx.Fee)
+		require.NoError(t, err)
+		feeAmountUSD := common.TokensToUSD(feeAmount,
+			tokens[tx.TokenID].Decimals, *tokens[tx.TokenID].USD)
+		assert.InEpsilon(t, feeAmountUSD, tx.AbsoluteFee, 0.01)
+	}
 }
 
 func TestStartForging(t *testing.T) {
@@ -253,13 +319,13 @@ func TestStartForging(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	var startForgingTxIDs []common.TxID
 	randomizer := 0
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if poolL2Txs[i].State == common.PoolL2TxStatePending && randomizer%2 == 0 {
 			startForgingTxIDs = append(startForgingTxIDs, poolL2Txs[i].TxID)
 		}
@@ -267,11 +333,11 @@ func TestStartForging(t *testing.T) {
 	}
 	// Start forging txs
 	err = l2DB.StartForging(startForgingTxIDs, fakeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range startForgingTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, common.PoolL2TxStateForging, fetchedTx.State)
 		assert.Equal(t, &fakeBatchNum, fetchedTx.BatchNum)
 	}
@@ -285,13 +351,13 @@ func TestDoneForging(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	var startForgingTxIDs []common.TxID
 	randomizer := 0
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if poolL2Txs[i].State == common.PoolL2TxStatePending && randomizer%2 == 0 {
 			startForgingTxIDs = append(startForgingTxIDs, poolL2Txs[i].TxID)
 		}
@@ -299,7 +365,7 @@ func TestDoneForging(t *testing.T) {
 	}
 	// Start forging txs
 	err = l2DB.StartForging(startForgingTxIDs, fakeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var doneForgingTxIDs []common.TxID
 	randomizer = 0
@@ -311,12 +377,12 @@ func TestDoneForging(t *testing.T) {
 	}
 	// Done forging txs
 	err = l2DB.DoneForging(doneForgingTxIDs, fakeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range doneForgingTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, common.PoolL2TxStateForged, fetchedTx.State)
 		assert.Equal(t, &fakeBatchNum, fetchedTx.BatchNum)
 	}
@@ -330,13 +396,13 @@ func TestInvalidate(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	var invalidTxIDs []common.TxID
 	randomizer := 0
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if poolL2Txs[i].State != common.PoolL2TxStateInvalid && randomizer%2 == 0 {
 			randomizer++
 			invalidTxIDs = append(invalidTxIDs, poolL2Txs[i].TxID)
@@ -344,11 +410,11 @@ func TestInvalidate(t *testing.T) {
 	}
 	// Invalidate txs
 	err = l2DB.InvalidateTxs(invalidTxIDs, fakeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range invalidTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, common.PoolL2TxStateInvalid, fetchedTx.State)
 		assert.Equal(t, &fakeBatchNum, fetchedTx.BatchNum)
 	}
@@ -362,7 +428,7 @@ func TestInvalidateOldNonces(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Update Accounts currentNonce
 	var updateAccounts []common.IdxNonce
 	var currentNonce = common.Nonce(1)
@@ -379,13 +445,13 @@ func TestInvalidateOldNonces(t *testing.T) {
 			invalidTxIDs = append(invalidTxIDs, poolL2Txs[i].TxID)
 		}
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 	// sanity check
 	require.Greater(t, len(invalidTxIDs), 0)
 
 	err = l2DB.InvalidateOldNonces(updateAccounts, fakeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range invalidTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
@@ -407,7 +473,7 @@ func TestReorg(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	reorgedTxIDs := []common.TxID{}
 	nonReorgedTxIDs := []common.TxID{}
@@ -418,7 +484,7 @@ func TestReorg(t *testing.T) {
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if poolL2Txs[i].State == common.PoolL2TxStatePending && randomizer%2 == 0 {
 			startForgingTxIDs = append(startForgingTxIDs, poolL2Txs[i].TxID)
 			allTxRandomize = append(allTxRandomize, poolL2Txs[i].TxID)
@@ -430,7 +496,7 @@ func TestReorg(t *testing.T) {
 	}
 	// Start forging txs
 	err = l2DB.StartForging(startForgingTxIDs, lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var doneForgingTxIDs []common.TxID
 	randomizer = 0
@@ -455,22 +521,22 @@ func TestReorg(t *testing.T) {
 
 	// Invalidate txs BEFORE reorgBatch --> nonReorg
 	err = l2DB.InvalidateTxs(invalidTxIDs, lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Done forging txs in reorgBatch --> Reorg
 	err = l2DB.DoneForging(doneForgingTxIDs, reorgBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = l2DB.Reorg(lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	for _, id := range reorgedTxIDs {
 		tx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, tx.BatchNum)
 		assert.Equal(t, common.PoolL2TxStatePending, tx.State)
 	}
 	for _, id := range nonReorgedTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, lastValidBatch, *fetchedTx.BatchNum)
 	}
 }
@@ -487,7 +553,7 @@ func TestReorg2(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	reorgedTxIDs := []common.TxID{}
 	nonReorgedTxIDs := []common.TxID{}
@@ -498,7 +564,7 @@ func TestReorg2(t *testing.T) {
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if poolL2Txs[i].State == common.PoolL2TxStatePending && randomizer%2 == 0 {
 			startForgingTxIDs = append(startForgingTxIDs, poolL2Txs[i].TxID)
 			allTxRandomize = append(allTxRandomize, poolL2Txs[i].TxID)
@@ -510,7 +576,7 @@ func TestReorg2(t *testing.T) {
 	}
 	// Start forging txs
 	err = l2DB.StartForging(startForgingTxIDs, lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var doneForgingTxIDs []common.TxID
 	randomizer = 0
@@ -532,22 +598,22 @@ func TestReorg2(t *testing.T) {
 	}
 	// Done forging txs BEFORE reorgBatch --> nonReorg
 	err = l2DB.DoneForging(doneForgingTxIDs, lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Invalidate txs in reorgBatch --> Reorg
 	err = l2DB.InvalidateTxs(invalidTxIDs, reorgBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = l2DB.Reorg(lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	for _, id := range reorgedTxIDs {
 		tx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, tx.BatchNum)
 		assert.Equal(t, common.PoolL2TxStatePending, tx.State)
 	}
 	for _, id := range nonReorgedTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, lastValidBatch, *fetchedTx.BatchNum)
 	}
 }
@@ -563,7 +629,7 @@ func TestPurge(t *testing.T) {
 	var poolL2Tx []common.PoolL2Tx
 	for i := 0; i < generateTx; i++ {
 		poolL2TxAux, err := generatePoolL2Txs()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		poolL2Tx = append(poolL2Tx, poolL2TxAux...)
 	}
 
@@ -590,39 +656,39 @@ func TestPurge(t *testing.T) {
 			deletedIDs = append(deletedIDs, poolL2Tx[i].TxID)
 		}
 		err := l2DB.AddTxTest(&tx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 	// Set batchNum keeped txs
 	for i := range keepedIDs {
-		_, err = l2DB.db.Exec(
+		_, err = l2DB.dbWrite.Exec(
 			"UPDATE tx_pool SET batch_num = $1 WHERE tx_id = $2;",
 			safeBatchNum, keepedIDs[i],
 		)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 	// Start forging txs and set batchNum
 	err = l2DB.StartForging(doneForgingTxIDs, toDeleteBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Done forging txs and set batchNum
 	err = l2DB.DoneForging(doneForgingTxIDs, toDeleteBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Invalidate txs and set batchNum
 	err = l2DB.InvalidateTxs(invalidTxIDs, toDeleteBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Update timestamp of afterTTL txs
 	deleteTimestamp := time.Unix(time.Now().UTC().Unix()-int64(l2DB.ttl.Seconds()+float64(4*time.Second)), 0)
 	for _, id := range afterTTLIDs {
 		// Set timestamp
-		_, err = l2DB.db.Exec(
+		_, err = l2DB.dbWrite.Exec(
 			"UPDATE tx_pool SET timestamp = $1, state = $2 WHERE tx_id = $3;",
 			deleteTimestamp, common.PoolL2TxStatePending, id,
 		)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	// Purge txs
 	err = l2DB.Purge(safeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Check results
 	for _, id := range deletedIDs {
 		_, err := l2DB.GetTx(id)
@@ -630,7 +696,7 @@ func TestPurge(t *testing.T) {
 	}
 	for _, id := range keepedIDs {
 		_, err := l2DB.GetTx(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 }
 
@@ -644,10 +710,10 @@ func TestAuth(t *testing.T) {
 	for i := 0; i < len(auths); i++ {
 		// Add to the DB
 		err := l2DB.AddAccountCreationAuth(auths[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		// Fetch from DB
 		auth, err := l2DB.GetAccountCreationAuth(auths[i].EthAddr)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		// Check fetched vs generated
 		assert.Equal(t, auths[i].EthAddr, auth.EthAddr)
 		assert.Equal(t, auths[i].BJJ, auth.BJJ)
@@ -665,7 +731,7 @@ func TestAddGet(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// We will work with only 3 txs
 	require.GreaterOrEqual(t, len(poolL2Txs), 3)
@@ -701,3 +767,56 @@ func TestAddGet(t *testing.T) {
 		assert.Equal(t, txs[i], *dbTx)
 	}
 }
+
+func TestPurgeByExternalDelete(t *testing.T) {
+	err := prepareHistoryDB(historyDB)
+	if err != nil {
+		log.Error("Error prepare historyDB", err)
+	}
+	txs, err := generatePoolL2Txs()
+	require.NoError(t, err)
+
+	// We will work with 8 txs
+	require.GreaterOrEqual(t, len(txs), 8)
+	txs = txs[:8]
+	for i := range txs {
+		require.NoError(t, l2DB.AddTxTest(&txs[i]))
+	}
+
+	// We will recreate this scenario:
+	// tx index, status , external_delete
+	// 0       , pending, false
+	// 1       , pending, false
+	// 2       , pending, true // will be deleted
+	// 3       , pending, true // will be deleted
+	// 4       , fging  , false
+	// 5       , fging  , false
+	// 6       , fging  , true
+	// 7       , fging  , true
+
+	require.NoError(t, l2DB.StartForging(
+		[]common.TxID{txs[4].TxID, txs[5].TxID, txs[6].TxID, txs[7].TxID},
+		1))
+	_, err = l2DB.dbWrite.Exec(
+		`UPDATE tx_pool SET external_delete = true WHERE
+			tx_id IN ($1, $2, $3, $4)
+		;`,
+		txs[2].TxID, txs[3].TxID, txs[6].TxID, txs[7].TxID,
+	)
+	require.NoError(t, err)
+	require.NoError(t, l2DB.PurgeByExternalDelete())
+
+	// Query txs that are have been not deleted
+	for _, i := range []int{0, 1, 4, 5, 6, 7} {
+		txID := txs[i].TxID
+		_, err := l2DB.GetTx(txID)
+		require.NoError(t, err)
+	}
+
+	// Query txs that have been deleted
+	for _, i := range []int{2, 3} {
+		txID := txs[i].TxID
+		_, err := l2DB.GetTx(txID)
+		require.Equal(t, sql.ErrNoRows, tracerr.Unwrap(err))
+	}
+}

db/l2db/views.go

@@ -34,6 +34,7 @@ type PoolL2TxWrite struct {
 	RqFee       *common.FeeSelector    `meddler:"rq_fee"`
 	RqNonce     *common.Nonce          `meddler:"rq_nonce"`
 	Type        common.TxType          `meddler:"tx_type"`
+	ClientIP    string                 `meddler:"client_ip"`
 }
 
 // PoolTxAPI represents a L2 Tx pool with extra metadata used by the API
@@ -94,7 +95,6 @@ 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,

db/migrations/0001.sql

@@ -47,7 +47,7 @@ CREATE TABLE token (
     name VARCHAR(20) NOT NULL,
     symbol VARCHAR(10) NOT NULL,
     decimals INT NOT NULL,
-    usd NUMERIC,
+    usd NUMERIC, -- value of a normalized token (1 token = 10^decimals units)
     usd_update TIMESTAMP WITHOUT TIME ZONE
 );
 
@@ -100,6 +100,15 @@ CREATE TABLE account (
     eth_addr BYTEA NOT NULL
 );
 
+CREATE TABLE account_update (
+    item_id SERIAL,
+    eth_block_num BIGINT NOT NULL REFERENCES block (eth_block_num) ON DELETE CASCADE,
+    batch_num BIGINT NOT NULL REFERENCES batch (batch_num) ON DELETE CASCADE,
+    idx BIGINT NOT NULL REFERENCES account (idx) ON DELETE CASCADE,
+    nonce BIGINT NOT NULL,
+    balance BYTEA NOT NULL
+);
+
 CREATE TABLE exit_tree (
     item_id SERIAL PRIMARY KEY,
     batch_num BIGINT REFERENCES batch (batch_num) ON DELETE CASCADE,
@@ -618,7 +627,9 @@ CREATE TABLE tx_pool (
     rq_amount BYTEA,
     rq_fee SMALLINT,
     rq_nonce BIGINT,
-    tx_type VARCHAR(40) NOT NULL
+    tx_type VARCHAR(40) NOT NULL,
+    client_ip VARCHAR,
+    external_delete BOOLEAN NOT NULL DEFAULT false
 );
 
 -- +migrate StatementBegin
@@ -650,35 +661,47 @@ 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
--- drop triggers
+-- triggers
-DROP TRIGGER trigger_token_usd_update ON token;
+DROP TRIGGER IF EXISTS trigger_token_usd_update ON token;
-DROP TRIGGER trigger_set_tx ON tx;
+DROP TRIGGER IF EXISTS trigger_set_tx ON tx;
-DROP TRIGGER trigger_forge_l1_txs ON batch;
+DROP TRIGGER IF EXISTS trigger_forge_l1_txs ON batch;
-DROP TRIGGER trigger_set_pool_tx ON tx_pool;
+DROP TRIGGER IF EXISTS trigger_set_pool_tx ON tx_pool;
--- drop functions
+-- functions
-DROP FUNCTION hez_idx;
+DROP FUNCTION IF EXISTS hez_idx;
-DROP FUNCTION set_token_usd_update;
+DROP FUNCTION IF EXISTS set_token_usd_update;
-DROP FUNCTION fee_percentage;
+DROP FUNCTION IF EXISTS fee_percentage;
-DROP FUNCTION set_tx;
+DROP FUNCTION IF EXISTS set_tx;
-DROP FUNCTION forge_l1_user_txs;
+DROP FUNCTION IF EXISTS forge_l1_user_txs;
-DROP FUNCTION set_pool_tx;
+DROP FUNCTION IF EXISTS set_pool_tx;
--- drop tables
+-- drop tables IF EXISTS
-DROP TABLE account_creation_auth;
+DROP TABLE IF EXISTS node_info;
-DROP TABLE tx_pool;
+DROP TABLE IF EXISTS account_creation_auth;
-DROP TABLE auction_vars;
+DROP TABLE IF EXISTS tx_pool;
-DROP TABLE rollup_vars;
+DROP TABLE IF EXISTS auction_vars;
-DROP TABLE escape_hatch_withdrawal;
+DROP TABLE IF EXISTS rollup_vars;
-DROP TABLE bucket_update;
+DROP TABLE IF EXISTS escape_hatch_withdrawal;
-DROP TABLE token_exchange;
+DROP TABLE IF EXISTS bucket_update;
-DROP TABLE wdelayer_vars;
+DROP TABLE IF EXISTS token_exchange;
-DROP TABLE tx;
+DROP TABLE IF EXISTS wdelayer_vars;
-DROP TABLE exit_tree;
+DROP TABLE IF EXISTS tx;
-DROP TABLE account;
+DROP TABLE IF EXISTS exit_tree;
-DROP TABLE token;
+DROP TABLE IF EXISTS account_update;
-DROP TABLE bid;
+DROP TABLE IF EXISTS account;
-DROP TABLE batch;
+DROP TABLE IF EXISTS token;
-DROP TABLE coordinator;
+DROP TABLE IF EXISTS bid;
-DROP TABLE block;
+DROP TABLE IF EXISTS batch;
--- drop sequences
+DROP TABLE IF EXISTS coordinator;
-DROP SEQUENCE tx_item_id;
+DROP TABLE IF EXISTS block;
+-- sequences
+DROP SEQUENCE IF EXISTS tx_item_id;

eth/ethereum.go

@@ -324,5 +324,6 @@ func (c *EthereumClient) EthCall(ctx context.Context, tx *types.Transaction,
 		Value:    tx.Value(),
 		Data:     tx.Data(),
 	}
-	return c.client.CallContract(ctx, msg, blockNum)
+	result, err := c.client.CallContract(ctx, msg, blockNum)
+	return result, tracerr.Wrap(err)
 }

eth/rollup.go

@@ -327,7 +327,7 @@ func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs, auth *bind.T
 	if auth == nil {
 		auth, err = c.client.NewAuth()
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		auth.GasLimit = 1000000
 	}
@@ -393,7 +393,7 @@ func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs, auth *bind.T
 		l1CoordinatorBytes, l1l2TxData, feeIdxCoordinator, args.VerifierIdx, args.L1Batch,
 		args.ProofA, args.ProofB, args.ProofC)
 	if err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("Failed Hermez.ForgeBatch: %w", err))
+		return nil, tracerr.Wrap(fmt.Errorf("Hermez.ForgeBatch: %w", err))
 	}
 	return tx, nil
 }

go.mod

@@ -21,6 +21,7 @@ require (
 	github.com/miguelmota/go-ethereum-hdwallet v0.0.0-20200123000308-a60dcd172b4c
 	github.com/mitchellh/copystructure v1.0.0
 	github.com/mitchellh/mapstructure v1.3.0
+	github.com/prometheus/client_golang v1.3.0
 	github.com/rubenv/sql-migrate v0.0.0-20200616145509-8d140a17f351
 	github.com/russross/meddler v1.0.0
 	github.com/stretchr/testify v1.6.1

go.sum

@@ -68,6 +68,7 @@ github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZw
 github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
 github.com/btcsuite/btcd v0.0.0-20171128150713-2e60448ffcc6/go.mod h1:Dmm/EzmjnCiweXmzRIAiUWCInVmPgjkzgv5k4tVyXiQ=
@@ -444,6 +445,7 @@ github.com/mattn/go-sqlite3 v1.12.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsO
 github.com/mattn/go-sqlite3 v2.0.3+incompatible h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U=
 github.com/mattn/go-sqlite3 v2.0.3+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mediocregopher/mediocre-go-lib v0.0.0-20181029021733-cb65787f37ed/go.mod h1:dSsfyI2zABAdhcbvkXqgxOxrCsbYeHCPgrZkku60dSg=
 github.com/mediocregopher/radix/v3 v3.3.0/go.mod h1:EmfVyvspXz1uZEyPBMyGK+kjWiKQGvsUt6O3Pj+LDCQ=
@@ -544,23 +546,27 @@ github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod
 github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=
+github.com/prometheus/client_golang v1.3.0 h1:miYCvYqFXtl/J9FIy8eNpBfYthAEFg+Ys0XyUVEcDsc=
 github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.1.0 h1:ElTg5tNp4DqfV7UQjDqv2+RJlNzsDtvNAWccbItceIE=
 github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
+github.com/prometheus/common v0.7.0 h1:L+1lyG48J1zAQXA3RBX/nG/B3gjlHq0zTt2tlbJLyCY=
 github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
+github.com/prometheus/procfs v0.0.8 h1:+fpWZdT24pJBiqJdAwYBjPSk+5YmQzYNPYzQsdzLkt8=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/tsdb v0.6.2-0.20190402121629-4f204dcbc150/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/prometheus/tsdb v0.7.1 h1:YZcsG11NqnK4czYLrWd9mpEuAJIHVQLwdrleYfszMAA=

log/log.go

@@ -67,6 +67,11 @@ func Init(levelStr string, outputs []string) {
 
 func sprintStackTrace(st []tracerr.Frame) string {
 	builder := strings.Builder{}
+	// Skip deepest frame because it belongs to the go runtime and we don't
+	// care about it.
+	if len(st) > 0 {
+		st = st[:len(st)-1]
+	}
 	for _, f := range st {
 		builder.WriteString(fmt.Sprintf("\n%s:%d %s()", f.Path, f.Line, f.Func))
 	}

node/node.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"net"
 	"net/http"
 	"sync"
 	"time"
@@ -52,9 +53,10 @@ const (
 
 // Node is the Hermez Node
 type Node struct {
-	nodeAPI      *NodeAPI
+	nodeAPI         *NodeAPI
-	debugAPI     *debugapi.DebugAPI
+	stateAPIUpdater *api.StateAPIUpdater
-	priceUpdater *priceupdater.PriceUpdater
+	debugAPI        *debugapi.DebugAPI
+	priceUpdater    *priceupdater.PriceUpdater
 	// Coordinator
 	coord *coordinator.Coordinator
 
@@ -62,27 +64,48 @@ type Node struct {
 	sync *synchronizer.Synchronizer
 
 	// General
-	cfg     *config.Node
+	cfg          *config.Node
-	mode    Mode
+	mode         Mode
-	sqlConn *sqlx.DB
+	sqlConnRead  *sqlx.DB
-	ctx     context.Context
+	sqlConnWrite *sqlx.DB
-	wg      sync.WaitGroup
+	historyDB    *historydb.HistoryDB
-	cancel  context.CancelFunc
+	ctx          context.Context
+	wg           sync.WaitGroup
+	cancel       context.CancelFunc
 }
 
 // NewNode creates a Node
 func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	meddler.Debug = cfg.Debug.MeddlerLogs
 	// Stablish DB connection
-	db, err := dbUtils.InitSQLDB(
+	dbWrite, err := dbUtils.InitSQLDB(
-		cfg.PostgreSQL.Port,
+		cfg.PostgreSQL.PortWrite,
-		cfg.PostgreSQL.Host,
+		cfg.PostgreSQL.HostWrite,
-		cfg.PostgreSQL.User,
+		cfg.PostgreSQL.UserWrite,
-		cfg.PostgreSQL.Password,
+		cfg.PostgreSQL.PasswordWrite,
-		cfg.PostgreSQL.Name,
+		cfg.PostgreSQL.NameWrite,
 	)
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		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 {
@@ -92,7 +115,7 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 		)
 	}
 
-	historyDB := historydb.NewHistoryDB(db, apiConnCon)
+	historyDB := historydb.NewHistoryDB(dbRead, dbWrite, apiConnCon)
 
 	ethClient, err := ethclient.Dial(cfg.Web3.URL)
 	if err != nil {
@@ -116,6 +139,23 @@ 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) {
@@ -191,19 +231,42 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	}
 	initSCVars := sync.SCVars()
 
-	scConsts := synchronizer.SCConsts{
+	scConsts := common.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)
+	}
+
+	stateAPIUpdater := api.NewStateAPIUpdater(historyDB, &hdbNodeCfg, initSCVars, &hdbConsts)
+
 	var coord *coordinator.Coordinator
 	var l2DB *l2db.L2DB
 	if mode == ModeCoordinator {
 		l2DB = l2db.NewL2DB(
-			db,
+			dbRead, dbWrite,
 			cfg.Coordinator.L2DB.SafetyPeriod,
 			cfg.Coordinator.L2DB.MaxTxs,
+			cfg.Coordinator.L2DB.MinFeeUSD,
 			cfg.Coordinator.L2DB.TTL.Duration,
 			apiConnCon,
 		)
@@ -245,9 +308,6 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
 		serverProofs := make([]prover.Client, len(cfg.Coordinator.ServerProofs))
 		for i, serverProofCfg := range cfg.Coordinator.ServerProofs {
 			serverProofs[i] = prover.NewProofServerClient(serverProofCfg.URL,
@@ -302,6 +362,7 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 				ForgeDelay:             cfg.Coordinator.ForgeDelay.Duration,
 				ForgeNoTxsDelay:        cfg.Coordinator.ForgeNoTxsDelay.Duration,
 				SyncRetryInterval:      cfg.Coordinator.SyncRetryInterval.Duration,
+				PurgeByExtDelInterval:  cfg.Coordinator.PurgeByExtDelInterval.Duration,
 				EthClientAttempts:      cfg.Coordinator.EthClient.Attempts,
 				EthClientAttemptsDelay: cfg.Coordinator.EthClient.AttemptsDelay.Duration,
 				EthNoReuseNonce:        cfg.Coordinator.EthClient.NoReuseNonce,
@@ -316,6 +377,7 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 					PurgeBlockDelay:      cfg.Coordinator.L2DB.PurgeBlockDelay,
 					InvalidateBlockDelay: cfg.Coordinator.L2DB.InvalidateBlockDelay,
 				},
+				ForgeBatchGasCost: cfg.Coordinator.EthClient.ForgeBatchGasCost,
 				VerifierIdx:       uint8(verifierIdx),
 				TxProcessorConfig: txProcessorCfg,
 			},
@@ -326,11 +388,7 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 			serverProofs,
 			client,
 			&scConsts,
-			&synchronizer.SCVariables{
+			initSCVars,
-				Rollup:   *initSCVars.Rollup,
-				Auction:  *initSCVars.Auction,
-				WDelayer: *initSCVars.WDelayer,
-			},
 		)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
@@ -338,6 +396,11 @@ 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))
@@ -357,22 +420,11 @@ 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 != "" {
@@ -385,19 +437,138 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	}
 	ctx, cancel := context.WithCancel(context.Background())
 	return &Node{
-		nodeAPI:      nodeAPI,
+		stateAPIUpdater: stateAPIUpdater,
-		debugAPI:     debugAPI,
+		nodeAPI:         nodeAPI,
-		priceUpdater: priceUpdater,
+		debugAPI:        debugAPI,
-		coord:        coord,
+		priceUpdater:    priceUpdater,
-		sync:         sync,
+		coord:           coord,
-		cfg:          cfg,
+		sync:            sync,
-		mode:         mode,
+		cfg:             cfg,
-		sqlConn:      db,
+		mode:            mode,
-		ctx:          ctx,
+		sqlConnRead:     dbRead,
-		cancel:       cancel,
+		sqlConnWrite:    dbWrite,
+		historyDB:       historyDB,
+		ctx:             ctx,
+		cancel:          cancel,
 	}, nil
 }
 
+// APIServer is a server that only runs the API
+type APIServer struct {
+	nodeAPI *NodeAPI
+	mode    Mode
+	ctx     context.Context
+	wg      sync.WaitGroup
+	cancel  context.CancelFunc
+}
+
+// NewAPIServer creates a new APIServer
+func NewAPIServer(mode Mode, cfg *config.APIServer) (*APIServer, error) {
+	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))
+		}
+	}
+	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,
+			0,
+			cfg.Coordinator.L2DB.MaxTxs,
+			cfg.Coordinator.L2DB.MinFeeUSD,
+			0,
+			apiConnCon,
+		)
+	}
+
+	if cfg.Debug.GinDebugMode {
+		gin.SetMode(gin.DebugMode)
+	} else {
+		gin.SetMode(gin.ReleaseMode)
+	}
+	server := gin.Default()
+	coord := false
+	if mode == ModeCoordinator {
+		coord = cfg.Coordinator.API.Coordinator
+	}
+	nodeAPI, err := NewNodeAPI(
+		cfg.API.Address,
+		coord, cfg.API.Explorer,
+		server,
+		historyDB,
+		l2DB,
+	)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	return &APIServer{
+		nodeAPI: nodeAPI,
+		mode:    mode,
+		ctx:     ctx,
+		cancel:  cancel,
+	}, nil
+}
+
+// Start the APIServer
+func (s *APIServer) Start() {
+	log.Infow("Starting api server...", "mode", s.mode)
+	log.Info("Starting NodeAPI...")
+	s.wg.Add(1)
+	go func() {
+		defer func() {
+			log.Info("NodeAPI routine stopped")
+			s.wg.Done()
+		}()
+		if err := s.nodeAPI.Run(s.ctx); err != nil {
+			if s.ctx.Err() != nil {
+				return
+			}
+			log.Fatalw("NodeAPI.Run", "err", err)
+		}
+	}()
+}
+
+// Stop the APIServer
+func (s *APIServer) Stop() {
+	log.Infow("Stopping NodeAPI...")
+	s.cancel()
+	s.wg.Wait()
+}
+
 // NodeAPI holds the node http API
 type NodeAPI struct { //nolint:golint
 	api    *api.API
@@ -417,9 +588,7 @@ 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)
@@ -428,9 +597,7 @@ func NewNodeAPI(
 		coordinatorEndpoints, explorerEndpoints,
 		engine,
 		hdb,
-		sdb,
 		l2db,
-		config,
 	)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -446,16 +613,20 @@ func NewNodeAPI(
 // cancelation.
 func (a *NodeAPI) Run(ctx context.Context) error {
 	server := &http.Server{
-		Addr:    a.addr,
 		Handler: a.engine,
 		// TODO: Figure out best parameters for production
 		ReadTimeout:    30 * time.Second, //nolint:gomnd
 		WriteTimeout:   30 * time.Second, //nolint:gomnd
 		MaxHeaderBytes: 1 << 20,          //nolint:gomnd
 	}
+	listener, err := net.Listen("tcp", a.addr)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	log.Infof("NodeAPI is ready at %v", a.addr)
 	go func() {
-		log.Infof("NodeAPI is ready at %v", a.addr)
+		if err := server.Serve(listener); err != nil &&
-		if err := server.ListenAndServe(); err != nil && tracerr.Unwrap(err) != http.ErrServerClosed {
+			tracerr.Unwrap(err) != http.ErrServerClosed {
 			log.Fatalf("Listen: %s\n", err)
 		}
 	}()
@@ -471,64 +642,57 @@ func (a *NodeAPI) Run(ctx context.Context) error {
 	return nil
 }
 
-func (n *Node) handleNewBlock(ctx context.Context, stats *synchronizer.Stats, vars synchronizer.SCVariablesPtr,
+func (n *Node) handleNewBlock(ctx context.Context, stats *synchronizer.Stats, vars *common.SCVariablesPtr,
-	batches []common.BatchData) {
+	batches []common.BatchData) error {
 	if n.mode == ModeCoordinator {
 		n.coord.SendMsg(ctx, coordinator.MsgSyncBlock{
 			Stats:   *stats,
-			Vars:    vars,
+			Vars:    *vars,
 			Batches: batches,
 		})
 	}
-	if n.nodeAPI != nil {
+	n.stateAPIUpdater.SetSCVars(vars)
-		if vars.Rollup != nil {
+	if stats.Synced() {
-			n.nodeAPI.api.SetRollupVariables(*vars.Rollup)
+		if err := n.stateAPIUpdater.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 vars.Auction != nil {
+	} else {
-			n.nodeAPI.api.SetAuctionVariables(*vars.Auction)
+		n.stateAPIUpdater.UpdateNetworkInfoBlock(
-		}
-		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,
-			)
-		}
-	}
-}
-
-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,
-		})
-	}
-	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,
 		)
 	}
+	if err := n.stateAPIUpdater.Store(); err != nil {
+		return tracerr.Wrap(err)
+	}
+	return nil
+}
+
+func (n *Node) handleReorg(ctx context.Context, stats *synchronizer.Stats,
+	vars *common.SCVariables) error {
+	if n.mode == ModeCoordinator {
+		n.coord.SendMsg(ctx, coordinator.MsgSyncReorg{
+			Stats: *stats,
+			Vars:  *vars.AsPtr(),
+		})
+	}
+	n.stateAPIUpdater.SetSCVars(vars.AsPtr())
+	n.stateAPIUpdater.UpdateNetworkInfoBlock(
+		stats.Eth.LastBlock, stats.Sync.LastBlock,
+	)
+	if err := n.stateAPIUpdater.Store(); err != nil {
+		return tracerr.Wrap(err)
+	}
+	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.Sync2(ctx, lastBlock)
+	blockData, discarded, err := n.sync.Sync(ctx, lastBlock)
 	stats := n.sync.Stats()
 	if err != nil {
 		// case: error
@@ -537,16 +701,20 @@ func (n *Node) syncLoopFn(ctx context.Context, lastBlock *common.Block) (*common
 		// case: reorg
 		log.Infow("Synchronizer.Sync reorg", "discarded", *discarded)
 		vars := n.sync.SCVars()
-		n.handleReorg(ctx, stats, vars)
+		if err := n.handleReorg(ctx, stats, vars); err != nil {
+			return nil, time.Duration(0), tracerr.Wrap(err)
+		}
 		return nil, time.Duration(0), nil
 	} else if blockData != nil {
 		// case: new block
-		vars := synchronizer.SCVariablesPtr{
+		vars := common.SCVariablesPtr{
 			Rollup:   blockData.Rollup.Vars,
 			Auction:  blockData.Auction.Vars,
 			WDelayer: blockData.WDelayer.Vars,
 		}
-		n.handleNewBlock(ctx, stats, vars, blockData.Rollup.Batches)
+		if err := n.handleNewBlock(ctx, stats, &vars, blockData.Rollup.Batches); err != nil {
+			return nil, time.Duration(0), tracerr.Wrap(err)
+		}
 		return &blockData.Block, time.Duration(0), nil
 	} else {
 		// case: no block
@@ -565,7 +733,9 @@ func (n *Node) StartSynchronizer() {
 	// the last synced one) is synchronized
 	stats := n.sync.Stats()
 	vars := n.sync.SCVars()
-	n.handleNewBlock(n.ctx, stats, vars, []common.BatchData{})
+	if err := n.handleNewBlock(n.ctx, stats, vars.AsPtr(), []common.BatchData{}); err != nil {
+		log.Fatalw("Node.handleNewBlock", "err", err)
+	}
 
 	n.wg.Add(1)
 	go func() {
@@ -651,15 +821,26 @@ func (n *Node) StartNodeAPI() {
 
 	n.wg.Add(1)
 	go func() {
+		// Do an initial update on startup
+		if err := n.stateAPIUpdater.UpdateMetrics(); err != nil {
+			log.Errorw("ApiStateUpdater.UpdateMetrics", "err", err)
+		}
+		if err := n.stateAPIUpdater.Store(); err != nil {
+			log.Errorw("ApiStateUpdater.Store", "err", err)
+		}
 		for {
 			select {
 			case <-n.ctx.Done():
-				log.Info("API.UpdateMetrics loop done")
+				log.Info("ApiStateUpdater.UpdateMetrics loop done")
 				n.wg.Done()
 				return
 			case <-time.After(n.cfg.API.UpdateMetricsInterval.Duration):
-				if err := n.nodeAPI.api.UpdateMetrics(); err != nil {
+				if err := n.stateAPIUpdater.UpdateMetrics(); err != nil {
-					log.Errorw("API.UpdateMetrics", "err", err)
+					log.Errorw("ApiStateUpdater.UpdateMetrics", "err", err)
+					continue
+				}
+				if err := n.stateAPIUpdater.Store(); err != nil {
+					log.Errorw("ApiStateUpdater.Store", "err", err)
 				}
 			}
 		}
@@ -667,15 +848,26 @@ func (n *Node) StartNodeAPI() {
 
 	n.wg.Add(1)
 	go func() {
+		// Do an initial update on startup
+		if err := n.stateAPIUpdater.UpdateRecommendedFee(); err != nil {
+			log.Errorw("ApiStateUpdater.UpdateRecommendedFee", "err", err)
+		}
+		if err := n.stateAPIUpdater.Store(); err != nil {
+			log.Errorw("ApiStateUpdater.Store", "err", err)
+		}
 		for {
 			select {
 			case <-n.ctx.Done():
-				log.Info("API.UpdateRecommendedFee loop done")
+				log.Info("ApiStateUpdaterAPI.UpdateRecommendedFee loop done")
 				n.wg.Done()
 				return
 			case <-time.After(n.cfg.API.UpdateRecommendedFeeInterval.Duration):
-				if err := n.nodeAPI.api.UpdateRecommendedFee(); err != nil {
+				if err := n.stateAPIUpdater.UpdateRecommendedFee(); err != nil {
-					log.Errorw("API.UpdateRecommendedFee", "err", err)
+					log.Errorw("ApiStateUpdaterAPI.UpdateRecommendedFee", "err", err)
+					continue
+				}
+				if err := n.stateAPIUpdater.Store(); err != nil {
+					log.Errorw("ApiStateUpdater.Store", "err", err)
 				}
 			}
 		}

priceupdater/priceupdater_test.go

@@ -20,7 +20,7 @@ func TestPriceUpdater(t *testing.T) {
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	assert.NoError(t, err)
-	historyDB := historydb.NewHistoryDB(db, nil)
+	historyDB := historydb.NewHistoryDB(db, db, nil)
 	// Clean DB
 	test.WipeDB(historyDB.DB())
 	// Populate DB

synchronizer/metrics.go

@@ -0,0 +1,44 @@
+package synchronizer
+
+import "github.com/prometheus/client_golang/prometheus"
+
+var (
+	metricReorgsCount = prometheus.NewCounter(
+		prometheus.CounterOpts{
+			Name: "sync_reorgs",
+			Help: "",
+		},
+	)
+	metricSyncedLastBlockNum = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "sync_synced_last_block_num",
+			Help: "",
+		},
+	)
+	metricEthLastBlockNum = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "sync_eth_last_block_num",
+			Help: "",
+		},
+	)
+	metricSyncedLastBatchNum = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "sync_synced_last_batch_num",
+			Help: "",
+		},
+	)
+	metricEthLastBatchNum = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "sync_eth_last_batch_num",
+			Help: "",
+		},
+	)
+)
+
+func init() {
+	prometheus.MustRegister(metricReorgsCount)
+	prometheus.MustRegister(metricSyncedLastBlockNum)
+	prometheus.MustRegister(metricEthLastBlockNum)
+	prometheus.MustRegister(metricSyncedLastBatchNum)
+	prometheus.MustRegister(metricEthLastBatchNum)
+}

synchronizer/synchronizer.go

@@ -183,26 +183,26 @@ type StartBlockNums struct {
 }
 
 // SCVariables joins all the smart contract variables in a single struct
-type SCVariables struct {
+// type SCVariables struct {
-	Rollup   common.RollupVariables   `validate:"required"`
+// 	Rollup   common.RollupVariables   `validate:"required"`
-	Auction  common.AuctionVariables  `validate:"required"`
+// 	Auction  common.AuctionVariables  `validate:"required"`
-	WDelayer common.WDelayerVariables `validate:"required"`
+// 	WDelayer common.WDelayerVariables `validate:"required"`
-}
+// }
-
+//
-// SCVariablesPtr joins all the smart contract variables as pointers in a single
+// // SCVariablesPtr joins all the smart contract variables as pointers in a single
-// struct
+// // struct
-type SCVariablesPtr struct {
+// type SCVariablesPtr struct {
-	Rollup   *common.RollupVariables   `validate:"required"`
+// 	Rollup   *common.RollupVariables   `validate:"required"`
-	Auction  *common.AuctionVariables  `validate:"required"`
+// 	Auction  *common.AuctionVariables  `validate:"required"`
-	WDelayer *common.WDelayerVariables `validate:"required"`
+// 	WDelayer *common.WDelayerVariables `validate:"required"`
-}
+// }
-
+//
-// SCConsts joins all the smart contract constants in a single struct
+// // SCConsts joins all the smart contract constants in a single struct
-type SCConsts struct {
+// type SCConsts struct {
-	Rollup   common.RollupConstants
+// 	Rollup   common.RollupConstants
-	Auction  common.AuctionConstants
+// 	Auction  common.AuctionConstants
-	WDelayer common.WDelayerConstants
+// 	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           SCConsts
+	consts           common.SCConsts
 	historyDB        *historydb.HistoryDB
 	stateDB          *statedb.StateDB
 	cfg              Config
-	initVars         SCVariables
+	initVars         common.SCVariables
 	startBlockNum    int64
-	vars             SCVariables
+	vars             common.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 := SCConsts{
+	consts := common.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() SCVariablesPtr {
+func (s *Synchronizer) SCVars() *common.SCVariables {
-	return SCVariablesPtr{
+	return &common.SCVariables{
-		Rollup:   s.vars.Rollup.Copy(),
+		Rollup:   *s.vars.Rollup.Copy(),
-		Auction:  s.vars.Auction.Copy(),
+		Auction:  *s.vars.Auction.Copy(),
-		WDelayer: s.vars.WDelayer.Copy(),
+		WDelayer: *s.vars.WDelayer.Copy(),
 	}
 }
 
@@ -503,13 +503,13 @@ func (s *Synchronizer) resetIntermediateState() error {
 	return nil
 }
 
-// Sync2 attems to synchronize an ethereum block starting from lastSavedBlock.
+// Sync attems to synchronize an ethereum block starting from lastSavedBlock.
 // If lastSavedBlock is nil, the lastSavedBlock value is obtained from de DB.
 // If a block is synched, it will be returned and also stored in the DB.  If a
 // reorg is detected, the number of discarded blocks will be returned and no
 // synchronization will be made.
 // TODO: Be smart about locking: only lock during the read/write operations
-func (s *Synchronizer) Sync2(ctx context.Context,
+func (s *Synchronizer) Sync(ctx context.Context,
 	lastSavedBlock *common.Block) (blockData *common.BlockData, discarded *int64, err error) {
 	if s.resetStateFailed {
 		if err := s.resetIntermediateState(); err != nil {
@@ -662,12 +662,16 @@ func (s *Synchronizer) Sync2(ctx context.Context,
 	}
 
 	for _, batchData := range rollupData.Batches {
+		metricSyncedLastBatchNum.Set(float64(batchData.Batch.BatchNum))
+		metricEthLastBatchNum.Set(float64(s.stats.Eth.LastBatchNum))
 		log.Debugw("Synced batch",
 			"syncLastBatch", batchData.Batch.BatchNum,
 			"syncBatchesPerc", s.stats.batchesPerc(batchData.Batch.BatchNum),
 			"ethLastBatch", s.stats.Eth.LastBatchNum,
 		)
 	}
+	metricSyncedLastBlockNum.Set(float64(s.stats.Sync.LastBlock.Num))
+	metricEthLastBlockNum.Set(float64(s.stats.Eth.LastBlock.Num))
 	log.Debugw("Synced block",
 		"syncLastBlockNum", s.stats.Sync.LastBlock.Num,
 		"syncBlocksPerc", s.stats.blocksPerc(),
@@ -720,7 +724,7 @@ func (s *Synchronizer) reorg(uncleBlock *common.Block) (int64, error) {
 }
 
 func getInitialVariables(ethClient eth.ClientInterface,
-	consts *SCConsts) (*SCVariables, *StartBlockNums, error) {
+	consts *common.SCConsts) (*common.SCVariables, *StartBlockNums, error) {
 	rollupInit, rollupInitBlock, err := ethClient.RollupEventInit()
 	if err != nil {
 		return nil, nil, tracerr.Wrap(fmt.Errorf("RollupEventInit: %w", err))
@@ -736,7 +740,7 @@ func getInitialVariables(ethClient eth.ClientInterface,
 	rollupVars := rollupInit.RollupVariables()
 	auctionVars := auctionInit.AuctionVariables(consts.Auction.InitialMinimalBidding)
 	wDelayerVars := wDelayerInit.WDelayerVariables()
-	return &SCVariables{
+	return &common.SCVariables{
 			Rollup:   *rollupVars,
 			Auction:  *auctionVars,
 			WDelayer: *wDelayerVars,
@@ -993,6 +997,19 @@ func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, e
 		}
 		batchData.CreatedAccounts = processTxsOut.CreatedAccounts
 
+		batchData.UpdatedAccounts = make([]common.AccountUpdate, 0,
+			len(processTxsOut.UpdatedAccounts))
+		for _, acc := range processTxsOut.UpdatedAccounts {
+			batchData.UpdatedAccounts = append(batchData.UpdatedAccounts,
+				common.AccountUpdate{
+					EthBlockNum: blockNum,
+					BatchNum:    batchNum,
+					Idx:         acc.Idx,
+					Nonce:       acc.Nonce,
+					Balance:     acc.Balance,
+				})
+		}
+
 		slotNum := int64(0)
 		if ethBlock.Num >= s.consts.Auction.GenesisBlockNum {
 			slotNum = (ethBlock.Num - s.consts.Auction.GenesisBlockNum) /

synchronizer/synchronizer_test.go

@@ -171,6 +171,8 @@ func checkSyncBlock(t *testing.T, s *Synchronizer, blockNum int, block, syncBloc
 			*exit = syncBatch.ExitTree[j]
 		}
 		assert.Equal(t, batch.Batch, syncBatch.Batch)
+		// Ignore updated accounts
+		syncBatch.UpdatedAccounts = nil
 		assert.Equal(t, batch, syncBatch)
 		assert.Equal(t, &batch.Batch, dbBatch) //nolint:gosec
 
@@ -313,7 +315,7 @@ func newTestModules(t *testing.T) (*statedb.StateDB, *historydb.HistoryDB) {
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	historyDB := historydb.NewHistoryDB(db, nil)
+	historyDB := historydb.NewHistoryDB(db, db, nil)
 	// Clear DB
 	test.WipeDB(historyDB.DB())
 
@@ -357,7 +359,7 @@ func TestSyncGeneral(t *testing.T) {
 	assert.Equal(t, false, stats.Synced())
 
 	// Test Sync for rollup genesis block
-	syncBlock, discards, err := s.Sync2(ctx, nil)
+	syncBlock, discards, err := s.Sync(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.NotNil(t, syncBlock)
@@ -370,9 +372,9 @@ func TestSyncGeneral(t *testing.T) {
 	assert.Equal(t, int64(1), stats.Eth.LastBlock.Num)
 	assert.Equal(t, int64(1), stats.Sync.LastBlock.Num)
 	vars := s.SCVars()
-	assert.Equal(t, clientSetup.RollupVariables, vars.Rollup)
+	assert.Equal(t, *clientSetup.RollupVariables, vars.Rollup)
-	assert.Equal(t, clientSetup.AuctionVariables, vars.Auction)
+	assert.Equal(t, *clientSetup.AuctionVariables, vars.Auction)
-	assert.Equal(t, clientSetup.WDelayerVariables, vars.WDelayer)
+	assert.Equal(t, *clientSetup.WDelayerVariables, vars.WDelayer)
 
 	dbBlocks, err := s.historyDB.GetAllBlocks()
 	require.NoError(t, err)
@@ -380,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.Sync2(ctx, nil)
+	syncBlock, discards, err = s.Sync(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.Nil(t, syncBlock)
@@ -477,7 +479,7 @@ func TestSyncGeneral(t *testing.T) {
 
 	// Block 2
 
-	syncBlock, discards, err = s.Sync2(ctx, nil)
+	syncBlock, discards, err = s.Sync(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.NotNil(t, syncBlock)
@@ -494,7 +496,7 @@ func TestSyncGeneral(t *testing.T) {
 
 	// Block 3
 
-	syncBlock, discards, err = s.Sync2(ctx, nil)
+	syncBlock, discards, err = s.Sync(ctx, nil)
 	assert.NoError(t, err)
 	require.NoError(t, err)
 	require.Nil(t, discards)
@@ -518,7 +520,7 @@ func TestSyncGeneral(t *testing.T) {
 	require.NoError(t, err)
 	client.CtlMineBlock()
 
-	syncBlock, discards, err = s.Sync2(ctx, nil)
+	syncBlock, discards, err = s.Sync(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.NotNil(t, syncBlock)
@@ -531,9 +533,9 @@ func TestSyncGeneral(t *testing.T) {
 	assert.Equal(t, int64(4), stats.Eth.LastBlock.Num)
 	assert.Equal(t, int64(4), stats.Sync.LastBlock.Num)
 	vars = s.SCVars()
-	assert.Equal(t, clientSetup.RollupVariables, vars.Rollup)
+	assert.Equal(t, *clientSetup.RollupVariables, vars.Rollup)
-	assert.Equal(t, clientSetup.AuctionVariables, vars.Auction)
+	assert.Equal(t, *clientSetup.AuctionVariables, vars.Auction)
-	assert.Equal(t, clientSetup.WDelayerVariables, vars.WDelayer)
+	assert.Equal(t, *clientSetup.WDelayerVariables, vars.WDelayer)
 
 	dbExits, err := s.historyDB.GetAllExits()
 	require.NoError(t, err)
@@ -569,7 +571,7 @@ func TestSyncGeneral(t *testing.T) {
 
 	client.CtlMineBlock()
 
-	syncBlock, discards, err = s.Sync2(ctx, nil)
+	syncBlock, discards, err = s.Sync(ctx, nil)
 	require.NoError(t, err)
 	require.Nil(t, discards)
 	require.NotNil(t, syncBlock)
@@ -654,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.Sync2(ctx, nil)
+	syncBlock, discards, err = s.Sync(ctx, nil)
 	require.NoError(t, err)
 	expetedDiscards := int64(4)
 	require.Equal(t, &expetedDiscards, discards)
@@ -663,9 +665,9 @@ func TestSyncGeneral(t *testing.T) {
 	assert.Equal(t, false, stats.Synced())
 	assert.Equal(t, int64(6), stats.Eth.LastBlock.Num)
 	vars = s.SCVars()
-	assert.Equal(t, clientSetup.RollupVariables, vars.Rollup)
+	assert.Equal(t, *clientSetup.RollupVariables, vars.Rollup)
-	assert.Equal(t, clientSetup.AuctionVariables, vars.Auction)
+	assert.Equal(t, *clientSetup.AuctionVariables, vars.Auction)
-	assert.Equal(t, clientSetup.WDelayerVariables, vars.WDelayer)
+	assert.Equal(t, *clientSetup.WDelayerVariables, vars.WDelayer)
 
 	// At this point, the DB only has data up to block 1
 	dbBlock, err := s.historyDB.GetLastBlock()
@@ -682,7 +684,7 @@ func TestSyncGeneral(t *testing.T) {
 
 	// Sync blocks 2-6
 	for i := 0; i < 5; i++ {
-		syncBlock, discards, err = s.Sync2(ctx, nil)
+		syncBlock, discards, err = s.Sync(ctx, nil)
 		require.NoError(t, err)
 		require.Nil(t, discards)
 		require.NotNil(t, syncBlock)
@@ -702,9 +704,9 @@ func TestSyncGeneral(t *testing.T) {
 		}
 
 		vars = s.SCVars()
-		assert.Equal(t, clientSetup.RollupVariables, vars.Rollup)
+		assert.Equal(t, *clientSetup.RollupVariables, vars.Rollup)
-		assert.Equal(t, clientSetup.AuctionVariables, vars.Auction)
+		assert.Equal(t, *clientSetup.AuctionVariables, vars.Auction)
-		assert.Equal(t, clientSetup.WDelayerVariables, vars.WDelayer)
+		assert.Equal(t, *clientSetup.WDelayerVariables, vars.WDelayer)
 	}
 
 	dbBlock, err = s.historyDB.GetLastBlock()
@@ -805,7 +807,7 @@ func TestSyncForgerCommitment(t *testing.T) {
 
 	// be in sync
 	for {
-		syncBlock, discards, err := s.Sync2(ctx, nil)
+		syncBlock, discards, err := s.Sync(ctx, nil)
 		require.NoError(t, err)
 		require.Nil(t, discards)
 		if syncBlock == nil {
@@ -824,7 +826,7 @@ func TestSyncForgerCommitment(t *testing.T) {
 		err = client.CtlAddBlocks([]common.BlockData{block})
 		require.NoError(t, err)
 
-		syncBlock, discards, err := s.Sync2(ctx, nil)
+		syncBlock, discards, err := s.Sync(ctx, nil)
 		require.NoError(t, err)
 		require.Nil(t, discards)
 		if syncBlock == nil {

test/debugapi/debugapi.go

@@ -2,6 +2,7 @@ package debugapi
 
 import (
 	"context"
+	"net"
 	"net/http"
 	"time"
 
@@ -12,6 +13,7 @@ import (
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/hermez-node/synchronizer"
 	"github.com/hermeznetwork/tracerr"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
 func handleNoRoute(c *gin.Context) {
@@ -107,6 +109,8 @@ func (a *DebugAPI) Run(ctx context.Context) error {
 	api.Use(cors.Default())
 	debugAPI := api.Group("/debug")
 
+	debugAPI.GET("/metrics", gin.WrapH(promhttp.Handler()))
+
 	debugAPI.GET("sdb/batchnum", a.handleCurrentBatch)
 	debugAPI.GET("sdb/mtroot", a.handleMTRoot)
 	// Accounts returned by these endpoints will always have BatchNum = 0,
@@ -118,16 +122,20 @@ func (a *DebugAPI) Run(ctx context.Context) error {
 	debugAPI.GET("sync/stats", a.handleSyncStats)
 
 	debugAPIServer := &http.Server{
-		Addr:    a.addr,
 		Handler: api,
-		// Use some hardcoded numberes that are suitable for testing
+		// Use some hardcoded numbers that are suitable for testing
 		ReadTimeout:    30 * time.Second, //nolint:gomnd
 		WriteTimeout:   30 * time.Second, //nolint:gomnd
 		MaxHeaderBytes: 1 << 20,          //nolint:gomnd
 	}
+	listener, err := net.Listen("tcp", a.addr)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	log.Infof("DebugAPI is ready at %v", a.addr)
 	go func() {
-		log.Infof("DebugAPI is ready at %v", a.addr)
+		if err := debugAPIServer.Serve(listener); err != nil &&
-		if err := debugAPIServer.ListenAndServe(); err != nil && tracerr.Unwrap(err) != http.ErrServerClosed {
+			tracerr.Unwrap(err) != http.ErrServerClosed {
 			log.Fatalf("Listen: %s\n", err)
 		}
 	}()

test/proofserver/proofserver.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"io/ioutil"
+	"net"
 	"net/http"
 	"sync"
 	"time"
@@ -145,7 +146,7 @@ const longWaitDuration = 999 * time.Hour
 // const provingDuration = 2 * time.Second
 
 func (s *Mock) runProver(ctx context.Context) {
-	waitCh := time.After(longWaitDuration)
+	timer := time.NewTimer(longWaitDuration)
 	for {
 		select {
 		case <-ctx.Done():
@@ -153,21 +154,27 @@ func (s *Mock) runProver(ctx context.Context) {
 		case msg := <-s.msgCh:
 			switch msg.value {
 			case "cancel":
-				waitCh = time.After(longWaitDuration)
+				if !timer.Stop() {
+					<-timer.C
+				}
+				timer.Reset(longWaitDuration)
 				s.Lock()
 				if !s.status.IsReady() {
 					s.status = prover.StatusCodeAborted
 				}
 				s.Unlock()
 			case "prove":
-				waitCh = time.After(s.provingDuration)
+				if !timer.Stop() {
+					<-timer.C
+				}
+				timer.Reset(s.provingDuration)
 				s.Lock()
 				s.status = prover.StatusCodeBusy
 				s.Unlock()
 			}
 			msg.ackCh <- true
-		case <-waitCh:
+		case <-timer.C:
-			waitCh = time.After(longWaitDuration)
+			timer.Reset(longWaitDuration)
 			s.Lock()
 			if s.status != prover.StatusCodeBusy {
 				s.Unlock()
@@ -202,16 +209,20 @@ func (s *Mock) Run(ctx context.Context) error {
 	apiGroup.POST("/cancel", s.handleCancel)
 
 	debugAPIServer := &http.Server{
-		Addr:    s.addr,
 		Handler: api,
 		// Use some hardcoded numberes that are suitable for testing
 		ReadTimeout:    30 * time.Second, //nolint:gomnd
 		WriteTimeout:   30 * time.Second, //nolint:gomnd
 		MaxHeaderBytes: 1 << 20,          //nolint:gomnd
 	}
+	listener, err := net.Listen("tcp", s.addr)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	log.Infof("prover.MockServer is ready at %v", s.addr)
 	go func() {
-		log.Infof("prover.MockServer is ready at %v", s.addr)
+		if err := debugAPIServer.Serve(listener); err != nil &&
-		if err := debugAPIServer.ListenAndServe(); err != nil && tracerr.Unwrap(err) != http.ErrServerClosed {
+			tracerr.Unwrap(err) != http.ErrServerClosed {
 			log.Fatalf("Listen: %s\n", err)
 		}
 	}()

test/zkproof/flows_test.go

@@ -38,7 +38,7 @@ func addTokens(t *testing.T, tc *til.Context, db *sqlx.DB) {
 		})
 	}
 
-	hdb := historydb.NewHistoryDB(db, nil)
+	hdb := historydb.NewHistoryDB(db, db, nil)
 	assert.NoError(t, hdb.AddBlock(&common.Block{
 		Num: 1,
 	}))
@@ -75,7 +75,7 @@ func initTxSelector(t *testing.T, chainID uint16, hermezContractAddr ethCommon.A
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpSyncDB")
 	require.NoError(t, err)

txprocessor/txprocessor.go

@@ -27,6 +27,9 @@ type TxProcessor struct {
 	// AccumulatedFees contains the accumulated fees for each token (Coord
 	// Idx) in the processed batch
 	AccumulatedFees map[common.Idx]*big.Int
+	// updatedAccounts stores the last version of the account when it has
+	// been created/updated by any of the processed transactions.
+	updatedAccounts map[common.Idx]*common.Account
 	config          Config
 }
 
@@ -55,6 +58,9 @@ type ProcessTxOutput struct {
 	CreatedAccounts    []common.Account
 	CoordinatorIdxsMap map[common.TokenID]common.Idx
 	CollectedFees      map[common.TokenID]*big.Int
+	// UpdatedAccounts returns the current state of each account
+	// created/updated by any of the processed transactions.
+	UpdatedAccounts map[common.Idx]*common.Account
 }
 
 func newErrorNotEnoughBalance(tx common.Tx) error {
@@ -127,6 +133,10 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 		return nil, tracerr.Wrap(fmt.Errorf("L1UserTx + L1CoordinatorTx (%d) can not be bigger than MaxL1Tx (%d)", len(l1usertxs)+len(l1coordinatortxs), tp.config.MaxTx))
 	}
 
+	if tp.s.Type() == statedb.TypeSynchronizer {
+		tp.updatedAccounts = make(map[common.Idx]*common.Account)
+	}
+
 	exits := make([]processedExit, nTx)
 
 	if tp.s.Type() == statedb.TypeBatchBuilder {
@@ -198,7 +208,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 			}
 		}
 		if tp.s.Type() == statedb.TypeSynchronizer || tp.s.Type() == statedb.TypeBatchBuilder {
-			if exitIdx != nil && exitTree != nil {
+			if exitIdx != nil && exitTree != nil && exitAccount != nil {
 				exits[tp.i] = processedExit{
 					exit:    true,
 					newExit: newExit,
@@ -382,7 +392,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 			tp.zki.EthAddr3[iFee] = common.EthAddrToBigInt(accCoord.EthAddr)
 		}
 		accCoord.Balance = new(big.Int).Add(accCoord.Balance, accumulatedFee)
-		pFee, err := tp.s.UpdateAccount(idx, accCoord)
+		pFee, err := tp.updateAccount(idx, accCoord)
 		if err != nil {
 			log.Error(err)
 			return nil, tracerr.Wrap(err)
@@ -407,39 +417,39 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 		return nil, nil
 	}
 
-	// once all txs processed (exitTree root frozen), for each Exit,
-	// generate common.ExitInfo data
-	var exitInfos []common.ExitInfo
-	exitInfosByIdx := make(map[common.Idx]*common.ExitInfo)
-	for i := 0; i < nTx; i++ {
-		if !exits[i].exit {
-			continue
-		}
-		exitIdx := exits[i].idx
-		exitAccount := exits[i].acc
-
-		// 0. generate MerkleProof
-		p, err := exitTree.GenerateSCVerifierProof(exitIdx.BigInt(), nil)
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-
-		// 1. generate common.ExitInfo
-		ei := common.ExitInfo{
-			AccountIdx:  exitIdx,
-			MerkleProof: p,
-			Balance:     exitAccount.Balance,
-		}
-		if prevExit, ok := exitInfosByIdx[exitIdx]; !ok {
-			exitInfos = append(exitInfos, ei)
-			exitInfosByIdx[exitIdx] = &exitInfos[len(exitInfos)-1]
-		} else {
-			*prevExit = ei
-		}
-	}
-
 	if tp.s.Type() == statedb.TypeSynchronizer {
-		// retuTypeexitInfos, createdAccounts and collectedFees, so Synchronizer will
+		// once all txs processed (exitTree root frozen), for each Exit,
+		// generate common.ExitInfo data
+		var exitInfos []common.ExitInfo
+		exitInfosByIdx := make(map[common.Idx]*common.ExitInfo)
+		for i := 0; i < nTx; i++ {
+			if !exits[i].exit {
+				continue
+			}
+			exitIdx := exits[i].idx
+			exitAccount := exits[i].acc
+
+			// 0. generate MerkleProof
+			p, err := exitTree.GenerateSCVerifierProof(exitIdx.BigInt(), nil)
+			if err != nil {
+				return nil, tracerr.Wrap(err)
+			}
+
+			// 1. generate common.ExitInfo
+			ei := common.ExitInfo{
+				AccountIdx:  exitIdx,
+				MerkleProof: p,
+				Balance:     exitAccount.Balance,
+			}
+			if prevExit, ok := exitInfosByIdx[exitIdx]; !ok {
+				exitInfos = append(exitInfos, ei)
+				exitInfosByIdx[exitIdx] = &exitInfos[len(exitInfos)-1]
+			} else {
+				*prevExit = ei
+			}
+		}
+
+		// retun exitInfos, createdAccounts and collectedFees, so Synchronizer will
 		// be able to store it into HistoryDB for the concrete BatchNum
 		return &ProcessTxOutput{
 			ZKInputs:           nil,
@@ -447,6 +457,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 			CreatedAccounts:    createdAccounts,
 			CoordinatorIdxsMap: coordIdxsMap,
 			CollectedFees:      collectedFees,
+			UpdatedAccounts:    tp.updatedAccounts,
 		}, nil
 	}
 
@@ -594,7 +605,7 @@ func (tp *TxProcessor) ProcessL1Tx(exitTree *merkletree.MerkleTree, tx *common.L
 
 		// execute exit flow
 		// coordIdxsMap is 'nil', as at L1Txs there is no L2 fees
-		exitAccount, newExit, err := tp.applyExit(nil, nil, exitTree, tx.Tx())
+		exitAccount, newExit, err := tp.applyExit(nil, nil, exitTree, tx.Tx(), tx.Amount)
 		if err != nil {
 			log.Error(err)
 			return nil, nil, false, nil, tracerr.Wrap(err)
@@ -719,7 +730,7 @@ func (tp *TxProcessor) ProcessL2Tx(coordIdxsMap map[common.TokenID]common.Idx,
 		}
 	case common.TxTypeExit:
 		// execute exit flow
-		exitAccount, newExit, err := tp.applyExit(coordIdxsMap, collectedFees, exitTree, tx.Tx())
+		exitAccount, newExit, err := tp.applyExit(coordIdxsMap, collectedFees, exitTree, tx.Tx(), tx.Amount)
 		if err != nil {
 			log.Error(err)
 			return nil, nil, false, tracerr.Wrap(err)
@@ -741,7 +752,7 @@ func (tp *TxProcessor) applyCreateAccount(tx *common.L1Tx) error {
 		EthAddr: tx.FromEthAddr,
 	}
 
-	p, err := tp.s.CreateAccount(common.Idx(tp.s.CurrentIdx()+1), account)
+	p, err := tp.createAccount(common.Idx(tp.s.CurrentIdx()+1), account)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -776,6 +787,28 @@ func (tp *TxProcessor) applyCreateAccount(tx *common.L1Tx) error {
 	return tp.s.SetCurrentIdx(tp.s.CurrentIdx() + 1)
 }
 
+// createAccount is a wrapper over the StateDB.CreateAccount method that also
+// stores the created account in the updatedAccounts map in case the StateDB is
+// of TypeSynchronizer
+func (tp *TxProcessor) createAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
+	if tp.s.Type() == statedb.TypeSynchronizer {
+		account.Idx = idx
+		tp.updatedAccounts[idx] = account
+	}
+	return tp.s.CreateAccount(idx, account)
+}
+
+// updateAccount is a wrapper over the StateDB.UpdateAccount method that also
+// stores the updated account in the updatedAccounts map in case the StateDB is
+// of TypeSynchronizer
+func (tp *TxProcessor) updateAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
+	if tp.s.Type() == statedb.TypeSynchronizer {
+		account.Idx = idx
+		tp.updatedAccounts[idx] = account
+	}
+	return tp.s.UpdateAccount(idx, account)
+}
+
 // applyDeposit updates the balance in the account of the depositer, if
 // andTransfer parameter is set to true, the method will also apply the
 // Transfer of the L1Tx/DepositTransfer
@@ -806,7 +839,7 @@ func (tp *TxProcessor) applyDeposit(tx *common.L1Tx, transfer bool) error {
 	}
 
 	// update sender account in localStateDB
-	p, err := tp.s.UpdateAccount(tx.FromIdx, accSender)
+	p, err := tp.updateAccount(tx.FromIdx, accSender)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -843,7 +876,7 @@ func (tp *TxProcessor) applyDeposit(tx *common.L1Tx, transfer bool) error {
 		accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.EffectiveAmount)
 
 		// update receiver account in localStateDB
-		p, err := tp.s.UpdateAccount(tx.ToIdx, accReceiver)
+		p, err := tp.updateAccount(tx.ToIdx, accReceiver)
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
@@ -926,7 +959,7 @@ func (tp *TxProcessor) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 	}
 
 	// update sender account in localStateDB
-	pSender, err := tp.s.UpdateAccount(tx.FromIdx, accSender)
+	pSender, err := tp.updateAccount(tx.FromIdx, accSender)
 	if err != nil {
 		log.Error(err)
 		return tracerr.Wrap(err)
@@ -965,7 +998,7 @@ func (tp *TxProcessor) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 	accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.Amount)
 
 	// update receiver account in localStateDB
-	pReceiver, err := tp.s.UpdateAccount(auxToIdx, accReceiver)
+	pReceiver, err := tp.updateAccount(auxToIdx, accReceiver)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1008,7 +1041,7 @@ func (tp *TxProcessor) applyCreateAccountDepositTransfer(tx *common.L1Tx) error
 	}
 
 	// create Account of the Sender
-	p, err := tp.s.CreateAccount(common.Idx(tp.s.CurrentIdx()+1), accSender)
+	p, err := tp.createAccount(common.Idx(tp.s.CurrentIdx()+1), accSender)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1056,7 +1089,7 @@ func (tp *TxProcessor) applyCreateAccountDepositTransfer(tx *common.L1Tx) error
 	accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.EffectiveAmount)
 
 	// update receiver account in localStateDB
-	p, err = tp.s.UpdateAccount(tx.ToIdx, accReceiver)
+	p, err = tp.updateAccount(tx.ToIdx, accReceiver)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1071,7 +1104,7 @@ func (tp *TxProcessor) applyCreateAccountDepositTransfer(tx *common.L1Tx) error
 // new Leaf in the ExitTree.
 func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 	collectedFees map[common.TokenID]*big.Int, exitTree *merkletree.MerkleTree,
-	tx common.Tx) (*common.Account, bool, error) {
+	tx common.Tx, originalAmount *big.Int) (*common.Account, bool, error) {
 	// 0. subtract tx.Amount from current Account in StateMT
 	// add the tx.Amount into the Account (tx.FromIdx) in the ExitMT
 	acc, err := tp.s.GetAccount(tx.FromIdx)
@@ -1130,7 +1163,7 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 		}
 	}
 
-	p, err := tp.s.UpdateAccount(tx.FromIdx, acc)
+	p, err := tp.updateAccount(tx.FromIdx, acc)
 	if err != nil {
 		return nil, false, tracerr.Wrap(err)
 	}
@@ -1141,6 +1174,21 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 	if exitTree == nil {
 		return nil, false, nil
 	}
+
+	// Do not add the Exit when Amount=0, not EffectiveAmount=0. In
+	// txprocessor.applyExit function, the tx.Amount is in reality the
+	// EffectiveAmount, that's why is used here the originalAmount
+	// parameter, which contains the real value of the tx.Amount (not
+	// tx.EffectiveAmount).  This is a particularity of the approach of the
+	// circuit, the idea will be in the future to update the circuit and
+	// when Amount>0 but EffectiveAmount=0, to not add the Exit in the
+	// Exits MerkleTree, but for the moment the Go code is adapted to the
+	// circuit.
+	if originalAmount.Cmp(big.NewInt(0)) == 0 { // Amount == 0
+		// if the Exit Amount==0, the Exit is not added to the ExitTree
+		return nil, false, nil
+	}
+
 	exitAccount, err := statedb.GetAccountInTreeDB(exitTree.DB(), tx.FromIdx)
 	if tracerr.Unwrap(err) == db.ErrNotFound {
 		// 1a. if idx does not exist in exitTree:
@@ -1149,6 +1197,8 @@ 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
+			// EffectiveAmount
 			Balance: tx.Amount,
 			BJJ:     acc.BJJ,
 			EthAddr: acc.EthAddr,
@@ -1162,7 +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
-			tp.zki.Balance2[tp.i] = tx.Amount
+			// Balance2 contains the ExitLeaf Balance before the
+			// leaf update, which is 0
+			tp.zki.Balance2[tp.i] = big.NewInt(0)
 			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)
@@ -1196,7 +1248,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
-		tp.zki.Balance2[tp.i] = tx.Amount
+		// Balance2 contains the ExitLeaf Balance before the leaf
+		// update
+		tp.zki.Balance2[tp.i] = exitAccount.Balance
 		tp.zki.EthAddr2[tp.i] = common.EthAddrToBigInt(acc.EthAddr)
 	}
 
@@ -1214,6 +1268,7 @@ 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

txprocessor/txprocessor_test.go

@@ -4,6 +4,7 @@ import (
 	"io/ioutil"
 	"math/big"
 	"os"
+	"sort"
 	"testing"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
@@ -794,7 +795,8 @@ func TestMultipleCoordIdxForTokenID(t *testing.T) {
 	checkBalanceByIdx(t, tp.s, 259, "0")   // Coord0
 }
 
-func TestTwoExits(t *testing.T) {
+func testTwoExits(t *testing.T, stateDBType statedb.TypeStateDB) ([]*ProcessTxOutput,
+	[]*ProcessTxOutput, []*ProcessTxOutput) {
 	// 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.
@@ -802,8 +804,9 @@ func TestTwoExits(t *testing.T) {
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
 
+	nLevels := 16
 	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
-		Type: statedb.TypeSynchronizer, NLevels: 32})
+		Type: stateDBType, NLevels: nLevels})
 	assert.NoError(t, err)
 
 	chainID := uint16(1)
@@ -839,10 +842,10 @@ func TestTwoExits(t *testing.T) {
 	require.Equal(t, 2, len(blocks[0].Rollup.Batches[3].L1UserTxs))
 
 	config := Config{
-		NLevels:  32,
+		NLevels:  uint32(nLevels),
-		MaxFeeTx: 64,
+		MaxTx:    3,
-		MaxTx:    512,
+		MaxL1Tx:  2,
-		MaxL1Tx:  16,
+		MaxFeeTx: 2,
 		ChainID:  chainID,
 	}
 	tp := NewTxProcessor(sdb, config)
@@ -855,8 +858,6 @@ func TestTwoExits(t *testing.T) {
 		}
 	}
 
-	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)
@@ -871,7 +872,7 @@ func TestTwoExits(t *testing.T) {
 	defer assert.NoError(t, os.RemoveAll(dir2))
 
 	sdb2, err := statedb.NewStateDB(statedb.Config{Path: dir2, Keep: 128,
-		Type: statedb.TypeSynchronizer, NLevels: 32})
+		Type: stateDBType, NLevels: nLevels})
 	assert.NoError(t, err)
 
 	tc = til.NewContext(chainID, common.RollupConstMaxL1UserTx)
@@ -909,5 +910,261 @@ func TestTwoExits(t *testing.T) {
 		}
 	}
 
-	assert.Equal(t, ptOuts[3].ExitInfos[0].MerkleProof, ptOuts2[3].ExitInfos[0].MerkleProof)
+	// 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) {
+	// Test to check that when doing an Exit with amount 0 the Exit Root
+	// does not change (as there is no new Exit Leaf created)
+
+	dir, err := ioutil.TempDir("", "tmpdb")
+	require.NoError(t, err)
+	defer assert.NoError(t, os.RemoveAll(dir))
+
+	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+		Type: statedb.TypeBatchBuilder, NLevels: 32})
+	assert.NoError(t, err)
+
+	chainID := uint16(1)
+
+	tc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
+
+	set := `
+		Type: Blockchain
+
+		CreateAccountDeposit(0) A: 100
+		CreateAccountDeposit(0) B: 100
+
+		> batchL1 // batch1: freeze L1User{2}
+		> batchL1 // batch2: forge L1User{2}
+
+		ForceExit(0) A: 10
+		ForceExit(0) B: 0
+
+		> batchL1 // batch3: freeze L1User{2}
+		> batchL1 // batch4: forge L1User{2}
+
+		ForceExit(0) A: 10
+
+		> batchL1 // batch5: freeze L1User{1}
+		> batchL1 // batch6: forge L1User{1}
+
+		ForceExit(0) A: 0
+		> batchL1 // batch7: freeze L1User{1}
+		> batchL1 // batch8: forge L1User{1}
+		> block
+	`
+	blocks, err := tc.GenerateBlocks(set)
+	require.NoError(t, err)
+	err = tc.FillBlocksExtra(blocks, &til.ConfigExtra{})
+	require.NoError(t, err)
+	err = tc.FillBlocksForgedL1UserTxs(blocks)
+	require.NoError(t, err)
+
+	// Sanity check
+	require.Equal(t, 2, len(blocks[0].Rollup.Batches[1].L1UserTxs))
+	require.Equal(t, 2, len(blocks[0].Rollup.Batches[3].L1UserTxs))
+	require.Equal(t, big.NewInt(10), blocks[0].Rollup.Batches[3].L1UserTxs[0].Amount)
+	require.Equal(t, big.NewInt(0), blocks[0].Rollup.Batches[3].L1UserTxs[1].Amount)
+
+	config := Config{
+		NLevels:  32,
+		MaxFeeTx: 64,
+		MaxTx:    512,
+		MaxL1Tx:  16,
+		ChainID:  chainID,
+	}
+	tp := NewTxProcessor(sdb, config)
+
+	// For this test are only processed the batches with transactions:
+	// - Batch2, equivalent to Batches[1]
+	// - Batch4, equivalent to Batches[3]
+	// - Batch6, equivalent to Batches[5]
+	// - Batch8, equivalent to Batches[7]
+
+	// process Batch2:
+	_, err = tp.ProcessTxs(nil, blocks[0].Rollup.Batches[1].L1UserTxs, nil, nil)
+	require.NoError(t, err)
+	// process Batch4:
+	ptOut, err := tp.ProcessTxs(nil, blocks[0].Rollup.Batches[3].L1UserTxs, nil, nil)
+	require.NoError(t, err)
+	assert.Equal(t, "14329759303391468223438874789317921522067594445474390443816827472846339238908", ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String())
+	exitRootBatch4 := ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String()
+
+	// process Batch6:
+	ptOut, err = tp.ProcessTxs(nil, blocks[0].Rollup.Batches[5].L1UserTxs, nil, nil)
+	require.NoError(t, err)
+	assert.Equal(t, "14329759303391468223438874789317921522067594445474390443816827472846339238908", ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String())
+	// Expect that the ExitRoot for the Batch6 will be equal than for the
+	// Batch4, as the Batch4 & Batch6 have the same tx with Exit Amount=10,
+	// and Batch4 has a 2nd tx with Exit Amount=0.
+	assert.Equal(t, exitRootBatch4, ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String())
+
+	// For the Batch8, as there is only 1 exit with Amount=0, the ExitRoot
+	// should be 0.
+	// process Batch8:
+	ptOut, err = tp.ProcessTxs(nil, blocks[0].Rollup.Batches[7].L1UserTxs, nil, nil)
+	require.NoError(t, err)
+	assert.Equal(t, "0", ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String())
+}
+
+func TestUpdatedAccounts(t *testing.T) {
+	dir, err := ioutil.TempDir("", "tmpdb")
+	require.NoError(t, err)
+	defer assert.NoError(t, os.RemoveAll(dir))
+
+	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+		Type: statedb.TypeSynchronizer, NLevels: 32})
+	assert.NoError(t, err)
+
+	set := `
+		Type: Blockchain
+		AddToken(1)
+		CreateAccountCoordinator(0) Coord // 256
+		CreateAccountCoordinator(1) Coord // 257
+		> batch // 1
+		CreateAccountDeposit(0) A: 50 // 258
+		CreateAccountDeposit(0) B: 60 // 259
+		CreateAccountDeposit(1) A: 70 // 260
+		CreateAccountDeposit(1) B: 80 // 261
+		> batchL1 // 2
+		> batchL1 // 3
+		Transfer(0) A-B: 5 (126)
+		> batch // 4
+		Exit(1) B: 5 (126)
+		> batch // 5
+		> block
+	`
+
+	chainID := uint16(0)
+	tc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
+	blocks, err := tc.GenerateBlocks(set)
+	require.NoError(t, err)
+	tilCfgExtra := til.ConfigExtra{
+		BootCoordAddr: ethCommon.HexToAddress("0xE39fEc6224708f0772D2A74fd3f9055A90E0A9f2"),
+		CoordUser:     "Coord",
+	}
+	err = tc.FillBlocksExtra(blocks, &tilCfgExtra)
+	require.NoError(t, err)
+	tc.FillBlocksL1UserTxsBatchNum(blocks)
+	err = tc.FillBlocksForgedL1UserTxs(blocks)
+	require.NoError(t, err)
+
+	require.Equal(t, 5, len(blocks[0].Rollup.Batches))
+
+	config := Config{
+		NLevels:  32,
+		MaxFeeTx: 64,
+		MaxTx:    512,
+		MaxL1Tx:  16,
+		ChainID:  chainID,
+	}
+	tp := NewTxProcessor(sdb, config)
+
+	sortedKeys := func(m map[common.Idx]*common.Account) []int {
+		keys := make([]int, 0)
+		for k := range m {
+			keys = append(keys, int(k))
+		}
+		sort.Ints(keys)
+		return keys
+	}
+
+	for _, batch := range blocks[0].Rollup.Batches {
+		l2Txs := common.L2TxsToPoolL2Txs(batch.L2Txs)
+		ptOut, err := tp.ProcessTxs(batch.Batch.FeeIdxsCoordinator, batch.L1UserTxs,
+			batch.L1CoordinatorTxs, l2Txs)
+		require.NoError(t, err)
+		switch batch.Batch.BatchNum {
+		case 1:
+			assert.Equal(t, 2, len(ptOut.UpdatedAccounts))
+			assert.Equal(t, []int{256, 257}, sortedKeys(ptOut.UpdatedAccounts))
+		case 2:
+			assert.Equal(t, 0, len(ptOut.UpdatedAccounts))
+			assert.Equal(t, []int{}, sortedKeys(ptOut.UpdatedAccounts))
+		case 3:
+			assert.Equal(t, 4, len(ptOut.UpdatedAccounts))
+			assert.Equal(t, []int{258, 259, 260, 261}, sortedKeys(ptOut.UpdatedAccounts))
+		case 4:
+			assert.Equal(t, 2+1, len(ptOut.UpdatedAccounts))
+			assert.Equal(t, []int{256, 258, 259}, sortedKeys(ptOut.UpdatedAccounts))
+		case 5:
+			assert.Equal(t, 1+1, len(ptOut.UpdatedAccounts))
+			assert.Equal(t, []int{257, 261}, sortedKeys(ptOut.UpdatedAccounts))
+		}
+		for idx, updAcc := range ptOut.UpdatedAccounts {
+			acc, err := sdb.GetAccount(idx)
+			require.NoError(t, err)
+			// If acc.Balance is 0, set it to 0 with big.NewInt so
+			// that the comparison succeeds.  Without this, the
+			// comparison will not succeed because acc.Balance is
+			// set from a slice, and thus the internal big.Int
+			// buffer is not nil (big.Int.abs)
+			if acc.Balance.BitLen() == 0 {
+				acc.Balance = big.NewInt(0)
+			}
+			assert.Equal(t, acc, updAcc)
+		}
+	}
 }

txselector/metrics.go

@@ -0,0 +1,53 @@
+package txselector
+
+import "github.com/prometheus/client_golang/prometheus"
+
+var (
+	metricGetL2TxSelection = prometheus.NewCounter(
+		prometheus.CounterOpts{
+			Name: "txsel_get_l2_txselecton_total",
+			Help: "",
+		},
+	)
+	metricGetL1L2TxSelection = prometheus.NewCounter(
+		prometheus.CounterOpts{
+			Name: "txsel_get_l1_l2_txselecton_total",
+			Help: "",
+		},
+	)
+
+	metricSelectedL1CoordinatorTxs = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "txsel_selected_l1_coordinator_txs",
+			Help: "",
+		},
+	)
+	metricSelectedL1UserTxs = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "txsel_selected_l1_user_txs",
+			Help: "",
+		},
+	)
+	metricSelectedL2Txs = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "txsel_selected_l2_txs",
+			Help: "",
+		},
+	)
+	metricDiscardedL2Txs = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "txsel_discarded_l2_txs",
+			Help: "",
+		},
+	)
+)
+
+func init() {
+	prometheus.MustRegister(metricGetL2TxSelection)
+	prometheus.MustRegister(metricGetL1L2TxSelection)
+
+	prometheus.MustRegister(metricSelectedL1CoordinatorTxs)
+	prometheus.MustRegister(metricSelectedL1UserTxs)
+	prometheus.MustRegister(metricSelectedL2Txs)
+	prometheus.MustRegister(metricDiscardedL2Txs)
+}

txselector/txselector.go

@@ -18,20 +18,6 @@ import (
 	"github.com/iden3/go-iden3-crypto/babyjub"
 )
 
-// txs implements the interface Sort for an array of Tx, and sorts the txs by
-// absolute fee
-type txs []common.PoolL2Tx
-
-func (t txs) Len() int {
-	return len(t)
-}
-func (t txs) Swap(i, j int) {
-	t[i], t[j] = t[j], t[i]
-}
-func (t txs) Less(i, j int) bool {
-	return t[i].AbsoluteFee > t[j].AbsoluteFee
-}
-
 // CoordAccount contains the data of the Coordinator account, that will be used
 // to create new transactions of CreateAccountDeposit type to add new TokenID
 // accounts for the Coordinator to receive the fees.
@@ -147,9 +133,11 @@ func (txsel *TxSelector) coordAccountForTokenID(l1CoordinatorTxs []common.L1Tx,
 // included in the next batch.
 func (txsel *TxSelector) GetL2TxSelection(selectionConfig *SelectionConfig) ([]common.Idx,
 	[][]byte, []common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
-	coordIdxs, accCreationAuths, _, l1CoordinatorTxs, l2Txs, discardedL2Txs, err :=
+	metricGetL2TxSelection.Inc()
-		txsel.GetL1L2TxSelection(selectionConfig, []common.L1Tx{})
+	coordIdxs, accCreationAuths, _, l1CoordinatorTxs, l2Txs,
-	return coordIdxs, accCreationAuths, l1CoordinatorTxs, l2Txs, discardedL2Txs, tracerr.Wrap(err)
+		discardedL2Txs, err := txsel.getL1L2TxSelection(selectionConfig, []common.L1Tx{})
+	return coordIdxs, accCreationAuths, l1CoordinatorTxs, l2Txs,
+		discardedL2Txs, tracerr.Wrap(err)
 }
 
 // GetL1L2TxSelection returns the selection of L1 + L2 txs.
@@ -161,6 +149,16 @@ func (txsel *TxSelector) GetL2TxSelection(selectionConfig *SelectionConfig) ([]c
 // creation exists. The L1UserTxs, L1CoordinatorTxs, PoolL2Txs that will be
 // included in the next batch.
 func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
+	l1UserTxs []common.L1Tx) ([]common.Idx, [][]byte, []common.L1Tx,
+	[]common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
+	metricGetL1L2TxSelection.Inc()
+	coordIdxs, accCreationAuths, l1UserTxs, l1CoordinatorTxs, l2Txs,
+		discardedL2Txs, err := txsel.getL1L2TxSelection(selectionConfig, l1UserTxs)
+	return coordIdxs, accCreationAuths, l1UserTxs, l1CoordinatorTxs, l2Txs,
+		discardedL2Txs, tracerr.Wrap(err)
+}
+
+func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 	l1UserTxs []common.L1Tx) ([]common.Idx, [][]byte, []common.L1Tx,
 	[]common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
 	// WIP.0: the TxSelector is not optimized and will need a redesign. The
@@ -191,14 +189,16 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 	}
 
 	// discardedL2Txs contains an array of the L2Txs that have not been selected in this Batch
-	var discardedL2Txs []common.PoolL2Tx
 
 	var l1CoordinatorTxs []common.L1Tx
 	positionL1 := len(l1UserTxs)
 	var accAuths [][]byte
 
 	// sort l2TxsRaw (cropping at MaxTx at this point)
-	l2Txs0 := txsel.getL2Profitable(l2TxsRaw, selectionConfig.TxProcessorConfig.MaxTx)
+	l2Txs0, discardedL2Txs := txsel.getL2Profitable(l2TxsRaw, selectionConfig.TxProcessorConfig.MaxTx)
+	for i := range discardedL2Txs {
+		discardedL2Txs[i].Info = "Tx not selected due to low absolute fee"
+	}
 
 	noncesMap := make(map[common.Idx]common.Nonce)
 	var l2Txs []common.PoolL2Tx
@@ -464,6 +464,11 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 		return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
 	}
 
+	metricSelectedL1CoordinatorTxs.Set(float64(len(l1CoordinatorTxs)))
+	metricSelectedL1UserTxs.Set(float64(len(l1UserTxs)))
+	metricSelectedL2Txs.Set(float64(len(finalL2Txs)))
+	metricDiscardedL2Txs.Set(float64(len(discardedL2Txs)))
+
 	return coordIdxs, accAuths, l1UserTxs, l1CoordinatorTxs, finalL2Txs, discardedL2Txs, nil
 }
 
@@ -590,11 +595,22 @@ func checkAlreadyPendingToCreate(l1CoordinatorTxs []common.L1Tx, tokenID common.
 }
 
 // getL2Profitable returns the profitable selection of L2Txssorted by Nonce
-func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) []common.PoolL2Tx {
+func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) ([]common.PoolL2Tx,
-	// Sort by absolute fee
+	[]common.PoolL2Tx) {
-	sort.Sort(txs(l2Txs))
+	// First sort by nonce so that txs from the same account are sorted so
+	// that they could be applied in succession.
+	sort.Slice(l2Txs, func(i, j int) bool {
+		return l2Txs[i].Nonce < l2Txs[j].Nonce
+	})
+	// Sort by absolute fee with SliceStable, so that txs with same
+	// AbsoluteFee are not rearranged and nonce order is kept in such case
+	sort.SliceStable(l2Txs, func(i, j int) bool {
+		return l2Txs[i].AbsoluteFee > l2Txs[j].AbsoluteFee
+	})
 
+	discardedL2Txs := []common.PoolL2Tx{}
 	if len(l2Txs) > int(max) {
+		discardedL2Txs = l2Txs[max:]
 		l2Txs = l2Txs[:max]
 	}
 
@@ -603,9 +619,9 @@ func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) []
 	// Account is sorted, but the l2Txs can not be grouped by sender Account
 	// neither by Fee. This is because later on the Nonces will need to be
 	// sequential for the zkproof generation.
-	sort.SliceStable(l2Txs, func(i, j int) bool {
+	sort.Slice(l2Txs, func(i, j int) bool {
 		return l2Txs[i].Nonce < l2Txs[j].Nonce
 	})
 
-	return l2Txs
+	return l2Txs, discardedL2Txs
 }

txselector/txselector_test.go

@@ -29,7 +29,7 @@ func initTest(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
@@ -106,7 +106,7 @@ func addTokens(t *testing.T, tc *til.Context, db *sqlx.DB) {
 		})
 	}
 
-	hdb := historydb.NewHistoryDB(db, nil)
+	hdb := historydb.NewHistoryDB(db, db, nil)
 	assert.NoError(t, hdb.AddBlock(&common.Block{
 		Num: 1,
 	}))
@@ -658,7 +658,7 @@ func TestTransferManyFromSameAccount(t *testing.T) {
 	tpc := txprocessor.Config{
 		NLevels:  16,
 		MaxFeeTx: 10,
-		MaxTx:    20,
+		MaxTx:    10,
 		MaxL1Tx:  10,
 		ChainID:  chainID,
 	}
@@ -683,13 +683,17 @@ func TestTransferManyFromSameAccount(t *testing.T) {
 	PoolTransfer(0) A-B: 10 (126) // 6
 	PoolTransfer(0) A-B: 10 (126) // 7
 	PoolTransfer(0) A-B: 10 (126) // 8
+	PoolTransfer(0) A-B: 10 (126) // 9
+	PoolTransfer(0) A-B: 10 (126) // 10
+	PoolTransfer(0) A-B: 10 (126) // 11
 	`
 	poolL2Txs, err := tc.GeneratePoolL2Txs(batchPoolL2)
 	require.NoError(t, err)
+	require.Equal(t, 11, len(poolL2Txs))
 
 	// reorder poolL2Txs so that nonces are not sorted
 	poolL2Txs[0], poolL2Txs[7] = poolL2Txs[7], poolL2Txs[0]
-	poolL2Txs[1], poolL2Txs[6] = poolL2Txs[6], poolL2Txs[1]
+	poolL2Txs[1], poolL2Txs[10] = poolL2Txs[10], poolL2Txs[1]
 
 	// add the PoolL2Txs to the l2DB
 	addL2Txs(t, txsel, poolL2Txs)
@@ -699,8 +703,9 @@ func TestTransferManyFromSameAccount(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, 3, len(oL1UserTxs))
 	require.Equal(t, 0, len(oL1CoordTxs))
-	assert.Equal(t, 8, len(oL2Txs))
+	assert.Equal(t, 7, len(oL2Txs))
-	assert.Equal(t, 0, len(discardedL2Txs))
+	assert.Equal(t, 1, len(discardedL2Txs))
+
 	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
 	require.NoError(t, err)
 }