Fix mock server

Move apitypes & stateapiupdater into api dir

.gitignore

@@ -0,0 +1 @@
+bin/

Makefile

@@ -0,0 +1,135 @@
+#! /usr/bin/make -f
+
+# Project variables.
+PACKAGE := github.com/hermeznetwork/hermez-node
+VERSION := $(shell git describe --tags --always)
+BUILD := $(shell git rev-parse --short HEAD)
+BUILD_DATE := $(shell date +%Y-%m-%dT%H:%M:%S%z)
+PROJECT_NAME := $(shell basename "$(PWD)")
+
+# Go related variables.
+GO_FILES ?= $$(find . -name '*.go' | grep -v vendor)
+GOBASE := $(shell pwd)
+GOBIN := $(GOBASE)/bin
+GOPKG := $(.)
+GOENVVARS := GOBIN=$(GOBIN)
+GOCMD := $(GOBASE)/cli/node
+GOPROOF := $(GOBASE)/test/proofserver/cli
+GOBINARY := node
+
+# Project configs.
+MODE ?= sync
+CONFIG ?= $(GOBASE)/cli/node/cfg.buidler.toml
+POSTGRES_PASS ?= yourpasswordhere
+
+# Use linker flags to provide version/build settings.
+LDFLAGS=-ldflags "-X=main.Version=$(VERSION) -X=main.Build=$(BUILD) -X=main.Date=$(BUILD_DATE)"
+
+# PID file will keep the process id of the server.
+PID_PROOF_MOCK := /tmp/.$(PROJECT_NAME).proof.pid
+
+# Make is verbose in Linux. Make it silent.
+MAKEFLAGS += --silent
+
+.PHONY: help
+help: Makefile
+	@echo
+	@echo " Choose a command run in "$(PROJECT_NAME)":"
+	@echo
+	@sed -n 's/^##//p' $< | column -t -s ':' |  sed -e 's/^/ /'
+	@echo
+
+## test: Run the application check and all tests.
+test: govet gocilint test-unit
+
+## test-unit: Run all unit tests.
+test-unit:
+	@echo "  >  Running unit tests"
+	$(GOENVVARS) go test -race -p 1 -failfast -timeout 300s -v ./...
+
+## test-api-server: Run the API server using the Go tests.
+test-api-server:
+	@echo "  >  Running unit tests"
+	$(GOENVVARS) FAKE_SERVER=yes go test -timeout 0 ./api -p 1 -count 1 -v
+
+## gofmt: Run `go fmt` for all go files.
+gofmt:
+	@echo "  >  Format all go files"
+	$(GOENVVARS) gofmt -w ${GO_FILES}
+
+## govet: Run go vet.
+govet:
+	@echo "  >  Running go vet"
+	$(GOENVVARS) go vet ./...
+
+## golint: Run default golint.
+golint:
+	@echo "  >  Running golint"
+	$(GOENVVARS) golint -set_exit_status ./...
+
+## gocilint: Run Golang CI Lint.
+gocilint:
+	@echo "  >  Running Golang CI Lint"
+	$-golangci-lint run --timeout=5m -E whitespace -E gosec -E gci -E misspell -E gomnd -E gofmt -E goimports -E golint --exclude-use-default=false --max-same-issues 0
+
+## exec: Run given command. e.g; make exec run="go test ./..."
+exec:
+	GOBIN=$(GOBIN) $(run)
+
+## clean: Clean build files. Runs `go clean` internally.
+clean:
+	@-rm $(GOBIN)/ 2> /dev/null
+	@echo "  >  Cleaning build cache"
+	$(GOENVVARS) go clean
+
+## build: Build the project.
+build: install
+	@echo "  >  Building Hermez binary..."
+	@bash -c "$(MAKE) migration-pack"
+	$(GOENVVARS) go build $(LDFLAGS) -o $(GOBIN)/$(GOBINARY) $(GOCMD)
+	@bash -c "$(MAKE) migration-clean"
+
+## install: Install missing dependencies. Runs `go get` internally. e.g; make install get=github.com/foo/bar
+install:
+	@echo "  >  Checking if there is any missing dependencies..."
+	$(GOENVVARS) go get $(GOCMD)/... $(get)
+
+## run: Run Hermez node.
+run:
+	@bash -c "$(MAKE) clean build"
+	@echo "  >  Running $(PROJECT_NAME)"
+	@$(GOBIN)/$(GOBINARY) --mode $(MODE) --cfg $(CONFIG) run
+
+## run-proof-mock: Run proof server mock API.
+run-proof-mock: stop-proof-mock
+	@echo "  >  Running Proof Server Mock"
+	$(GOENVVARS) go build -o $(GOBIN)/proof $(GOPROOF)
+	@$(GOBIN)/proof 2>&1 & echo $$! > $(PID_PROOF_MOCK)
+	@cat $(PID_PROOF_MOCK) | sed "/^/s/^/  \>  Proof Server Mock PID: /"
+
+## stop-proof-mock: Stop proof server mock API.
+stop-proof-mock:
+	@-touch $(PID_PROOF_MOCK)
+	@-kill -s INT `cat $(PID_PROOF_MOCK)` 2> /dev/null || true
+	@-rm $(PID_PROOF_MOCK) $(GOBIN)/proof 2> /dev/null || true
+
+## migration-pack: Pack the database migrations into the binary.
+migration-pack:
+	@echo "  >  Packing the migrations..."
+	@cd /tmp && go get -u github.com/gobuffalo/packr/v2/packr2 && cd -
+	@cd $(GOBASE)/db && packr2 && cd -
+
+## migration-clean: Clean the database migrations pack.
+migration-clean:
+	@echo "  >  Cleaning the migrations..."
+	@cd $(GOBASE)/db && packr2 clean && cd -
+
+## run-database-container: Run the Postgres container
+run-database-container:
+	@echo "  >  Running the postgreSQL DB..."
+	@-docker run --rm --name hermez-db -p 5432:5432 -e POSTGRES_DB=hermez -e POSTGRES_USER=hermez -e POSTGRES_PASSWORD="$(POSTGRES_PASS)" -d postgres
+
+## stop-database-container: Stop the Postgres container
+stop-database-container:
+	@echo "  >  Stopping the postgreSQL DB..."
+	@-docker stop hermez-db

README.md

@@ -4,42 +4,79 @@ Go implementation of the Hermez node.
 
 ## Developing
 
+### Go version
+
+The `hermez-node` has been tested with go version 1.14
+
+### Build
+
+Build the binary and check the current version:
+
+```shell
+$ make build
+$ bin/node version
+```
+
+### Run
+
+First you must edit the default/template config file into [cli/node/cfg.buidler.toml](cli/node/cfg.buidler.toml), 
+there are more information about the config file into [cli/node/README.md](cli/node/README.md)
+
+After setting the config, you can build and run the Hermez Node as a synchronizer:
+
+```shell
+$ make run
+```
+
+Or build and run as a coordinator, and also passing the config file from other location:
+
+```shell
+$ MODE=sync CONFIG=cli/node/cfg.buidler.toml make run
+```
+
+To check the useful make commands:
+
+```shell
+$ make help
+```
+
 ### Unit testing
 
 Running the unit tests requires a connection to a PostgreSQL database.  You can
-start PostgreSQL with docker easily this way (where `yourpasswordhere` should
+run PostgreSQL with docker easily this way (where `yourpasswordhere` should
 be your password):
 
-```
+```shell
-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" make run-database-container
 ```
 
-Afterwards, run the tests with the password as env var:
+Afterward, run the tests with the password as env var:
 
-```
+```shell
-POSTGRES_PASS=yourpasswordhere go test -p 1 ./...
+$ POSTGRES_PASS="yourpasswordhere" make test
 ```
 
-NOTE: `-p 1` forces execution of package test in serial.  Otherwise they may be
+NOTE: `-p 1` forces execution of package test in serial. Otherwise, they may be
-executed in paralel and the test may find unexpected entries in the SQL databse
+executed in parallel, and the test may find unexpected entries in the SQL database
 because it's shared among all tests.
 
-There is an extra temporary option that allows you to run the API server using
+There is an extra temporary option that allows you to run the API server using the 
-the Go tests. This will be removed once the API can be properly initialized,
+Go tests. It will be removed once the API can be properly initialized with data 
-with data from the synchronizer and so on. To use this, run:
+from the synchronizer. To use this, run:
 
-```
+```shell
-FAKE_SERVER=yes POSTGRES_PASS=yourpasswordhere go test -timeout 0  ./api -p 1 -count 1 -v`
+$ POSTGRES_PASS="yourpasswordhere" make test-api-server
 ```
 
 ### Lint
 
 All Pull Requests need to pass the configured linter.
 
-To run the linter locally, first install [golangci-lint](https://golangci-lint.run).  Afterwards you can check the lints with this command:
+To run the linter locally, first, install [golangci-lint](https://golangci-lint.run).  
+Afterward, you can check the lints with this command:
 
-```
+```shell
-golangci-lint run --timeout=5m -E whitespace -E gosec -E gci -E misspell -E gomnd -E gofmt -E goimports -E golint --exclude-use-default=false --max-same-issues 0
+$ make gocilint
 ```
 
 ## Usage
@@ -50,13 +87,13 @@ See [cli/node/README.md](cli/node/README.md)
 
 ### Proof Server
 
-The node in mode coordinator requires a proof server (a server that is capable
+The node in mode coordinator requires a proof server (a server capable of 
-of calculating proofs from the zkInputs). For testing purposes there is a mock
+calculating proofs from the zkInputs). There is a mock proof server CLI 
-proof server cli at `test/proofserver/cli`.
+at `test/proofserver/cli` for testing purposes.
 
 Usage of `test/proofserver/cli`:
 
-```
+```shell
 USAGE:
     go run ./test/proofserver/cli OPTIONS
 
@@ -67,11 +104,19 @@ OPTIONS:
         proving time duration (default 2s)
 ```
 
+Also, the Makefile commands can be used to run and stop the proof server 
+in the background:
+
+```shell
+$ make run-proof-mock
+$ make stop-proof-mock
+```
+
 ### `/tmp` as tmpfs
 
 For every processed batch, the node builds a temporary exit tree in a key-value
 DB stored in `/tmp`.  It is highly recommended that `/tmp` is mounted as a RAM
-file system in production to avoid unecessary reads an writes to disk.  This
+file system in production to avoid unnecessary reads a writes to disk.  This
 can be done by mounting `/tmp` as tmpfs; for example, by having this line in
 `/etc/fstab`:
 ```

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,27 +44,7 @@ func (a *API) getAccounts(c *gin.Context) {
 		return
 	}
 
-	// Get balances from stateDB
+	// Build successful response
-	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"`
 		PendingItems uint64                 `json:"pendingItems"`

api/account_test.go

@@ -5,7 +5,7 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/mitchellh/copystructure"

api/accountcreationauths.go

@@ -7,7 +7,7 @@ import (
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/gin-gonic/gin"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 )
@@ -47,7 +47,7 @@ func (a *API) getAccountCreationAuth(c *gin.Context) {
 		retSQLErr(err, c)
 		return
 	}
-	// Build succesfull response
+	// Build successful response
 	c.JSON(http.StatusOK, auth)
 }
 

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,53 +34,56 @@ 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,
 	}
 
+	v1 := server.Group("/v1")
+
 	// Add coordinator endpoints
 	if coordinatorEndpoints {
 		// Account
-		server.POST("/account-creation-authorization", a.postAccountCreationAuth)
+		v1.POST("/account-creation-authorization", a.postAccountCreationAuth)
-		server.GET("/account-creation-authorization/:hezEthereumAddress", a.getAccountCreationAuth)
+		v1.GET("/account-creation-authorization/:hezEthereumAddress", a.getAccountCreationAuth)
 		// Transaction
-		server.POST("/transactions-pool", a.postPoolTx)
+		v1.POST("/transactions-pool", a.postPoolTx)
-		server.GET("/transactions-pool/:id", a.getPoolTx)
+		v1.GET("/transactions-pool/:id", a.getPoolTx)
 	}
 
 	// Add explorer endpoints
 	if explorerEndpoints {
 		// Account
-		server.GET("/accounts", a.getAccounts)
+		v1.GET("/accounts", a.getAccounts)
-		server.GET("/accounts/:accountIndex", a.getAccount)
+		v1.GET("/accounts/:accountIndex", a.getAccount)
-		server.GET("/exits", a.getExits)
+		v1.GET("/exits", a.getExits)
-		server.GET("/exits/:batchNum/:accountIndex", a.getExit)
+		v1.GET("/exits/:batchNum/:accountIndex", a.getExit)
 		// Transaction
-		server.GET("/transactions-history", a.getHistoryTxs)
+		v1.GET("/transactions-history", a.getHistoryTxs)
-		server.GET("/transactions-history/:id", a.getHistoryTx)
+		v1.GET("/transactions-history/:id", a.getHistoryTx)
 		// Status
-		server.GET("/batches", a.getBatches)
+		v1.GET("/batches", a.getBatches)
-		server.GET("/batches/:batchNum", a.getBatch)
+		v1.GET("/batches/:batchNum", a.getBatch)
-		server.GET("/full-batches/:batchNum", a.getFullBatch)
+		v1.GET("/full-batches/:batchNum", a.getFullBatch)
-		server.GET("/slots", a.getSlots)
+		v1.GET("/slots", a.getSlots)
-		server.GET("/slots/:slotNum", a.getSlot)
+		v1.GET("/slots/:slotNum", a.getSlot)
-		server.GET("/bids", a.getBids)
+		v1.GET("/bids", a.getBids)
-		server.GET("/state", a.getState)
+		v1.GET("/state", a.getState)
-		server.GET("/config", a.getConfig)
+		v1.GET("/config", a.getConfig)
-		server.GET("/tokens", a.getTokens)
+		v1.GET("/tokens", a.getTokens)
-		server.GET("/tokens/:id", a.getToken)
+		v1.GET("/tokens/:id", a.getToken)
-		server.GET("/coordinators", a.getCoordinators)
+		v1.GET("/coordinators", a.getCoordinators)
 	}
 
 	return a, nil

api/api_test.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"io/ioutil"
 	"math/big"
+	"net"
 	"net/http"
 	"os"
 	"strconv"
@@ -18,11 +19,11 @@ import (
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	swagger "github.com/getkin/kin-openapi/openapi3filter"
 	"github.com/gin-gonic/gin"
+	"github.com/hermeznetwork/hermez-node/api/stateapiupdater"
 	"github.com/hermeznetwork/hermez-node/common"
 	"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 +40,8 @@ type Pendinger interface {
 	New() Pendinger
 }
 
-const apiPort = ":4010"
+const apiPort = "4010"
-const apiURL = "http://localhost" + apiPort + "/"
+const apiURL = "http://localhost:" + apiPort + "/v1/"
 
 var SetBlockchain = `
 	Type: Blockchain
@@ -180,12 +181,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.Updater
 
 // 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
@@ -201,27 +203,13 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
-	apiConnCon := db.NewAPICnnectionController(1, time.Second)
+	apiConnCon := db.NewAPIConnectionController(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, 1000.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB()) // this will clean HistoryDB and L2DB
 	// Config (smart contract constants)
 	chainID := uint16(0)
@@ -234,30 +222,55 @@ 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,
+		MaxFeeUSD:  10000000000,
+	}
+	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", ":"+apiPort) //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
+	// Generate blockchain data with til
-	test.WipeDB(api.h.DB())
-
-	// Genratre blockchain data with til
 	tcc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
 	tilCfgExtra := til.ConfigExtra{
 		BootCoordAddr: ethCommon.HexToAddress("0xE39fEc6224708f0772D2A74fd3f9055A90E0A9f2"),
@@ -303,7 +316,7 @@ func TestMain(m *testing.M) {
 		USD:         &ethUSD,
 		USDUpdate:   &ethNow,
 	})
-	err = api.h.UpdateTokenValue(test.EthToken.Symbol, ethUSD)
+	err = api.h.UpdateTokenValue(common.EmptyAddr, ethUSD)
 	if err != nil {
 		panic(err)
 	}
@@ -330,7 +343,7 @@ func TestMain(m *testing.M) {
 			token.USD = &value
 			token.USDUpdate = &now
 			// Set value in DB
-			err = api.h.UpdateTokenValue(token.Symbol, value)
+			err = api.h.UpdateTokenValue(token.EthAddr, value)
 			if err != nil {
 				panic(err)
 			}
@@ -350,19 +363,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 +470,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 +522,12 @@ func TestMain(m *testing.M) {
 		WithdrawalDelay: uint64(3000),
 	}
 
+	stateAPIUpdater = stateapiupdater.NewUpdater(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 +535,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,27 +605,24 @@ 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)
+	apiConnConTO := db.NewAPIConnectionController(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, 1000.0, 24*time.Hour, apiConnConTO)
 
 	// API
 	apiGinTO := gin.Default()
 	finishWait := make(chan interface{})
 	startWait := make(chan interface{})
-	apiGinTO.GET("/wait", func(c *gin.Context) {
+	apiGinTO.GET("/v1/wait", func(c *gin.Context) {
 		cancel, err := apiConnConTO.Acquire()
 		defer cancel()
 		require.NoError(t, err)
@@ -600,28 +631,28 @@ 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)
 
 	client := &http.Client{}
-	httpReq, err := http.NewRequest("GET", "http://localhost:4444/tokens", nil)
+	httpReq, err := http.NewRequest("GET", "http://localhost:4444/v1/tokens", nil)
 	require.NoError(t, err)
-	httpReqWait, err := http.NewRequest("GET", "http://localhost:4444/wait", nil)
+	httpReqWait, err := http.NewRequest("GET", "http://localhost:4444/v1/wait", nil)
 	require.NoError(t, err)
 	// Request that will get timed out
 	var wg sync.WaitGroup

api/apitypes/apitypes.go

@@ -4,7 +4,6 @@ import (
 	"database/sql/driver"
 	"encoding/base64"
 	"encoding/hex"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"math/big"
@@ -19,7 +18,10 @@ import (
 
 // BigIntStr is used to scan/value *big.Int directly into strings from/to sql DBs.
 // It assumes that *big.Int are inserted/fetched to/from the DB using the BigIntMeddler meddler
-// defined at github.com/hermeznetwork/hermez-node/db
+// defined at github.com/hermeznetwork/hermez-node/db.  Since *big.Int is
+// stored as DECIMAL in SQL, there's no need to implement Scan()/Value()
+// because DECIMALS are encoded/decoded as strings by the sql driver, and
+// BigIntStr is already a string.
 type BigIntStr string
 
 // NewBigIntStr creates a *BigIntStr from a *big.Int.
@@ -32,34 +34,6 @@ func NewBigIntStr(bigInt *big.Int) *BigIntStr {
 	return &bigIntStr
 }
 
-// Scan implements Scanner for database/sql
-func (b *BigIntStr) Scan(src interface{}) error {
-	srcBytes, ok := src.([]byte)
-	if !ok {
-		return tracerr.Wrap(fmt.Errorf("can't scan %T into apitypes.BigIntStr", src))
-	}
-	// bytes to *big.Int
-	bigInt := new(big.Int).SetBytes(srcBytes)
-	// *big.Int to BigIntStr
-	bigIntStr := NewBigIntStr(bigInt)
-	if bigIntStr == nil {
-		return nil
-	}
-	*b = *bigIntStr
-	return nil
-}
-
-// Value implements valuer for database/sql
-func (b BigIntStr) Value() (driver.Value, error) {
-	// string to *big.Int
-	bigInt, ok := new(big.Int).SetString(string(b), 10)
-	if !ok || bigInt == nil {
-		return nil, tracerr.Wrap(errors.New("invalid representation of a *big.Int"))
-	}
-	// *big.Int to bytes
-	return bigInt.Bytes(), nil
-}
-
 // StrBigInt is used to unmarshal BigIntStr directly into an alias of big.Int
 type StrBigInt big.Int
 
@@ -73,25 +47,19 @@ func (s *StrBigInt) UnmarshalText(text []byte) error {
 	return nil
 }
 
-// CollectedFees is used to retrieve common.batch.CollectedFee from the DB
+// CollectedFeesAPI is send common.batch.CollectedFee through the API
-type CollectedFees map[common.TokenID]BigIntStr
+type CollectedFeesAPI map[common.TokenID]BigIntStr
 
-// UnmarshalJSON unmarshals a json representation of map[common.TokenID]*big.Int
+// NewCollectedFeesAPI creates a new CollectedFeesAPI from a *big.Int map
-func (c *CollectedFees) UnmarshalJSON(text []byte) error {
+func NewCollectedFeesAPI(m map[common.TokenID]*big.Int) CollectedFeesAPI {
-	bigIntMap := make(map[common.TokenID]*big.Int)
+	c := CollectedFeesAPI(make(map[common.TokenID]BigIntStr))
-	if err := json.Unmarshal(text, &bigIntMap); err != nil {
+	for k, v := range m {
-		return tracerr.Wrap(err)
+		c[k] = *NewBigIntStr(v)
 	}
-	*c = CollectedFees(make(map[common.TokenID]BigIntStr))
+	return c
-	for k, v := range bigIntMap {
-		bStr := NewBigIntStr(v)
-		(CollectedFees(*c)[k]) = *bStr
-	}
-	// *c = CollectedFees(bStrMap)
-	return nil
 }
 
-// HezEthAddr is used to scan/value Ethereum Address directly into strings that follow the Ethereum address hez fotmat (^hez:0x[a-fA-F0-9]{40}$) from/to sql DBs.
+// HezEthAddr is used to scan/value Ethereum Address directly into strings that follow the Ethereum address hez format (^hez:0x[a-fA-F0-9]{40}$) from/to sql DBs.
 // It assumes that Ethereum Address are inserted/fetched to/from the DB using the default Scan/Value interface
 type HezEthAddr string
 
@@ -143,7 +111,7 @@ func (s *StrHezEthAddr) UnmarshalText(text []byte) error {
 	return nil
 }
 
-// HezBJJ is used to scan/value *babyjub.PublicKeyComp directly into strings that follow the BJJ public key hez fotmat (^hez:[A-Za-z0-9_-]{44}$) from/to sql DBs.
+// HezBJJ is used to scan/value *babyjub.PublicKeyComp directly into strings that follow the BJJ public key hez format (^hez:[A-Za-z0-9_-]{44}$) from/to sql DBs.
 // It assumes that *babyjub.PublicKeyComp are inserted/fetched to/from the DB using the default Scan/Value interface
 type HezBJJ string
 
@@ -216,7 +184,7 @@ func (b HezBJJ) Value() (driver.Value, error) {
 // StrHezBJJ is used to unmarshal HezBJJ directly into an alias of babyjub.PublicKeyComp
 type StrHezBJJ babyjub.PublicKeyComp
 
-// UnmarshalText unmarshals a StrHezBJJ
+// UnmarshalText unmarshalls a StrHezBJJ
 func (s *StrHezBJJ) UnmarshalText(text []byte) error {
 	bjj, err := hezStrToBJJ(string(text))
 	if err != nil {
@@ -226,8 +194,8 @@ func (s *StrHezBJJ) UnmarshalText(text []byte) error {
 	return nil
 }
 
-// HezIdx is used to value common.Idx directly into strings that follow the Idx key hez fotmat (hez:tokenSymbol:idx) to sql DBs.
+// HezIdx is used to value common.Idx directly into strings that follow the Idx key hez format (hez:tokenSymbol:idx) to sql DBs.
-// Note that this can only be used to insert to DB since there is no way to automaticaly read from the DB since it needs the tokenSymbol
+// Note that this can only be used to insert to DB since there is no way to automatically read from the DB since it needs the tokenSymbol
 type HezIdx string
 
 // StrHezIdx is used to unmarshal HezIdx directly into an alias of common.Idx

api/batch.go

@@ -52,7 +52,7 @@ func (a *API) getBatches(c *gin.Context) {
 		return
 	}
 
-	// Build succesfull response
+	// Build successful response
 	type batchesResponse struct {
 		Batches      []historydb.BatchAPI `json:"batches"`
 		PendingItems uint64               `json:"pendingItems"`

api/batch_test.go

@@ -7,10 +7,12 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/mitchellh/copystructure"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type testBatch struct {
@@ -20,7 +22,7 @@ type testBatch struct {
 	EthBlockHash  ethCommon.Hash            `json:"ethereumBlockHash"`
 	Timestamp     time.Time                 `json:"timestamp"`
 	ForgerAddr    ethCommon.Address         `json:"forgerAddr"`
-	CollectedFees map[common.TokenID]string `json:"collectedFees"`
+	CollectedFees apitypes.CollectedFeesAPI `json:"collectedFees"`
 	TotalFeesUSD  *float64                  `json:"historicTotalCollectedFeesUSD"`
 	StateRoot     string                    `json:"stateRoot"`
 	NumAccounts   int                       `json:"numAccounts"`
@@ -73,9 +75,9 @@ func genTestBatches(
 		if !found {
 			panic("block not found")
 		}
-		collectedFees := make(map[common.TokenID]string)
+		collectedFees := apitypes.CollectedFeesAPI(make(map[common.TokenID]apitypes.BigIntStr))
 		for k, v := range cBatches[i].CollectedFees {
-			collectedFees[k] = v.String()
+			collectedFees[k] = *apitypes.NewBigIntStr(v)
 		}
 		forgedTxs := 0
 		for _, tx := range txs {
@@ -132,7 +134,7 @@ func TestGetBatches(t *testing.T) {
 	limit := 3
 	path := fmt.Sprintf("%s?limit=%d", endpoint, limit)
 	err := doGoodReqPaginated(path, historydb.OrderAsc, &testBatchesResponse{}, appendIter)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assertBatches(t, tc.batches, fetchedBatches)
 
 	// minBatchNum
@@ -141,7 +143,7 @@ func TestGetBatches(t *testing.T) {
 	minBatchNum := tc.batches[len(tc.batches)/2].BatchNum
 	path = fmt.Sprintf("%s?minBatchNum=%d&limit=%d", endpoint, minBatchNum, limit)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testBatchesResponse{}, appendIter)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	minBatchNumBatches := []testBatch{}
 	for i := 0; i < len(tc.batches); i++ {
 		if tc.batches[i].BatchNum > minBatchNum {
@@ -156,7 +158,7 @@ func TestGetBatches(t *testing.T) {
 	maxBatchNum := tc.batches[len(tc.batches)/2].BatchNum
 	path = fmt.Sprintf("%s?maxBatchNum=%d&limit=%d", endpoint, maxBatchNum, limit)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testBatchesResponse{}, appendIter)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	maxBatchNumBatches := []testBatch{}
 	for i := 0; i < len(tc.batches); i++ {
 		if tc.batches[i].BatchNum < maxBatchNum {
@@ -171,7 +173,7 @@ func TestGetBatches(t *testing.T) {
 	slotNum := tc.batches[len(tc.batches)/2].SlotNum
 	path = fmt.Sprintf("%s?slotNum=%d&limit=%d", endpoint, slotNum, limit)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testBatchesResponse{}, appendIter)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	slotNumBatches := []testBatch{}
 	for i := 0; i < len(tc.batches); i++ {
 		if tc.batches[i].SlotNum == slotNum {
@@ -186,7 +188,7 @@ func TestGetBatches(t *testing.T) {
 	forgerAddr := tc.batches[len(tc.batches)/2].ForgerAddr
 	path = fmt.Sprintf("%s?forgerAddr=%s&limit=%d", endpoint, forgerAddr.String(), limit)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testBatchesResponse{}, appendIter)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	forgerAddrBatches := []testBatch{}
 	for i := 0; i < len(tc.batches); i++ {
 		if tc.batches[i].ForgerAddr == forgerAddr {
@@ -200,7 +202,7 @@ func TestGetBatches(t *testing.T) {
 	limit = 6
 	path = fmt.Sprintf("%s?limit=%d", endpoint, limit)
 	err = doGoodReqPaginated(path, historydb.OrderDesc, &testBatchesResponse{}, appendIter)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	flippedBatches := []testBatch{}
 	for i := len(tc.batches) - 1; i >= 0; i-- {
 		flippedBatches = append(flippedBatches, tc.batches[i])
@@ -214,7 +216,7 @@ func TestGetBatches(t *testing.T) {
 	minBatchNum = tc.batches[len(tc.batches)/4].BatchNum
 	path = fmt.Sprintf("%s?minBatchNum=%d&maxBatchNum=%d&limit=%d", endpoint, minBatchNum, maxBatchNum, limit)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testBatchesResponse{}, appendIter)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	minMaxBatchNumBatches := []testBatch{}
 	for i := 0; i < len(tc.batches); i++ {
 		if tc.batches[i].BatchNum < maxBatchNum && tc.batches[i].BatchNum > minBatchNum {
@@ -227,25 +229,25 @@ func TestGetBatches(t *testing.T) {
 	fetchedBatches = []testBatch{}
 	path = fmt.Sprintf("%s?slotNum=%d&minBatchNum=%d", endpoint, 1, 25)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testBatchesResponse{}, appendIter)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assertBatches(t, []testBatch{}, fetchedBatches)
 
 	// 400
 	// Invalid minBatchNum
 	path = fmt.Sprintf("%s?minBatchNum=%d", endpoint, -2)
 	err = doBadReq("GET", path, nil, 400)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Invalid forgerAddr
 	path = fmt.Sprintf("%s?forgerAddr=%s", endpoint, "0xG0000001")
 	err = doBadReq("GET", path, nil, 400)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestGetBatch(t *testing.T) {
 	endpoint := apiURL + "batches/"
 	for _, batch := range tc.batches {
 		fetchedBatch := testBatch{}
-		assert.NoError(
+		require.NoError(
 			t, doGoodReq(
 				"GET",
 				endpoint+strconv.Itoa(int(batch.BatchNum)),
@@ -255,16 +257,16 @@ func TestGetBatch(t *testing.T) {
 		assertBatch(t, batch, fetchedBatch)
 	}
 	// 400
-	assert.NoError(t, doBadReq("GET", endpoint+"foo", nil, 400))
+	require.NoError(t, doBadReq("GET", endpoint+"foo", nil, 400))
 	// 404
-	assert.NoError(t, doBadReq("GET", endpoint+"99999", nil, 404))
+	require.NoError(t, doBadReq("GET", endpoint+"99999", nil, 404))
 }
 
 func TestGetFullBatch(t *testing.T) {
 	endpoint := apiURL + "full-batches/"
 	for _, fullBatch := range tc.fullBatches {
 		fetchedFullBatch := testFullBatch{}
-		assert.NoError(
+		require.NoError(
 			t, doGoodReq(
 				"GET",
 				endpoint+strconv.Itoa(int(fullBatch.Batch.BatchNum)),
@@ -275,9 +277,9 @@ func TestGetFullBatch(t *testing.T) {
 		assertTxs(t, fullBatch.Txs, fetchedFullBatch.Txs)
 	}
 	// 400
-	assert.NoError(t, doBadReq("GET", endpoint+"foo", nil, 400))
+	require.NoError(t, doBadReq("GET", endpoint+"foo", nil, 400))
 	// 404
-	assert.NoError(t, doBadReq("GET", endpoint+"99999", nil, 404))
+	require.NoError(t, doBadReq("GET", endpoint+"99999", nil, 404))
 }
 
 func assertBatches(t *testing.T, expected, actual []testBatch) {

api/bids.go

@@ -34,7 +34,7 @@ func (a *API) getBids(c *gin.Context) {
 		return
 	}
 
-	// Build succesfull response
+	// Build successful response
 	type bidsResponse struct {
 		Bids         []historydb.BidAPI `json:"bids"`
 		PendingItems uint64             `json:"pendingItems"`

api/coordinator.go

@@ -32,7 +32,7 @@ func (a *API) getCoordinators(c *gin.Context) {
 		return
 	}
 
-	// Build succesfull response
+	// Build successful response
 	type coordinatorsResponse struct {
 		Coordinators []historydb.CoordinatorAPI `json:"coordinators"`
 		PendingItems uint64                     `json:"pendingItems"`

api/exits.go

@@ -43,7 +43,7 @@ func (a *API) getExits(c *gin.Context) {
 		return
 	}
 
-	// Build succesfull response
+	// Build successful response
 	type exitsResponse struct {
 		Exits        []historydb.ExitAPI `json:"exits"`
 		PendingItems uint64              `json:"pendingItems"`
@@ -72,6 +72,6 @@ func (a *API) getExit(c *gin.Context) {
 		retSQLErr(err, c)
 		return
 	}
-	// Build succesfull response
+	// Build successful response
 	c.JSON(http.StatusOK, exit)
 }

api/exits_test.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/mitchellh/copystructure"

api/handlers.go

@@ -10,10 +10,11 @@ import (
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/lib/pq"
+	"github.com/russross/meddler"
 )
 
 const (
-	// maxLimit is the max permited items to be returned in paginated responses
+	// maxLimit is the max permitted items to be returned in paginated responses
 	maxLimit uint = 2049
 
 	// dfltOrder indicates how paginated endpoints are ordered if not specified
@@ -39,31 +40,40 @@ const (
 )
 
 var (
-	// ErrNillBidderAddr is used when a nil bidderAddr is received in the getCoordinator method
+	// ErrNilBidderAddr is used when a nil bidderAddr is received in the getCoordinator method
-	ErrNillBidderAddr = errors.New("biderAddr can not be nil")
+	ErrNilBidderAddr = errors.New("biderAddr can not be nil")
 )
 
 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/parsers.go

@@ -50,19 +50,19 @@ func parsePagination(c querier) (fromItem *uint, order string, limit *uint, err
 	return fromItem, order, limit, nil
 }
 
-// nolint reason: res may be not overwriten
+// nolint reason: res may be not overwritten
 func parseQueryUint(name string, dflt *uint, min, max uint, c querier) (*uint, error) { //nolint:SA4009
 	str := c.Query(name)
 	return stringToUint(str, name, dflt, min, max)
 }
 
-// nolint reason: res may be not overwriten
+// nolint reason: res may be not overwritten
 func parseQueryInt64(name string, dflt *int64, min, max int64, c querier) (*int64, error) { //nolint:SA4009
 	str := c.Query(name)
 	return stringToInt64(str, name, dflt, min, max)
 }
 
-// nolint reason: res may be not overwriten
+// nolint reason: res may be not overwritten
 func parseQueryBool(name string, dflt *bool, c querier) (*bool, error) { //nolint:SA4009
 	str := c.Query(name)
 	if str == "" {
@@ -295,13 +295,13 @@ func parseParamIdx(c paramer) (*common.Idx, error) {
 	return stringToIdx(idxStr, name)
 }
 
-// nolint reason: res may be not overwriten
+// nolint reason: res may be not overwritten
 func parseParamUint(name string, dflt *uint, min, max uint, c paramer) (*uint, error) { //nolint:SA4009
 	str := c.Param(name)
 	return stringToUint(str, name, dflt, min, max)
 }
 
-// nolint reason: res may be not overwriten
+// nolint reason: res may be not overwritten
 func parseParamInt64(name string, dflt *int64, min, max int64, c paramer) (*int64, error) { //nolint:SA4009
 	str := c.Param(name)
 	return stringToInt64(str, name, dflt, min, max)

api/slots.go

@@ -11,7 +11,7 @@ import (
 	"github.com/hermeznetwork/tracerr"
 )
 
-// SlotAPI is a repesentation of a slot information
+// SlotAPI is a representation of a slot information
 type SlotAPI struct {
 	ItemID      uint64            `json:"itemId"`
 	SlotNum     int64             `json:"slotNum"`
@@ -316,7 +316,7 @@ func (a *API) getSlots(c *gin.Context) {
 		return
 	}
 
-	// Build succesfull response
+	// Build successful response
 	type slotsResponse struct {
 		Slots        []SlotAPI `json:"slots"`
 		PendingItems uint64    `json:"pendingItems"`

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

@@ -1,306 +1,16 @@
 package api
 
 import (
-	"database/sql"
-	"fmt"
-	"math/big"
 	"net/http"
-	"time"
 
 	"github.com/gin-gonic/gin"
-	"github.com/hermeznetwork/hermez-node/apitypes"
-	"github.com/hermeznetwork/hermez-node/common"
-	"github.com/hermeznetwork/hermez-node/db/historydb"
-	"github.com/hermeznetwork/tracerr"
 )
 
-// Network define status of the network
-type Network struct {
-	LastEthBlock  int64               `json:"lastEthereumBlock"`
-	LastSyncBlock int64               `json:"lastSynchedBlock"`
-	LastBatch     *historydb.BatchAPI `json:"lastBatch"`
-	CurrentSlot   int64               `json:"currentSlot"`
-	NextForgers   []NextForger        `json:"nextForgers"`
-}
-
-// NextForger  is a representation of the information of a coordinator and the period will forge
-type NextForger struct {
-	Coordinator historydb.CoordinatorAPI `json:"coordinator"`
-	Period      Period                   `json:"period"`
-}
-
-// Period is a representation of a period
-type Period struct {
-	SlotNum       int64     `json:"slotNum"`
-	FromBlock     int64     `json:"fromBlock"`
-	ToBlock       int64     `json:"toBlock"`
-	FromTimestamp time.Time `json:"fromTimestamp"`
-	ToTimestamp   time.Time `json:"toTimestamp"`
-}
-
 func (a *API) getState(c *gin.Context) {
-	// TODO: There are no events for the buckets information, so now this information will be 0
+	stateAPI, err := a.h.GetStateAPI()
-	a.status.RLock()
-	status := a.status //nolint
-	a.status.RUnlock()
-	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
-	}
-
-	rollupVAPI.SafeMode = rollupVariables.SafeMode
-	a.status.Rollup = rollupVAPI
-	a.status.Unlock()
-}
-
-// SetWDelayerVariables set Status.WithdrawalDelayer variables
-func (a *API) SetWDelayerVariables(wDelayerVariables common.WDelayerVariables) {
-	a.status.Lock()
-	a.status.WithdrawalDelayer = wDelayerVariables
-	a.status.Unlock()
-}
-
-// SetAuctionVariables set Status.Auction variables
-func (a *API) SetAuctionVariables(auctionVariables common.AuctionVariables) {
-	a.status.Lock()
-	var auctionAPI historydb.AuctionVariablesAPI
-
-	auctionAPI.EthBlockNum = auctionVariables.EthBlockNum
-	auctionAPI.DonationAddress = auctionVariables.DonationAddress
-	auctionAPI.BootCoordinator = auctionVariables.BootCoordinator
-	auctionAPI.BootCoordinatorURL = auctionVariables.BootCoordinatorURL
-	auctionAPI.DefaultSlotSetBidSlotNum = auctionVariables.DefaultSlotSetBidSlotNum
-	auctionAPI.ClosedAuctionSlots = auctionVariables.ClosedAuctionSlots
-	auctionAPI.OpenAuctionSlots = auctionVariables.OpenAuctionSlots
-	auctionAPI.Outbidding = auctionVariables.Outbidding
-	auctionAPI.SlotDeadline = auctionVariables.SlotDeadline
-
-	for i, slot := range auctionVariables.DefaultSlotSetBid {
-		auctionAPI.DefaultSlotSetBid[i] = apitypes.NewBigIntStr(slot)
-	}
-
-	for i, ratio := range auctionVariables.AllocationRatio {
-		auctionAPI.AllocationRatio[i] = ratio
-	}
-
-	a.status.Auction = auctionAPI
-	a.status.Unlock()
-}
-
-// Network
-
-// UpdateNetworkInfoBlock update Status.Network block related information
-func (a *API) UpdateNetworkInfoBlock(
-	lastEthBlock, lastSyncBlock common.Block,
-) {
-	a.status.Network.LastSyncBlock = lastSyncBlock.Num
-	a.status.Network.LastEthBlock = lastEthBlock.Num
-}
-
-// UpdateNetworkInfo update Status.Network information
-func (a *API) UpdateNetworkInfo(
-	lastEthBlock, lastSyncBlock common.Block,
-	lastBatchNum common.BatchNum, currentSlot int64,
-) error {
-	lastBatch, err := a.h.GetBatchAPI(lastBatchNum)
-	if tracerr.Unwrap(err) == sql.ErrNoRows {
-		lastBatch = nil
-	} else if err != nil {
-		return tracerr.Wrap(err)
-	}
-	lastClosedSlot := currentSlot + int64(a.status.Auction.ClosedAuctionSlots)
-	nextForgers, err := a.getNextForgers(lastSyncBlock, currentSlot, lastClosedSlot)
-	if tracerr.Unwrap(err) == sql.ErrNoRows {
-		nextForgers = nil
-	} else if err != nil {
-		return tracerr.Wrap(err)
-	}
-	a.status.Lock()
-	a.status.Network.LastSyncBlock = lastSyncBlock.Num
-	a.status.Network.LastEthBlock = lastEthBlock.Num
-	a.status.Network.LastBatch = lastBatch
-	a.status.Network.CurrentSlot = currentSlot
-	a.status.Network.NextForgers = nextForgers
-
-	// Update buckets withdrawals
-	bucketsUpdate, err := a.h.GetBucketUpdatesAPI()
-	if tracerr.Unwrap(err) == sql.ErrNoRows {
-		bucketsUpdate = nil
-	} else if err != nil {
-		return tracerr.Wrap(err)
-	}
-
-	for i, bucketParams := range a.status.Rollup.Buckets {
-		for _, bucketUpdate := range bucketsUpdate {
-			if bucketUpdate.NumBucket == i {
-				bucketParams.Withdrawals = bucketUpdate.Withdrawals
-				a.status.Rollup.Buckets[i] = bucketParams
-				break
-			}
-		}
-	}
-	a.status.Unlock()
-	return nil
-}
-
-// apiSlotToBigInts converts from [6]*apitypes.BigIntStr to [6]*big.Int
-func apiSlotToBigInts(defaultSlotSetBid [6]*apitypes.BigIntStr) ([6]*big.Int, error) {
-	var slots [6]*big.Int
-
-	for i, slot := range defaultSlotSetBid {
-		bigInt, ok := new(big.Int).SetString(string(*slot), 10)
-		if !ok {
-			return slots, tracerr.Wrap(fmt.Errorf("can't convert %T into big.Int", slot))
-		}
-		slots[i] = bigInt
-	}
-
-	return slots, nil
-}
-
-// getNextForgers returns next forgers
-func (a *API) getNextForgers(lastBlock common.Block, currentSlot, lastClosedSlot int64) ([]NextForger, error) {
-	secondsPerBlock := int64(15) //nolint:gomnd
-	// currentSlot and lastClosedSlot included
-	limit := uint(lastClosedSlot - currentSlot + 1)
-	bids, _, err := a.h.GetBestBidsAPI(&currentSlot, &lastClosedSlot, nil, &limit, "ASC")
-	if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
-		return nil, tracerr.Wrap(err)
-	}
-	nextForgers := []NextForger{}
-	// Get min bid info
-	var minBidInfo []historydb.MinBidInfo
-	if currentSlot >= a.status.Auction.DefaultSlotSetBidSlotNum {
-		// All min bids can be calculated with the last update of AuctionVariables
-		bigIntSlots, err := apiSlotToBigInts(a.status.Auction.DefaultSlotSetBid)
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-
-		minBidInfo = []historydb.MinBidInfo{{
-			DefaultSlotSetBid:        bigIntSlots,
-			DefaultSlotSetBidSlotNum: a.status.Auction.DefaultSlotSetBidSlotNum,
-		}}
-	} else {
-		// Get all the relevant updates from the DB
-		minBidInfo, err = a.h.GetAuctionVarsUntilSetSlotNumAPI(lastClosedSlot, int(lastClosedSlot-currentSlot)+1)
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-	}
-	// Create nextForger for each slot
-	for i := currentSlot; i <= lastClosedSlot; i++ {
-		fromBlock := i*int64(a.cg.AuctionConstants.BlocksPerSlot) + a.cg.AuctionConstants.GenesisBlockNum
-		toBlock := (i+1)*int64(a.cg.AuctionConstants.BlocksPerSlot) + a.cg.AuctionConstants.GenesisBlockNum - 1
-		nextForger := NextForger{
-			Period: Period{
-				SlotNum:       i,
-				FromBlock:     fromBlock,
-				ToBlock:       toBlock,
-				FromTimestamp: lastBlock.Timestamp.Add(time.Second * time.Duration(secondsPerBlock*(fromBlock-lastBlock.Num))),
-				ToTimestamp:   lastBlock.Timestamp.Add(time.Second * time.Duration(secondsPerBlock*(toBlock-lastBlock.Num))),
-			},
-		}
-		foundForger := false
-		// If there is a bid for a slot, get forger (coordinator)
-		for j := range bids {
-			slotNum := bids[j].SlotNum
-			if slotNum == i {
-				// There's a bid for the slot
-				// Check if the bid is greater than the minimum required
-				for i := 0; i < len(minBidInfo); i++ {
-					// Find the most recent update
-					if slotNum >= minBidInfo[i].DefaultSlotSetBidSlotNum {
-						// Get min bid
-						minBidSelector := slotNum % int64(len(a.status.Auction.DefaultSlotSetBid))
-						minBid := minBidInfo[i].DefaultSlotSetBid[minBidSelector]
-						// Check if the bid has beaten the minimum
-						bid, ok := new(big.Int).SetString(string(bids[j].BidValue), 10)
-						if !ok {
-							return nil, tracerr.New("Wrong bid value, error parsing it as big.Int")
-						}
-						if minBid.Cmp(bid) == 1 {
-							// Min bid is greater than bid, the slot will be forged by boot coordinator
-							break
-						}
-						foundForger = true
-						break
-					}
-				}
-				if !foundForger { // There is no bid or it's smaller than the minimum
-					break
-				}
-				coordinator, err := a.h.GetCoordinatorAPI(bids[j].Bidder)
-				if err != nil {
-					return nil, tracerr.Wrap(err)
-				}
-				nextForger.Coordinator = *coordinator
-				break
-			}
-		}
-		// If there is no bid, the coordinator that will forge is boot coordinator
-		if !foundForger {
-			nextForger.Coordinator = historydb.CoordinatorAPI{
-				Forger: a.status.Auction.BootCoordinator,
-				URL:    a.status.Auction.BootCoordinatorURL,
-			}
-		}
-		nextForgers = append(nextForgers, nextForger)
-	}
-	return nextForgers, nil
-}
-
-// Metrics
-
-// UpdateMetrics update Status.Metrics information
-func (a *API) UpdateMetrics() error {
-	a.status.RLock()
-	if a.status.Network.LastBatch == nil {
-		a.status.RUnlock()
-		return nil
-	}
-	batchNum := a.status.Network.LastBatch.BatchNum
-	a.status.RUnlock()
-	metrics, err := a.h.GetMetricsAPI(batchNum)
 	if err != nil {
-		return tracerr.Wrap(err)
+		retBadReq(err, c)
+		return
 	}
-	a.status.Lock()
+	c.JSON(http.StatusOK, stateAPI)
-	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

@@ -4,7 +4,7 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/stretchr/testify/assert"
@@ -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,80 @@ func TestUpdateNetworkInfo(t *testing.T) {
 	err := api.h.AddBucketUpdatesTest(api.h.DB(), bucketUpdates)
 	require.NoError(t, err)
 
-	err = api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
+	err = stateAPIUpdater.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
-	assert.Equal(t, lastBlock.Num, api.status.Network.LastSyncBlock)
+	require.NoError(t, stateAPIUpdater.Store())
-	assert.Equal(t, lastBatchNum, api.status.Network.LastBatch.BatchNum)
+	ni, err := api.h.GetNodeInfoAPI()
-	assert.Equal(t, currentSlotNum, api.status.Network.CurrentSlot)
+	require.NoError(t, err)
-	assert.Equal(t, int(api.status.Auction.ClosedAuctionSlots)+1, len(api.status.Network.NextForgers))
+	assert.Equal(t, lastBlock.Num, ni.StateAPI.Network.LastSyncBlock)
-	assert.Equal(t, api.status.Rollup.Buckets[0].Withdrawals, apitypes.NewBigIntStr(big.NewInt(123)))
+	assert.Equal(t, lastBatchNum, ni.StateAPI.Network.LastBatch.BatchNum)
-	assert.Equal(t, api.status.Rollup.Buckets[2].Withdrawals, apitypes.NewBigIntStr(big.NewInt(43)))
+	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.TokenAccounts, int64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.Wallets, 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*
+			historydb.CreateAccountExtraFeePercentage)
+	assert.Equal(t, ni.StateAPI.RecommendedFee.CreatesAccountInternal,
+		ni.StateAPI.RecommendedFee.ExistingAccount*
+			historydb.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
@@ -194,19 +210,21 @@ func TestGetState(t *testing.T) {
 	assert.Greater(t, status.Metrics.TransactionsPerBatch, float64(0))
 	assert.Greater(t, status.Metrics.BatchFrequency, float64(0))
 	assert.Greater(t, status.Metrics.TransactionsPerSecond, float64(0))
-	assert.Greater(t, status.Metrics.TotalAccounts, int64(0))
+	assert.Greater(t, status.Metrics.TokenAccounts, int64(0))
-	assert.Greater(t, status.Metrics.TotalBJJs, int64(0))
+	assert.Greater(t, status.Metrics.Wallets, int64(0))
 	assert.Greater(t, status.Metrics.AvgTransactionFee, float64(0))
 	// Recommended fee
 	// TODO: perform real asserts (not just greater than 0)
 	assert.Greater(t, status.RecommendedFee.ExistingAccount, float64(0))
 	assert.Equal(t, status.RecommendedFee.CreatesAccount,
-		status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
+		status.RecommendedFee.ExistingAccount*
-	assert.Equal(t, status.RecommendedFee.CreatesAccountAndRegister,
+			historydb.CreateAccountExtraFeePercentage)
-		status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
+	assert.Equal(t, status.RecommendedFee.CreatesAccountInternal,
+		status.RecommendedFee.ExistingAccount*
+			historydb.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/stateapiupdater/stateapiupdater.go

@@ -0,0 +1,162 @@
+package stateapiupdater
+
+import (
+	"database/sql"
+	"sync"
+
+	"github.com/hermeznetwork/hermez-node/common"
+	"github.com/hermeznetwork/hermez-node/db/historydb"
+	"github.com/hermeznetwork/tracerr"
+)
+
+// Updater is an utility object to facilitate updating the StateAPI
+type Updater struct {
+	hdb    *historydb.HistoryDB
+	state  historydb.StateAPI
+	config historydb.NodeConfig
+	vars   common.SCVariablesPtr
+	consts historydb.Constants
+	rw     sync.RWMutex
+}
+
+// NewUpdater creates a new Updater
+func NewUpdater(hdb *historydb.HistoryDB, config *historydb.NodeConfig, vars *common.SCVariables,
+	consts *historydb.Constants) *Updater {
+	u := Updater{
+		hdb:    hdb,
+		config: *config,
+		consts: *consts,
+		state: historydb.StateAPI{
+			NodePublicInfo: historydb.NodePublicInfo{
+				ForgeDelay: config.ForgeDelay,
+			},
+		},
+	}
+	u.SetSCVars(vars.AsPtr())
+	return &u
+}
+
+// Store the State in the HistoryDB
+func (u *Updater) 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 *Updater) 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 *Updater) UpdateRecommendedFee() error {
+	recommendedFee, err := u.hdb.GetRecommendedFee(u.config.MinFeeUSD, u.config.MaxFeeUSD)
+	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 *Updater) UpdateMetrics() error {
+	u.rw.RLock()
+	lastBatch := u.state.Network.LastBatch
+	u.rw.RUnlock()
+	if lastBatch == nil {
+		return nil
+	}
+	lastBatchNum := lastBatch.BatchNum
+	metrics, poolLoad, err := u.hdb.GetMetricsInternalAPI(lastBatchNum)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	u.rw.Lock()
+	u.state.Metrics = *metrics
+	u.state.NodePublicInfo.PoolLoad = poolLoad
+	u.rw.Unlock()
+	return nil
+}
+
+// UpdateNetworkInfoBlock update Status.Network block related information
+func (u *Updater) UpdateNetworkInfoBlock(lastEthBlock, lastSyncBlock common.Block) {
+	u.rw.Lock()
+	u.state.Network.LastSyncBlock = lastSyncBlock.Num
+	u.state.Network.LastEthBlock = lastEthBlock.Num
+	u.rw.Unlock()
+}
+
+// UpdateNetworkInfo update Status.Network information
+func (u *Updater) UpdateNetworkInfo(
+	lastEthBlock, lastSyncBlock common.Block,
+	lastBatchNum common.BatchNum, currentSlot int64,
+) error {
+	// 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)
+	}
+	u.rw.RLock()
+	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)
+	}
+
+	bucketUpdates, err := u.hdb.GetBucketUpdatesInternalAPI()
+	if err == sql.ErrNoRows {
+		bucketUpdates = nil
+	} else if err != nil {
+		return tracerr.Wrap(err)
+	}
+
+	u.rw.Lock()
+	// Update NodeInfo struct
+	for i, bucketParams := range u.state.Rollup.Buckets {
+		for _, bucketUpdate := range bucketUpdates {
+			if bucketUpdate.NumBucket == i {
+				bucketParams.Withdrawals = bucketUpdate.Withdrawals
+				u.state.Rollup.Buckets[i] = bucketParams
+				break
+			}
+		}
+	}
+	// Update pending L1s
+	pendingL1s, err := u.hdb.GetUnforgedL1UserTxsCount()
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	u.state.Network.LastSyncBlock = lastSyncBlock.Num
+	u.state.Network.LastEthBlock = lastEthBlock.Num
+	u.state.Network.LastBatch = lastBatch
+	u.state.Network.CurrentSlot = currentSlot
+	u.state.Network.NextForgers = nextForgers
+	u.state.Network.PendingL1Txs = pendingL1s
+	u.rw.Unlock()
+	return nil
+}

api/swagger.yml

@@ -59,10 +59,10 @@ externalDocs:
   description: Find out more about Hermez network.
   url: 'https://hermez.io'
 servers:
-  - description: Hosted mock up
+  - description: Testnet api, connected to Rinkeby deployment
-    url: https://apimock.hermez.network
+    url: https://api.testnet.hermez.io/v1
-  - description: Localhost mock Up
+  - description: Localhost usefull for testing/developing the api
-    url: http://localhost:4010
+    url: http://localhost:4010/v1
 tags:
   - name: Coordinator
     description: Endpoints used by the nodes running in coordinator mode. They are used to interact with the network.
@@ -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,26 @@ components:
       description: List of next coordinators to forge.
       items: 
         $ref: '#/components/schemas/NextForger'
+    Node:
+      type: object
+      description: Configuration and metrics 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
+        poolLoad:
+          type: number
+          description: Number of pending transactions in the pool
+          example: 23201
+      additionalProperties: false
+      required: 
+        - forgeDelay
+        - poolLoad
     State:
       type: object
       description: Gobal variables of the network
@@ -2594,6 +2605,8 @@ components:
           $ref: '#/components/schemas/StateWithdrawDelayer'
         recommendedFee:
           $ref: '#/components/schemas/RecommendedFee'
+        node:
+          $ref: '#/components/schemas/Node'
       additionalProperties: false
       required: 
         - network
@@ -2602,6 +2615,7 @@ components:
         - auction
         - withdrawalDelayer
         - recommendedFee
+        - node
     StateNetwork:
       type: object
       description: Gobal statistics of the network
@@ -2625,6 +2639,10 @@ components:
             - example: 2334
         nextForgers:
           $ref: '#/components/schemas/NextForgers'
+        pendingL1Transactions:
+          type: number
+          description: Number of pending L1 transactions (added in the smart contract queue but not forged).
+          example: 22
       additionalProperties: false
       required: 
         - lastEthereumBlock
@@ -2800,11 +2818,11 @@ components:
           type: number
           description: Average transactions per second in the last 24 hours.
           example: 302.3
-        totalAccounts:
+        tokenAccounts:
           type: integer
           description: Number of created accounts.
           example: 90473
-        totalBJJs:
+        wallets:
           type: integer
           description: Number of different registered BJJs.
           example: 23067
@@ -2812,14 +2830,19 @@ 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
         - batchFrequency
         - transactionsPerSecond
-        - totalAccounts
+        - tokenAccounts
-        - totalBJJs
+        - wallets
         - 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.
@@ -2916,7 +2939,7 @@ components:
               example: 101
             l1UserTotalBytes:
               type: integer
-              description: Number of bytes that a L1 user transaction has ([20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6 bytes] fromIdx + [2 bytes] depositAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx).
+              description: Number of bytes that a L1 user transaction has ([20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6 bytes] fromIdx + [5 bytes] depositAmountFloat40 + [5 bytes] amountFloat40 + [4 bytes] tokenId + [6 bytes] toIdx).
               example: 72
             maxL1UserTx:
               type: integer

api/token.go

@@ -53,7 +53,7 @@ func (a *API) getTokens(c *gin.Context) {
 		return
 	}
 
-	// Build succesfull response
+	// Build successful response
 	type tokensResponse struct {
 		Tokens       []historydb.TokenWithUSD `json:"tokens"`
 		PendingItems uint64                   `json:"pendingItems"`

api/txshistory.go

@@ -42,7 +42,7 @@ func (a *API) getHistoryTxs(c *gin.Context) {
 		return
 	}
 
-	// Build succesfull response
+	// Build successful response
 	type txsResponse struct {
 		Txs          []historydb.TxAPI `json:"transactions"`
 		PendingItems uint64            `json:"pendingItems"`
@@ -66,6 +66,6 @@ func (a *API) getHistoryTx(c *gin.Context) {
 		retSQLErr(err, c)
 		return
 	}
-	// Build succesfull response
+	// Build successful response
 	c.JSON(http.StatusOK, tx)
 }

api/txshistory_test.go

@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/test"
@@ -455,7 +455,7 @@ func TestGetHistoryTx(t *testing.T) {
 	// 400, due invalid TxID
 	err := doBadReq("GET", endpoint+"0x001", nil, 400)
 	assert.NoError(t, err)
-	// 404, due inexistent TxID in DB
+	// 404, due nonexistent TxID in DB
 	err = doBadReq("GET", endpoint+"0x00eb5e95e1ce5e9f6c4ed402d415e8d0bdd7664769cfd2064d28da04a2c76be432", nil, 404)
 	assert.NoError(t, err)
 }

api/txspool.go

@@ -2,12 +2,13 @@ package api
 
 import (
 	"errors"
+	"fmt"
 	"math/big"
 	"net/http"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/gin-gonic/gin"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
 	"github.com/hermeznetwork/tracerr"
@@ -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)
@@ -49,7 +51,7 @@ func (a *API) getPoolTx(c *gin.Context) {
 		retSQLErr(err, c)
 		return
 	}
-	// Build succesfull response
+	// Build successful response
 	c.JSON(http.StatusOK, tx)
 }
 
@@ -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(fmt.Errorf("Error getting from account: %w", 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

@@ -2,14 +2,20 @@ package api
 
 import (
 	"bytes"
+	"crypto/ecdsa"
+	"encoding/binary"
+	"encoding/hex"
 	"encoding/json"
+	"math/big"
 	"testing"
 	"time"
 
+	ethCrypto "github.com/ethereum/go-ethereum/crypto"
 	"github.com/hermeznetwork/hermez-node/common"
 	"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 +176,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 +193,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 +239,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
+	// 404, due nonexistent 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) {
@@ -256,3 +262,73 @@ func assertPoolTx(t *testing.T, expected, actual testPoolTxReceive) {
 	}
 	assert.Equal(t, expected, actual)
 }
+
+// TestAllTosNull test that the API doesn't accept txs with all the TOs set to null (to eth, to bjj, to idx)
+func TestAllTosNull(t *testing.T) {
+	// Generate account:
+	// Ethereum private key
+	var key ecdsa.PrivateKey
+	key.D = big.NewInt(int64(4444)) // only for testing
+	key.PublicKey.X, key.PublicKey.Y = ethCrypto.S256().ScalarBaseMult(key.D.Bytes())
+	key.Curve = ethCrypto.S256()
+	addr := ethCrypto.PubkeyToAddress(key.PublicKey)
+	// BJJ private key
+	var sk babyjub.PrivateKey
+	var iBytes [8]byte
+	binary.LittleEndian.PutUint64(iBytes[:], 4444)
+	copy(sk[:], iBytes[:]) // only for testing
+	account := common.Account{
+		Idx:      4444,
+		TokenID:  0,
+		BatchNum: 1,
+		BJJ:      sk.Public().Compress(),
+		EthAddr:  addr,
+		Nonce:    0,
+		Balance:  big.NewInt(1000000),
+	}
+	// Add account to history DB (required to verify signature)
+	err := api.h.AddAccounts([]common.Account{account})
+	assert.NoError(t, err)
+	// Genrate tx with all tos set to nil (to eth, to bjj, to idx)
+	tx := common.PoolL2Tx{
+		FromIdx: account.Idx,
+		TokenID: account.TokenID,
+		Amount:  big.NewInt(1000),
+		Fee:     200,
+		Nonce:   0,
+	}
+	// Set idx and type manually, and check that the function doesn't allow it
+	_, err = common.NewPoolL2Tx(&tx)
+	assert.Error(t, err)
+	tx.Type = common.TxTypeTransfer
+	var txID common.TxID
+	txIDRaw, err := hex.DecodeString("02e66e24f7f25272906647c8fd1d7fe8acf3cf3e9b38ffc9f94bbb5090dc275073")
+	assert.NoError(t, err)
+	copy(txID[:], txIDRaw)
+	tx.TxID = txID
+	// Sign tx
+	toSign, err := tx.HashToSign(0)
+	assert.NoError(t, err)
+	sig := sk.SignPoseidon(toSign)
+	tx.Signature = sig.Compress()
+	// Transform common.PoolL2Tx ==> testPoolTxSend
+	txToSend := testPoolTxSend{
+		TxID:      tx.TxID,
+		Type:      tx.Type,
+		TokenID:   tx.TokenID,
+		FromIdx:   idxToHez(tx.FromIdx, "ETH"),
+		Amount:    tx.Amount.String(),
+		Fee:       tx.Fee,
+		Nonce:     tx.Nonce,
+		Signature: tx.Signature,
+	}
+	// Send tx to the API
+	jsonTxBytes, err := json.Marshal(txToSend)
+	require.NoError(t, err)
+	jsonTxReader := bytes.NewReader(jsonTxBytes)
+	err = doBadReq("POST", apiURL+"transactions-pool", jsonTxReader, 400)
+	require.NoError(t, err)
+	// Clean historyDB: the added account shouldn't be there for other tests
+	_, err = api.h.DB().DB.Exec("delete from account where idx = 4444")
+	assert.NoError(t, err)
+}

batchbuilder/batchbuilder.go

@@ -28,7 +28,8 @@ type ConfigBatch struct {
 
 // NewBatchBuilder constructs a new BatchBuilder, and executes the bb.Reset
 // method
-func NewBatchBuilder(dbpath string, synchronizerStateDB *statedb.StateDB, batchNum common.BatchNum, nLevels uint64) (*BatchBuilder, error) {
+func NewBatchBuilder(dbpath string, synchronizerStateDB *statedb.StateDB, batchNum common.BatchNum,
+	nLevels uint64) (*BatchBuilder, error) {
 	localStateDB, err := statedb.NewLocalStateDB(
 		statedb.Config{
 			Path:    dbpath,
@@ -64,7 +65,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

batchbuilder/batchbuilder_test.go

@@ -15,7 +15,8 @@ func TestBatchBuilder(t *testing.T) {
 	require.Nil(t, err)
 	defer assert.Nil(t, os.RemoveAll(dir))
 
-	synchDB, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128, Type: statedb.TypeBatchBuilder, NLevels: 0})
+	synchDB, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+		Type: statedb.TypeBatchBuilder, NLevels: 0})
 	assert.Nil(t, err)
 
 	bbDir, err := ioutil.TempDir("", "tmpBatchBuilderDB")

cli/node/.gitignore

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

cli/node/README.md

@@ -2,9 +2,13 @@
 
 This is the main cli for the node
 
+## Go version
+
+The `hermez-node` has been tested with go version 1.14
+
 ## Usage
 
-```
+```shell
 NAME:
    hermez-node - A new cli application
 
@@ -12,18 +16,18 @@ USAGE:
    node [global options] command [command options] [arguments...]
 
 VERSION:
-   0.1.0-alpha
+   v0.1.0-6-gd8a50c5
 
 COMMANDS:
+   version    Show the application version
    importkey  Import ethereum private key
    genbjj     Generate a new BabyJubJub key
-   wipesql    Wipe the SQL DB (HistoryDB and L2DB), leaving the DB in a clean state
+   wipesql    Wipe the SQL DB (HistoryDB and L2DB) and the StateDBs, leaving the DB in a clean state
    run        Run the hermez-node in the indicated mode
+   discard    Discard blocks up to a specified block number
    help, h    Shows a list of commands or help for one command
 
 GLOBAL OPTIONS:
-   --mode MODE    Set node MODE (can be "sync" or "coord")
-   --cfg FILE     Node configuration FILE
    --help, -h     show help (default: false)
    --version, -v  print the version (default: false)
 ```
@@ -65,29 +69,69 @@ when running the coordinator in sync mode
 - The node requires a PostgreSQL database.  The parameters of the server and
   database must be set in the `PostgreSQL` section.
 
+## Building
+
+*All commands assume you are at the `cli/node` directory.*
+
+Building the node requires using the packr utility to bundle the database
+migrations inside the resulting binary.  Install the packr utility with:
+```shell
+cd /tmp && go get -u github.com/gobuffalo/packr/v2/packr2 && cd -
+```
+
+Make sure your `$PATH` contains `$GOPATH/bin`, otherwise the packr utility will
+not be found.
+
+Now build the node executable:
+```shell
+cd ../../db && packr2 && cd -
+go build .
+cd ../../db && packr2 clean && cd -
+```
+
+The executable is `node`.
+
 ## Usage Examples
 
+The following commands assume you have built the node previously.  You can also
+run the following examples by replacing `./node` with `go run .` and executing
+them in the `cli/node` directory to build from source and run at the same time.
+
 Run the node in mode synchronizer:
-```
+```shell
-go run . --mode sync --cfg cfg.buidler.toml run
+./node run --mode sync --cfg cfg.buidler.toml
 ```
 
 Run the node in mode coordinator:
-```
+```shell
-go run . --mode coord --cfg cfg.buidler.toml run
+./node run --mode coord --cfg cfg.buidler.toml
 ```
 
 Import an ethereum private key into the keystore:
-```
+```shell
-go run . --mode coord --cfg cfg.buidler.toml importkey --privatekey  0x618b35096c477aab18b11a752be619f0023a539bb02dd6c813477a6211916cde
+./node importkey --mode coord --cfg cfg.buidler.toml --privatekey  0x618b35096c477aab18b11a752be619f0023a539bb02dd6c813477a6211916cde
 ```
 
 Generate a new BabyJubJub key pair:
-```
+```shell
-go run . --mode coord --cfg cfg.buidler.toml genbjj
+./node genbjj
 ```
 
-Wipe the entier SQL database (this will destroy all synchronized and pool data):
+Check the binary version:
+```shell
+./node version
 ```
-go run . --mode coord --cfg cfg.buidler.toml wipesql
+
+Wipe the entier SQL database (this will destroy all synchronized and pool
+data):
+```shell
+./node wipesql --mode coord --cfg cfg.buidler.toml 
+```
+
+Discard all synchronized blocks and associated state up to a given block
+number.  This command is useful in case the synchronizer reaches an invalid
+state and you want to roll back a few blocks and try again (maybe with some
+fixes in the code).
+```shell
+./node discard --mode coord --cfg cfg.buidler.toml --block 8061330
 ```

cli/node/cfg.api.toml

@@ -0,0 +1,24 @@
+[API]
+Address = "localhost:8386"
+Explorer = true
+MaxSQLConnections = 10
+SQLConnectionTimeout = "2s"
+
+[PostgreSQL]
+PortWrite     = 5432
+HostWrite     = "localhost"
+UserWrite     = "hermez"
+PasswordWrite = "yourpasswordhere"
+NameWrite     = "hermez"
+
+[Coordinator.L2DB]
+SafetyPeriod = 10
+MaxTxs       = 512
+TTL          = "24h"
+PurgeBatchDelay = 10
+InvalidateBatchDelay = 20
+PurgeBlockDelay = 10
+InvalidateBlockDelay = 20
+
+[Coordinator.API]
+Coordinator = true

cli/node/cfg.buidler.toml

@@ -8,23 +8,52 @@ SQLConnectionTimeout = "2s"
 
 [PriceUpdater]
 Interval = "10s"
-URL = "https://api-pub.bitfinex.com/v2/"
+URLBitfinexV2 = "https://api-pub.bitfinex.com/v2/"
-Type = "bitfinexV2"
+URLCoinGeckoV3 = "https://api.coingecko.com/api/v3/"
+# Available update methods:
+# - coingeckoV3 (recommended): get price by SC addr using coingecko API
+# - bitfinexV2: get price by token symbol using bitfinex API
+# - static (recommended for blacklisting tokens): use the given StaticValue to set the price (if not provided 0 will be used)
+# - ignore: don't update the price leave it as it is on the DB
+DefaultUpdateMethod = "coingeckoV3" # Update method used for all the tokens registered on the network, and not listed in [[PriceUpdater.TokensConfig]]
+[[PriceUpdater.TokensConfig]]
+UpdateMethod = "bitfinexV2"
+Symbol = "USDT"
+Addr = "0xdac17f958d2ee523a2206206994597c13d831ec7"
+[[PriceUpdater.TokensConfig]]
+UpdateMethod = "coingeckoV3"
+Symbol = "ETH"
+Addr = "0x0000000000000000000000000000000000000000"
+[[PriceUpdater.TokensConfig]]
+UpdateMethod = "static"
+Symbol = "UNI"
+Addr = "0x1f9840a85d5af5bf1d1762f925bdaddc4201f984"
+StaticValue = 30.12
+[[PriceUpdater.TokensConfig]]
+UpdateMethod = "ignore"
+Symbol = "SUSHI"
+Addr = "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2"
 
 [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 +74,7 @@ ForgerAddress = "0x05c23b938a85ab26A36E6314a0D02080E9ca6BeD" # Non-Boot Coordina
 # ForgerAddressPrivateKey = "0x30f5fddb34cd4166adb2c6003fa6b18f380fd2341376be42cf1c7937004ac7a3"
 # ForgerAddress = "0xb4124ceb3451635dacedd11767f004d8a28c6ee7" # Boot Coordinator
 # ForgerAddressPrivateKey = "0xa8a54b2d8197bc0b19bb8a084031be71835580a01e70a45a13babd16c9bc1563"
+MinimumForgeAddressBalance = "0"
 ConfirmBlocks = 10
 L1BatchTimeoutPerc = 0.6
 StartSlotBlocksDelay = 2
@@ -53,6 +83,11 @@ SendBatchBlocksMarginCheck = 1
 ProofServerPollInterval = "1s"
 ForgeRetryInterval = "500ms"
 SyncRetryInterval = "1s"
+ForgeDelay = "10s"
+ForgeNoTxsDelay = "0s"
+PurgeByExtDelInterval = "1m"
+MustForgeAtSlotDeadline = true
+IgnoreSlotCommitment = false
 
 [Coordinator.FeeAccount]
 Address = "0x56232B1c5B10038125Bc7345664B4AFD745bcF8E"
@@ -63,6 +98,8 @@ BJJ = "0x1b176232f78ba0d388ecc5f4896eca2d3b3d4f272092469f559247297f5c0c13"
 [Coordinator.L2DB]
 SafetyPeriod = 10
 MaxTxs       = 512
+MinFeeUSD    = 0.0
+MaxFeeUSD    = 50.0
 TTL          = "24h"
 PurgeBatchDelay = 10
 InvalidateBatchDelay = 20
@@ -83,21 +120,24 @@ MaxTx = 512
 NLevels = 32
 
 [Coordinator.EthClient]
-ReceiptTimeout      = "60s"
-ReceiptLoopInterval = "500ms"
 CheckLoopInterval = "500ms"
 Attempts = 4
 AttemptsDelay = "500ms"
 TxResendTimeout = "2m"
 NoReuseNonce = false
-CallGasLimit = 300000
-GasPriceDiv = 100
 MaxGasPrice = "5000000000"
+GasPriceIncPerc = 10
 
 [Coordinator.EthClient.Keystore]
 Path = "/tmp/iden3-test/hermez/ethkeystore"
 Password = "yourpasswordhere"
 
+[Coordinator.EthClient.ForgeBatchGasCost]
+Fixed = 600000
+L1UserTx = 15000
+L1CoordTx = 8000
+L2Tx = 250
+
 [Coordinator.API]
 Coordinator = true
 

cli/node/main.go

@@ -5,16 +5,22 @@ import (
 	"fmt"
 	"os"
 	"os/signal"
+	"path"
 	"strings"
 
 	ethKeystore "github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/config"
 	dbUtils "github.com/hermeznetwork/hermez-node/db"
+	"github.com/hermeznetwork/hermez-node/db/historydb"
+	"github.com/hermeznetwork/hermez-node/db/kvdb"
+	"github.com/hermeznetwork/hermez-node/db/l2db"
 	"github.com/hermeznetwork/hermez-node/log"
 	"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"
 )
 
@@ -23,10 +29,27 @@ const (
 	flagMode  = "mode"
 	flagSK    = "privatekey"
 	flagYes   = "yes"
+	flagBlock = "block"
 	modeSync  = "sync"
 	modeCoord = "coord"
 )
 
+var (
+	// Version represents the program based on the git tag
+	Version = "v0.1.0"
+	// Build represents the program based on the git commit
+	Build = "dev"
+	// Date represents the date of application was built
+	Date = ""
+)
+
+func cmdVersion(c *cli.Context) error {
+	fmt.Printf("Version = \"%v\"\n", Version)
+	fmt.Printf("Build = \"%v\"\n", Build)
+	fmt.Printf("Date = \"%v\"\n", Date)
+	return nil
+}
+
 func cmdGenBJJ(c *cli.Context) error {
 	sk := babyjub.NewRandPrivKey()
 	skBuf := [32]byte(sk)
@@ -68,6 +91,86 @@ func cmdImportKey(c *cli.Context) error {
 	return nil
 }
 
+func resetStateDBs(cfg *Config, batchNum common.BatchNum) error {
+	log.Infof("Reset Synchronizer StateDB to batchNum %v...", batchNum)
+
+	// Manually make a checkpoint from batchNum to current to force current
+	// to be a valid checkpoint.  This is useful because in case of a
+	// crash, current can be corrupted and the first thing that
+	// `kvdb.NewKVDB` does is read the current checkpoint, which wouldn't
+	// succeed in case of corruption.
+	dbPath := cfg.node.StateDB.Path
+	source := path.Join(dbPath, fmt.Sprintf("%s%d", kvdb.PathBatchNum, batchNum))
+	current := path.Join(dbPath, kvdb.PathCurrent)
+	last := path.Join(dbPath, kvdb.PathLast)
+	if err := os.RemoveAll(last); err != nil {
+		return tracerr.Wrap(fmt.Errorf("os.RemoveAll: %w", err))
+	}
+	if batchNum == 0 {
+		if err := os.RemoveAll(current); err != nil {
+			return tracerr.Wrap(fmt.Errorf("os.RemoveAll: %w", err))
+		}
+	} else {
+		if err := kvdb.PebbleMakeCheckpoint(source, current); err != nil {
+			return tracerr.Wrap(fmt.Errorf("kvdb.PebbleMakeCheckpoint: %w", err))
+		}
+	}
+	db, err := kvdb.NewKVDB(kvdb.Config{
+		Path:        dbPath,
+		NoGapsCheck: true,
+		NoLast:      true,
+	})
+	if err != nil {
+		return tracerr.Wrap(fmt.Errorf("kvdb.NewKVDB: %w", err))
+	}
+	if err := db.Reset(batchNum); err != nil {
+		return tracerr.Wrap(fmt.Errorf("db.Reset: %w", err))
+	}
+
+	if cfg.mode == node.ModeCoordinator {
+		log.Infof("Wipe Coordinator StateDBs...")
+
+		// We wipe the Coordinator StateDBs entirely (by deleting
+		// current and resetting to batchNum 0) because the Coordinator
+		// StateDBs are always reset from Synchronizer when the
+		// coordinator pipeline starts.
+		dbPath := cfg.node.Coordinator.TxSelector.Path
+		current := path.Join(dbPath, kvdb.PathCurrent)
+		if err := os.RemoveAll(current); err != nil {
+			return tracerr.Wrap(fmt.Errorf("os.RemoveAll: %w", err))
+		}
+		db, err := kvdb.NewKVDB(kvdb.Config{
+			Path:        dbPath,
+			NoGapsCheck: true,
+			NoLast:      true,
+		})
+		if err != nil {
+			return tracerr.Wrap(fmt.Errorf("kvdb.NewKVDB: %w", err))
+		}
+		if err := db.Reset(0); err != nil {
+			return tracerr.Wrap(fmt.Errorf("db.Reset: %w", err))
+		}
+
+		dbPath = cfg.node.Coordinator.BatchBuilder.Path
+		current = path.Join(dbPath, kvdb.PathCurrent)
+		if err := os.RemoveAll(current); err != nil {
+			return tracerr.Wrap(fmt.Errorf("os.RemoveAll: %w", err))
+		}
+		db, err = kvdb.NewKVDB(kvdb.Config{
+			Path:        dbPath,
+			NoGapsCheck: true,
+			NoLast:      true,
+		})
+		if err != nil {
+			return tracerr.Wrap(fmt.Errorf("statedb.NewKVDB: %w", err))
+		}
+		if err := db.Reset(0); err != nil {
+			return tracerr.Wrap(fmt.Errorf("db.Reset: %w", err))
+		}
+	}
+	return nil
+}
+
 func cmdWipeSQL(c *cli.Context) error {
 	_cfg, err := parseCli(c)
 	if err != nil {
@@ -76,7 +179,8 @@ func cmdWipeSQL(c *cli.Context) error {
 	cfg := _cfg.node
 	yes := c.Bool(flagYes)
 	if !yes {
-		fmt.Print("*WARNING* Are you sure you want to delete the SQL DB? [y/N]: ")
+		fmt.Print("*WARNING* Are you sure you want to delete " +
+			"the SQL DB and StateDBs? [y/N]: ")
 		var input string
 		if _, err := fmt.Scanln(&input); err != nil {
 			return tracerr.Wrap(err)
@@ -87,33 +191,28 @@ 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)
 	}
 	log.Info("Wiping SQL DB...")
 	if err := dbUtils.MigrationsDown(db.DB); err != nil {
-		return tracerr.Wrap(err)
+		return tracerr.Wrap(fmt.Errorf("dbUtils.MigrationsDown: %w", err))
+	}
+
+	log.Info("Wiping StateDBs...")
+	if err := resetStateDBs(_cfg, 0); err != nil {
+		return tracerr.Wrap(fmt.Errorf("resetStateDBs: %w", err))
 	}
 	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
@@ -134,11 +233,107 @@ 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 {
+		return tracerr.Wrap(fmt.Errorf("error parsing flags and config: %w", err))
+	}
+	cfg := _cfg.node
+	blockNum := c.Int64(flagBlock)
+	log.Infof("Discarding all blocks up to block %v...", blockNum)
+
+	dbWrite, err := dbUtils.InitSQLDB(
+		cfg.PostgreSQL.PortWrite,
+		cfg.PostgreSQL.HostWrite,
+		cfg.PostgreSQL.UserWrite,
+		cfg.PostgreSQL.PasswordWrite,
+		cfg.PostgreSQL.NameWrite,
+	)
+	if err != nil {
+		return 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 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))
+	}
+	batchNum, err := historyDB.GetLastBatchNum()
+	if err != nil {
+		return tracerr.Wrap(fmt.Errorf("historyDB.GetLastBatchNum: %w", err))
+	}
+	l2DB := l2db.NewL2DB(
+		dbRead, dbWrite,
+		cfg.Coordinator.L2DB.SafetyPeriod,
+		cfg.Coordinator.L2DB.MaxTxs,
+		cfg.Coordinator.L2DB.MinFeeUSD,
+		cfg.Coordinator.L2DB.MaxFeeUSD,
+		cfg.Coordinator.L2DB.TTL.Duration,
+		nil,
+	)
+	if err := l2DB.Reorg(batchNum); err != nil {
+		return tracerr.Wrap(fmt.Errorf("l2DB.Reorg: %w", err))
+	}
+
+	log.Info("Resetting StateDBs...")
+	if err := resetStateDBs(_cfg, batchNum); err != nil {
+		return tracerr.Wrap(fmt.Errorf("resetStateDBs: %w", err))
+	}
+
+	return nil
+}
+
 // Config is the configuration of the hermez node execution
 type Config struct {
 	mode node.Mode
@@ -160,20 +355,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)
 		}
@@ -187,8 +421,8 @@ func getConfig(c *cli.Context) (*Config, error) {
 func main() {
 	app := cli.NewApp()
 	app.Name = "hermez-node"
-	app.Version = "0.1.0-alpha"
+	app.Version = Version
-	app.Flags = []cli.Flag{
+	flags := []cli.Flag{
 		&cli.StringFlag{
 			Name:     flagMode,
 			Usage:    fmt.Sprintf("Set node `MODE` (can be \"%v\" or \"%v\")", modeSync, modeCoord),
@@ -202,17 +436,23 @@ func main() {
 	}
 
 	app.Commands = []*cli.Command{
+		{
+			Name:    "version",
+			Aliases: []string{},
+			Usage:   "Show the application version and build",
+			Action:  cmdVersion,
+		},
 		{
 			Name:    "importkey",
 			Aliases: []string{},
 			Usage:   "Import ethereum private key",
 			Action:  cmdImportKey,
-			Flags: []cli.Flag{
+			Flags: append(flags,
 				&cli.StringFlag{
 					Name:     flagSK,
 					Usage:    "ethereum `PRIVATE_KEY` in hex",
 					Required: true,
-				}},
+				}),
 		},
 		{
 			Name:    "genbjj",
@@ -223,21 +463,40 @@ func main() {
 		{
 			Name:    "wipesql",
 			Aliases: []string{},
-			Usage: "Wipe the SQL DB (HistoryDB and L2DB), " +
+			Usage: "Wipe the SQL DB (HistoryDB and L2DB) and the StateDBs, " +
 				"leaving the DB in a clean state",
 			Action: cmdWipeSQL,
-			Flags: []cli.Flag{
+			Flags: append(flags,
 				&cli.BoolFlag{
 					Name:     flagYes,
 					Usage:    "automatic yes to the prompt",
 					Required: false,
-				}},
+				}),
 		},
 		{
 			Name:    "run",
 			Aliases: []string{},
 			Usage:   "Run the hermez-node in the indicated mode",
 			Action:  cmdRun,
+			Flags:   flags,
+		},
+		{
+			Name:    "serveapi",
+			Aliases: []string{},
+			Usage:   "Serve the API only",
+			Action:  cmdServeAPI,
+		},
+		{
+			Name:    "discard",
+			Aliases: []string{},
+			Usage:   "Discard blocks up to a specified block number",
+			Action:  cmdDiscard,
+			Flags: append(flags,
+				&cli.Int64Flag{
+					Name:     flagBlock,
+					Usage:    "last block number to keep",
+					Required: false,
+				}),
 		},
 	}
 

common/account.go

@@ -72,7 +72,8 @@ func (idx Idx) BigInt() *big.Int {
 // IdxFromBytes returns Idx from a byte array
 func IdxFromBytes(b []byte) (Idx, error) {
 	if len(b) != IdxBytesLen {
-		return 0, tracerr.Wrap(fmt.Errorf("can not parse Idx, bytes len %d, expected %d", len(b), IdxBytesLen))
+		return 0, tracerr.Wrap(fmt.Errorf("can not parse Idx, bytes len %d, expected %d",
+			len(b), IdxBytesLen))
 	}
 	var idxBytes [8]byte
 	copy(idxBytes[2:], b[:])
@@ -194,7 +195,8 @@ func (a *Account) BigInts() ([NLeafElems]*big.Int, error) {
 	return e, nil
 }
 
-// HashValue returns the value of the Account, which is the Poseidon hash of its *big.Int representation
+// HashValue returns the value of the Account, which is the Poseidon hash of its
+// *big.Int representation
 func (a *Account) HashValue() (*big.Int, error) {
 	bi, err := a.BigInts()
 	if err != nil {
@@ -263,3 +265,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/account_test.go

@@ -76,7 +76,8 @@ func TestNonceParser(t *testing.T) {
 
 func TestAccount(t *testing.T) {
 	var sk babyjub.PrivateKey
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	_, err := hex.Decode(sk[:],
+		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 	assert.NoError(t, err)
 	pk := sk.Public()
 
@@ -115,7 +116,8 @@ func TestAccountLoop(t *testing.T) {
 	// check that for different deterministic BabyJubJub keys & random Address there is no problem
 	for i := 0; i < 256; i++ {
 		var sk babyjub.PrivateKey
-		_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+		_, err := hex.Decode(sk[:],
+			[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 		assert.NoError(t, err)
 		pk := sk.Public()
 
@@ -199,7 +201,8 @@ func bigFromStr(h string, u int) *big.Int {
 
 func TestAccountHashValue(t *testing.T) {
 	var sk babyjub.PrivateKey
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	_, err := hex.Decode(sk[:],
+		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 	assert.NoError(t, err)
 	pk := sk.Public()
 
@@ -212,13 +215,16 @@ func TestAccountHashValue(t *testing.T) {
 	}
 	v, err := account.HashValue()
 	assert.NoError(t, err)
-	assert.Equal(t, "16297758255249203915951182296472515138555043617458222397753168518282206850764", v.String())
+	assert.Equal(t,
+		"447675324273474410516096114710387312413478475468606444107594732044698919451",
+		v.String())
 }
 
 func TestAccountHashValueTestVectors(t *testing.T) {
 	// values from js test vectors
 	ay := new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(253), nil), big.NewInt(1))
-	assert.Equal(t, "1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", (hex.EncodeToString(ay.Bytes())))
+	assert.Equal(t, "1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+		(hex.EncodeToString(ay.Bytes())))
 	bjjPoint, err := babyjub.PointFromSignAndY(true, ay)
 	require.NoError(t, err)
 	bjj := babyjub.PublicKey(*bjjPoint)
@@ -236,16 +242,22 @@ func TestAccountHashValueTestVectors(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, "9444732965739290427391", e[0].String())
 	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", e[1].String())
-	assert.Equal(t, "14474011154664524427946373126085988481658748083205070504932198000989141204991", e[2].String())
+	assert.Equal(t,
+		"14474011154664524427946373126085988481658748083205070504932198000989141204991",
+		e[2].String())
 	assert.Equal(t, "1461501637330902918203684832716283019655932542975", e[3].String())
 
 	h, err := poseidon.Hash(e[:])
 	assert.NoError(t, err)
-	assert.Equal(t, "4550823210217540218403400309533329186487982452461145263910122718498735057257", h.String())
+	assert.Equal(t,
+		"13265203488631320682117942952393454767418777767637549409684833552016769103047",
+		h.String())
 
 	v, err := account.HashValue()
 	assert.NoError(t, err)
-	assert.Equal(t, "4550823210217540218403400309533329186487982452461145263910122718498735057257", v.String())
+	assert.Equal(t,
+		"13265203488631320682117942952393454767418777767637549409684833552016769103047",
+		v.String())
 
 	// second account
 	ay = big.NewInt(0)
@@ -261,7 +273,9 @@ func TestAccountHashValueTestVectors(t *testing.T) {
 	}
 	v, err = account.HashValue()
 	assert.NoError(t, err)
-	assert.Equal(t, "7750253361301235345986002241352365187241910378619330147114280396816709365657", v.String())
+	assert.Equal(t,
+		"2351654555892372227640888372176282444150254868378439619268573230312091195718",
+		v.String())
 
 	// third account
 	ay = bigFromStr("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7", 16)
@@ -279,11 +293,15 @@ func TestAccountHashValueTestVectors(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, "554050781187", e[0].String())
 	assert.Equal(t, "42000000000000000000", e[1].String())
-	assert.Equal(t, "15238403086306505038849621710779816852318505119327426213168494964113886299863", e[2].String())
+	assert.Equal(t,
+		"15238403086306505038849621710779816852318505119327426213168494964113886299863",
+		e[2].String())
 	assert.Equal(t, "935037732739828347587684875151694054123613453305", e[3].String())
 	v, err = account.HashValue()
 	assert.NoError(t, err)
-	assert.Equal(t, "10565754214047872850889045989683221123564392137456000481397520902594455245517", v.String())
+	assert.Equal(t,
+		"15036148928138382129196903417666258171042923749783835283230591475172197254845",
+		v.String())
 }
 
 func TestAccountErrNotInFF(t *testing.T) {
@@ -312,7 +330,8 @@ func TestAccountErrNotInFF(t *testing.T) {
 
 func TestAccountErrNumOverflowNonce(t *testing.T) {
 	var sk babyjub.PrivateKey
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	_, err := hex.Decode(sk[:],
+		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 	assert.NoError(t, err)
 	pk := sk.Public()
 
@@ -339,7 +358,8 @@ func TestAccountErrNumOverflowNonce(t *testing.T) {
 
 func TestAccountErrNumOverflowBalance(t *testing.T) {
 	var sk babyjub.PrivateKey
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	_, err := hex.Decode(sk[:],
+		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 	assert.NoError(t, err)
 	pk := sk.Public()
 
@@ -351,14 +371,16 @@ func TestAccountErrNumOverflowBalance(t *testing.T) {
 		BJJ:     pk.Compress(),
 		EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
 	}
-	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", account.Balance.String())
+	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895",
+		account.Balance.String())
 
 	_, err = account.Bytes()
 	assert.NoError(t, err)
 
 	// force value overflow
 	account.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
-	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896", account.Balance.String())
+	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896",
+		account.Balance.String())
 	b, err := account.Bytes()
 	assert.NotNil(t, err)
 	assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), tracerr.Unwrap(err))

common/accountcreationauths.go

@@ -1,21 +1,30 @@
 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
+const (
-// account creation
+	// AccountCreationAuthMsg is the message that is signed to authorize a
-const AccountCreationAuthMsg = "I authorize this babyjubjub key for hermez rollup account creation"
+	// Hermez account creation
+	AccountCreationAuthMsg = "Account creation"
+	// EIP712Version is the used version of the EIP-712
+	EIP712Version = "1"
+	// EIP712Provider defines the Provider for the EIP-712
+	EIP712Provider = "Hermez Network"
+)
 
-// EthMsgPrefix is the prefix for message signing at the Ethereum ecosystem
+var (
-const EthMsgPrefix = "\x19Ethereum Signed Message:\n"
+	// EmptyEthSignature is an ethereum signature of all zeroes
+	EmptyEthSignature = make([]byte, 65)
+)
 
 // AccountCreationAuth authorizations sent by users to the L2DB, to be used for
 // account creations when necessary
@@ -26,44 +35,82 @@ 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
+// HashToSign returns the hash to be signed by the Ethereum 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
-// `signHash` function, and stores the signaure in `a.Signature`.  `signHash`
+// `signHash` function, and stores the signature in `a.Signature`.  `signHash`
 // should do an ethereum signature using the account corresponding to
-// `a.EthAddr`.  The `signHash` function is used to make signig flexible: in
+// `a.EthAddr`.  The `signHash` function is used to make signing 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
@@ -72,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

@@ -13,7 +13,8 @@ import (
 
 func TestAccountCreationAuthSignVerify(t *testing.T) {
 	// Ethereum key
-	ethSk, err := ethCrypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
+	ethSk, err :=
+		ethCrypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
 	require.NoError(t, err)
 	ethAddr := ethCrypto.PubkeyToAddress(ethSk.PublicKey)
 
@@ -39,7 +40,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)
@@ -69,35 +70,38 @@ func TestAccountCreationAuthJSComp(t *testing.T) {
 		sigExpected        string
 	}
 	var tvs []testVector
+	//nolint:lll
 	tv0 := testVector{
 		ethSk:              "0000000000000000000000000000000000000000000000000000000000000001",
 		expectedAddress:    "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf",
 		pkCompStr:          "21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7",
 		chainID:            uint16(4),
 		hermezContractAddr: "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
-		toHashExpected:     "19457468657265756d205369676e6564204d6573736167653a0a3132304920617574686f72697a65207468697320626162796a75626a7562206b657920666f72206865726d657a20726f6c6c7570206163636f756e74206372656174696f6e21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d700047e5f4552091a69125d5dfcb7b8c2659029395bdf",
+		toHashExpected:     "190189658bba487e11c7da602676ee32bc90b77d3f32a305b147e4f3c3b35f19672e5d84ccc38d0ab245c469b719549d837113465c2abf9972c49403ca6fd10ed3dc",
-		hashExpected:       "39afea52d843a4de905b6b5ebb0ee8c678141f711d96d9b429c4aec10ef9911f",
+		hashExpected:       "c56eba41e511df100c804c5c09288f35887efea4f033be956481af335df3bea2",
-		sigExpected:        "73d10d6ecf06ee8a5f60ac90f06b78bef9c650f414ba3ac73e176dc32e896159147457e9c86f0b4bd60fdaf2c0b2aec890a7df993d69a4805e242a6b845ebf231c",
+		sigExpected:        "dbedcc5ce02db8f48afbdb2feba9a3a31848eaa8fca5f312ce37b01db45d2199208335330d4445bd2f51d1db68dbc0d0bf3585c4a07504b4efbe46a69eaae5a21b",
 	}
+	//nolint:lll
 	tv1 := testVector{
 		ethSk:              "0000000000000000000000000000000000000000000000000000000000000002",
 		expectedAddress:    "0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF",
 		pkCompStr:          "093985b1993d9f743f9d7d943ed56f38601cb8b196db025f79650c4007c3054d",
 		chainID:            uint16(0),
 		hermezContractAddr: "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
-		toHashExpected:     "19457468657265756d205369676e6564204d6573736167653a0a3132304920617574686f72697a65207468697320626162796a75626a7562206b657920666f72206865726d657a20726f6c6c7570206163636f756e74206372656174696f6e093985b1993d9f743f9d7d943ed56f38601cb8b196db025f79650c4007c3054d00002b5ad5c4795c026514f8317c7a215e218dccd6cf",
+		toHashExpected:     "1901dafbc253dedf90d6421dc6e25d5d9efc6985133cb2a8d363d0a081a0e3eddddc65f603a88de36aaeabd3b4cf586538c7f3fd50c94780530a3707c8c14ad9fd11",
-		hashExpected:       "89a3895993a4736232212e59566294feb3da227af44375daf3307dcad5451d5d",
+		hashExpected:       "deb9afa479282cf27b442ce8ba86b19448aa87eacef691521a33db5d0feb9959",
-		sigExpected:        "bb4156156c705494ad5f99030342c64657e51e2994750f92125717c40bf56ad632044aa6bd00979feea92c417b552401e65fe5f531f15010d9d1c278da8be1df1b",
+		sigExpected:        "6a0da90ba2d2b1be679a28ebe54ee03082d44b836087391cd7d2607c1e4dafe04476e6e88dccb8707c68312512f16c947524b35c80f26c642d23953e9bb84c701c",
 	}
+	//nolint:lll
 	tv2 := testVector{
 		ethSk:              "c5e8f61d1ab959b397eecc0a37a6517b8e67a0e7cf1f4bce5591f3ed80199122",
 		expectedAddress:    "0xc783df8a850f42e7F7e57013759C285caa701eB6",
 		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 +126,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

@@ -13,8 +13,9 @@ const batchNumBytesLen = 8
 
 // Batch is a struct that represents Hermez network batch
 type Batch struct {
-	BatchNum           BatchNum             `meddler:"batch_num"`
+	BatchNum BatchNum `meddler:"batch_num"`
-	EthBlockNum        int64                `meddler:"eth_block_num"` // Ethereum block in which the batch is forged
+	// Ethereum block in which the batch is forged
+	EthBlockNum        int64                `meddler:"eth_block_num"`
 	ForgerAddr         ethCommon.Address    `meddler:"forger_addr"`
 	CollectedFees      map[TokenID]*big.Int `meddler:"fees_collected,json"`
 	FeeIdxsCoordinator []Idx                `meddler:"fee_idxs_coordinator,json"`
@@ -22,9 +23,11 @@ type Batch struct {
 	NumAccounts        int                  `meddler:"num_accounts"`
 	LastIdx            int64                `meddler:"last_idx"`
 	ExitRoot           *big.Int             `meddler:"exit_root,bigint"`
-	ForgeL1TxsNum      *int64               `meddler:"forge_l1_txs_num"` // optional, Only when the batch forges L1 txs. Identifier that corresponds to the group of L1 txs forged in the current batch.
+	// ForgeL1TxsNum is optional, Only when the batch forges L1 txs. Identifier that corresponds
-	SlotNum            int64                `meddler:"slot_num"`         // Slot in which the batch is forged
+	// to the group of L1 txs forged in the current batch.
-	TotalFeesUSD       *float64             `meddler:"total_fees_usd"`
+	ForgeL1TxsNum *int64   `meddler:"forge_l1_txs_num"`
+	SlotNum       int64    `meddler:"slot_num"` // Slot in which the batch is forged
+	TotalFeesUSD  *float64 `meddler:"total_fees_usd"`
 }
 
 // NewEmptyBatch creates a new empty batch
@@ -63,7 +66,9 @@ func (bn BatchNum) BigInt() *big.Int {
 // BatchNumFromBytes returns BatchNum from a []byte
 func BatchNumFromBytes(b []byte) (BatchNum, error) {
 	if len(b) != batchNumBytesLen {
-		return 0, tracerr.Wrap(fmt.Errorf("can not parse BatchNumFromBytes, bytes len %d, expected %d", len(b), batchNumBytesLen))
+		return 0,
+			tracerr.Wrap(fmt.Errorf("can not parse BatchNumFromBytes, bytes len %d, expected %d",
+				len(b), batchNumBytesLen))
 	}
 	batchNum := binary.BigEndian.Uint64(b[:batchNumBytesLen])
 	return BatchNum(batchNum), nil
@@ -77,6 +82,7 @@ type BatchData struct {
 	L1CoordinatorTxs []L1Tx
 	L2Txs            []L2Tx
 	CreatedAccounts  []Account
+	UpdatedAccounts  []AccountUpdate
 	ExitTree         []ExitInfo
 	Batch            Batch
 }
@@ -93,23 +99,3 @@ func NewBatchData() *BatchData {
 		Batch:            Batch{},
 	}
 }
-
-// BatchSync is a subset of Batch that contains fileds needed for the
-// synchronizer and coordinator
-// type BatchSync struct {
-// 	BatchNum    BatchNum          `meddler:"batch_num"`
-// 	EthBlockNum int64             `meddler:"eth_block_num"` // Ethereum block in which the batch is forged
-// 	ForgerAddr  ethCommon.Address `meddler:"forger_addr"`
-// 	StateRoot   *big.Int          `meddler:"state_root,bigint"`
-// 	SlotNum     int64             `meddler:"slot_num"` // Slot in which the batch is forged
-// }
-//
-// func NewBatchSync() *BatchSync {
-// 	return &BatchSync{
-// 		BatchNum:    0,
-// 		EthBlockNum: 0,
-// 		ForgerAddr:  ethCommon.Address,
-// 		StateRoot:   big.NewInt(0),
-// 		SlotNum:     0,
-// 	}
-// }

common/bid.go

@@ -34,7 +34,7 @@ type Slot struct {
 	// BatchesLen       int
 	BidValue  *big.Int
 	BootCoord bool
-	// Bidder, Forer and URL correspond to the winner of the slot (which is
+	// Bidder, Forger and URL correspond to the winner of the slot (which is
 	// not always the highest bidder).  These are the values of the
 	// coordinator that is able to forge exclusively before the deadline.
 	Bidder ethCommon.Address

common/coordinator.go

@@ -5,10 +5,15 @@ import (
 )
 
 // Coordinator represents a Hermez network coordinator who wins an auction for an specific slot
-// WARNING: this is strongly based on the previous implementation, once the new spec is done, this may change a lot.
+// WARNING: this is strongly based on the previous implementation, once the new spec is done, this
+// may change a lot.
 type Coordinator struct {
-	Bidder      ethCommon.Address `meddler:"bidder_addr"`   // address of the bidder
+	// Bidder is the address of the bidder
-	Forger      ethCommon.Address `meddler:"forger_addr"`   // address of the forger
+	Bidder ethCommon.Address `meddler:"bidder_addr"`
-	EthBlockNum int64             `meddler:"eth_block_num"` // block in which the coordinator was registered
+	// Forger is the address of the forger
-	URL         string            `meddler:"url"`           // URL of the coordinators API
+	Forger ethCommon.Address `meddler:"forger_addr"`
+	// EthBlockNum is the block in which the coordinator was registered
+	EthBlockNum int64 `meddler:"eth_block_num"`
+	// URL of the coordinators API
+	URL string `meddler:"url"`
 }

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/ethauction.go

@@ -68,11 +68,13 @@ type AuctionVariables struct {
 	ClosedAuctionSlots uint16 `meddler:"closed_auction_slots" validate:"required"`
 	// Distance (#slots) to the farthest slot to which you can bid (30 days = 4320 slots )
 	OpenAuctionSlots uint16 `meddler:"open_auction_slots" validate:"required"`
-	// How the HEZ tokens deposited by the slot winner are distributed (Burn: 40% - Donation: 40% - HGT: 20%)
+	// How the HEZ tokens deposited by the slot winner are distributed (Burn: 40% - Donation:
+	// 40% - HGT: 20%)
 	AllocationRatio [3]uint16 `meddler:"allocation_ratio,json" validate:"required"`
 	// Minimum outbid (percentage) over the previous one to consider it valid
 	Outbidding uint16 `meddler:"outbidding" validate:"required"`
-	// Number of blocks at the end of a slot in which any coordinator can forge if the winner has not forged one before
+	// 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 `meddler:"slot_deadline" validate:"required"`
 }
 

common/ethrollup.go

@@ -20,19 +20,22 @@ const (
 	// RollupConstExitIDx IDX 1 is reserved for exits
 	RollupConstExitIDx = 1
 	// RollupConstLimitTokens Max number of tokens allowed to be registered inside the rollup
-	RollupConstLimitTokens = (1 << 32)
+	RollupConstLimitTokens = (1 << 32) //nolint:gomnd
-	// RollupConstL1CoordinatorTotalBytes [4 bytes] token + [32 bytes] babyjub + [65 bytes] compressedSignature
+	// RollupConstL1CoordinatorTotalBytes [4 bytes] token + [32 bytes] babyjub + [65 bytes]
+	// compressedSignature
 	RollupConstL1CoordinatorTotalBytes = 101
-	// RollupConstL1UserTotalBytes [20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6 bytes] fromIdx +
+	// RollupConstL1UserTotalBytes [20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6
-	// [2 bytes] depositAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx
+	// bytes] fromIdx + [5 bytes] depositAmountFloat40 + [5 bytes] amountFloat40 + [4 bytes]
-	RollupConstL1UserTotalBytes = 72
+	// tokenId + [6 bytes] toIdx
+	RollupConstL1UserTotalBytes = 78
 	// RollupConstMaxL1UserTx Maximum L1-user transactions allowed to be queued in a batch
 	RollupConstMaxL1UserTx = 128
 	// RollupConstMaxL1Tx Maximum L1 transactions allowed to be queued in a batch
 	RollupConstMaxL1Tx = 256
-	// RollupConstInputSHAConstantBytes [6 bytes] lastIdx + [6 bytes] newLastIdx  + [32 bytes] stateRoot  + [32 bytes] newStRoot  + [32 bytes] newExitRoot +
+	// RollupConstInputSHAConstantBytes [6 bytes] lastIdx + [6 bytes] newLastIdx  + [32 bytes]
-	// [_MAX_L1_TX * _L1_USER_TOTALBYTES bytes] l1TxsData + totalL2TxsDataLength + feeIdxCoordinatorLength + [2 bytes] chainID =
+	// stateRoot  + [32 bytes] newStRoot  + [32 bytes] newExitRoot + [_MAX_L1_TX *
-	// 18542 bytes +  totalL2TxsDataLength + feeIdxCoordinatorLength
+	// _L1_USER_TOTALBYTES bytes] l1TxsData + totalL2TxsDataLength + feeIdxCoordinatorLength +
+	// [2 bytes] chainID = 18542 bytes +  totalL2TxsDataLength + feeIdxCoordinatorLength
 	RollupConstInputSHAConstantBytes = 18546
 	// RollupConstNumBuckets Number of buckets
 	RollupConstNumBuckets = 5
@@ -44,14 +47,18 @@ const (
 
 var (
 	// RollupConstLimitDepositAmount Max deposit amount allowed (depositAmount: L1 --> L2)
-	RollupConstLimitDepositAmount, _ = new(big.Int).SetString("340282366920938463463374607431768211456", 10)
+	RollupConstLimitDepositAmount, _ = new(big.Int).SetString(
+		"340282366920938463463374607431768211456", 10)
 	// RollupConstLimitL2TransferAmount Max amount allowed (amount L2 --> L2)
-	RollupConstLimitL2TransferAmount, _ = new(big.Int).SetString("6277101735386680763835789423207666416102355444464034512896", 10)
+	RollupConstLimitL2TransferAmount, _ = new(big.Int).SetString(
+		"6277101735386680763835789423207666416102355444464034512896", 10)
 
-	// RollupConstEthAddressInternalOnly This ethereum address is used internally for rollup accounts that don't have ethereum address, only Babyjubjub
+	// RollupConstEthAddressInternalOnly This ethereum address is used internally for rollup
-	// This non-ethereum accounts can be created by the coordinator and allow users to have a rollup
+	// accounts that don't have ethereum address, only Babyjubjub.
-	// account without needing an ethereum address
+	// This non-ethereum accounts can be created by the coordinator and allow users to have a
-	RollupConstEthAddressInternalOnly = ethCommon.HexToAddress("0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF")
+	// rollup account without needing an ethereum address
+	RollupConstEthAddressInternalOnly = ethCommon.HexToAddress(
+		"0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF")
 	// RollupConstRfield Modulus zkSNARK
 	RollupConstRfield, _ = new(big.Int).SetString(
 		"21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
@@ -63,24 +70,32 @@ var (
 
 	// RollupConstRecipientInterfaceHash ERC777 recipient interface hash
 	RollupConstRecipientInterfaceHash = crypto.Keccak256([]byte("ERC777TokensRecipient"))
-	// RollupConstPerformL1UserTxSignature the signature of the function that can be called thru an ERC777 `send`
+	// RollupConstPerformL1UserTxSignature the signature of the function that can be called thru
-	RollupConstPerformL1UserTxSignature = crypto.Keccak256([]byte("addL1Transaction(uint256,uint48,uint16,uint16,uint32,uint48)"))
+	// an ERC777 `send`
-	// RollupConstAddTokenSignature the signature of the function that can be called thru an ERC777 `send`
+	RollupConstPerformL1UserTxSignature = crypto.Keccak256([]byte(
+		"addL1Transaction(uint256,uint48,uint16,uint16,uint32,uint48)"))
+	// RollupConstAddTokenSignature the signature of the function that can be called thru an
+	// ERC777 `send`
 	RollupConstAddTokenSignature = crypto.Keccak256([]byte("addToken(address)"))
 	// RollupConstSendSignature ERC777 Signature
 	RollupConstSendSignature = crypto.Keccak256([]byte("send(address,uint256,bytes)"))
 	// RollupConstERC777Granularity ERC777 Signature
 	RollupConstERC777Granularity = crypto.Keccak256([]byte("granularity()"))
-	// RollupConstWithdrawalDelayerDeposit  This constant are used to deposit tokens from ERC77 tokens into withdrawal delayer
+	// RollupConstWithdrawalDelayerDeposit  This constant are used to deposit tokens from ERC77
+	// tokens into withdrawal delayer
 	RollupConstWithdrawalDelayerDeposit = crypto.Keccak256([]byte("deposit(address,address,uint192)"))
 
 	// ERC20 signature
 
-	// RollupConstTransferSignature This constant is used in the _safeTransfer internal method in order to safe GAS.
+	// RollupConstTransferSignature This constant is used in the _safeTransfer internal method
+	// in order to safe GAS.
 	RollupConstTransferSignature = crypto.Keccak256([]byte("transfer(address,uint256)"))
-	// RollupConstTransferFromSignature This constant is used in the _safeTransfer internal method in order to safe GAS.
+	// RollupConstTransferFromSignature This constant is used in the _safeTransfer internal
-	RollupConstTransferFromSignature = crypto.Keccak256([]byte("transferFrom(address,address,uint256)"))
+	// method in order to safe GAS.
-	// RollupConstApproveSignature This constant is used in the _safeTransfer internal method in order to safe GAS.
+	RollupConstTransferFromSignature = crypto.Keccak256([]byte(
+		"transferFrom(address,address,uint256)"))
+	// RollupConstApproveSignature This constant is used in the _safeTransfer internal method in
+	// order to safe GAS.
 	RollupConstApproveSignature = crypto.Keccak256([]byte("approve(address,uint256)"))
 	// RollupConstERC20Signature ERC20 decimals signature
 	RollupConstERC20Signature = crypto.Keccak256([]byte("decimals()"))
@@ -141,6 +156,7 @@ type TokenExchange struct {
 }
 
 // RollupVariables are the variables of the Rollup Smart Contract
+//nolint:lll
 type RollupVariables struct {
 	EthBlockNum           int64                               `meddler:"eth_block_num"`
 	FeeAddToken           *big.Int                            `meddler:"fee_add_token,bigint" validate:"required"`

common/ethwdelayer.go

@@ -27,6 +27,7 @@ type WDelayerEscapeHatchWithdrawal struct {
 }
 
 // WDelayerVariables are the variables of the Withdrawal Delayer Smart Contract
+//nolint:lll
 type WDelayerVariables struct {
 	EthBlockNum int64 `json:"ethereumBlockNum" meddler:"eth_block_num"`
 	// HermezRollupAddress        ethCommon.Address `json:"hermezRollupAddress" meddler:"rollup_address"`

common/fee.go

@@ -22,9 +22,9 @@ var FeeFactorLsh60 [256]*big.Int
 // the coordinator according to the tx type (if the tx requires to create an
 // account and register, only register or he account already esists)
 type RecommendedFee struct {
-	ExistingAccount           float64 `json:"existingAccount"`
+	ExistingAccount        float64 `json:"existingAccount"`
-	CreatesAccount            float64 `json:"createAccount"`
+	CreatesAccount         float64 `json:"createAccount"`
-	CreatesAccountAndRegister float64 `json:"createAccountInternal"`
+	CreatesAccountInternal float64 `json:"createAccountInternal"`
 }
 
 // FeeSelector is used to select a percentage from the FeePlan.

common/float16.go

@@ -1,131 +0,0 @@
-// Package common Float16 provides methods to work with Hermez custom half float
-// precision, 16 bits, codification internally called Float16 has been adopted
-// to encode large integers. This is done in order to save bits when L2
-// transactions are published.
-//nolint:gomnd
-package common
-
-import (
-	"encoding/binary"
-	"errors"
-	"math/big"
-
-	"github.com/hermeznetwork/tracerr"
-)
-
-var (
-	// ErrRoundingLoss is used when converted big.Int to Float16 causes rounding loss
-	ErrRoundingLoss = errors.New("input value causes rounding loss")
-)
-
-// Float16 represents a float in a 16 bit format
-type Float16 uint16
-
-// Bytes return a byte array of length 2 with the Float16 value encoded in BigEndian
-func (f16 Float16) Bytes() []byte {
-	var b [2]byte
-	binary.BigEndian.PutUint16(b[:], uint16(f16))
-	return b[:]
-}
-
-// Float16FromBytes returns a Float16 from a byte array of 2 bytes.
-func Float16FromBytes(b []byte) *Float16 {
-	f16 := Float16(binary.BigEndian.Uint16(b[:2]))
-	return &f16
-}
-
-// BigInt converts the Float16 to a *big.Int integer
-func (f16 *Float16) BigInt() *big.Int {
-	fl := int64(*f16)
-
-	m := big.NewInt(fl & 0x3FF)
-	e := big.NewInt(fl >> 11)
-	e5 := (fl >> 10) & 0x01
-
-	exp := big.NewInt(0).Exp(big.NewInt(10), e, nil)
-	res := m.Mul(m, exp)
-
-	if e5 != 0 && e.Cmp(big.NewInt(0)) != 0 {
-		res.Add(res, exp.Div(exp, big.NewInt(2)))
-	}
-	return res
-}
-
-// floorFix2Float converts a fix to a float, always rounding down
-func floorFix2Float(_f *big.Int) Float16 {
-	zero := big.NewInt(0)
-	ten := big.NewInt(10)
-	e := int64(0)
-
-	m := big.NewInt(0)
-	m.Set(_f)
-
-	if m.Cmp(zero) == 0 {
-		return 0
-	}
-
-	s := big.NewInt(0).Rsh(m, 10)
-
-	for s.Cmp(zero) != 0 {
-		m.Div(m, ten)
-		s.Rsh(m, 10)
-		e++
-	}
-
-	return Float16(m.Int64() | e<<11)
-}
-
-// NewFloat16 encodes a *big.Int integer as a Float16, returning error in
-// case of loss during the encoding.
-func NewFloat16(f *big.Int) (Float16, error) {
-	fl1 := floorFix2Float(f)
-	fi1 := fl1.BigInt()
-	fl2 := fl1 | 0x400
-	fi2 := fl2.BigInt()
-
-	m3 := (fl1 & 0x3FF) + 1
-	e3 := fl1 >> 11
-
-	if m3&0x400 == 0 {
-		m3 = 0x66
-		e3++
-	}
-
-	fl3 := m3 + e3<<11
-	fi3 := fl3.BigInt()
-
-	res := fl1
-
-	d := big.NewInt(0).Abs(fi1.Sub(fi1, f))
-	d2 := big.NewInt(0).Abs(fi2.Sub(fi2, f))
-
-	if d.Cmp(d2) == 1 {
-		res = fl2
-		d = d2
-	}
-
-	d3 := big.NewInt(0).Abs(fi3.Sub(fi3, f))
-
-	if d.Cmp(d3) == 1 {
-		res = fl3
-	}
-
-	// Do rounding check
-	if res.BigInt().Cmp(f) == 0 {
-		return res, nil
-	}
-	return res, tracerr.Wrap(ErrRoundingLoss)
-}
-
-// NewFloat16Floor encodes a big.Int integer as a Float16, rounding down in
-// case of loss during the encoding.
-func NewFloat16Floor(f *big.Int) Float16 {
-	fl1 := floorFix2Float(f)
-	fl2 := fl1 | 0x400
-	fi2 := fl2.BigInt()
-
-	if fi2.Cmp(f) < 1 {
-		return fl2
-	}
-	return fl1
-}

common/float16_test.go

@@ -1,132 +0,0 @@
-package common
-
-import (
-	"math/big"
-	"testing"
-
-	"github.com/hermeznetwork/tracerr"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestConversions(t *testing.T) {
-	testVector := map[Float16]string{
-		0x307B: "123000000",
-		0x1DC6: "454500",
-		0xFFFF: "10235000000000000000000000000000000",
-		0x0000: "0",
-		0x0400: "0",
-		0x0001: "1",
-		0x0401: "1",
-		0x0800: "0",
-		0x0c00: "5",
-		0x0801: "10",
-		0x0c01: "15",
-	}
-
-	for test := range testVector {
-		fix := test.BigInt()
-
-		assert.Equal(t, fix.String(), testVector[test])
-
-		bi := big.NewInt(0)
-		bi.SetString(testVector[test], 10)
-
-		fl, err := NewFloat16(bi)
-		assert.Equal(t, nil, err)
-
-		fx2 := fl.BigInt()
-		assert.Equal(t, fx2.String(), testVector[test])
-	}
-}
-
-func TestFloorFix2Float(t *testing.T) {
-	testVector := map[string]Float16{
-		"87999990000000000": 0x776f,
-		"87950000000000001": 0x776f,
-		"87950000000000000": 0x776f,
-		"87949999999999999": 0x736f,
-	}
-
-	for test := range testVector {
-		bi := big.NewInt(0)
-		bi.SetString(test, 10)
-
-		testFloat := NewFloat16Floor(bi)
-
-		assert.Equal(t, testFloat, testVector[test])
-	}
-}
-
-func TestConversionLosses(t *testing.T) {
-	a := big.NewInt(1000)
-	b, err := NewFloat16(a)
-	assert.Equal(t, nil, err)
-	c := b.BigInt()
-	assert.Equal(t, c, a)
-
-	a = big.NewInt(1024)
-	b, err = NewFloat16(a)
-	assert.Equal(t, ErrRoundingLoss, tracerr.Unwrap(err))
-	c = b.BigInt()
-	assert.NotEqual(t, c, a)
-
-	a = big.NewInt(32767)
-	b, err = NewFloat16(a)
-	assert.Equal(t, ErrRoundingLoss, tracerr.Unwrap(err))
-	c = b.BigInt()
-	assert.NotEqual(t, c, a)
-
-	a = big.NewInt(32768)
-	b, err = NewFloat16(a)
-	assert.Equal(t, ErrRoundingLoss, tracerr.Unwrap(err))
-	c = b.BigInt()
-	assert.NotEqual(t, c, a)
-
-	a = big.NewInt(65536000)
-	b, err = NewFloat16(a)
-	assert.Equal(t, ErrRoundingLoss, tracerr.Unwrap(err))
-	c = b.BigInt()
-	assert.NotEqual(t, c, a)
-}
-
-func BenchmarkFloat16(b *testing.B) {
-	newBigInt := func(s string) *big.Int {
-		bigInt, ok := new(big.Int).SetString(s, 10)
-		if !ok {
-			panic("Bad big int")
-		}
-		return bigInt
-	}
-	type pair struct {
-		Float16 Float16
-		BigInt  *big.Int
-	}
-	testVector := []pair{
-		{0x307B, newBigInt("123000000")},
-		{0x1DC6, newBigInt("454500")},
-		{0xFFFF, newBigInt("10235000000000000000000000000000000")},
-		{0x0000, newBigInt("0")},
-		{0x0400, newBigInt("0")},
-		{0x0001, newBigInt("1")},
-		{0x0401, newBigInt("1")},
-		{0x0800, newBigInt("0")},
-		{0x0c00, newBigInt("5")},
-		{0x0801, newBigInt("10")},
-		{0x0c01, newBigInt("15")},
-	}
-	b.Run("floorFix2Float()", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			NewFloat16Floor(testVector[i%len(testVector)].BigInt)
-		}
-	})
-	b.Run("NewFloat16()", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			_, _ = NewFloat16(testVector[i%len(testVector)].BigInt)
-		}
-	})
-	b.Run("Float16.BigInt()", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			testVector[i%len(testVector)].Float16.BigInt()
-		}
-	})
-}

common/float40.go

@@ -0,0 +1,128 @@
+// Package common float40.go provides methods to work with Hermez custom half
+// float precision, 40 bits, codification internally called Float40 has been
+// adopted to encode large integers. This is done in order to save bits when L2
+// transactions are published.
+//nolint:gomnd
+package common
+
+import (
+	"encoding/binary"
+	"errors"
+	"math/big"
+
+	"github.com/hermeznetwork/tracerr"
+)
+
+const (
+	// maxFloat40Value is the maximum value that the Float40 can have
+	// (40 bits: maxFloat40Value=2**40-1)
+	maxFloat40Value = 0xffffffffff
+	// Float40BytesLength defines the length of the Float40 values
+	// represented as byte arrays
+	Float40BytesLength = 5
+)
+
+var (
+	// ErrFloat40Overflow is used when a given Float40 overflows the
+	// maximum capacity of the Float40 (2**40-1)
+	ErrFloat40Overflow = errors.New("Float40 overflow, max value: 2**40 -1")
+	// ErrFloat40E31 is used when the e > 31 when trying to convert a
+	// *big.Int to Float40
+	ErrFloat40E31 = errors.New("Float40 error, e > 31")
+	// ErrFloat40NotEnoughPrecission is used when the given *big.Int can
+	// not be represented as Float40 due not enough precission
+	ErrFloat40NotEnoughPrecission = errors.New("Float40 error, not enough precission")
+
+	thres = big.NewInt(0x08_00_00_00_00)
+)
+
+// Float40 represents a float in a 64 bit format
+type Float40 uint64
+
+// Bytes return a byte array of length 5 with the Float40 value encoded in
+// BigEndian
+func (f40 Float40) Bytes() ([]byte, error) {
+	if f40 > maxFloat40Value {
+		return []byte{}, tracerr.Wrap(ErrFloat40Overflow)
+	}
+
+	var f40Bytes [8]byte
+	binary.BigEndian.PutUint64(f40Bytes[:], uint64(f40))
+	var b [5]byte
+	copy(b[:], f40Bytes[3:])
+	return b[:], nil
+}
+
+// Float40FromBytes returns a Float40 from a byte array of 5 bytes in Bigendian
+// representation.
+func Float40FromBytes(b []byte) Float40 {
+	var f40Bytes [8]byte
+	copy(f40Bytes[3:], b[:])
+	f40 := binary.BigEndian.Uint64(f40Bytes[:])
+	return Float40(f40)
+}
+
+// BigInt converts the Float40 to a *big.Int v, where v = m * 10^e, being:
+// [    e   |    m    ]
+// [ 5 bits | 35 bits ]
+func (f40 Float40) BigInt() (*big.Int, error) {
+	// take the 5 used bytes (FF * 5)
+	var f40Uint64 uint64 = uint64(f40) & 0x00_00_00_FF_FF_FF_FF_FF
+	f40Bytes, err := f40.Bytes()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+
+	e := f40Bytes[0] & 0xF8 >> 3      // take first 5 bits
+	m := f40Uint64 & 0x07_FF_FF_FF_FF // take the others 35 bits
+
+	exp := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(e)), nil)
+	r := new(big.Int).Mul(big.NewInt(int64(m)), exp)
+	return r, nil
+}
+
+// NewFloat40 encodes a *big.Int integer as a Float40, returning error in case
+// of loss during the encoding.
+func NewFloat40(f *big.Int) (Float40, error) {
+	m := f
+	e := big.NewInt(0)
+	zero := big.NewInt(0)
+	ten := big.NewInt(10)
+	for new(big.Int).Mod(m, ten).Cmp(zero) == 0 && m.Cmp(thres) >= 0 {
+		m = new(big.Int).Div(m, ten)
+		e = new(big.Int).Add(e, big.NewInt(1))
+	}
+	if e.Int64() > 31 {
+		return 0, tracerr.Wrap(ErrFloat40E31)
+	}
+	if m.Cmp(thres) >= 0 {
+		return 0, tracerr.Wrap(ErrFloat40NotEnoughPrecission)
+	}
+	r := new(big.Int).Add(m,
+		new(big.Int).Mul(e, thres))
+	return Float40(r.Uint64()), nil
+}
+
+// NewFloat40Floor encodes a *big.Int integer as a Float40, rounding down in
+// case of loss during the encoding. It returns an error in case that the number
+// is too big (e>31). Warning: this method should not be used inside the
+// hermez-node, it's a helper for external usage to generate valid Float40
+// values.
+func NewFloat40Floor(f *big.Int) (Float40, error) {
+	m := f
+	e := big.NewInt(0)
+	// zero := big.NewInt(0)
+	ten := big.NewInt(10)
+	for m.Cmp(thres) >= 0 {
+		m = new(big.Int).Div(m, ten)
+		e = new(big.Int).Add(e, big.NewInt(1))
+	}
+	if e.Int64() > 31 {
+		return 0, tracerr.Wrap(ErrFloat40E31)
+	}
+
+	r := new(big.Int).Add(m,
+		new(big.Int).Mul(e, thres))
+
+	return Float40(r.Uint64()), nil
+}

common/float40_test.go

@@ -0,0 +1,146 @@
+package common
+
+import (
+	"fmt"
+	"math/big"
+	"testing"
+
+	"github.com/hermeznetwork/tracerr"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConversionsFloat40(t *testing.T) {
+	testVector := map[Float40]string{
+		6*0x800000000 + 123:    "123000000",
+		2*0x800000000 + 4545:   "454500",
+		30*0x800000000 + 10235: "10235000000000000000000000000000000",
+		0x000000000:            "0",
+		0x800000000:            "0",
+		0x0001:                 "1",
+		0x0401:                 "1025",
+		0x800000000 + 1:        "10",
+		0xFFFFFFFFFF:           "343597383670000000000000000000000000000000",
+	}
+
+	for test := range testVector {
+		fix, err := test.BigInt()
+		require.NoError(t, err)
+		assert.Equal(t, fix.String(), testVector[test])
+
+		bi, ok := new(big.Int).SetString(testVector[test], 10)
+		require.True(t, ok)
+
+		fl, err := NewFloat40(bi)
+		assert.NoError(t, err)
+
+		fx2, err := fl.BigInt()
+		require.NoError(t, err)
+		assert.Equal(t, fx2.String(), testVector[test])
+	}
+}
+
+func TestExpectError(t *testing.T) {
+	testVector := map[string]error{
+		"9922334455000000000000000000000000000000":   nil,
+		"9922334455000000000000000000000000000001":   ErrFloat40NotEnoughPrecission,
+		"9922334454999999999999999999999999999999":   ErrFloat40NotEnoughPrecission,
+		"42949672950000000000000000000000000000000":  nil,
+		"99223344556573838487575":                    ErrFloat40NotEnoughPrecission,
+		"992233445500000000000000000000000000000000": ErrFloat40E31,
+		"343597383670000000000000000000000000000000": nil,
+		"343597383680000000000000000000000000000000": ErrFloat40NotEnoughPrecission,
+		"343597383690000000000000000000000000000000": ErrFloat40NotEnoughPrecission,
+		"343597383700000000000000000000000000000000": ErrFloat40E31,
+	}
+	for test := range testVector {
+		bi, ok := new(big.Int).SetString(test, 10)
+		require.True(t, ok)
+		_, err := NewFloat40(bi)
+		assert.Equal(t, testVector[test], tracerr.Unwrap(err))
+	}
+}
+
+func TestNewFloat40Floor(t *testing.T) {
+	testVector := map[string][]string{
+		// []int contains [Float40 value, Flot40 Floor value], when
+		// Float40 value is expected to be 0, is because is expected to
+		// be an error
+		"9922334455000000000000000000000000000000": {
+			"1040714485495", "1040714485495", "9922334455000000000000000000000000000000"},
+		"9922334455000000000000000000000000000001": { // Floor [2] will be same as prev line
+			"0", "1040714485495", "9922334455000000000000000000000000000000"},
+		"9922334454999999999999999999999999999999": {
+			"0", "1040714485494", "9922334454000000000000000000000000000000"},
+		"42949672950000000000000000000000000000000": {
+			"1069446856703", "1069446856703", "42949672950000000000000000000000000000000"},
+		"99223344556573838487575": {
+			"0", "456598933239", "99223344550000000000000"},
+		"992233445500000000000000000000000000000000": {
+			"0", "0", "0"}, // e>31, returns 0, err
+		"343597383670000000000000000000000000000000": {
+			"1099511627775", "1099511627775", "343597383670000000000000000000000000000000"},
+		"343597383680000000000000000000000000000000": {
+			"0", "0", "0"}, // e>31, returns 0, err
+		"1157073197879933027": {
+			"0", "286448638922", "1157073197800000000"},
+	}
+	for test := range testVector {
+		bi, ok := new(big.Int).SetString(test, 10)
+		require.True(t, ok)
+		f40, err := NewFloat40(bi)
+		if f40 == 0 {
+			assert.Error(t, err)
+		} else {
+			assert.NoError(t, err)
+		}
+		assert.Equal(t, testVector[test][0], fmt.Sprint(uint64(f40)))
+
+		f40, err = NewFloat40Floor(bi)
+		if f40 == 0 {
+			assert.Equal(t, ErrFloat40E31, tracerr.Unwrap(err))
+		} else {
+			assert.NoError(t, err)
+		}
+		assert.Equal(t, testVector[test][1], fmt.Sprint(uint64(f40)))
+
+		bi2, err := f40.BigInt()
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprint(testVector[test][2]), bi2.String())
+	}
+}
+
+func BenchmarkFloat40(b *testing.B) {
+	newBigInt := func(s string) *big.Int {
+		bigInt, ok := new(big.Int).SetString(s, 10)
+		if !ok {
+			panic("Can not convert string to *big.Int")
+		}
+		return bigInt
+	}
+	type pair struct {
+		Float40 Float40
+		BigInt  *big.Int
+	}
+	testVector := []pair{
+		{6*0x800000000 + 123, newBigInt("123000000")},
+		{2*0x800000000 + 4545, newBigInt("454500")},
+		{30*0x800000000 + 10235, newBigInt("10235000000000000000000000000000000")},
+		{0x000000000, newBigInt("0")},
+		{0x800000000, newBigInt("0")},
+		{0x0001, newBigInt("1")},
+		{0x0401, newBigInt("1025")},
+		{0x800000000 + 1, newBigInt("10")},
+		{0xFFFFFFFFFF, newBigInt("343597383670000000000000000000000000000000")},
+	}
+	b.Run("NewFloat40()", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			_, _ = NewFloat40(testVector[i%len(testVector)].BigInt)
+		}
+	})
+	b.Run("Float40.BigInt()", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			_, _ = testVector[i%len(testVector)].Float40.BigInt()
+		}
+	})
+}

common/l1tx.go

@@ -11,42 +11,43 @@ import (
 	"github.com/iden3/go-iden3-crypto/babyjub"
 )
 
-const (
-	// L1UserTxBytesLen is the length of the byte array that represents the L1Tx
-	L1UserTxBytesLen = 72
-	// L1CoordinatorTxBytesLen is the length of the byte array that represents the L1CoordinatorTx
-	L1CoordinatorTxBytesLen = 101
-)
-
 // L1Tx is a struct that represents a L1 tx
 type L1Tx struct {
 	// Stored in DB: mandatory fileds
 
-	// TxID (12 bytes) for L1Tx is:
+	// TxID (32 bytes) for L1Tx is the Keccak256 (ethereum) hash of:
 	// bytes:  |  1   |        8        |    2     |      1      |
 	// values: | type | ToForgeL1TxsNum | Position | 0 (padding) |
 	// where type:
 	// 	- L1UserTx: 0
 	// 	- L1CoordinatorTx: 1
-	TxID             TxID                  `meddler:"id"`
+	TxID TxID `meddler:"id"`
-	ToForgeL1TxsNum  *int64                `meddler:"to_forge_l1_txs_num"` // toForgeL1TxsNum in which the tx was forged / will be forged
+	// ToForgeL1TxsNum indicates in which the tx was forged / will be forged
-	Position         int                   `meddler:"position"`
+	ToForgeL1TxsNum *int64 `meddler:"to_forge_l1_txs_num"`
-	UserOrigin       bool                  `meddler:"user_origin"`         // true if the tx was originated by a user, false if it was aoriginated by a coordinator. Note that this differ from the spec for implementation simplification purpposes
+	Position        int    `meddler:"position"`
-	FromIdx          Idx                   `meddler:"from_idx,zeroisnull"` // FromIdx is used by L1Tx/Deposit to indicate the Idx receiver of the L1Tx.DepositAmount (deposit)
+	// UserOrigin is set to true if the tx was originated by a user, false if it was
+	// aoriginated by a coordinator. Note that this differ from the spec for implementation
+	// simplification purpposes
+	UserOrigin bool `meddler:"user_origin"`
+	// FromIdx is used by L1Tx/Deposit to indicate the Idx receiver of the L1Tx.DepositAmount
+	// (deposit)
+	FromIdx          Idx                   `meddler:"from_idx,zeroisnull"`
 	EffectiveFromIdx Idx                   `meddler:"effective_from_idx,zeroisnull"`
 	FromEthAddr      ethCommon.Address     `meddler:"from_eth_addr,zeroisnull"`
 	FromBJJ          babyjub.PublicKeyComp `meddler:"from_bjj,zeroisnull"`
-	ToIdx            Idx                   `meddler:"to_idx"` // ToIdx is ignored in L1Tx/Deposit, but used in the L1Tx/DepositAndTransfer
+	// ToIdx is ignored in L1Tx/Deposit, but used in the L1Tx/DepositAndTransfer
-	TokenID          TokenID               `meddler:"token_id"`
+	ToIdx   Idx      `meddler:"to_idx"`
-	Amount           *big.Int              `meddler:"amount,bigint"`
+	TokenID TokenID  `meddler:"token_id"`
+	Amount  *big.Int `meddler:"amount,bigint"`
 	// EffectiveAmount only applies to L1UserTx.
 	EffectiveAmount *big.Int `meddler:"effective_amount,bigintnull"`
 	DepositAmount   *big.Int `meddler:"deposit_amount,bigint"`
 	// EffectiveDepositAmount only applies to L1UserTx.
-	EffectiveDepositAmount *big.Int  `meddler:"effective_deposit_amount,bigintnull"`
+	EffectiveDepositAmount *big.Int `meddler:"effective_deposit_amount,bigintnull"`
-	EthBlockNum            int64     `meddler:"eth_block_num"` // Ethereum Block Number in which this L1Tx was added to the queue
+	// Ethereum Block Number in which this L1Tx was added to the queue
-	Type                   TxType    `meddler:"type"`
+	EthBlockNum int64     `meddler:"eth_block_num"`
-	BatchNum               *BatchNum `meddler:"batch_num"`
+	Type        TxType    `meddler:"type"`
+	BatchNum    *BatchNum `meddler:"batch_num"`
 }
 
 // NewL1Tx returns the given L1Tx with the TxId & Type parameters calculated
@@ -179,45 +180,38 @@ func (tx L1Tx) Tx() Tx {
 // [ 8 bits  ] empty (userFee) // 1 byte
 // [ 40 bits ] empty (nonce) // 5 bytes
 // [ 32 bits ] tokenID // 4 bytes
-// [ 16 bits ] amountFloat16 // 2 bytes
 // [ 48 bits ] toIdx // 6 bytes
 // [ 48 bits ] fromIdx // 6 bytes
 // [ 16 bits ] chainId // 2 bytes
 // [ 32 bits ] empty (signatureConstant) // 4 bytes
-// Total bits compressed data:  241 bits // 31 bytes in *big.Int representation
+// Total bits compressed data:  225 bits // 29 bytes in *big.Int representation
 func (tx L1Tx) TxCompressedData(chainID uint16) (*big.Int, error) {
-	amountFloat16, err := NewFloat16(tx.Amount)
+	var b [29]byte
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-
-	var b [31]byte
 	// b[0:7] empty: no ToBJJSign, no fee, no nonce
 	copy(b[7:11], tx.TokenID.Bytes())
-	copy(b[11:13], amountFloat16.Bytes())
 	toIdxBytes, err := tx.ToIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[13:19], toIdxBytes[:])
+	copy(b[11:17], toIdxBytes[:])
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[19:25], fromIdxBytes[:])
+	copy(b[17:23], fromIdxBytes[:])
-	binary.BigEndian.PutUint16(b[25:27], chainID)
+	binary.BigEndian.PutUint16(b[23:25], chainID)
-	copy(b[27:31], SignatureConstantBytes[:])
+	copy(b[25:29], SignatureConstantBytes[:])
 
 	bi := new(big.Int).SetBytes(b[:])
 	return bi, nil
 }
 
 // BytesDataAvailability encodes a L1Tx into []byte for the Data Availability
-// [ fromIdx | toIdx | amountFloat16 | Fee ]
+// [ fromIdx | toIdx | amountFloat40 | Fee ]
 func (tx *L1Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 	idxLen := nLevels / 8 //nolint:gomnd
 
-	b := make([]byte, ((nLevels*2)+16+8)/8) //nolint:gomnd
+	b := make([]byte, ((nLevels*2)+40+8)/8) //nolint:gomnd
 
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
@@ -231,13 +225,17 @@ func (tx *L1Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 	copy(b[idxLen:idxLen*2], toIdxBytes[6-idxLen:])
 
 	if tx.EffectiveAmount != nil {
-		amountFloat16, err := NewFloat16(tx.EffectiveAmount)
+		amountFloat40, err := NewFloat40(tx.EffectiveAmount)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
-		copy(b[idxLen*2:idxLen*2+2], amountFloat16.Bytes())
+		amountFloat40Bytes, err := amountFloat40.Bytes()
+		if err != nil {
+			return nil, tracerr.Wrap(err)
+		}
+		copy(b[idxLen*2:idxLen*2+Float40BytesLength], amountFloat40Bytes)
 	}
-	// fee = 0 (as is L1Tx) b[10:11]
+	// fee = 0 (as is L1Tx)
 	return b[:], nil
 }
 
@@ -247,7 +245,7 @@ func L1TxFromDataAvailability(b []byte, nLevels uint32) (*L1Tx, error) {
 
 	fromIdxBytes := b[0:idxLen]
 	toIdxBytes := b[idxLen : idxLen*2]
-	amountBytes := b[idxLen*2 : idxLen*2+2]
+	amountBytes := b[idxLen*2 : idxLen*2+Float40BytesLength]
 
 	l1tx := L1Tx{}
 	fromIdx, err := IdxFromBytes(ethCommon.LeftPadBytes(fromIdxBytes, 6))
@@ -260,8 +258,8 @@ func L1TxFromDataAvailability(b []byte, nLevels uint32) (*L1Tx, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	l1tx.ToIdx = toIdx
-	l1tx.EffectiveAmount = Float16FromBytes(amountBytes).BigInt()
+	l1tx.EffectiveAmount, err = Float40FromBytes(amountBytes).BigInt()
-	return &l1tx, nil
+	return &l1tx, tracerr.Wrap(err)
 }
 
 // BytesGeneric returns the generic representation of a L1Tx. This method is
@@ -269,7 +267,7 @@ func L1TxFromDataAvailability(b []byte, nLevels uint32) (*L1Tx, error) {
 // the L1TxData for the ZKInputs (at the HashGlobalInputs), using this method
 // for L1CoordinatorTxs & L1UserTxs (for the ZKInputs case).
 func (tx *L1Tx) BytesGeneric() ([]byte, error) {
-	var b [L1UserTxBytesLen]byte
+	var b [RollupConstL1UserTotalBytes]byte
 	copy(b[0:20], tx.FromEthAddr.Bytes())
 	if tx.FromBJJ != EmptyBJJComp {
 		pkCompL := tx.FromBJJ
@@ -281,22 +279,33 @@ func (tx *L1Tx) BytesGeneric() ([]byte, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	copy(b[52:58], fromIdxBytes[:])
-	depositAmountFloat16, err := NewFloat16(tx.DepositAmount)
+
+	depositAmountFloat40, err := NewFloat40(tx.DepositAmount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[58:60], depositAmountFloat16.Bytes())
+	depositAmountFloat40Bytes, err := depositAmountFloat40.Bytes()
-	amountFloat16, err := NewFloat16(tx.Amount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[60:62], amountFloat16.Bytes())
+	copy(b[58:63], depositAmountFloat40Bytes)
-	copy(b[62:66], tx.TokenID.Bytes())
+
+	amountFloat40, err := NewFloat40(tx.Amount)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	amountFloat40Bytes, err := amountFloat40.Bytes()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	copy(b[63:68], amountFloat40Bytes)
+
+	copy(b[68:72], tx.TokenID.Bytes())
 	toIdxBytes, err := tx.ToIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[66:72], toIdxBytes[:])
+	copy(b[72:78], toIdxBytes[:])
 	return b[:], nil
 }
 
@@ -313,7 +322,7 @@ func (tx *L1Tx) BytesCoordinatorTx(compressedSignatureBytes []byte) ([]byte, err
 	if tx.UserOrigin {
 		return nil, tracerr.Wrap(fmt.Errorf("Can not calculate BytesCoordinatorTx() for a L1UserTx"))
 	}
-	var b [L1CoordinatorTxBytesLen]byte
+	var b [RollupConstL1CoordinatorTotalBytes]byte
 	v := compressedSignatureBytes[64]
 	s := compressedSignatureBytes[32:64]
 	r := compressedSignatureBytes[0:32]
@@ -329,8 +338,10 @@ func (tx *L1Tx) BytesCoordinatorTx(compressedSignatureBytes []byte) ([]byte, err
 
 // L1UserTxFromBytes decodes a L1Tx from []byte
 func L1UserTxFromBytes(b []byte) (*L1Tx, error) {
-	if len(b) != L1UserTxBytesLen {
+	if len(b) != RollupConstL1UserTotalBytes {
-		return nil, tracerr.Wrap(fmt.Errorf("Can not parse L1Tx bytes, expected length %d, current: %d", 68, len(b)))
+		return nil,
+			tracerr.Wrap(fmt.Errorf("Can not parse L1Tx bytes, expected length %d, current: %d",
+				68, len(b)))
 	}
 
 	tx := &L1Tx{
@@ -347,13 +358,19 @@ func L1UserTxFromBytes(b []byte) (*L1Tx, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	tx.FromIdx = fromIdx
-	tx.DepositAmount = Float16FromBytes(b[58:60]).BigInt()
+	tx.DepositAmount, err = Float40FromBytes(b[58:63]).BigInt()
-	tx.Amount = Float16FromBytes(b[60:62]).BigInt()
-	tx.TokenID, err = TokenIDFromBytes(b[62:66])
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	tx.ToIdx, err = IdxFromBytes(b[66:72])
+	tx.Amount, err = Float40FromBytes(b[63:68]).BigInt()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	tx.TokenID, err = TokenIDFromBytes(b[68:72])
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	tx.ToIdx, err = IdxFromBytes(b[72:78])
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -361,19 +378,15 @@ 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) {
+func L1CoordinatorTxFromBytes(b []byte, chainID *big.Int, hermezAddress ethCommon.Address) (*L1Tx,
-	if len(b) != L1CoordinatorTxBytesLen {
+	error) {
-		return nil, tracerr.Wrap(fmt.Errorf("Can not parse L1CoordinatorTx bytes, expected length %d, current: %d", 101, len(b)))
+	if len(b) != RollupConstL1CoordinatorTotalBytes {
+		return nil, tracerr.Wrap(
+			fmt.Errorf("Can not parse L1CoordinatorTx bytes, expected length %d, current: %d",
+				101, len(b)))
 	}
 
-	bytesMessage := []byte("I authorize this babyjubjub key for hermez rollup account creation")
-
 	tx := &L1Tx{
 		UserOrigin: false,
 	}
@@ -394,18 +407,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

@@ -29,7 +29,8 @@ func TestNewL1UserTx(t *testing.T) {
 	}
 	l1Tx, err := NewL1Tx(l1Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x00a6cbae3b8661fb75b0919ca6605a02cfb04d9c6dd16870fa0fcdf01befa32768", l1Tx.TxID.String())
+	assert.Equal(t, "0x00a6cbae3b8661fb75b0919ca6605a02cfb04d9c6dd16870fa0fcdf01befa32768",
+		l1Tx.TxID.String())
 }
 
 func TestNewL1CoordinatorTx(t *testing.T) {
@@ -46,68 +47,115 @@ func TestNewL1CoordinatorTx(t *testing.T) {
 	}
 	l1Tx, err := NewL1Tx(l1Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x01274482d73df4dab34a1b6740adfca347a462513aa14e82f27b12f818d1b68c84", l1Tx.TxID.String())
+	assert.Equal(t, "0x01274482d73df4dab34a1b6740adfca347a462513aa14e82f27b12f818d1b68c84",
+		l1Tx.TxID.String())
 }
 
 func TestL1TxCompressedData(t *testing.T) {
+	// test vectors values generated from javascript implementation (using
+	// PoolL2Tx values)
+	amount, ok := new(big.Int).SetString("343597383670000000000000000000000000000000", 10)
+	require.True(t, ok)
 	tx := L1Tx{
-		FromIdx: 2,
+		FromIdx: (1 << 48) - 1,
-		ToIdx:   3,
+		ToIdx:   (1 << 48) - 1,
-		Amount:  big.NewInt(4),
+		Amount:  amount,
-		TokenID: 5,
+		TokenID: (1 << 32) - 1,
 	}
-	chainID := uint16(0)
+	txCompressedData, err := tx.TxCompressedData(uint16((1 << 16) - 1))
-	txCompressedData, err := tx.TxCompressedData(chainID)
 	assert.NoError(t, err)
+	expectedStr := "ffffffffffffffffffffffffffffffffffffc60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
 
-	// test vector value generated from javascript implementation
+	tx = L1Tx{
-	expectedStr := "7307597389635308713748674793997299267459594577423"
+		FromIdx: 0,
-	assert.Equal(t, expectedStr, txCompressedData.String())
+		ToIdx:   0,
-	assert.Equal(t, "0500040000000000030000000000020000c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
+		Amount:  big.NewInt(0),
+		TokenID: 0,
+	}
+	txCompressedData, err = tx.TxCompressedData(uint16(0))
+	assert.NoError(t, err)
+	expectedStr = "c60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
+
+	amount, ok = new(big.Int).SetString("63000000000000000", 10)
+	require.True(t, ok)
+	tx = L1Tx{
+		FromIdx: 324,
+		ToIdx:   256,
+		Amount:  amount,
+		TokenID: 123,
+	}
+	txCompressedData, err = tx.TxCompressedData(uint16(1))
+	assert.NoError(t, err)
+	expectedStr = "7b0000000001000000000001440001c60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
+
+	tx = L1Tx{
+		FromIdx: 1,
+		ToIdx:   2,
+		TokenID: 3,
+	}
+	txCompressedData, err = tx.TxCompressedData(uint16(0))
+	assert.NoError(t, err)
+	expectedStr = "030000000000020000000000010000c60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
 }
 
 func TestBytesDataAvailability(t *testing.T) {
+	// test vectors values generated from javascript implementation
+	amount, ok := new(big.Int).SetString("343597383670000000000000000000000000000000", 10)
+	require.True(t, ok)
 	tx := L1Tx{
-		FromIdx: 2,
+		ToIdx:           (1 << 16) - 1,
-		ToIdx:   3,
+		FromIdx:         (1 << 16) - 1,
-		Amount:  big.NewInt(4),
+		EffectiveAmount: amount,
-		TokenID: 5,
 	}
-	txCompressedData, err := tx.BytesDataAvailability(32)
+	txCompressedData, err := tx.BytesDataAvailability(16)
 	assert.NoError(t, err)
-	assert.Equal(t, "0000000200000003000000", hex.EncodeToString(txCompressedData))
+	assert.Equal(t, "ffffffffffffffffff00", hex.EncodeToString(txCompressedData))
-
+	l1tx, err := L1TxFromDataAvailability(txCompressedData, 16)
-	tx = L1Tx{
-		FromIdx:         2,
-		ToIdx:           3,
-		EffectiveAmount: big.NewInt(4),
-		TokenID:         5,
-	}
-	txCompressedData, err = tx.BytesDataAvailability(32)
-	assert.NoError(t, err)
-	assert.Equal(t, "0000000200000003000400", hex.EncodeToString(txCompressedData))
-}
-
-func TestL1TxFromDataAvailability(t *testing.T) {
-	tx := L1Tx{
-		FromIdx: 2,
-		ToIdx:   3,
-		Amount:  big.NewInt(4),
-	}
-	txCompressedData, err := tx.BytesDataAvailability(32)
-	assert.NoError(t, err)
-	l1tx, err := L1TxFromDataAvailability(txCompressedData, 32)
 	require.NoError(t, err)
 	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
 	assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
+	assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
 
 	tx = L1Tx{
-		FromIdx:         2,
+		ToIdx:           (1 << 32) - 1,
-		ToIdx:           3,
+		FromIdx:         (1 << 32) - 1,
-		EffectiveAmount: big.NewInt(4),
+		EffectiveAmount: amount,
 	}
 	txCompressedData, err = tx.BytesDataAvailability(32)
 	assert.NoError(t, err)
+	assert.Equal(t, "ffffffffffffffffffffffffff00", hex.EncodeToString(txCompressedData))
+	l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
+	require.NoError(t, err)
+	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
+	assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
+	assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
+
+	tx = L1Tx{
+		ToIdx:           0,
+		FromIdx:         0,
+		EffectiveAmount: big.NewInt(0),
+	}
+	txCompressedData, err = tx.BytesDataAvailability(32)
+	assert.NoError(t, err)
+	assert.Equal(t, "0000000000000000000000000000", hex.EncodeToString(txCompressedData))
+	l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
+	require.NoError(t, err)
+	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
+	assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
+	assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
+
+	tx = L1Tx{
+		ToIdx:           635,
+		FromIdx:         296,
+		EffectiveAmount: big.NewInt(1000000000000000000),
+	}
+	txCompressedData, err = tx.BytesDataAvailability(32)
+	assert.NoError(t, err)
+	assert.Equal(t, "000001280000027b42540be40000", hex.EncodeToString(txCompressedData))
 	l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
 	require.NoError(t, err)
 	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
@@ -153,7 +201,8 @@ func TestL1userTxByteParsers(t *testing.T) {
 func TestL1TxByteParsersCompatibility(t *testing.T) {
 	// Data from compatibility test
 	var pkComp babyjub.PublicKeyComp
-	pkCompB, err := hex.DecodeString("0dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a")
+	pkCompB, err :=
+		hex.DecodeString("0dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a")
 	require.NoError(t, err)
 	pkCompL := SwapEndianness(pkCompB)
 	err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
@@ -172,20 +221,19 @@ func TestL1TxByteParsersCompatibility(t *testing.T) {
 		UserOrigin:    true,
 	}
 
-	expected, err := utils.HexDecode("85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a000001c638db8be880f00020039c0000053cb88d")
-	require.NoError(t, err)
-
 	encodedData, err := l1Tx.BytesUser()
 	require.NoError(t, err)
-	assert.Equal(t, expected, encodedData)
+	expected := "85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79e" +
+		"e1f41a7def613e73a20c32eece5a000001c638db52540be400459682f0000020039c0000053cb88d"
+	assert.Equal(t, expected, hex.EncodeToString(encodedData))
 }
 
 func TestL1CoordinatorTxByteParsers(t *testing.T) {
 	hermezAddress := ethCommon.HexToAddress("0xD6C850aeBFDC46D7F4c207e445cC0d6B0919BDBe")
 	chainID := big.NewInt(1337)
-	chainIDBytes := ethCommon.LeftPadBytes(chainID.Bytes(), 2)
 
-	privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
+	privateKey, err :=
+		crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
 	require.NoError(t, err)
 
 	publicKey := privateKey.Public()
@@ -201,18 +249,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])
@@ -259,7 +305,8 @@ func TestL1CoordinatorTxByteParsersCompatibility(t *testing.T) {
 	signature = append(signature, v[:]...)
 
 	var pkComp babyjub.PublicKeyComp
-	pkCompB, err := hex.DecodeString("a2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c")
+	pkCompB, err :=
+		hex.DecodeString("a2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c")
 	require.NoError(t, err)
 	pkCompL := SwapEndianness(pkCompB)
 	err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
@@ -274,7 +321,9 @@ func TestL1CoordinatorTxByteParsersCompatibility(t *testing.T) {
 	encodeData, err := l1Tx.BytesCoordinatorTx(signature)
 	require.NoError(t, err)
 
-	expected, err := utils.HexDecode("1b186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8cda71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3ba2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c000000e7")
+	expected, err := utils.HexDecode("1b186d7122ff7f654cfed3156719774898d573900c86599a885a706" +
+		"dbdffe5ea8cda71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3ba2c28" +
+		"07ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c000000e7")
 	require.NoError(t, err)
 
 	assert.Equal(t, expected, encodeData)

common/l2tx.go

@@ -10,7 +10,7 @@ import (
 
 // L2Tx is a struct that represents an already forged L2 tx
 type L2Tx struct {
-	// Stored in DB: mandatory fileds
+	// Stored in DB: mandatory fields
 	TxID     TxID     `meddler:"id"`
 	BatchNum BatchNum `meddler:"batch_num"` // batchNum in which this tx was forged.
 	Position int      `meddler:"position"`
@@ -21,9 +21,10 @@ type L2Tx struct {
 	Amount  *big.Int    `meddler:"amount,bigint"`
 	Fee     FeeSelector `meddler:"fee"`
 	// Nonce is filled by the TxProcessor
-	Nonce       Nonce  `meddler:"nonce"`
+	Nonce Nonce  `meddler:"nonce"`
-	Type        TxType `meddler:"type"`
+	Type  TxType `meddler:"type"`
-	EthBlockNum int64  `meddler:"eth_block_num"` // EthereumBlockNumber in which this L2Tx was added to the queue
+	// EthBlockNum in which this L2Tx was added to the queue
+	EthBlockNum int64 `meddler:"eth_block_num"`
 }
 
 // NewL2Tx returns the given L2Tx with the TxId & Type parameters calculated
@@ -89,11 +90,15 @@ func (tx L2Tx) CalculateTxID() ([TxIDLen]byte, error) {
 	// TokenID
 	b = append(b, tx.TokenID.Bytes()[:]...)
 	// Amount
-	amountFloat16, err := NewFloat16(tx.Amount)
+	amountFloat40, err := NewFloat40(tx.Amount)
 	if err != nil {
 		return txID, tracerr.Wrap(fmt.Errorf("%s: %d", err, tx.Amount))
 	}
-	b = append(b, amountFloat16.Bytes()...)
+	amountFloat40Bytes, err := amountFloat40.Bytes()
+	if err != nil {
+		return txID, tracerr.Wrap(err)
+	}
+	b = append(b, amountFloat40Bytes...)
 	// Nonce
 	nonceBytes, err := tx.Nonce.Bytes()
 	if err != nil {
@@ -170,11 +175,11 @@ func TxIDsFromL2Txs(txs []L2Tx) []TxID {
 }
 
 // BytesDataAvailability encodes a L2Tx into []byte for the Data Availability
-// [ fromIdx | toIdx | amountFloat16 | Fee ]
+// [ fromIdx | toIdx | amountFloat40 | Fee ]
 func (tx L2Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 	idxLen := nLevels / 8 //nolint:gomnd
 
-	b := make([]byte, ((nLevels*2)+16+8)/8) //nolint:gomnd
+	b := make([]byte, ((nLevels*2)+40+8)/8) //nolint:gomnd
 
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
@@ -188,13 +193,16 @@ func (tx L2Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 	}
 	copy(b[idxLen:idxLen*2], toIdxBytes[6-idxLen:])
 
-	amountFloat16, err := NewFloat16(tx.Amount)
+	amountFloat40, err := NewFloat40(tx.Amount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-
+	amountFloat40Bytes, err := amountFloat40.Bytes()
-	copy(b[idxLen*2:idxLen*2+2], amountFloat16.Bytes())
+	if err != nil {
-	b[idxLen*2+2] = byte(tx.Fee)
+		return nil, tracerr.Wrap(err)
+	}
+	copy(b[idxLen*2:idxLen*2+Float40BytesLength], amountFloat40Bytes)
+	b[idxLen*2+Float40BytesLength] = byte(tx.Fee)
 
 	return b[:], nil
 }
@@ -219,7 +227,10 @@ func L2TxFromBytesDataAvailability(b []byte, nLevels int) (*L2Tx, error) {
 		return nil, tracerr.Wrap(err)
 	}
 
-	tx.Amount = Float16FromBytes(b[idxLen*2 : idxLen*2+2]).BigInt()
+	tx.Amount, err = Float40FromBytes(b[idxLen*2 : idxLen*2+Float40BytesLength]).BigInt()
-	tx.Fee = FeeSelector(b[idxLen*2+2])
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	tx.Fee = FeeSelector(b[idxLen*2+Float40BytesLength])
 	return tx, nil
 }

common/l2tx_test.go

@@ -19,7 +19,8 @@ func TestNewL2Tx(t *testing.T) {
 	}
 	l2Tx, err := NewL2Tx(l2Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x02fb52b5d0b9ef2626c11701bb751b2720c76d59946b9a48146ac153bb6e63bf6a", l2Tx.TxID.String())
+	assert.Equal(t, "0x022669acda59b827d20ef5354a3eebd1dffb3972b0a6bf89d18bfd2efa0ab9f41e",
+		l2Tx.TxID.String())
 
 	l2Tx = &L2Tx{
 		FromIdx: 87654,
@@ -30,7 +31,8 @@ func TestNewL2Tx(t *testing.T) {
 	}
 	l2Tx, err = NewL2Tx(l2Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x0276114a8f666fa1ff7dbf34b4a9da577808dc501e3b2760d01fe3ef5473f5737f", l2Tx.TxID.String())
+	assert.Equal(t, "0x029e7499a830f8f5eb17c07da48cf91415710f1bcbe0169d363ff91e81faf92fc2",
+		l2Tx.TxID.String())
 
 	l2Tx = &L2Tx{
 		FromIdx: 87654,
@@ -42,7 +44,8 @@ func TestNewL2Tx(t *testing.T) {
 	}
 	l2Tx, err = NewL2Tx(l2Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x025afb63126d3067f61f633d13e5a51da0551af3a4567a9af2db5321ed04214ff4", l2Tx.TxID.String())
+	assert.Equal(t, "0x0255c70ed20e1b8935232e1b9c5884dbcc88a6e1a3454d24f2d77252eb2bb0b64e",
+		l2Tx.TxID.String())
 
 	l2Tx = &L2Tx{
 		FromIdx: 87654,
@@ -54,7 +57,8 @@ func TestNewL2Tx(t *testing.T) {
 	}
 	l2Tx, err = NewL2Tx(l2Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x02cf390157041c3b1b59f0aaed4da464f0d0d48f1d026e46fd89c7fe1e5aed7fcf", l2Tx.TxID.String())
+	assert.Equal(t, "0x0206b372f967061d1148bbcff679de38120e075141a80a07326d0f514c2efc6ca9",
+		l2Tx.TxID.String())
 
 	l2Tx = &L2Tx{
 		FromIdx: 1,
@@ -66,7 +70,8 @@ func TestNewL2Tx(t *testing.T) {
 	}
 	l2Tx, err = NewL2Tx(l2Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x020ec18eaae67fcd545998841a9c4be09ee3083e12db6ae5e5213a2ecaaa52d5cf", l2Tx.TxID.String())
+	assert.Equal(t, "0x0236f7ea5bccf78ba60baf56c058d235a844f9b09259fd0efa4f5f72a7d4a26618",
+		l2Tx.TxID.String())
 
 	l2Tx = &L2Tx{
 		FromIdx: 999,
@@ -78,7 +83,8 @@ func TestNewL2Tx(t *testing.T) {
 	}
 	l2Tx, err = NewL2Tx(l2Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x02f036223e79fac776de107f50822552cc964ee9fc4caa304613285f6976bcc940", l2Tx.TxID.String())
+	assert.Equal(t, "0x02ac122f5b709ce190129fecbbe35bfd30c70e6433dbd85a8eb743d110906a1dc1",
+		l2Tx.TxID.String())
 
 	l2Tx = &L2Tx{
 		FromIdx: 4444,
@@ -90,25 +96,86 @@ func TestNewL2Tx(t *testing.T) {
 	}
 	l2Tx, err = NewL2Tx(l2Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x029c8aef9ef24531e4cf84e78cbab1018ba1626a5a10afb6b7c356be1b5c28e92c", l2Tx.TxID.String())
+	assert.Equal(t, "0x02c674951a81881b7bc50db3b9e5efd97ac88550c7426ac548720e5057cfba515a",
+		l2Tx.TxID.String())
 }
 
 func TestL2TxByteParsers(t *testing.T) {
-	amount := new(big.Int)
+	// test vectors values generated from javascript implementation
-	amount.SetString("79000000", 10)
+	amount, ok := new(big.Int).SetString("343597383670000000000000000000000000000000", 10)
+	require.True(t, ok)
 	l2Tx := &L2Tx{
-		ToIdx:   256,
+		ToIdx:   (1 << 16) - 1,
+		FromIdx: (1 << 16) - 1,
 		Amount:  amount,
-		FromIdx: 257,
+		Fee:     (1 << 8) - 1,
-		Fee:     201,
 	}
-	// Data from the compatibility test
+	expected := "ffffffffffffffffffff"
-	expected := "00000101000001002b16c9"
+	encodedData, err := l2Tx.BytesDataAvailability(16)
-	encodedData, err := l2Tx.BytesDataAvailability(32)
 	require.NoError(t, err)
 	assert.Equal(t, expected, hex.EncodeToString(encodedData))
 
-	decodedData, err := L2TxFromBytesDataAvailability(encodedData, 32)
+	decodedData, err := L2TxFromBytesDataAvailability(encodedData, 16)
+	require.NoError(t, err)
+	assert.Equal(t, l2Tx, decodedData)
+
+	l2Tx = &L2Tx{
+		ToIdx:   (1 << 32) - 1,
+		FromIdx: (1 << 32) - 1,
+		Amount:  amount,
+		Fee:     (1 << 8) - 1,
+	}
+	expected = "ffffffffffffffffffffffffffff"
+	encodedData, err = l2Tx.BytesDataAvailability(32)
+	require.NoError(t, err)
+	assert.Equal(t, expected, hex.EncodeToString(encodedData))
+
+	decodedData, err = L2TxFromBytesDataAvailability(encodedData, 32)
+	require.NoError(t, err)
+	assert.Equal(t, l2Tx, decodedData)
+
+	l2Tx = &L2Tx{
+		ToIdx:   0,
+		FromIdx: 0,
+		Amount:  big.NewInt(0),
+		Fee:     0,
+	}
+	expected = "0000000000000000000000000000"
+	encodedData, err = l2Tx.BytesDataAvailability(32)
+	require.NoError(t, err)
+	assert.Equal(t, expected, hex.EncodeToString(encodedData))
+
+	decodedData, err = L2TxFromBytesDataAvailability(encodedData, 32)
+	require.NoError(t, err)
+	assert.Equal(t, l2Tx, decodedData)
+
+	l2Tx = &L2Tx{
+		ToIdx:   0,
+		FromIdx: 1061,
+		Amount:  big.NewInt(420000000000),
+		Fee:     127,
+	}
+	expected = "000004250000000010fa56ea007f"
+	encodedData, err = l2Tx.BytesDataAvailability(32)
+	require.NoError(t, err)
+	assert.Equal(t, expected, hex.EncodeToString(encodedData))
+
+	decodedData, err = L2TxFromBytesDataAvailability(encodedData, 32)
+	require.NoError(t, err)
+	assert.Equal(t, l2Tx, decodedData)
+
+	l2Tx = &L2Tx{
+		ToIdx:   256,
+		FromIdx: 257,
+		Amount:  big.NewInt(79000000),
+		Fee:     201,
+	}
+	expected = "00000101000001000004b571c0c9"
+	encodedData, err = l2Tx.BytesDataAvailability(32)
+	require.NoError(t, err)
+	assert.Equal(t, expected, hex.EncodeToString(encodedData))
+
+	decodedData, err = L2TxFromBytesDataAvailability(encodedData, 32)
 	require.NoError(t, err)
 	assert.Equal(t, l2Tx, decodedData)
 }

common/pooll2tx.go

@@ -16,7 +16,8 @@ import (
 // EmptyBJJComp contains the 32 byte array of a empty BabyJubJub PublicKey
 // Compressed. It is a valid point in the BabyJubJub curve, so does not give
 // errors when being decompressed.
-var EmptyBJJComp = babyjub.PublicKeyComp([32]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
+var EmptyBJJComp = babyjub.PublicKeyComp([32]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
 
 // PoolL2Tx is a struct that represents a L2Tx sent by an account to the
 // coordinator that is waiting to be forged
@@ -36,7 +37,7 @@ type PoolL2Tx struct {
 	ToEthAddr ethCommon.Address     `meddler:"to_eth_addr,zeroisnull"`
 	ToBJJ     babyjub.PublicKeyComp `meddler:"to_bjj,zeroisnull"`
 	TokenID   TokenID               `meddler:"token_id"`
-	Amount    *big.Int              `meddler:"amount,bigint"` // TODO: change to float16
+	Amount    *big.Int              `meddler:"amount,bigint"`
 	Fee       FeeSelector           `meddler:"fee"`
 	Nonce     Nonce                 `meddler:"nonce"` // effective 40 bits used
 	State     PoolL2TxState         `meddler:"state"`
@@ -53,7 +54,7 @@ type PoolL2Tx struct {
 	RqToEthAddr       ethCommon.Address     `meddler:"rq_to_eth_addr,zeroisnull"`
 	RqToBJJ           babyjub.PublicKeyComp `meddler:"rq_to_bjj,zeroisnull"`
 	RqTokenID         TokenID               `meddler:"rq_token_id,zeroisnull"`
-	RqAmount          *big.Int              `meddler:"rq_amount,bigintnull"` // TODO: change to float16
+	RqAmount          *big.Int              `meddler:"rq_amount,bigintnull"`
 	RqFee             FeeSelector           `meddler:"rq_fee,zeroisnull"`
 	RqNonce           Nonce                 `meddler:"rq_nonce,zeroisnull"` // effective 48 bits used
 	AbsoluteFee       float64               `meddler:"fee_usd,zeroisnull"`
@@ -73,7 +74,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 +84,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
@@ -100,6 +101,8 @@ func (tx *PoolL2Tx) SetType() error {
 			tx.Type = TxTypeTransferToBJJ
 		} else if tx.ToEthAddr != FFAddr && tx.ToEthAddr != EmptyAddr {
 			tx.Type = TxTypeTransferToEthAddr
+		} else {
+			return tracerr.Wrap(errors.New("malformed transaction"))
 		}
 	} else {
 		return tracerr.Wrap(errors.New("malformed transaction"))
@@ -122,18 +125,13 @@ func (tx *PoolL2Tx) SetID() error {
 // [ 8 bits  ] userFee // 1 byte
 // [ 40 bits ] nonce // 5 bytes
 // [ 32 bits ] tokenID // 4 bytes
-// [ 16 bits ] amountFloat16 // 2 bytes
 // [ 48 bits ] toIdx // 6 bytes
 // [ 48 bits ] fromIdx // 6 bytes
 // [ 16 bits ] chainId // 2 bytes
 // [ 32 bits ] signatureConstant // 4 bytes
-// Total bits compressed data:  241 bits // 31 bytes in *big.Int representation
+// Total bits compressed data:  225 bits // 29 bytes in *big.Int representation
 func (tx *PoolL2Tx) TxCompressedData(chainID uint16) (*big.Int, error) {
-	amountFloat16, err := NewFloat16(tx.Amount)
+	var b [29]byte
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	var b [31]byte
 
 	toBJJSign := byte(0)
 	pkSign, _ := babyjub.UnpackSignY(tx.ToBJJ)
@@ -149,19 +147,18 @@ func (tx *PoolL2Tx) TxCompressedData(chainID uint16) (*big.Int, error) {
 	}
 	copy(b[2:7], nonceBytes[:])
 	copy(b[7:11], tx.TokenID.Bytes())
-	copy(b[11:13], amountFloat16.Bytes())
 	toIdxBytes, err := tx.ToIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[13:19], toIdxBytes[:])
+	copy(b[11:17], toIdxBytes[:])
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[19:25], fromIdxBytes[:])
+	copy(b[17:23], fromIdxBytes[:])
-	binary.BigEndian.PutUint16(b[25:27], chainID)
+	binary.BigEndian.PutUint16(b[23:25], chainID)
-	copy(b[27:31], SignatureConstantBytes[:])
+	copy(b[25:29], SignatureConstantBytes[:])
 
 	bi := new(big.Int).SetBytes(b[:])
 	return bi, nil
@@ -170,9 +167,9 @@ func (tx *PoolL2Tx) TxCompressedData(chainID uint16) (*big.Int, error) {
 // TxCompressedDataEmpty calculates the TxCompressedData of an empty
 // transaction
 func TxCompressedDataEmpty(chainID uint16) *big.Int {
-	var b [31]byte
+	var b [29]byte
-	binary.BigEndian.PutUint16(b[25:27], chainID)
+	binary.BigEndian.PutUint16(b[23:25], chainID)
-	copy(b[27:31], SignatureConstantBytes[:])
+	copy(b[25:29], SignatureConstantBytes[:])
 	bi := new(big.Int).SetBytes(b[:])
 	return bi
 }
@@ -182,19 +179,24 @@ func TxCompressedDataEmpty(chainID uint16) *big.Int {
 // [ 8 bits  ] userFee // 1 byte
 // [ 40 bits ] nonce // 5 bytes
 // [ 32 bits ] tokenID // 4 bytes
-// [ 16 bits ] amountFloat16 // 2 bytes
+// [ 40 bits ] amountFloat40 // 5 bytes
 // [ 48 bits ] toIdx // 6 bytes
 // [ 48 bits ] fromIdx // 6 bytes
-// Total bits compressed data:  193 bits // 25 bytes in *big.Int representation
+// Total bits compressed data:  217 bits // 28 bytes in *big.Int representation
 func (tx *PoolL2Tx) TxCompressedDataV2() (*big.Int, error) {
 	if tx.Amount == nil {
 		tx.Amount = big.NewInt(0)
 	}
-	amountFloat16, err := NewFloat16(tx.Amount)
+	amountFloat40, err := NewFloat40(tx.Amount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	var b [25]byte
+	amountFloat40Bytes, err := amountFloat40.Bytes()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+
+	var b [28]byte
 	toBJJSign := byte(0)
 	if tx.ToBJJ != EmptyBJJComp {
 		sign, _ := babyjub.UnpackSignY(tx.ToBJJ)
@@ -210,17 +212,17 @@ func (tx *PoolL2Tx) TxCompressedDataV2() (*big.Int, error) {
 	}
 	copy(b[2:7], nonceBytes[:])
 	copy(b[7:11], tx.TokenID.Bytes())
-	copy(b[11:13], amountFloat16.Bytes())
+	copy(b[11:16], amountFloat40Bytes)
 	toIdxBytes, err := tx.ToIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[13:19], toIdxBytes[:])
+	copy(b[16:22], toIdxBytes[:])
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[19:25], fromIdxBytes[:])
+	copy(b[22:28], fromIdxBytes[:])
 
 	bi := new(big.Int).SetBytes(b[:])
 	return bi, nil
@@ -236,19 +238,24 @@ func (tx *PoolL2Tx) TxCompressedDataV2() (*big.Int, error) {
 // [ 8 bits  ] rqUserFee // 1 byte
 // [ 40 bits ] rqNonce // 5 bytes
 // [ 32 bits ] rqTokenID // 4 bytes
-// [ 16 bits ] rqAmountFloat16 // 2 bytes
+// [ 40 bits ] rqAmountFloat40 // 5 bytes
 // [ 48 bits ] rqToIdx // 6 bytes
 // [ 48 bits ] rqFromIdx // 6 bytes
-// Total bits compressed data:  193 bits // 25 bytes in *big.Int representation
+// Total bits compressed data:  217 bits // 28 bytes in *big.Int representation
 func (tx *PoolL2Tx) RqTxCompressedDataV2() (*big.Int, error) {
 	if tx.RqAmount == nil {
 		tx.RqAmount = big.NewInt(0)
 	}
-	amountFloat16, err := NewFloat16(tx.RqAmount)
+	amountFloat40, err := NewFloat40(tx.RqAmount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	var b [25]byte
+	amountFloat40Bytes, err := amountFloat40.Bytes()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+
+	var b [28]byte
 	rqToBJJSign := byte(0)
 	if tx.RqToBJJ != EmptyBJJComp {
 		sign, _ := babyjub.UnpackSignY(tx.RqToBJJ)
@@ -264,17 +271,17 @@ func (tx *PoolL2Tx) RqTxCompressedDataV2() (*big.Int, error) {
 	}
 	copy(b[2:7], nonceBytes[:])
 	copy(b[7:11], tx.RqTokenID.Bytes())
-	copy(b[11:13], amountFloat16.Bytes())
+	copy(b[11:16], amountFloat40Bytes)
 	toIdxBytes, err := tx.RqToIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[13:19], toIdxBytes[:])
+	copy(b[16:22], toIdxBytes[:])
 	fromIdxBytes, err := tx.RqFromIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[19:25], fromIdxBytes[:])
+	copy(b[22:28], fromIdxBytes[:])
 
 	bi := new(big.Int).SetBytes(b[:])
 	return bi, nil
@@ -287,7 +294,20 @@ func (tx *PoolL2Tx) HashToSign(chainID uint16) (*big.Int, error) {
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	toEthAddr := EthAddrToBigInt(tx.ToEthAddr)
+
+	// e1: [5 bytes AmountFloat40 | 20 bytes ToEthAddr]
+	var e1B [25]byte
+	amountFloat40, err := NewFloat40(tx.Amount)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	amountFloat40Bytes, err := amountFloat40.Bytes()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	copy(e1B[0:5], amountFloat40Bytes)
+	copy(e1B[5:25], tx.ToEthAddr[:])
+	e1 := new(big.Int).SetBytes(e1B[:])
 	rqToEthAddr := EthAddrToBigInt(tx.RqToEthAddr)
 
 	_, toBJJY := babyjub.UnpackSignY(tx.ToBJJ)
@@ -299,7 +319,8 @@ func (tx *PoolL2Tx) HashToSign(chainID uint16) (*big.Int, error) {
 
 	_, rqToBJJY := babyjub.UnpackSignY(tx.RqToBJJ)
 
-	return poseidon.Hash([]*big.Int{toCompressedData, toEthAddr, toBJJY, rqTxCompressedDataV2, rqToEthAddr, rqToBJJY})
+	return poseidon.Hash([]*big.Int{toCompressedData, e1, toBJJY, rqTxCompressedDataV2,
+		rqToEthAddr, rqToBJJY})
 }
 
 // VerifySignature returns true if the signature verification is correct for the given PublicKeyComp

common/pooll2tx_test.go

@@ -21,85 +21,113 @@ func TestNewPoolL2Tx(t *testing.T) {
 	}
 	poolL2Tx, err := NewPoolL2Tx(poolL2Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x02fb52b5d0b9ef2626c11701bb751b2720c76d59946b9a48146ac153bb6e63bf6a", poolL2Tx.TxID.String())
+	assert.Equal(t, "0x022669acda59b827d20ef5354a3eebd1dffb3972b0a6bf89d18bfd2efa0ab9f41e",
+		poolL2Tx.TxID.String())
 }
 
-func TestTxCompressedData(t *testing.T) {
+func TestTxCompressedDataAndTxCompressedDataV2JSVectors(t *testing.T) {
-	chainID := uint16(0)
+	// test vectors values generated from javascript implementation
-	var sk babyjub.PrivateKey
+	var skPositive babyjub.PrivateKey // 'Positive' refers to the sign
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	_, err := hex.Decode(skPositive[:],
+		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 	assert.NoError(t, err)
+
+	var skNegative babyjub.PrivateKey // 'Negative' refers to the sign
+	_, err = hex.Decode(skNegative[:],
+		[]byte("0001020304050607080900010203040506070809000102030405060708090002"))
+	assert.NoError(t, err)
+
+	amount, ok := new(big.Int).SetString("343597383670000000000000000000000000000000", 10)
+	require.True(t, ok)
 	tx := PoolL2Tx{
-		FromIdx: 2,
+		FromIdx: (1 << 48) - 1,
-		ToIdx:   3,
+		ToIdx:   (1 << 48) - 1,
-		Amount:  big.NewInt(4),
+		Amount:  amount,
-		TokenID: 5,
+		TokenID: (1 << 32) - 1,
-		Nonce:   6,
+		Nonce:   (1 << 40) - 1,
-		ToBJJ:   sk.Public().Compress(),
+		Fee:     (1 << 3) - 1,
+		ToBJJ:   skPositive.Public().Compress(),
 	}
-	txCompressedData, err := tx.TxCompressedData(chainID)
+	txCompressedData, err := tx.TxCompressedData(uint16((1 << 16) - 1))
-	assert.NoError(t, err)
+	require.NoError(t, err)
-	// test vector value generated from javascript implementation
+	expectedStr := "0107ffffffffffffffffffffffffffffffffffffffffffffffc60be60f"
-	expectedStr := "1766847064778421992193717128424891165872736891548909569553540445094274575"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
-	assert.Equal(t, expectedStr, txCompressedData.String())
+
-	assert.Equal(t, "010000000000060000000500040000000000030000000000020000c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
+	txCompressedDataV2, err := tx.TxCompressedDataV2()
-	// using a different chainID
+	require.NoError(t, err)
-	txCompressedData, err = tx.TxCompressedData(uint16(100))
+	expectedStr = "0107ffffffffffffffffffffffffffffffffffffffffffffffffffff"
-	assert.NoError(t, err)
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedDataV2.Bytes()))
-	expectedStr = "1766847064778421992193717128424891165872736891548909569553540874591004175"
-	assert.Equal(t, expectedStr, txCompressedData.String())
-	assert.Equal(t, "010000000000060000000500040000000000030000000000020064c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
-	txCompressedData, err = tx.TxCompressedData(uint16(65535))
-	assert.NoError(t, err)
-	expectedStr = "1766847064778421992193717128424891165872736891548909569553821915776017935"
-	assert.Equal(t, expectedStr, txCompressedData.String())
-	assert.Equal(t, "01000000000006000000050004000000000003000000000002ffffc60be60f", hex.EncodeToString(txCompressedData.Bytes()))
 
 	tx = PoolL2Tx{
-		RqFromIdx: 7,
+		FromIdx: 0,
-		RqToIdx:   8,
+		ToIdx:   0,
-		RqAmount:  big.NewInt(9),
+		Amount:  big.NewInt(0),
-		RqTokenID: 10,
+		TokenID: 0,
-		RqNonce:   11,
+		Nonce:   0,
-		RqFee:     12,
+		Fee:     0,
-		RqToBJJ:   sk.Public().Compress(),
+		ToBJJ:   skNegative.Public().Compress(),
 	}
-	rqTxCompressedData, err := tx.RqTxCompressedDataV2()
+	txCompressedData, err = tx.TxCompressedData(uint16(0))
-	assert.NoError(t, err)
+	require.NoError(t, err)
-	// test vector value generated from javascript implementation
+	expectedStr = "c60be60f"
-	expectedStr = "6571340879233176732837827812956721483162819083004853354503"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
-	assert.Equal(t, expectedStr, rqTxCompressedData.String())
-	assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(rqTxCompressedData.Bytes()))
-}
 
-func TestTxCompressedDataV2(t *testing.T) {
+	txCompressedDataV2, err = tx.TxCompressedDataV2()
-	var sk babyjub.PrivateKey
+	require.NoError(t, err)
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	assert.Equal(t, "0", txCompressedDataV2.String())
-	assert.NoError(t, err)
+
-	tx := PoolL2Tx{
+	amount, ok = new(big.Int).SetString("63000000000000000", 10)
-		FromIdx: 7,
+	require.True(t, ok)
-		ToIdx:   8,
+	tx = PoolL2Tx{
-		Amount:  big.NewInt(9),
+		FromIdx: 324,
-		TokenID: 10,
+		ToIdx:   256,
-		Nonce:   11,
+		Amount:  amount,
-		Fee:     12,
+		TokenID: 123,
-		ToBJJ:   sk.Public().Compress(),
+		Nonce:   76,
+		Fee:     214,
+		ToBJJ:   skNegative.Public().Compress(),
 	}
-	txCompressedData, err := tx.TxCompressedDataV2()
+	txCompressedData, err = tx.TxCompressedData(uint16(1))
-	assert.NoError(t, err)
+	require.NoError(t, err)
-	// test vector value generated from javascript implementation
+	expectedStr = "d6000000004c0000007b0000000001000000000001440001c60be60f"
-	expectedStr := "6571340879233176732837827812956721483162819083004853354503"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
-	assert.Equal(t, expectedStr, txCompressedData.String())
-	expected, ok := new(big.Int).SetString(expectedStr, 10)
-	assert.True(t, ok)
 
-	assert.Equal(t, expected.Bytes(), txCompressedData.Bytes())
+	txCompressedDataV2, err = tx.TxCompressedDataV2()
-	assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(txCompressedData.Bytes()))
+	require.NoError(t, err)
+	expectedStr = "d6000000004c0000007b3977825f00000000000100000000000144"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedDataV2.Bytes()))
+
+	tx = PoolL2Tx{
+		FromIdx: 1,
+		ToIdx:   2,
+		TokenID: 3,
+		Nonce:   4,
+		Fee:     5,
+		ToBJJ:   skNegative.Public().Compress(),
+	}
+	txCompressedData, err = tx.TxCompressedData(uint16(0))
+	require.NoError(t, err)
+	expectedStr = "050000000004000000030000000000020000000000010000c60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
+
+	tx = PoolL2Tx{
+		FromIdx: 2,
+		ToIdx:   3,
+		TokenID: 4,
+		Nonce:   5,
+		Fee:     6,
+		ToBJJ:   skPositive.Public().Compress(),
+	}
+	txCompressedData, err = tx.TxCompressedData(uint16(0))
+	require.NoError(t, err)
+	expectedStr = "01060000000005000000040000000000030000000000020000c60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
 }
 
 func TestRqTxCompressedDataV2(t *testing.T) {
 	var sk babyjub.PrivateKey
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	_, err := hex.Decode(sk[:],
+		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 	assert.NoError(t, err)
 	tx := PoolL2Tx{
 		RqFromIdx: 7,
@@ -113,19 +141,17 @@ func TestRqTxCompressedDataV2(t *testing.T) {
 	txCompressedData, err := tx.RqTxCompressedDataV2()
 	assert.NoError(t, err)
 	// test vector value generated from javascript implementation
-	expectedStr := "6571340879233176732837827812956721483162819083004853354503"
+	expectedStr := "110248805340524920412994530176819463725852160917809517418728390663"
 	assert.Equal(t, expectedStr, txCompressedData.String())
 	expected, ok := new(big.Int).SetString(expectedStr, 10)
 	assert.True(t, ok)
 	assert.Equal(t, expected.Bytes(), txCompressedData.Bytes())
-	assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(txCompressedData.Bytes()))
+	assert.Equal(t, "010c000000000b0000000a0000000009000000000008000000000007",
+		hex.EncodeToString(txCompressedData.Bytes()))
 }
 
 func TestHashToSign(t *testing.T) {
 	chainID := uint16(0)
-	var sk babyjub.PrivateKey
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
-	assert.NoError(t, err)
 	tx := PoolL2Tx{
 		FromIdx:   2,
 		ToIdx:     3,
@@ -136,13 +162,15 @@ func TestHashToSign(t *testing.T) {
 	}
 	toSign, err := tx.HashToSign(chainID)
 	assert.NoError(t, err)
-	assert.Equal(t, "1469900657138253851938022936440971384682713995864967090251961124784132925291", toSign.String())
+	assert.Equal(t, "0b8abaf6b7933464e4450df2514da8b72606c02bf7f89bf6e54816fbda9d9d57",
+		hex.EncodeToString(toSign.Bytes()))
 }
 
 func TestVerifyTxSignature(t *testing.T) {
 	chainID := uint16(0)
 	var sk babyjub.PrivateKey
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	_, err := hex.Decode(sk[:],
+		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 	assert.NoError(t, err)
 	tx := PoolL2Tx{
 		FromIdx:     2,
@@ -156,18 +184,49 @@ func TestVerifyTxSignature(t *testing.T) {
 	}
 	toSign, err := tx.HashToSign(chainID)
 	assert.NoError(t, err)
-	assert.Equal(t, "18645218094210271622244722988708640202588315450486586312909439859037906375295", toSign.String())
+	assert.Equal(t,
+		"3144939470626721092564692894890580265754250231349521601298746071096761507003",
+		toSign.String())
 
 	sig := sk.SignPoseidon(toSign)
 	tx.Signature = sig.Compress()
 	assert.True(t, tx.VerifySignature(chainID, sk.Public().Compress()))
 }
 
+func TestVerifyTxSignatureEthAddrWith0(t *testing.T) {
+	chainID := uint16(5)
+	var sk babyjub.PrivateKey
+	_, err := hex.Decode(sk[:],
+		[]byte("02f0b4f87065af3797aaaf934e8b5c31563c17f2272fa71bd0146535bfbb4184"))
+	assert.NoError(t, err)
+	tx := PoolL2Tx{
+		FromIdx:   10659,
+		ToIdx:     0,
+		ToEthAddr: ethCommon.HexToAddress("0x0004308BD15Ead4F1173624dC289DBdcC806a309"),
+		Amount:    big.NewInt(5000),
+		TokenID:   0,
+		Nonce:     946,
+		Fee:       231,
+	}
+	toSign, err := tx.HashToSign(chainID)
+	assert.NoError(t, err)
+
+	sig := sk.SignPoseidon(toSign)
+	assert.Equal(t,
+		"f208b8298d5f37148ac3c0c03703272ea47b9f836851bcf8dd5f7e4e3b336ca1d2f6e92ad85dc25f174daf7a0abfd5f71dead3f059b783f4c4b2f56a18a47000",
+		sig.Compress().String(),
+	)
+	tx.Signature = sig.Compress()
+	assert.True(t, tx.VerifySignature(chainID, sk.Public().Compress()))
+}
+
 func TestDecompressEmptyBJJComp(t *testing.T) {
 	pkComp := EmptyBJJComp
 	pk, err := pkComp.Decompress()
 	require.NoError(t, err)
-	assert.Equal(t, "2957874849018779266517920829765869116077630550401372566248359756137677864698", pk.X.String())
+	assert.Equal(t,
+		"2957874849018779266517920829765869116077630550401372566248359756137677864698",
+		pk.X.String())
 	assert.Equal(t, "0", pk.Y.String())
 }
 

common/token.go

@@ -15,8 +15,9 @@ const tokenIDBytesLen = 4
 
 // Token is a struct that represents an Ethereum token that is supported in Hermez network
 type Token struct {
-	TokenID     TokenID           `json:"id" meddler:"token_id"`
+	TokenID TokenID `json:"id" meddler:"token_id"`
-	EthBlockNum int64             `json:"ethereumBlockNum" meddler:"eth_block_num"` // Ethereum block number in which this token was registered
+	// EthBlockNum indicates the Ethereum block number in which this token was registered
+	EthBlockNum int64             `json:"ethereumBlockNum" meddler:"eth_block_num"`
 	EthAddr     ethCommon.Address `json:"ethereumAddress" meddler:"eth_addr"`
 	Name        string            `json:"name" meddler:"name"`
 	Symbol      string            `json:"symbol" meddler:"symbol"`
@@ -48,7 +49,8 @@ func (t TokenID) BigInt() *big.Int {
 // TokenIDFromBytes returns TokenID from a byte array
 func TokenIDFromBytes(b []byte) (TokenID, error) {
 	if len(b) != tokenIDBytesLen {
-		return 0, tracerr.Wrap(fmt.Errorf("can not parse TokenID, bytes len %d, expected 4", len(b)))
+		return 0, tracerr.Wrap(fmt.Errorf("can not parse TokenID, bytes len %d, expected 4",
+			len(b)))
 	}
 	tid := binary.BigEndian.Uint32(b[:4])
 	return TokenID(tid), nil

common/tx.go

@@ -15,12 +15,12 @@ import (
 )
 
 const (
-	// TXIDPrefixL1UserTx is the prefix that determines that the TxID is
+	// TxIDPrefixL1UserTx is the prefix that determines that the TxID is for
-	// for a L1UserTx
+	// a L1UserTx
 	//nolinter:gomnd
 	TxIDPrefixL1UserTx = byte(0)
 
-	// TXIDPrefixL1CoordTx is the prefix that determines that the TxID is
+	// TxIDPrefixL1CoordTx is the prefix that determines that the TxID is
 	// for a L1CoordinatorTx
 	//nolinter:gomnd
 	TxIDPrefixL1CoordTx = byte(1)
@@ -51,7 +51,8 @@ func (txid *TxID) Scan(src interface{}) error {
 		return tracerr.Wrap(fmt.Errorf("can't scan %T into TxID", src))
 	}
 	if len(srcB) != TxIDLen {
-		return tracerr.Wrap(fmt.Errorf("can't scan []byte of len %d into TxID, need %d", len(srcB), TxIDLen))
+		return tracerr.Wrap(fmt.Errorf("can't scan []byte of len %d into TxID, need %d",
+			len(srcB), TxIDLen))
 	}
 	copy(txid[:], srcB)
 	return nil
@@ -87,7 +88,7 @@ func (txid TxID) MarshalText() ([]byte, error) {
 	return []byte(txid.String()), nil
 }
 
-// UnmarshalText unmarshals a TxID
+// UnmarshalText unmarshalls a TxID
 func (txid *TxID) UnmarshalText(data []byte) error {
 	idStr := string(data)
 	id, err := NewTxIDFromString(idStr)
@@ -102,13 +103,15 @@ func (txid *TxID) UnmarshalText(data []byte) error {
 type TxType string
 
 const (
-	// TxTypeExit represents L2->L1 token transfer.  A leaf for this account appears in the exit tree of the block
+	// TxTypeExit represents L2->L1 token transfer.  A leaf for this account appears in the exit
+	// tree of the block
 	TxTypeExit TxType = "Exit"
 	// TxTypeTransfer represents L2->L2 token transfer
 	TxTypeTransfer TxType = "Transfer"
 	// TxTypeDeposit represents L1->L2 transfer
 	TxTypeDeposit TxType = "Deposit"
-	// TxTypeCreateAccountDeposit represents creation of a new leaf in the state tree (newAcconut) + L1->L2 transfer
+	// TxTypeCreateAccountDeposit represents creation of a new leaf in the state tree
+	// (newAcconut) + L1->L2 transfer
 	TxTypeCreateAccountDeposit TxType = "CreateAccountDeposit"
 	// TxTypeCreateAccountDepositTransfer represents L1->L2 transfer + L2->L2 transfer
 	TxTypeCreateAccountDepositTransfer TxType = "CreateAccountDepositTransfer"
@@ -124,24 +127,31 @@ const (
 	TxTypeTransferToBJJ TxType = "TransferToBJJ"
 )
 
-// Tx is a struct used by the TxSelector & BatchBuilder as a generic type generated from L1Tx & PoolL2Tx
+// Tx is a struct used by the TxSelector & BatchBuilder as a generic type generated from L1Tx &
+// PoolL2Tx
 type Tx struct {
 	// Generic
-	IsL1        bool      `meddler:"is_l1"`
+	IsL1        bool     `meddler:"is_l1"`
-	TxID        TxID      `meddler:"id"`
+	TxID        TxID     `meddler:"id"`
-	Type        TxType    `meddler:"type"`
+	Type        TxType   `meddler:"type"`
-	Position    int       `meddler:"position"`
+	Position    int      `meddler:"position"`
-	FromIdx     Idx       `meddler:"from_idx"`
+	FromIdx     Idx      `meddler:"from_idx"`
-	ToIdx       Idx       `meddler:"to_idx"`
+	ToIdx       Idx      `meddler:"to_idx"`
-	Amount      *big.Int  `meddler:"amount,bigint"`
+	Amount      *big.Int `meddler:"amount,bigint"`
-	AmountFloat float64   `meddler:"amount_f"`
+	AmountFloat float64  `meddler:"amount_f"`
-	TokenID     TokenID   `meddler:"token_id"`
+	TokenID     TokenID  `meddler:"token_id"`
-	USD         *float64  `meddler:"amount_usd"`
+	USD         *float64 `meddler:"amount_usd"`
-	BatchNum    *BatchNum `meddler:"batch_num"`     // batchNum in which this tx was forged. If the tx is L2, this must be != 0
+	// BatchNum in which this tx was forged. If the tx is L2, this must be != 0
-	EthBlockNum int64     `meddler:"eth_block_num"` // Ethereum Block Number in which this L1Tx was added to the queue
+	BatchNum *BatchNum `meddler:"batch_num"`
+	// Ethereum Block Number in which this L1Tx was added to the queue
+	EthBlockNum int64 `meddler:"eth_block_num"`
 	// L1
-	ToForgeL1TxsNum    *int64                `meddler:"to_forge_l1_txs_num"` // toForgeL1TxsNum in which the tx was forged / will be forged
+	// ToForgeL1TxsNum in which the tx was forged / will be forged
-	UserOrigin         *bool                 `meddler:"user_origin"`         // true if the tx was originated by a user, false if it was aoriginated by a coordinator. Note that this differ from the spec for implementation simplification purpposes
+	ToForgeL1TxsNum *int64 `meddler:"to_forge_l1_txs_num"`
+	// UserOrigin is set to true if the tx was originated by a user, false if it was aoriginated
+	// by a coordinator. Note that this differ from the spec for implementation simplification
+	// purpposes
+	UserOrigin         *bool                 `meddler:"user_origin"`
 	FromEthAddr        ethCommon.Address     `meddler:"from_eth_addr"`
 	FromBJJ            babyjub.PublicKeyComp `meddler:"from_bjj"`
 	DepositAmount      *big.Int              `meddler:"deposit_amount,bigintnull"`

common/tx_test.go

@@ -21,8 +21,10 @@ func TestSignatureConstant(t *testing.T) {
 func TestTxIDScannerValue(t *testing.T) {
 	txid0 := &TxID{}
 	txid1 := &TxID{}
-	txid0B := [TxIDLen]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2}
+	txid0B := [TxIDLen]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
-	txid1B := [TxIDLen]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+		3, 4, 5, 6, 7, 8, 9, 0, 1, 2}
+	txid1B := [TxIDLen]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 
 	copy(txid0[:], txid0B[:])
 	copy(txid1[:], txid1B[:])

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

common/utils_test.go

@@ -21,16 +21,23 @@ func TestBJJFromStringWithChecksum(t *testing.T) {
 	assert.NoError(t, err)
 
 	// expected values computed with js implementation
-	assert.Equal(t, "2492816973395423007340226948038371729989170225696553239457870892535792679622", pk.X.String())
+	assert.Equal(t,
-	assert.Equal(t, "15238403086306505038849621710779816852318505119327426213168494964113886299863", pk.Y.String())
+		"2492816973395423007340226948038371729989170225696553239457870892535792679622",
+		pk.X.String())
+	assert.Equal(t,
+		"15238403086306505038849621710779816852318505119327426213168494964113886299863",
+		pk.Y.String())
 }
 
 func TestRmEndingZeroes(t *testing.T) {
-	s0, err := merkletree.NewHashFromHex("0x0000000000000000000000000000000000000000000000000000000000000000")
+	s0, err :=
+		merkletree.NewHashFromHex("0x0000000000000000000000000000000000000000000000000000000000000000")
 	require.NoError(t, err)
-	s1, err := merkletree.NewHashFromHex("0x0000000000000000000000000000000000000000000000000000000000000001")
+	s1, err :=
+		merkletree.NewHashFromHex("0x0000000000000000000000000000000000000000000000000000000000000001")
 	require.NoError(t, err)
-	s2, err := merkletree.NewHashFromHex("0x0000000000000000000000000000000000000000000000000000000000000002")
+	s2, err :=
+		merkletree.NewHashFromHex("0x0000000000000000000000000000000000000000000000000000000000000002")
 	require.NoError(t, err)
 
 	// expect cropped last zeroes

common/zk.go

@@ -1,4 +1,4 @@
-// Package common contains all the common data structures used at the
+// Package common zk.go contains all the common data structures used at the
 // hermez-node, zk.go contains the zkSnark inputs used to generate the proof
 package common
 
@@ -67,7 +67,7 @@ type ZKInputs struct {
 
 	// accumulate fees
 	// FeePlanTokens contains all the tokenIDs for which the fees are being
-	// accumulated and those fees accoumulated will be paid to the FeeIdxs
+	// accumulated and those fees accumulated will be paid to the FeeIdxs
 	// array.  The order of FeeIdxs & FeePlanTokens & State3 must match.
 	// Coordinator fees are processed correlated such as:
 	// [FeePlanTokens[i], FeeIdxs[i]]
@@ -102,6 +102,8 @@ type ZKInputs struct {
 	ToBJJAy []*big.Int `json:"toBjjAy"` // big.Int, len: [maxTx]
 	// ToEthAddr
 	ToEthAddr []*big.Int `json:"toEthAddr"` // ethCommon.Address, len: [maxTx]
+	// AmountF encoded as float40
+	AmountF []*big.Int `json:"amountF"` // uint40 len: [maxTx]
 
 	// OnChain determines if is L1 (1/true) or L2 (0/false)
 	OnChain []*big.Int `json:"onChain"` // bool, len: [maxTx]
@@ -112,8 +114,8 @@ type ZKInputs struct {
 	// NewAccount boolean (0/1) flag set 'true' when L1 tx creates a new
 	// account (fromIdx==0)
 	NewAccount []*big.Int `json:"newAccount"` // bool, len: [maxTx]
-	// DepositAmountF encoded as float16
+	// DepositAmountF encoded as float40
-	DepositAmountF []*big.Int `json:"loadAmountF"` // uint16, len: [maxTx]
+	DepositAmountF []*big.Int `json:"loadAmountF"` // uint40, len: [maxTx]
 	// FromEthAddr
 	FromEthAddr []*big.Int `json:"fromEthAddr"` // ethCommon.Address, len: [maxTx]
 	// FromBJJCompressed boolean encoded where each value is a *big.Int
@@ -128,8 +130,8 @@ type ZKInputs struct {
 	RqOffset []*big.Int `json:"rqOffset"` // uint8 (max 3 bits), len: [maxTx]
 
 	// transaction L2 request data
-	// RqTxCompressedDataV2
+	// RqTxCompressedDataV2 big.Int (max 251 bits), len: [maxTx]
-	RqTxCompressedDataV2 []*big.Int `json:"rqTxCompressedDataV2"` // big.Int (max 251 bits), len: [maxTx]
+	RqTxCompressedDataV2 []*big.Int `json:"rqTxCompressedDataV2"`
 	// RqToEthAddr
 	RqToEthAddr []*big.Int `json:"rqToEthAddr"` // ethCommon.Address, len: [maxTx]
 	// RqToBJJAy
@@ -299,7 +301,8 @@ func (z ZKInputs) MarshalJSON() ([]byte, error) {
 }
 
 // NewZKInputs returns a pointer to an initialized struct of ZKInputs
-func NewZKInputs(chainID uint16, maxTx, maxL1Tx, maxFeeIdxs, nLevels uint32, currentNumBatch *big.Int) *ZKInputs {
+func NewZKInputs(chainID uint16, maxTx, maxL1Tx, maxFeeIdxs, nLevels uint32,
+	currentNumBatch *big.Int) *ZKInputs {
 	zki := &ZKInputs{}
 	zki.Metadata.MaxFeeIdxs = maxFeeIdxs
 	zki.Metadata.MaxLevels = uint32(48) //nolint:gomnd
@@ -326,6 +329,7 @@ func NewZKInputs(chainID uint16, maxTx, maxL1Tx, maxFeeIdxs, nLevels uint32, cur
 	zki.AuxToIdx = newSlice(maxTx)
 	zki.ToBJJAy = newSlice(maxTx)
 	zki.ToEthAddr = newSlice(maxTx)
+	zki.AmountF = newSlice(maxTx)
 	zki.OnChain = newSlice(maxTx)
 	zki.NewAccount = newSlice(maxTx)
 
@@ -476,8 +480,8 @@ func (z ZKInputs) ToHashGlobalData() ([]byte, error) {
 	copy(newExitRoot, z.Metadata.NewExitRootRaw.Bytes())
 	b = append(b, newExitRoot...)
 
-	// [MAX_L1_TX * (2 * MAX_NLEVELS + 480) bits] L1TxsData
+	// [MAX_L1_TX * (2 * MAX_NLEVELS + 528) bits] L1TxsData
-	l1TxDataLen := (2*z.Metadata.MaxLevels + 480)
+	l1TxDataLen := (2*z.Metadata.MaxLevels + 528) //nolint:gomnd
 	l1TxsDataLen := (z.Metadata.MaxL1Tx * l1TxDataLen)
 	l1TxsData := make([]byte, l1TxsDataLen/8) //nolint:gomnd
 	for i := 0; i < len(z.Metadata.L1TxsData); i++ {
@@ -494,20 +498,23 @@ func (z ZKInputs) ToHashGlobalData() ([]byte, error) {
 	}
 	b = append(b, l1TxsDataAvailability...)
 
-	// [MAX_TX*(2*NLevels + 24) bits] L2TxsData
+	// [MAX_TX*(2*NLevels + 48) bits] L2TxsData
 	var l2TxsData []byte
-	l2TxDataLen := 2*z.Metadata.NLevels + 24 //nolint:gomnd
+	l2TxDataLen := 2*z.Metadata.NLevels + 48 //nolint:gomnd
 	l2TxsDataLen := (z.Metadata.MaxTx * l2TxDataLen)
 	expectedL2TxsDataLen := l2TxsDataLen / 8 //nolint:gomnd
 	for i := 0; i < len(z.Metadata.L2TxsData); i++ {
 		l2TxsData = append(l2TxsData, z.Metadata.L2TxsData[i]...)
 	}
 	if len(l2TxsData) > int(expectedL2TxsDataLen) {
-		return nil, tracerr.Wrap(fmt.Errorf("len(l2TxsData): %d, expected: %d", len(l2TxsData), expectedL2TxsDataLen))
+		return nil, tracerr.Wrap(fmt.Errorf("len(l2TxsData): %d, expected: %d",
+			len(l2TxsData), expectedL2TxsDataLen))
 	}
 
 	b = append(b, l2TxsData...)
-	l2TxsPadding := make([]byte, (int(z.Metadata.MaxTx)-len(z.Metadata.L1TxsDataAvailability)-len(z.Metadata.L2TxsData))*int(l2TxDataLen)/8) //nolint:gomnd
+	l2TxsPadding := make([]byte,
+		(int(z.Metadata.MaxTx)-len(z.Metadata.L1TxsDataAvailability)-
+			len(z.Metadata.L2TxsData))*int(l2TxDataLen)/8) //nolint:gomnd
 	b = append(b, l2TxsPadding...)
 
 	// [NLevels * MAX_TOKENS_FEE bits] feeTxsData

config/config.go

@@ -9,6 +9,7 @@ import (
 	"github.com/BurntSushi/toml"
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/hermeznetwork/hermez-node/common"
+	"github.com/hermeznetwork/hermez-node/priceupdater"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 	"gopkg.in/go-playground/validator.v9"
@@ -35,10 +36,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
@@ -60,7 +81,7 @@ type Coordinator struct {
 	// checking the next block), used to decide when to stop scheduling new
 	// batches (by stopping the pipeline).
 	// For example, if we are at block 10 and ScheduleBatchBlocksAheadCheck
-	// is 5, eventhough at block 11 we canForge, the pipeline will be
+	// is 5, even though at block 11 we canForge, the pipeline will be
 	// stopped if we can't forge at block 15.
 	// This value should be the expected number of blocks it takes between
 	// scheduling a batch and having it mined.
@@ -70,7 +91,7 @@ type Coordinator struct {
 	// from the next block; used to decide when to stop sending batches to
 	// the smart contract.
 	// For example, if we are at block 10 and SendBatchBlocksMarginCheck is
-	// 5, eventhough at block 11 we canForge, the batch will be discarded
+	// 5, even though at block 11 we canForge, the batch will be discarded
 	// if we can't forge at block 15.
 	SendBatchBlocksMarginCheck int64
 	// ProofServerPollInterval is the waiting interval between polling the
@@ -79,27 +100,76 @@ type Coordinator struct {
 	// ForgeRetryInterval is the waiting interval between calls forge a
 	// batch after an error
 	ForgeRetryInterval Duration `validate:"required"`
+	// ForgeDelay is the delay 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.
+	ForgeDelay Duration `validate:"-"`
+	// ForgeNoTxsDelay is the delay after which a batch is forged even if
+	// there are no txs to forge if the slot is already committed.  If set
+	// to 0s, the coordinator will continuously forge even if the batches
+	// are empty.
+	ForgeNoTxsDelay Duration `validate:"-"`
+	// MustForgeAtSlotDeadline enables the coordinator to forge slots if
+	// the empty slots reach the slot deadline.
+	MustForgeAtSlotDeadline bool
+	// IgnoreSlotCommitment disables forcing the coordinator to forge a
+	// slot immediately when the slot is not committed. If set to false,
+	// the coordinator will immediately forge a batch at the beginning of a
+	// slot if it's the slot winner.
+	IgnoreSlotCommitment bool
+	// ForgeOncePerSlotIfTxs will make the coordinator forge at most one
+	// batch per slot, only if there are included txs in that batch, or
+	// pending l1UserTxs in the smart contract.  Setting this parameter
+	// overrides `ForgeDelay`, `ForgeNoTxsDelay`, `MustForgeAtSlotDeadline`
+	// and `IgnoreSlotCommitment`.
+	ForgeOncePerSlotIfTxs bool
 	// 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
 		// non-pending L2Txs are deleted from the pool
 		SafetyPeriod common.BatchNum `validate:"required"`
-		// MaxTxs is the number of L2Txs that once reached triggers
+		// MaxTxs is the maximum number of pending L2Txs that can be
-		// deletion of old L2Txs
+		// 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
+		// MaxFeeUSD is the maximum fee in USD that a tx must pay in
+		// order to be accepted into the pool.  Txs with greater than
+		// maximum fee will be rejected at the API level.
+		MaxFeeUSD float64 `validate:"required"`
 		// 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"`
-		// PurgeBatchDelay is the delay between batches to purge outdated transactions
+		// PurgeBatchDelay is the delay between batches to purge
+		// outdated transactions. Outdated L2Txs are those that have
+		// been forged or marked as invalid for longer than the
+		// SafetyPeriod and pending L2Txs that have been in the pool
+		// for longer than TTL once there are MaxTxs.
 		PurgeBatchDelay int64 `validate:"required"`
-		// InvalidateBatchDelay is the delay between batches to mark invalid transactions
+		// InvalidateBatchDelay is the delay between batches to mark
+		// invalid transactions due to nonce lower than the account
+		// nonce.
 		InvalidateBatchDelay int64 `validate:"required"`
-		// PurgeBlockDelay is the delay between blocks to purge outdated transactions
+		// PurgeBlockDelay is the delay between blocks to purge
+		// outdated transactions. Outdated L2Txs are those that have
+		// been forged or marked as invalid for longer than the
+		// SafetyPeriod and pending L2Txs that have been in the pool
+		// for longer than TTL once there are MaxTxs.
 		PurgeBlockDelay int64 `validate:"required"`
-		// InvalidateBlockDelay is the delay between blocks to mark invalid transactions
+		// InvalidateBlockDelay is the delay between blocks to mark
+		// invalid transactions due to nonce lower than the account
+		// nonce.
 		InvalidateBlockDelay int64 `validate:"required"`
 	} `validate:"required"`
 	TxSelector struct {
@@ -119,15 +189,13 @@ type Coordinator struct {
 		NLevels int64 `validate:"required"`
 	} `validate:"required"`
 	EthClient struct {
-		// CallGasLimit is the default gas limit set for ethereum
-		// calls, except for methods  where a particular gas limit is
-		// harcoded because it's known to be a big value
-		CallGasLimit uint64 `validate:"required"`
 		// MaxGasPrice is the maximum gas price allowed for ethereum
 		// transactions
 		MaxGasPrice *big.Int `validate:"required"`
-		// GasPriceDiv is the gas price division
+		// GasPriceIncPerc is the percentage increase of gas price set
-		GasPriceDiv uint64 `validate:"required"`
+		// in an ethereum transaction from the suggested gas price by
+		// the ethereum node
+		GasPriceIncPerc int64
 		// CheckLoopInterval is the waiting interval between receipt
 		// checks of ethereum transactions in the TxManager
 		CheckLoopInterval Duration `validate:"required"`
@@ -151,11 +219,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
@@ -170,15 +238,58 @@ 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 {
 		// Interval between price updater calls
-		Interval Duration `valudate:"required"`
+		Interval Duration `validate:"required"`
-		// URL of the token prices provider
+		// URLBitfinexV2 is the URL of bitfinex V2 API
-		URL string `valudate:"required"`
+		URLBitfinexV2 string `validate:"required"`
-		// Type of the API of the token prices provider
+		// URLCoinGeckoV3 is the URL of coingecko V3 API
-		Type string `valudate:"required"`
+		URLCoinGeckoV3 string `validate:"required"`
+		// DefaultUpdateMethod to get token prices
+		DefaultUpdateMethod priceupdater.UpdateMethodType `validate:"required"`
+		// TokensConfig to specify how each token get it's price updated
+		TokensConfig []priceupdater.TokenConfig
 	} `validate:"required"`
 	StateDB struct {
 		// Path where the synchronizer StateDB is stored
@@ -186,19 +297,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"`
@@ -228,6 +328,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
@@ -245,17 +346,49 @@ 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
+			// MaxFeeUSD is the maximum fee in USD that a tx must pay in
+			// order to be accepted into the pool.  Txs with greater than
+			// maximum fee will be rejected at the API level.
+			MaxFeeUSD float64 `validate:"required"`
+		} `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
@@ -269,8 +402,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))
@@ -279,21 +412,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/batch.go

@@ -8,6 +8,7 @@ import (
 	"path"
 	"time"
 
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/eth"
@@ -84,14 +85,15 @@ type BatchInfo struct {
 	PublicInputs          []*big.Int
 	L1Batch               bool
 	VerifierIdx           uint8
-	L1UserTxsExtra        []common.L1Tx
+	L1UserTxs             []common.L1Tx
 	L1CoordTxs            []common.L1Tx
 	L1CoordinatorTxsAuths [][]byte
 	L2Txs                 []common.L2Tx
 	CoordIdxs             []common.Idx
 	ForgeBatchArgs        *eth.RollupForgeBatchArgs
-	// FeesInfo
+	Auth                  *bind.TransactOpts `json:"-"`
-	EthTx *types.Transaction
+	EthTx                 *types.Transaction
+	EthTxErr              error
 	// SendTimestamp  the time of batch sent to ethereum
 	SendTimestamp time.Time
 	Receipt       *types.Receipt

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"
@@ -24,6 +25,7 @@ import (
 
 var (
 	errLastL1BatchNotSynced = fmt.Errorf("last L1Batch not synced yet")
+	errSkipBatchByPolicy    = fmt.Errorf("skip batch by policy")
 )
 
 const (
@@ -50,7 +52,7 @@ type Config struct {
 	// checking the next block), used to decide when to stop scheduling new
 	// batches (by stopping the pipeline).
 	// For example, if we are at block 10 and ScheduleBatchBlocksAheadCheck
-	// is 5, eventhough at block 11 we canForge, the pipeline will be
+	// is 5, even though at block 11 we canForge, the pipeline will be
 	// stopped if we can't forge at block 15.
 	// This value should be the expected number of blocks it takes between
 	// scheduling a batch and having it mined.
@@ -60,7 +62,7 @@ type Config struct {
 	// from the next block; used to decide when to stop sending batches to
 	// the smart contract.
 	// For example, if we are at block 10 and SendBatchBlocksMarginCheck is
-	// 5, eventhough at block 11 we canForge, the batch will be discarded
+	// 5, even though at block 11 we canForge, the batch will be discarded
 	// if we can't forge at block 15.
 	// This value should be the expected number of blocks it takes between
 	// sending a batch and having it mined.
@@ -71,9 +73,36 @@ type Config struct {
 	// ForgeRetryInterval is the waiting interval between calls forge a
 	// batch after an error
 	ForgeRetryInterval time.Duration
+	// ForgeDelay is the delay 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.
+	ForgeDelay time.Duration
+	// ForgeNoTxsDelay is the delay after which a batch is forged even if
+	// there are no txs to forge if the slot is already committed.  If set
+	// to 0s, the coordinator will continuously forge even if the batches
+	// are empty.
+	ForgeNoTxsDelay time.Duration
+	// MustForgeAtSlotDeadline enables the coordinator to forge slots if
+	// the empty slots reach the slot deadline.
+	MustForgeAtSlotDeadline bool
+	// IgnoreSlotCommitment disables forcing the coordinator to forge a
+	// slot immediately when the slot is not committed. If set to false,
+	// the coordinator will immediately forge a batch at the beginning of
+	// a slot if it's the slot winner.
+	IgnoreSlotCommitment bool
+	// ForgeOncePerSlotIfTxs will make the coordinator forge at most one
+	// batch per slot, only if there are included txs in that batch, or
+	// pending l1UserTxs in the smart contract.  Setting this parameter
+	// overrides `ForgeDelay`, `ForgeNoTxsDelay`, `MustForgeAtSlotDeadline`
+	// and `IgnoreSlotCommitment`.
+	ForgeOncePerSlotIfTxs bool
 	// 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
@@ -87,6 +116,10 @@ type Config struct {
 	// MaxGasPrice is the maximum gas price allowed for ethereum
 	// transactions
 	MaxGasPrice *big.Int
+	// GasPriceIncPerc is the percentage increase of gas price set in an
+	// ethereum transaction from the suggested gas price by the ehtereum
+	// node
+	GasPriceIncPerc int64
 	// TxManagerCheckInterval is the waiting interval between receipt
 	// checks of ethereum transactions in the TxManager
 	TxManagerCheckInterval time.Duration
@@ -96,7 +129,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
 }
 
@@ -121,8 +157,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
 
@@ -138,6 +174,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
 
@@ -153,8 +198,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
@@ -233,7 +278,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
@@ -242,19 +288,19 @@ 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
 type MsgStopPipeline struct {
 	Reason string
-	// FailedBatchNum indicates the first batchNum that faile in the
+	// FailedBatchNum indicates the first batchNum that failed in the
 	// pipeline.  If FailedBatchNum is 0, it should be ignored.
 	FailedBatchNum common.BatchNum
 }
@@ -267,7 +313,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
 	}
@@ -279,12 +325,13 @@ 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)
 }
 
 func canForge(auctionConstants *common.AuctionConstants, auctionVars *common.AuctionVariables,
-	currentSlot *common.Slot, nextSlot *common.Slot, addr ethCommon.Address, blockNum int64) bool {
+	currentSlot *common.Slot, nextSlot *common.Slot, addr ethCommon.Address, blockNum int64,
+	mustForgeAtDeadline bool) bool {
 	if blockNum < auctionConstants.GenesisBlockNum {
 		log.Infow("canForge: requested blockNum is < genesis", "blockNum", blockNum,
 			"genesis", auctionConstants.GenesisBlockNum)
@@ -309,7 +356,7 @@ func canForge(auctionConstants *common.AuctionConstants, auctionVars *common.Auc
 			"block", blockNum)
 		anyoneForge = true
 	}
-	if slot.Forger == addr || anyoneForge {
+	if slot.Forger == addr || (anyoneForge && mustForgeAtDeadline) {
 		return true
 	}
 	log.Debugw("canForge: can't forge", "slot.Forger", slot.Forger)
@@ -319,14 +366,14 @@ func canForge(auctionConstants *common.AuctionConstants, auctionVars *common.Auc
 func (c *Coordinator) canForgeAt(blockNum int64) bool {
 	return canForge(&c.consts.Auction, &c.vars.Auction,
 		&c.stats.Sync.Auction.CurrentSlot, &c.stats.Sync.Auction.NextSlot,
-		c.cfg.ForgerAddress, blockNum)
+		c.cfg.ForgerAddress, blockNum, c.cfg.MustForgeAtSlotDeadline)
 }
 
 func (c *Coordinator) canForge() bool {
 	blockNum := c.stats.Eth.LastBlock.Num + 1
 	return canForge(&c.consts.Auction, &c.vars.Auction,
 		&c.stats.Sync.Auction.CurrentSlot, &c.stats.Sync.Auction.NextSlot,
-		c.cfg.ForgerAddress, blockNum)
+		c.cfg.ForgerAddress, blockNum, c.cfg.MustForgeAtSlotDeadline)
 }
 
 func (c *Coordinator) syncStats(ctx context.Context, stats *synchronizer.Stats) error {
@@ -338,25 +385,43 @@ func (c *Coordinator) syncStats(ctx context.Context, stats *synchronizer.Stats)
 	if c.pipeline == nil {
 		relativeBlock := c.consts.Auction.RelativeBlock(nextBlock)
 		if canForge && relativeBlock < c.cfg.StartSlotBlocksDelay {
-			log.Debugw("Coordinator: delaying pipeline start due to "+
+			log.Debugf("Coordinator: delaying pipeline start due to "+
 				"relativeBlock (%v) < cfg.StartSlotBlocksDelay (%v)",
 				relativeBlock, c.cfg.StartSlotBlocksDelay)
 		} else if canForge {
 			log.Infow("Coordinator: forging state begin", "block",
 				stats.Eth.LastBlock.Num+1, "batch", stats.Sync.LastBatch.BatchNum)
-			batchNum := stats.Sync.LastBatch.BatchNum
+			fromBatch := fromBatch{
-			if c.lastNonFailedBatchNum > batchNum {
+				BatchNum:   stats.Sync.LastBatch.BatchNum,
-				batchNum = c.lastNonFailedBatchNum
+				ForgerAddr: stats.Sync.LastBatch.ForgerAddr,
+				StateRoot:  stats.Sync.LastBatch.StateRoot,
+			}
+			if c.lastNonFailedBatchNum > fromBatch.BatchNum {
+				fromBatch.BatchNum = c.lastNonFailedBatchNum
+				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)
 			}
-			if err := c.pipeline.Start(batchNum, stats, &c.vars); err != nil {
+			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)
 			}
-			// c.pipelineBatchNum = batchNum
 		}
 	} else {
 		if !canForge {
@@ -366,18 +431,6 @@ func (c *Coordinator) syncStats(ctx context.Context, stats *synchronizer.Stats)
 		}
 	}
 	if c.pipeline == nil {
-		// Mark invalid in Pool due to forged L2Txs
-		// for _, batch := range batches {
-		// 	if err := c.l2DB.InvalidateOldNonces(
-		// 		idxsNonceFromL2Txs(batch.L2Txs), batch.Batch.BatchNum); err != nil {
-		// 		return err
-		// 	}
-		// }
-		// if c.purger.CanInvalidate(stats.Sync.LastBlock.Num, int64(stats.Sync.LastBatch.BatchNum)) {
-		// 	if err := c.txSelector.Reset(stats.Sync.LastBatch.BatchNum); err != nil {
-		// 		return tracerr.Wrap(err)
-		// 	}
-		// }
 		if _, err := c.purger.InvalidateMaybe(c.l2DB, c.txSelector.LocalAccountsDB(),
 			stats.Sync.LastBlock.Num, int64(stats.Sync.LastBatch.BatchNum)); err != nil {
 			return tracerr.Wrap(err)
@@ -411,7 +464,8 @@ func (c *Coordinator) handleReorg(ctx context.Context, msg *MsgSyncReorg) error
 		c.pipeline.SetSyncStatsVars(ctx, &msg.Stats, &msg.Vars)
 	}
 	if c.stats.Sync.LastBatch.ForgerAddr != c.cfg.ForgerAddress &&
-		c.stats.Sync.LastBatch.StateRoot.Cmp(c.pipelineFromBatch.StateRoot) != 0 {
+		(c.stats.Sync.LastBatch.StateRoot == nil || c.pipelineFromBatch.StateRoot == nil ||
+			c.stats.Sync.LastBatch.StateRoot.Cmp(c.pipelineFromBatch.StateRoot) != 0) {
 		// There's been a reorg and the batch state root from which the
 		// pipeline was started has changed (probably because it was in
 		// a block that was discarded), and it was sent by a different
@@ -433,7 +487,8 @@ func (c *Coordinator) handleReorg(ctx context.Context, msg *MsgSyncReorg) error
 // handleStopPipeline handles stopping the pipeline.  If failedBatchNum is 0,
 // the next pipeline will start from the last state of the synchronizer,
 // otherwise, it will state from failedBatchNum-1.
-func (c *Coordinator) handleStopPipeline(ctx context.Context, reason string, failedBatchNum common.BatchNum) error {
+func (c *Coordinator) handleStopPipeline(ctx context.Context, reason string,
+	failedBatchNum common.BatchNum) error {
 	batchNum := c.stats.Sync.LastBatch.BatchNum
 	if failedBatchNum != 0 {
 		batchNum = failedBatchNum - 1
@@ -484,7 +539,7 @@ func (c *Coordinator) Start() {
 
 	c.wg.Add(1)
 	go func() {
-		waitDuration := longWaitDuration
+		timer := time.NewTimer(longWaitDuration)
 		for {
 			select {
 			case <-c.ctx.Done():
@@ -496,23 +551,45 @@ func (c *Coordinator) Start() {
 					continue
 				} else if err != nil {
 					log.Errorw("Coordinator.handleMsg", "err", err)
-					waitDuration = c.cfg.SyncRetryInterval
+					if !timer.Stop() {
+						<-timer.C
+					}
+					timer.Reset(c.cfg.SyncRetryInterval)
 					continue
 				}
-				waitDuration = longWaitDuration
+			case <-timer.C:
-			case <-time.After(waitDuration):
+				timer.Reset(longWaitDuration)
 				if !c.stats.Synced() {
-					waitDuration = longWaitDuration
 					continue
 				}
 				if err := c.syncStats(c.ctx, &c.stats); c.ctx.Err() != nil {
 					continue
 				} else if err != nil {
 					log.Errorw("Coordinator.syncStats", "err", err)
-					waitDuration = c.cfg.SyncRetryInterval
+					if !timer.Stop() {
+						<-timer.C
+					}
+					timer.Reset(c.cfg.SyncRetryInterval)
 					continue
 				}
-				waitDuration = 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

@@ -2,7 +2,6 @@ package coordinator
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"math/big"
@@ -12,7 +11,6 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
 	"github.com/hermeznetwork/hermez-node/batchbuilder"
 	"github.com/hermeznetwork/hermez-node/common"
 	dbUtils "github.com/hermeznetwork/hermez-node/db"
@@ -107,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, 1000.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)
@@ -128,7 +126,8 @@ func newTestModules(t *testing.T) modules {
 	batchBuilderDBPath, err = ioutil.TempDir("", "tmpBatchBuilderDB")
 	require.NoError(t, err)
 	deleteme = append(deleteme, batchBuilderDBPath)
-	batchBuilder, err := batchbuilder.NewBatchBuilder(batchBuilderDBPath, syncStateDB, 0, uint64(nLevels))
+	batchBuilder, err := batchbuilder.NewBatchBuilder(batchBuilderDBPath, syncStateDB, 0,
+		uint64(nLevels))
 	assert.NoError(t, err)
 
 	return modules{
@@ -160,14 +159,15 @@ func newTestCoordinator(t *testing.T, forgerAddr ethCommon.Address, ethClient *t
 	deleteme = append(deleteme, debugBatchPath)
 
 	conf := Config{
-		ForgerAddress:          forgerAddr,
+		ForgerAddress:           forgerAddr,
-		ConfirmBlocks:          5,
+		ConfirmBlocks:           5,
-		L1BatchTimeoutPerc:     0.5,
+		L1BatchTimeoutPerc:      0.5,
-		EthClientAttempts:      5,
+		EthClientAttempts:       5,
-		SyncRetryInterval:      400 * time.Microsecond,
+		SyncRetryInterval:       400 * time.Microsecond,
-		EthClientAttemptsDelay: 100 * time.Millisecond,
+		EthClientAttemptsDelay:  100 * time.Millisecond,
-		TxManagerCheckInterval: 300 * time.Millisecond,
+		TxManagerCheckInterval:  300 * time.Millisecond,
-		DebugBatchPath:         debugBatchPath,
+		DebugBatchPath:          debugBatchPath,
+		MustForgeAtSlotDeadline: true,
 		Purger: PurgerCfg{
 			PurgeBatchDelay:      10,
 			PurgeBlockDelay:      10,
@@ -189,12 +189,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,
@@ -207,7 +207,7 @@ func newTestCoordinator(t *testing.T, forgerAddr ethCommon.Address, ethClient *t
 
 func newTestSynchronizer(t *testing.T, ethClient *test.Client, ethClientSetup *test.ClientSetup,
 	modules modules) *synchronizer.Synchronizer {
-	sync, err := synchronizer.NewSynchronizer(ethClient, modules.historyDB, modules.stateDB,
+	sync, err := synchronizer.NewSynchronizer(ethClient, modules.historyDB, modules.l2DB, modules.stateDB,
 		synchronizer.Config{
 			StatsRefreshPeriod: 0 * time.Second,
 		})
@@ -392,6 +392,10 @@ func TestCoordCanForge(t *testing.T) {
 	assert.Equal(t, true, coord.canForge())
 	assert.Equal(t, true, bootCoord.canForge())
 
+	// Anyone can forge but the node MustForgeAtSlotDeadline as set as false
+	coord.cfg.MustForgeAtSlotDeadline = false
+	assert.Equal(t, false, coord.canForge())
+
 	// Slot 3. coordinator bid, so the winner is the coordinator
 	stats.Eth.LastBlock.Num = ethClientSetup.AuctionConstants.GenesisBlockNum +
 		3*int64(ethClientSetup.AuctionConstants.BlocksPerSlot)
@@ -519,7 +523,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
@@ -530,7 +534,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,
@@ -568,8 +572,3 @@ func TestCoordinatorStress(t *testing.T) {
 // TODO: Test forgeBatch
 // TODO: Test waitServerProof
 // TODO: Test handleReorg
-
-func TestFoo(t *testing.T) {
-	a := tracerr.Wrap(fmt.Errorf("AAA: %w", core.ErrNonceTooLow))
-	fmt.Println(errors.Is(a, core.ErrNonceTooLow))
-}

coordinator/pipeline.go

@@ -22,42 +22,42 @@ import (
 
 type statsVars struct {
 	Stats synchronizer.Stats
-	Vars  synchronizer.SCVariablesPtr
+	Vars  common.SCVariablesPtr
 }
 
 type state struct {
 	batchNum                     common.BatchNum
 	lastScheduledL1BatchBlockNum int64
 	lastForgeL1TxsNum            int64
+	lastSlotForged               int64
 }
 
 // Pipeline manages the forging of batches with parallel server proofs
 type Pipeline struct {
 	num    int
 	cfg    Config
-	consts synchronizer.SCConsts
+	consts common.SCConsts
 
 	// state
-	state state
+	state         state
-	// batchNum                     common.BatchNum
-	// lastScheduledL1BatchBlockNum int64
-	// lastForgeL1TxsNum            int64
 	started       bool
 	rw            sync.RWMutex
 	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
@@ -85,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
@@ -105,24 +106,26 @@ 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():
@@ -131,11 +134,12 @@ 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,
 		lastScheduledL1BatchBlockNum: 0,
+		lastSlotForged:               -1,
 	}
 	p.stats = *stats
 	p.vars = *vars
@@ -191,15 +195,39 @@ 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, tracerr.Wrap(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)
+	var skipReason *string
+	p.mutexL2DBUpdateDelete.Lock()
+	batchInfo, skipReason, err = p.forgeBatch(batchNum)
+	p.mutexL2DBUpdateDelete.Unlock()
 	if ctx.Err() != nil {
 		return nil, ctx.Err()
 	} else if err != nil {
@@ -210,31 +238,26 @@ func (p *Pipeline) handleForgeBatch(ctx context.Context, batchNum common.BatchNu
 		} else {
 			log.Errorw("forgeBatch", "err", err)
 		}
-		return nil, err
+		return nil, tracerr.Wrap(err)
-	}
+	} else if skipReason != nil {
-	// 6. Wait for an available server proof (blocking call)
+		log.Debugw("skipping batch", "batch", batchNum, "reason", *skipReason)
-	serverProof, err := p.proversPool.Get(ctx)
+		return nil, tracerr.Wrap(errSkipBatchByPolicy)
-	if ctx.Err() != nil {
-		return nil, ctx.Err()
-	} else if err != nil {
-		log.Errorw("proversPool.Get", "err", err)
-		return nil, err
 	}
+
+	// 3. Send the ZKInputs to the proof server
 	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
+		return nil, tracerr.Wrap(err)
-		p.proversPool.Add(ctx, serverProof)
-		return nil, err
 	}
 	return batchInfo, nil
 }
 
 // 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")
 	}
@@ -250,7 +273,7 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 
 	p.wg.Add(1)
 	go func() {
-		waitDuration := zeroDuration
+		timer := time.NewTimer(zeroDuration)
 		for {
 			select {
 			case <-p.ctx.Done():
@@ -260,24 +283,23 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 			case statsVars := <-p.statsVarsCh:
 				p.stats = statsVars.Stats
 				p.syncSCVars(statsVars.Vars)
-			case <-time.After(waitDuration):
+			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 {
-					waitDuration = p.cfg.ForgeRetryInterval
 					continue
 				}
 				batchNum = p.state.batchNum + 1
 				batchInfo, err := p.handleForgeBatch(p.ctx, batchNum)
 				if p.ctx.Err() != nil {
 					continue
-				} else if tracerr.Unwrap(err) == errLastL1BatchNotSynced {
+				} else if tracerr.Unwrap(err) == errLastL1BatchNotSynced ||
-					waitDuration = p.cfg.ForgeRetryInterval
+					tracerr.Unwrap(err) == errSkipBatchByPolicy {
 					continue
 				} else if err != nil {
 					p.setErrAtBatchNum(batchNum)
-					waitDuration = p.cfg.ForgeRetryInterval
 					p.coord.SendMsg(p.ctx, MsgStopPipeline{
 						Reason: fmt.Sprintf(
 							"Pipeline.handleForgBatch: %v", err),
@@ -285,12 +307,17 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 					})
 					continue
 				}
+				p.lastForgeTime = time.Now()
 
 				p.state.batchNum = batchNum
 				select {
 				case batchChSentServerProof <- batchInfo:
 				case <-p.ctx.Done():
 				}
+				if !timer.Stop() {
+					<-timer.C
+				}
+				timer.Reset(zeroDuration)
 			}
 		}
 	}()
@@ -325,7 +352,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)
 			}
 		}
@@ -363,103 +389,203 @@ func (p *Pipeline) sendServerProof(ctx context.Context, batchInfo *BatchInfo) er
 	return nil
 }
 
+// slotCommitted returns true if the current slot has already been committed
+func (p *Pipeline) slotCommitted() bool {
+	// Synchronizer has synchronized a batch in the current slot (setting
+	// CurrentSlot.ForgerCommitment) or the pipeline has already
+	// internally-forged a batch in the current slot
+	return p.stats.Sync.Auction.CurrentSlot.ForgerCommitment ||
+		p.stats.Sync.Auction.CurrentSlot.SlotNum == p.state.lastSlotForged
+}
+
+// forgePolicySkipPreSelection is called before doing a tx selection in a batch to
+// determine by policy if we should forge the batch or not.  Returns true and
+// the reason when the forging of the batch must be skipped.
+func (p *Pipeline) forgePolicySkipPreSelection(now time.Time) (bool, string) {
+	// Check if the slot is not yet fulfilled
+	slotCommitted := p.slotCommitted()
+	if p.cfg.ForgeOncePerSlotIfTxs {
+		if slotCommitted {
+			return true, "cfg.ForgeOncePerSlotIfTxs = true and slot already committed"
+		}
+		return false, ""
+	}
+	// Determine if we must commit the slot
+	if !p.cfg.IgnoreSlotCommitment && !slotCommitted {
+		return false, ""
+	}
+
+	// If we haven't reached the ForgeDelay, skip forging the batch
+	if now.Sub(p.lastForgeTime) < p.cfg.ForgeDelay {
+		return true, "we haven't reached the forge delay"
+	}
+	return false, ""
+}
+
+// forgePolicySkipPostSelection is called after doing a tx selection in a batch to
+// determine by policy if we should forge the batch or not.  Returns true and
+// the reason when the forging of the batch must be skipped.
+func (p *Pipeline) forgePolicySkipPostSelection(now time.Time, l1UserTxsExtra, l1CoordTxs []common.L1Tx,
+	poolL2Txs []common.PoolL2Tx, batchInfo *BatchInfo) (bool, string, error) {
+	// Check if the slot is not yet fulfilled
+	slotCommitted := p.slotCommitted()
+
+	pendingTxs := true
+	if len(l1UserTxsExtra) == 0 && len(l1CoordTxs) == 0 && len(poolL2Txs) == 0 {
+		if batchInfo.L1Batch {
+			// Query the number of unforged L1UserTxs
+			// (either in a open queue or in a frozen
+			// not-yet-forged queue).
+			count, err := p.historyDB.GetUnforgedL1UserTxsCount()
+			if err != nil {
+				return false, "", err
+			}
+			// If there are future L1UserTxs, we forge a
+			// batch to advance the queues to be able to
+			// forge the L1UserTxs in the future.
+			// Otherwise, skip.
+			if count == 0 {
+				pendingTxs = false
+			}
+		} else {
+			pendingTxs = false
+		}
+	}
+
+	if p.cfg.ForgeOncePerSlotIfTxs {
+		if slotCommitted {
+			return true, "cfg.ForgeOncePerSlotIfTxs = true and slot already committed",
+				nil
+		}
+		if pendingTxs {
+			return false, "", nil
+		}
+		return true, "cfg.ForgeOncePerSlotIfTxs = true and no pending txs",
+			nil
+	}
+
+	// Determine if we must commit the slot
+	if !p.cfg.IgnoreSlotCommitment && !slotCommitted {
+		return false, "", nil
+	}
+
+	// check if there is no txs to forge, no l1UserTxs in the open queue to
+	// freeze and we haven't reached the ForgeNoTxsDelay
+	if now.Sub(p.lastForgeTime) < p.cfg.ForgeNoTxsDelay {
+		if !pendingTxs {
+			return true, "no txs to forge and we haven't reached the forge no txs delay",
+				nil
+		}
+	}
+	return false, "", nil
+}
+
 // forgeBatch forges the batchNum batch.
-func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo, err error) {
+func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo,
+	skipReason *string, err error) {
 	// remove transactions from the pool that have been there for too long
 	_, err = p.purger.InvalidateMaybe(p.l2DB, p.txSelector.LocalAccountsDB(),
 		p.stats.Sync.LastBlock.Num, int64(batchNum))
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(err)
 	}
 	_, err = p.purger.PurgeMaybe(p.l2DB, p.stats.Sync.LastBlock.Num, int64(batchNum))
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(err)
 	}
 	// Structure to accumulate data and metadata of the batch
+	now := time.Now()
 	batchInfo = &BatchInfo{PipelineNum: p.num, BatchNum: batchNum}
-	batchInfo.Debug.StartTimestamp = time.Now()
+	batchInfo.Debug.StartTimestamp = now
 	batchInfo.Debug.StartBlockNum = p.stats.Eth.LastBlock.Num + 1
 
-	selectionCfg := &txselector.SelectionConfig{
-		MaxL1UserTxs:      common.RollupConstMaxL1UserTx,
-		TxProcessorConfig: p.cfg.TxProcessorConfig,
-	}
-
 	var poolL2Txs []common.PoolL2Tx
 	var discardedL2Txs []common.PoolL2Tx
-	var l1UserTxsExtra, l1CoordTxs []common.L1Tx
+	var l1UserTxs, l1CoordTxs []common.L1Tx
 	var auths [][]byte
 	var coordIdxs []common.Idx
 
-	// TODO: If there are no txs and we are behind the timeout, skip
+	if skip, reason := p.forgePolicySkipPreSelection(now); skip {
-	// forging a batch and return a particular error that can be handleded
+		return nil, &reason, nil
-	// in the loop where handleForgeBatch is called to retry after an
+	}
-	// interval
 
 	// 1. Decide if we forge L2Tx or L1+L2Tx
 	if p.shouldL1L2Batch(batchInfo) {
 		batchInfo.L1Batch = true
 		if p.state.lastForgeL1TxsNum != p.stats.Sync.LastForgeL1TxsNum {
-			return nil, tracerr.Wrap(errLastL1BatchNotSynced)
+			return nil, nil, tracerr.Wrap(errLastL1BatchNotSynced)
 		}
 		// 2a: L1+L2 txs
-		l1UserTxs, err := p.historyDB.GetUnforgedL1UserTxs(p.state.lastForgeL1TxsNum + 1)
+		_l1UserTxs, err := p.historyDB.GetUnforgedL1UserTxs(p.state.lastForgeL1TxsNum + 1)
 		if err != nil {
-			return nil, tracerr.Wrap(err)
+			return nil, nil, tracerr.Wrap(err)
 		}
-		coordIdxs, auths, l1UserTxsExtra, l1CoordTxs, poolL2Txs, discardedL2Txs, err =
+		coordIdxs, auths, l1UserTxs, l1CoordTxs, poolL2Txs, discardedL2Txs, err =
-			p.txSelector.GetL1L2TxSelection(selectionCfg, l1UserTxs)
+			p.txSelector.GetL1L2TxSelection(p.cfg.TxProcessorConfig, _l1UserTxs)
 		if err != nil {
-			return nil, tracerr.Wrap(err)
+			return nil, nil, tracerr.Wrap(err)
 		}
-
-		p.state.lastScheduledL1BatchBlockNum = p.stats.Eth.LastBlock.Num + 1
-		p.state.lastForgeL1TxsNum++
 	} else {
 		// 2b: only L2 txs
 		coordIdxs, auths, l1CoordTxs, poolL2Txs, discardedL2Txs, err =
-			p.txSelector.GetL2TxSelection(selectionCfg)
+			p.txSelector.GetL2TxSelection(p.cfg.TxProcessorConfig)
 		if err != nil {
-			return nil, tracerr.Wrap(err)
+			return nil, nil, tracerr.Wrap(err)
 		}
-		l1UserTxsExtra = nil
+		l1UserTxs = nil
+	}
+
+	if skip, reason, err := p.forgePolicySkipPostSelection(now,
+		l1UserTxs, l1CoordTxs, poolL2Txs, batchInfo); err != nil {
+		return nil, nil, tracerr.Wrap(err)
+	} else if skip {
+		if err := p.txSelector.Reset(batchInfo.BatchNum-1, false); err != nil {
+			return nil, nil, tracerr.Wrap(err)
+		}
+		return nil, &reason, tracerr.Wrap(err)
+	}
+
+	if batchInfo.L1Batch {
+		p.state.lastScheduledL1BatchBlockNum = p.stats.Eth.LastBlock.Num + 1
+		p.state.lastForgeL1TxsNum++
 	}
 
 	// 3.  Save metadata from TxSelector output for BatchNum
-	batchInfo.L1UserTxsExtra = l1UserTxsExtra
+	batchInfo.L1UserTxs = l1UserTxs
 	batchInfo.L1CoordTxs = l1CoordTxs
 	batchInfo.L1CoordinatorTxsAuths = auths
 	batchInfo.CoordIdxs = coordIdxs
 	batchInfo.VerifierIdx = p.cfg.VerifierIdx
 
-	if err := p.l2DB.StartForging(common.TxIDsFromPoolL2Txs(poolL2Txs), batchInfo.BatchNum); err != nil {
+	if err := p.l2DB.StartForging(common.TxIDsFromPoolL2Txs(poolL2Txs),
-		return nil, tracerr.Wrap(err)
+		batchInfo.BatchNum); err != nil {
+		return nil, nil, tracerr.Wrap(err)
 	}
 	if err := p.l2DB.UpdateTxsInfo(discardedL2Txs); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(err)
 	}
 
-	// Invalidate transactions that become invalid beause of
+	// Invalidate transactions that become invalid because of
 	// the poolL2Txs selected.  Will mark as invalid the txs that have a
 	// (fromIdx, nonce) which already appears in the selected txs (includes
 	// all the nonces smaller than the current one)
 	err = p.l2DB.InvalidateOldNonces(idxsNonceFromPoolL2Txs(poolL2Txs), batchInfo.BatchNum)
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(err)
 	}
 
 	// 4. Call BatchBuilder with TxSelector output
 	configBatch := &batchbuilder.ConfigBatch{
 		TxProcessorConfig: p.cfg.TxProcessorConfig,
 	}
-	zkInputs, err := p.batchBuilder.BuildBatch(coordIdxs, configBatch, l1UserTxsExtra,
+	zkInputs, err := p.batchBuilder.BuildBatch(coordIdxs, configBatch, l1UserTxs,
 		l1CoordTxs, poolL2Txs)
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(err)
 	}
 	l2Txs, err := common.PoolL2TxsToL2Txs(poolL2Txs) // NOTE: This is a big uggly, find a better way
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(err)
 	}
 	batchInfo.L2Txs = l2Txs
 
@@ -469,12 +595,15 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo, e
 	p.cfg.debugBatchStore(batchInfo)
 	log.Infow("Pipeline: batch forged internally", "batch", batchInfo.BatchNum)
 
-	return batchInfo, nil
+	p.state.lastSlotForged = p.stats.Sync.Auction.CurrentSlot.SlotNum
+
+	return batchInfo, nil, nil
 }
 
 // waitServerProof gets the generated zkProof & sends it to the SmartContract
 func (p *Pipeline) waitServerProof(ctx context.Context, batchInfo *BatchInfo) error {
-	proof, pubInputs, err := batchInfo.ServerProof.GetProof(ctx) // blocking call, until not resolved don't continue. Returns when the proof server has calculated the proof
+	proof, pubInputs, err := batchInfo.ServerProof.GetProof(ctx) // blocking call,
+	// until not resolved don't continue. Returns when the proof server has calculated the proof
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -513,7 +642,7 @@ func prepareForgeBatchArgs(batchInfo *BatchInfo) *eth.RollupForgeBatchArgs {
 		NewLastIdx:            int64(zki.Metadata.NewLastIdxRaw),
 		NewStRoot:             zki.Metadata.NewStateRootRaw.BigInt(),
 		NewExitRoot:           zki.Metadata.NewExitRootRaw.BigInt(),
-		L1UserTxs:             batchInfo.L1UserTxsExtra,
+		L1UserTxs:             batchInfo.L1UserTxs,
 		L1CoordinatorTxs:      batchInfo.L1CoordTxs,
 		L1CoordinatorTxsAuths: batchInfo.L1CoordinatorTxsAuths,
 		L2TxsData:             batchInfo.L2Txs,

coordinator/pipeline_test.go

@@ -25,6 +25,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func newBigInt(s string) *big.Int {
+	v, ok := new(big.Int).SetString(s, 10)
+	if !ok {
+		panic(fmt.Errorf("Can't set big.Int from %s", s))
+	}
+	return v
+}
+
 func TestPipelineShouldL1L2Batch(t *testing.T) {
 	ethClientSetup := test.NewClientSetupExample()
 	ethClientSetup.ChainID = big.NewInt(int64(chainID))
@@ -128,6 +136,11 @@ func preloadSync(t *testing.T, ethClient *test.Client, sync *synchronizer.Synchr
 	blocks, err := tc.GenerateBlocksFromInstructions(set)
 	require.NoError(t, err)
 	require.NotNil(t, blocks)
+	// Set StateRoots for batches manually (til doesn't set it)
+	blocks[0].Rollup.Batches[0].Batch.StateRoot =
+		newBigInt("0")
+	blocks[0].Rollup.Batches[1].Batch.StateRoot =
+		newBigInt("6860514559199319426609623120853503165917774887908204288119245630904770452486")
 
 	ethAddTokens(blocks, ethClient)
 	err = ethClient.CtlAddBlocks(blocks)
@@ -135,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 {
@@ -193,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()
@@ -215,12 +224,12 @@ PoolTransfer(0) User2-User3: 300 (126)
 
 	batchNum++
 
-	batchInfo, err := pipeline.forgeBatch(batchNum)
+	batchInfo, _, err := pipeline.forgeBatch(batchNum)
 	require.NoError(t, err)
 	assert.Equal(t, 3, len(batchInfo.L2Txs))
 
 	batchNum++
-	batchInfo, err = pipeline.forgeBatch(batchNum)
+	batchInfo, _, err = pipeline.forgeBatch(batchNum)
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(batchInfo.L2Txs))
 }

coordinator/purger.go

@@ -13,13 +13,23 @@ import (
 
 // PurgerCfg is the purger configuration
 type PurgerCfg struct {
-	// PurgeBatchDelay is the delay between batches to purge outdated transactions
+	// PurgeBatchDelay is the delay between batches to purge outdated
+	// transactions. Outdated L2Txs are those that have been forged or
+	// marked as invalid for longer than the SafetyPeriod and pending L2Txs
+	// that have been in the pool for longer than TTL once there are
+	// MaxTxs.
 	PurgeBatchDelay int64
-	// InvalidateBatchDelay is the delay between batches to mark invalid transactions
+	// InvalidateBatchDelay is the delay between batches to mark invalid
+	// transactions due to nonce lower than the account nonce.
 	InvalidateBatchDelay int64
-	// PurgeBlockDelay is the delay between blocks to purge outdated transactions
+	// PurgeBlockDelay is the delay between blocks to purge outdated
+	// transactions. Outdated L2Txs are those that have been forged or
+	// marked as invalid for longer than the SafetyPeriod and pending L2Txs
+	// that have been in the pool for longer than TTL once there are
+	// MaxTxs.
 	PurgeBlockDelay int64
-	// InvalidateBlockDelay is the delay between blocks to mark invalid transactions
+	// InvalidateBlockDelay is the delay between blocks to mark invalid
+	// transactions due to nonce lower than the account nonce.
 	InvalidateBlockDelay int64
 }
 

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, 1000.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
@@ -49,15 +49,14 @@ type TxManager struct {
 	// accNextNonce is the nonce that we should use to send the next tx.
 	// In some cases this will be a reused nonce of an already pending tx.
 	accNextNonce uint64
-	// accPendingNonce is the pending nonce of the account due to pending txs
-	// accPendingNonce uint64
 
 	lastSentL1BatchBlockNum int64
 }
 
 // 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)
@@ -68,16 +67,8 @@ func NewTxManager(ctx context.Context, cfg *Config, ethClient eth.ClientInterfac
 	}
 	accNonce, err := ethClient.EthNonceAt(ctx, *address, nil)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
-	// accPendingNonce, err := ethClient.EthPendingNonceAt(ctx, *address)
-	// if err != nil {
-	// 	return nil, err
-	// }
-	// if accNonce != accPendingNonce {
-	// 	return nil, tracerr.Wrap(fmt.Errorf("currentNonce (%v) != accPendingNonce (%v)",
-	// 		accNonce, accPendingNonce))
-	// }
 	log.Infow("TxManager started", "nonce", accNonce)
 	return &TxManager{
 		cfg:               *cfg,
@@ -99,7 +90,6 @@ func NewTxManager(ctx context.Context, cfg *Config, ethClient eth.ClientInterfac
 		queue:          NewQueue(),
 		accNonce:       accNonce,
 		accNextNonce:   accNonce,
-		// accPendingNonce: accPendingNonce,
 	}, nil
 }
 
@@ -113,7 +103,8 @@ 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():
@@ -129,21 +120,24 @@ 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)
 	}
-	inc := new(big.Int).Set(gasPrice)
+	if t.cfg.GasPriceIncPerc != 0 {
-	// TODO: Replace this by a value of percentage
+		inc := new(big.Int).Set(gasPrice)
-	const gasPriceDiv = 100
+		inc.Mul(inc, new(big.Int).SetInt64(t.cfg.GasPriceIncPerc))
-	inc.Div(inc, new(big.Int).SetUint64(gasPriceDiv))
+		// nolint reason: to calculate percentages we use 100
-	gasPrice.Add(gasPrice, inc)
+		inc.Div(inc, new(big.Int).SetUint64(100)) //nolint:gomnd
+		gasPrice.Add(gasPrice, inc)
+	}
+
 	// log.Debugw("TxManager: transaction metadata", "gasPrice", gasPrice)
 
 	auth, err := bind.NewKeyStoreTransactorWithChainID(t.ethClient.EthKeyStore(), t.account, t.chainID)
@@ -151,8 +145,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
+
-	auth.GasLimit = 1000000
+	gasLimit := t.cfg.ForgeBatchGasCost.Fixed +
+		uint64(len(batchInfo.L1UserTxs))*t.cfg.ForgeBatchGasCost.L1UserTx +
+		uint64(len(batchInfo.L1CoordTxs))*t.cfg.ForgeBatchGasCost.L1CoordTx +
+		uint64(len(batchInfo.L2Txs))*t.cfg.ForgeBatchGasCost.L2Tx
+	auth.GasLimit = gasLimit
 	auth.GasPrice = gasPrice
 	auth.Nonce = nil
 
@@ -184,21 +182,32 @@ func (t *TxManager) shouldSendRollupForgeBatch(batchInfo *BatchInfo) error {
 func addPerc(v *big.Int, p int64) *big.Int {
 	r := new(big.Int).Set(v)
 	r.Mul(r, big.NewInt(p))
-	// nolint reason: to calculate percetnages we divide by 100
+	// nolint reason: to calculate percentages we divide by 100
 	r.Div(r, big.NewInt(100)) //nolit:gomnd
+	// If the increase is 0, force it to be 1 so that a gas increase
+	// doesn't result in the same value, making the transaction to be equal
+	// than before.
+	if r.Cmp(big.NewInt(0)) == 0 {
+		r = big.NewInt(1)
+	}
 	return r.Add(v, r)
 }
 
-func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchInfo, resend bool) error {
+func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchInfo,
+	resend bool) error {
 	var ethTx *types.Transaction
 	var err error
-	auth, err := t.NewAuth(ctx)
+	var auth *bind.TransactOpts
-	if err != nil {
-		return tracerr.Wrap(err)
-	}
-	auth.Nonce = big.NewInt(int64(t.accNextNonce))
 	if resend {
-		auth.Nonce = big.NewInt(int64(batchInfo.EthTx.Nonce()))
+		auth = batchInfo.Auth
+		auth.GasPrice = addPerc(auth.GasPrice, 10)
+	} else {
+		auth, err = t.NewAuth(ctx, batchInfo)
+		if err != nil {
+			return tracerr.Wrap(err)
+		}
+		batchInfo.Auth = auth
+		auth.Nonce = big.NewInt(int64(t.accNextNonce))
 	}
 	for attempt := 0; attempt < t.cfg.EthClientAttempts; attempt++ {
 		if auth.GasPrice.Cmp(t.cfg.MaxGasPrice) > 0 {
@@ -207,32 +216,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():
@@ -261,13 +273,13 @@ func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchIn
 		batchInfo.Debug.StartTimestamp).Seconds()
 	t.cfg.debugBatchStore(batchInfo)
 
-	// t.lastPendingBatch = batchInfo.BatchNum
 	if !resend {
 		if batchInfo.L1Batch {
 			t.lastSentL1BatchBlockNum = t.stats.Eth.LastBlock.Num + 1
 		}
 	}
-	if err := t.l2DB.DoneForging(common.TxIDsFromL2Txs(batchInfo.L2Txs), batchInfo.BatchNum); err != nil {
+	if err := t.l2DB.DoneForging(common.TxIDsFromL2Txs(batchInfo.L2Txs),
+		batchInfo.BatchNum); err != nil {
 		return tracerr.Wrap(err)
 	}
 	return nil
@@ -299,7 +311,9 @@ func (t *TxManager) checkEthTransactionReceipt(ctx context.Context, batchInfo *B
 		}
 	}
 	if err != nil {
-		return tracerr.Wrap(fmt.Errorf("reached max attempts for ethClient.EthTransactionReceipt: %w", err))
+		return tracerr.Wrap(
+			fmt.Errorf("reached max attempts for ethClient.EthTransactionReceipt: %w",
+				err))
 	}
 	batchInfo.Receipt = receipt
 	t.cfg.debugBatchStore(batchInfo)
@@ -314,14 +328,15 @@ func (t *TxManager) handleReceipt(ctx context.Context, batchInfo *BatchInfo) (*i
 		}
 		if receipt.Status == types.ReceiptStatusFailed {
 			batchInfo.Debug.Status = StatusFailed
-			t.cfg.debugBatchStore(batchInfo)
 			_, err := t.ethClient.EthCall(ctx, batchInfo.EthTx, receipt.BlockNumber)
 			log.Warnw("TxManager receipt status is failed", "tx", receipt.TxHash,
 				"batch", batchInfo.BatchNum, "block", receipt.BlockNumber.Int64(),
 				"err", err)
+			batchInfo.EthTxErr = err
 			if batchInfo.BatchNum <= t.lastSuccessBatch {
 				t.lastSuccessBatch = batchInfo.BatchNum - 1
 			}
+			t.cfg.debugBatchStore(batchInfo)
 			return nil, tracerr.Wrap(fmt.Errorf(
 				"ethereum transaction receipt status is failed: %w", err))
 		} else if receipt.Status == types.ReceiptStatusSuccessful {
@@ -417,8 +432,6 @@ func (q *Queue) Push(batchInfo *BatchInfo) {
 
 // Run the TxManager
 func (t *TxManager) Run(ctx context.Context) {
-	waitDuration := longWaitDuration
-
 	var statsVars statsVars
 	select {
 	case statsVars = <-t.statsVarsCh:
@@ -429,6 +442,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():
@@ -472,20 +486,24 @@ func (t *TxManager) Run(ctx context.Context) {
 				continue
 			}
 			t.queue.Push(batchInfo)
-			waitDuration = t.cfg.TxManagerCheckInterval
+			if !timer.Stop() {
-		case <-time.After(waitDuration):
+				<-timer.C
+			}
+			timer.Reset(t.cfg.TxManagerCheckInterval)
+		case <-timer.C:
 			queuePosition, batchInfo := t.queue.Next()
 			if batchInfo == nil {
-				waitDuration = 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
 				// Our ethNode is giving an error different
 				// than "not found" when getting the receipt
 				// for the transaction, so we can't figure out
-				// if it was not mined, mined and succesfull or
+				// if it was not mined, mined and successful or
 				// mined and failed.  This could be due to the
 				// ethNode failure.
 				t.coord.SendMsg(ctx, MsgStopPipeline{
@@ -539,7 +557,6 @@ func (t *TxManager) Run(ctx context.Context) {
 
 func (t *TxManager) removeBadBatchInfos(ctx context.Context) error {
 	next := 0
-	// batchNum := 0
 	for {
 		batchInfo := t.queue.At(next)
 		if batchInfo == nil {
@@ -551,7 +568,7 @@ func (t *TxManager) removeBadBatchInfos(ctx context.Context) error {
 			// Our ethNode is giving an error different
 			// than "not found" when getting the receipt
 			// for the transaction, so we can't figure out
-			// if it was not mined, mined and succesfull or
+			// if it was not mined, mined and successful or
 			// mined and failed.  This could be due to the
 			// ethNode failure.
 			next++
@@ -572,7 +589,6 @@ func (t *TxManager) removeBadBatchInfos(ctx context.Context) error {
 		// from the queue
 		if confirm == nil {
 			if batchInfo.PipelineNum < t.minPipelineNum {
-				// batchNum++
 				t.queue.Remove(next)
 				continue
 			}
@@ -592,7 +608,7 @@ func (t *TxManager) removeBadBatchInfos(ctx context.Context) error {
 func (t *TxManager) canForgeAt(blockNum int64) bool {
 	return canForge(&t.consts.Auction, &t.vars.Auction,
 		&t.stats.Sync.Auction.CurrentSlot, &t.stats.Sync.Auction.NextSlot,
-		t.cfg.ForgerAddress, blockNum)
+		t.cfg.ForgerAddress, blockNum, t.cfg.MustForgeAtSlotDeadline)
 }
 
 func (t *TxManager) mustL1L2Batch(blockNum int64) bool {

db/historydb/apiqueries.go

@@ -1,10 +1,14 @@
 package historydb
 
 import (
+	"database/sql"
 	"errors"
 	"fmt"
+	"math/big"
+	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db"
 	"github.com/hermeznetwork/tracerr"
@@ -32,9 +36,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(
+	if err := 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,
@@ -42,7 +55,11 @@ func (hdb *HistoryDB) GetBatchAPI(batchNum common.BatchNum) (*BatchAPI, error) {
 	    COALESCE ((SELECT COUNT(*) FROM tx WHERE batch_num = batch.batch_num), 0) AS forged_txs
 	    FROM batch INNER JOIN block ON batch.eth_block_num = block.eth_block_num
 	 	WHERE batch_num = $1;`, batchNum,
-	))
+	); err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	batch.CollectedFeesAPI = apitypes.NewCollectedFeesAPI(batch.CollectedFeesDB)
+	return batch, nil
 }
 
 // GetBatchesAPI return the batches applying the given filters
@@ -133,16 +150,19 @@ 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)
 	if len(batches) == 0 {
 		return batches, 0, nil
 	}
+	for i := range batches {
+		batches[i].CollectedFeesAPI = apitypes.NewCollectedFeesAPI(batches[i].CollectedFeesDB)
+	}
 	return batches, batches[0].TotalItems - uint64(len(batches)), nil
 }
 
@@ -156,7 +176,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 +200,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 +240,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 +324,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 +412,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 +436,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 +569,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 +592,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 +713,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 +725,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 +781,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 +804,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 +818,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 +858,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 +913,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 +927,280 @@ 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 idx, token_id, batch_num, bjj, eth_addr
-		COALESCE (MIN(tx.batch_num), 0) as batch_num, COALESCE (MIN(block.timestamp), 
+		FROM account WHERE idx = $1;`, idx,
-		NOW()) AS min_timestamp, COALESCE (MAX(block.timestamp), NOW()) AS max_timestamp
+	)
-		FROM tx INNER JOIN block ON tx.eth_block_num = block.eth_block_num
+	return account, tracerr.Wrap(err)
-		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) (metrics *MetricsAPI, poolLoad int64, err error) {
+	metrics = &MetricsAPI{}
+	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, 0, 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, 0, 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)
+	}
+	if (p.ToBatchNum - p.FromBatchNum) > 0 {
+		metrics.TransactionsPerBatch = float64(nTxs) /
+			float64(nBatches)
 	} else {
-		metrics.TransactionsPerBatch = float64(0)
+		metrics.TransactionsPerBatch = 0
 	}
-
+	// Get total fee of that period
-	err = meddler.QueryRow(
+	row = hdb.dbRead.QueryRow(
-		hdb.db, metricsTotals, `SELECT COUNT(*) AS total_batches, 
+		`SELECT COALESCE (SUM(total_fees_usd), 0) FROM batch WHERE batch_num between $1 AND $2;`,
-		COALESCE (SUM(total_fees_usd), 0) AS total_fees FROM batch 
+		p.FromBatchNum, p.ToBatchNum,
-		WHERE batch_num > $1;`, metricsTotals.FirstBatchNum)
+	)
-	if err != nil {
+	var totalFee float64
-		return nil, tracerr.Wrap(err)
+	if err := row.Scan(&totalFee); err != nil {
+		return nil, 0, tracerr.Wrap(err)
 	}
-	if metricsTotals.TotalBatches > 0 {
+	// Set batch frequency
-		metrics.BatchFrequency = seconds / float64(metricsTotals.TotalBatches)
+	metrics.BatchFrequency = seconds / float64(nBatches)
-	} else {
+	// Set avg transaction fee (only L2 txs have fee)
-		metrics.BatchFrequency = 0
+	row = hdb.dbRead.QueryRow(
+		`SELECT COUNT(*) as total_txs FROM tx WHERE tx.batch_num between $1 AND $2 AND NOT is_l1;`,
+		p.FromBatchNum, p.ToBatchNum,
+	)
+	var nL2Txs int
+	if err := row.Scan(&nL2Txs); err != nil {
+		return nil, 0, tracerr.Wrap(err)
 	}
-	if metricsTotals.TotalTransactions > 0 {
+	if nL2Txs > 0 {
-		metrics.AvgTransactionFee = metricsTotals.TotalFeesUSD / float64(metricsTotals.TotalTransactions)
+		metrics.AvgTransactionFee = totalFee / float64(nL2Txs)
 	} 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;`)
+		TokenAccounts int64 `meddler:"token_accounts"`
-	if err != nil {
+		Wallets       int64 `meddler:"wallets"`
-		return nil, tracerr.Wrap(err)
 	}
-
+	ra := &registeredAccounts{}
-	return metrics, nil
+	if err := meddler.QueryRow(
+		hdb.dbRead, ra,
+		`SELECT COUNT(*) AS token_accounts, COUNT(DISTINCT(bjj)) AS wallets FROM account;`,
+	); err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	metrics.TokenAccounts = ra.TokenAccounts
+	metrics.Wallets = ra.Wallets
+	// 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, 0, tracerr.Wrap(err)
+	}
+	metrics.EstimatedTimeToForgeL1 = timeToForgeL1
+	// Get amount of txs in the pool
+	row = hdb.dbRead.QueryRow(
+		`SELECT COUNT(*) FROM tx_pool WHERE state = $1 AND NOT external_delete;`,
+		common.PoolL2TxStatePending,
+	)
+	if err := row.Scan(&poolLoad); err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	return metrics, poolLoad, 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,20 +173,20 @@ 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;`,
 		batchNum,
 	)
-	return &batch, err
+	return &batch, tracerr.Wrap(err)
 }
 
 // GetAllBatches retrieve all batches from the DB
 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,17 +230,17 @@ 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;`,
 	)
-	return &batch, err
+	return &batch, tracerr.Wrap(err)
 }
 
 // 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,18 +450,16 @@ 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
-func (hdb *HistoryDB) UpdateTokenValue(tokenSymbol string, value float64) error {
+// USD of a normalized token (1 token = 10^decimals units)
-	// Sanitize symbol
+func (hdb *HistoryDB) UpdateTokenValue(tokenAddr ethCommon.Address, value float64) error {
-	tokenSymbol = strings.ToValidUTF8(tokenSymbol, " ")
+	_, err := hdb.dbWrite.Exec(
-
+		"UPDATE token SET usd = $1 WHERE eth_addr = $2;",
-	_, err := hdb.db.Exec(
+		value, tokenAddr,
-		"UPDATE token SET usd = $1 WHERE symbol = $2;",
-		value, tokenSymbol,
 	)
 	return tracerr.Wrap(err)
 }
@@ -463,7 +468,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,34 +477,25 @@ 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)
 }
 
-// GetTokenSymbols returns all the token symbols from the DB
+// GetTokenSymbolsAndAddrs returns all the token symbols and addresses from the DB
-func (hdb *HistoryDB) GetTokenSymbols() ([]string, error) {
+func (hdb *HistoryDB) GetTokenSymbolsAndAddrs() ([]TokenSymbolAndAddr, error) {
-	var tokenSymbols []string
+	var tokens []*TokenSymbolAndAddr
-	rows, err := hdb.db.Query("SELECT symbol FROM token;")
+	err := meddler.QueryAll(
-	if err != nil {
+		hdb.dbRead, &tokens,
-		return nil, tracerr.Wrap(err)
+		"SELECT symbol, eth_addr FROM token;",
-	}
+	)
-	defer db.RowsClose(rows)
+	return db.SlicePtrsToSlice(tokens).([]TokenSymbolAndAddr), tracerr.Wrap(err)
-	sym := new(string)
-	for rows.Next() {
-		err = rows.Scan(sym)
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-		tokenSymbols = append(tokenSymbols, *sym)
-	}
-	return tokenSymbols, nil
 }
 
 // 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 +510,7 @@ func (hdb *HistoryDB) addAccounts(d meddler.DB, accounts []common.Account) error
 			bjj,
 			eth_addr
 		) VALUES %s;`,
-		accounts[:],
+		accounts,
 	))
 }
 
@@ -522,18 +518,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 +614,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 +673,7 @@ func (hdb *HistoryDB) addTxs(d meddler.DB, txs []txWrite) error {
 			fee,
 			nonce
 		) VALUES %s;`,
-		txs[:],
+		txs,
 	))
 }
 
@@ -654,7 +681,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,11 +693,11 @@ 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,
 		`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,
+		tx.amount, (CASE WHEN tx.batch_num IS NULL THEN NULL WHEN tx.amount_success THEN tx.amount ELSE 0 END) AS effective_amount,
-		tx.deposit_amount, (CASE WHEN tx.batch_num IS NULL THEN NULL WHEN tx.deposit_amount_success THEN tx.deposit_amount ELSE '\x' END) AS effective_deposit_amount,
+		tx.deposit_amount, (CASE WHEN tx.batch_num IS NULL THEN NULL WHEN tx.deposit_amount_success THEN tx.deposit_amount ELSE 0 END) AS effective_deposit_amount,
 		tx.eth_block_num, tx.type, tx.batch_num
 		FROM tx WHERE is_l1 = TRUE AND user_origin = TRUE ORDER BY item_id;`,
 	)
@@ -683,7 +710,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 +725,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 +738,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,
@@ -724,11 +751,21 @@ func (hdb *HistoryDB) GetUnforgedL1UserTxs(toForgeL1TxsNum int64) ([]common.L1Tx
 	return db.SlicePtrsToSlice(txs).([]common.L1Tx), tracerr.Wrap(err)
 }
 
+// GetUnforgedL1UserTxsCount returns the count of unforged L1Txs (either in
+// open or frozen queues that are not yet forged)
+func (hdb *HistoryDB) GetUnforgedL1UserTxsCount() (int, error) {
+	row := hdb.dbRead.QueryRow(
+		`SELECT COUNT(*) FROM tx WHERE batch_num IS NULL;`,
+	)
+	var count int
+	return count, tracerr.Wrap(row.Scan(&count))
+}
+
 // TODO: Think about chaning all the queries that return a last value, to queries that return the next valid value.
 
 // 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 +779,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 +818,7 @@ func (hdb *HistoryDB) addBucketUpdates(d meddler.DB, bucketUpdates []common.Buck
 		 	block_stamp,
 		 	withdrawals
 		) VALUES %s;`,
-		bucketUpdates[:],
+		bucketUpdates,
 	))
 }
 
@@ -795,13 +832,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 +862,7 @@ func (hdb *HistoryDB) addTokenExchanges(d meddler.DB, tokenExchanges []common.To
     			eth_addr,
     			value_usd
 		) VALUES %s;`,
-		tokenExchanges[:],
+		tokenExchanges,
 	))
 }
 
@@ -821,7 +870,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 +890,7 @@ func (hdb *HistoryDB) addEscapeHatchWithdrawals(d meddler.DB,
 			token_addr,
 			amount
 		) VALUES %s;`,
-		escapeHatchWithdrawals[:],
+		escapeHatchWithdrawals,
 	))
 }
 
@@ -849,7 +898,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 +911,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 +995,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 +1067,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,28 +1149,17 @@ func (hdb *HistoryDB) AddBlockSCData(blockData *common.BlockData) (err error) {
 	return tracerr.Wrap(txn.Commit())
 }
 
-// GetCoordinatorAPI returns a coordinator by its bidderAddr
-func (hdb *HistoryDB) GetCoordinatorAPI(bidderAddr ethCommon.Address) (*CoordinatorAPI, error) {
-	coordinator := &CoordinatorAPI{}
-	err := meddler.QueryRow(
-		hdb.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",
+		"SELECT * FROM token ORDER BY token_id ASC",
 	); err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -1125,3 +1168,60 @@ func (hdb *HistoryDB) GetTokensTest() ([]TokenWithUSD, error) {
 	}
 	return db.SlicePtrsToSlice(tokens).([]TokenWithUSD), nil
 }
+
+const (
+	// CreateAccountExtraFeePercentage is the multiplication factor over
+	// the average fee for CreateAccount that is applied to obtain the
+	// recommended fee for CreateAccount
+	CreateAccountExtraFeePercentage float64 = 2.5
+	// CreateAccountInternalExtraFeePercentage is the multiplication factor
+	// over the average fee for CreateAccountInternal that is applied to
+	// obtain the recommended fee for CreateAccountInternal
+	CreateAccountInternalExtraFeePercentage float64 = 2.0
+)
+
+// GetRecommendedFee returns the RecommendedFee information
+func (hdb *HistoryDB) GetRecommendedFee(minFeeUSD, maxFeeUSD 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.Min(maxFeeUSD,
+		math.Max(avgTransactionFee, minFeeUSD))
+	recommendedFee.CreatesAccount = math.Min(maxFeeUSD,
+		math.Max(CreateAccountExtraFeePercentage*avgTransactionFee, minFeeUSD))
+	recommendedFee.CreatesAccountInternal = math.Min(maxFeeUSD,
+		math.Max(CreateAccountInternalExtraFeePercentage*avgTransactionFee, minFeeUSD))
+	return &recommendedFee, nil
+}

db/historydb/historydb_test.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	dbUtils "github.com/hermeznetwork/hermez-node/db"
 	"github.com/hermeznetwork/hermez-node/log"
@@ -39,12 +40,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)
+	apiConnCon := dbUtils.NewAPIConnectionController(1, time.Second)
-	historyDBWithACC = NewHistoryDB(db, apiConnCon)
+	historyDBWithACC = NewHistoryDB(db, db, apiConnCon)
 	// Run tests
 	result := m.Run()
 	// Close DB
@@ -166,7 +167,7 @@ func TestBatches(t *testing.T) {
 			if i%2 != 0 {
 				// Set value to the token
 				value := (float64(i) + 5) * 5.389329
-				assert.NoError(t, historyDB.UpdateTokenValue(token.Symbol, value))
+				assert.NoError(t, historyDB.UpdateTokenValue(token.EthAddr, value))
 				tokensValue[token.TokenID] = value / math.Pow(10, float64(token.Decimals))
 			}
 		}
@@ -276,7 +277,7 @@ func TestTokens(t *testing.T) {
 	// Update token value
 	for i, token := range tokens {
 		value := 1.01 * float64(i)
-		assert.NoError(t, historyDB.UpdateTokenValue(token.Symbol, value))
+		assert.NoError(t, historyDB.UpdateTokenValue(token.EthAddr, value))
 	}
 	// Fetch tokens
 	fetchedTokens, err = historyDB.GetTokensTest()
@@ -302,7 +303,7 @@ func TestTokensUTF8(t *testing.T) {
 	// Generate fake tokens
 	const nTokens = 5
 	tokens, ethToken := test.GenTokens(nTokens, blocks)
-	nonUTFTokens := make([]common.Token, len(tokens)+1)
+	nonUTFTokens := make([]common.Token, len(tokens))
 	// Force token.name and token.symbol to be non UTF-8 Strings
 	for i, token := range tokens {
 		token.Name = fmt.Sprint("NON-UTF8-NAME-\xc5-", i)
@@ -332,7 +333,7 @@ func TestTokensUTF8(t *testing.T) {
 	// Update token value
 	for i, token := range nonUTFTokens {
 		value := 1.01 * float64(i)
-		assert.NoError(t, historyDB.UpdateTokenValue(token.Symbol, value))
+		assert.NoError(t, historyDB.UpdateTokenValue(token.EthAddr, value))
 	}
 	// Fetch tokens
 	fetchedTokens, err = historyDB.GetTokensTest()
@@ -377,6 +378,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) {
@@ -621,10 +638,10 @@ func TestTxs(t *testing.T) {
 	assert.Equal(t, common.TxTypeExit, dbL2Txs[3].Type)
 
 	// Tx ID
-	assert.Equal(t, "0x02d709307533c4e3c03f20751fc4d72bc18b225d14f9616525540a64342c7c350d", dbL2Txs[0].TxID.String())
+	assert.Equal(t, "0x024e555248100b69a8aabf6d31719b9fe8a60dcc6c3407904a93c8d2d9ade18ee5", dbL2Txs[0].TxID.String())
-	assert.Equal(t, "0x02e88bc5503f282cca045847668511290e642410a459bb67b1fafcd1b6097c149c", dbL2Txs[1].TxID.String())
+	assert.Equal(t, "0x021ae87ca34d50ff35d98dfc0d7c95f2bf2e4ffeebb82ea71f43a8b0dfa5d36d89", dbL2Txs[1].TxID.String())
-	assert.Equal(t, "0x027911262b43315c0b24942a02fe228274b6e4d57a476bfcdd7a324b3091362c7d", dbL2Txs[2].TxID.String())
+	assert.Equal(t, "0x024abce7f3f2382dc520ed557593f11dea1ee197e55b60402e664facc27aa19774", dbL2Txs[2].TxID.String())
-	assert.Equal(t, "0x02f572b63f2a5c302e1b9337ea6944bfbac3d199e4ddd262b5a53759c72ec10ee6", dbL2Txs[3].TxID.String())
+	assert.Equal(t, "0x02f921ad9e7a6e59606570fe12a7dde0e36014197de0363b9b45e5097d6f2b1dd0", dbL2Txs[3].TxID.String())
 
 	// Tx From and To IDx
 	assert.Equal(t, dbL2Txs[0].ToIdx, dbL2Txs[2].FromIdx)
@@ -704,6 +721,10 @@ func TestGetUnforgedL1UserTxs(t *testing.T) {
 	assert.Equal(t, 5, len(l1UserTxs))
 	assert.Equal(t, blocks[0].Rollup.L1UserTxs, l1UserTxs)
 
+	count, err := historyDB.GetUnforgedL1UserTxsCount()
+	require.NoError(t, err)
+	assert.Equal(t, 5, count)
+
 	// No l1UserTxs for this toForgeL1TxsNum
 	l1UserTxs, err = historyDB.GetUnforgedL1UserTxs(2)
 	require.NoError(t, err)
@@ -801,11 +822,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 +836,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 +923,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 +956,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 +1002,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 +1020,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 +1058,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 +1083,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 +1112,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,21 +1177,17 @@ 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))
+	assert.Equal(t, int64(3), res.TokenAccounts)
-	// This may also be different in some decimals
+	assert.Equal(t, int64(3), res.Wallets)
-	// 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
 	assert.Equal(t, float64(0), res.AvgTransactionFee)
 }
@@ -1195,7 +1212,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,51 +1237,40 @@ 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))
+	assert.Equal(t, int64(3), res.TokenAccounts)
-	// Truncate frecuency into an int to do an exact check
+	assert.Equal(t, int64(3), res.Wallets)
-	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
 	assert.Equal(t, float64(0), res.AvgTransactionFee)
 }
 
 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 +1459,128 @@ 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
+	var f64 float64 = 1.2
+	var i64 int64 = 8888
+	addr := ethCommon.HexToAddress("0x1234")
+	hash := ethCommon.HexToHash("0x5678")
+	stateAPI := &StateAPI{
+		NodePublicInfo: NodePublicInfo{
+			ForgeDelay: 3.1,
+		},
+		Network: NetworkAPI{
+			LastEthBlock:  12,
+			LastSyncBlock: 34,
+			LastBatch: &BatchAPI{
+				ItemID:       123,
+				BatchNum:     456,
+				EthBlockNum:  789,
+				EthBlockHash: hash,
+				Timestamp:    time.Now(),
+				ForgerAddr:   addr,
+				// CollectedFeesDB: map[common.TokenID]*big.Int{
+				// 	0: big.NewInt(11111),
+				// 	1: big.NewInt(21111),
+				// 	2: big.NewInt(31111),
+				// },
+				CollectedFeesAPI: apitypes.CollectedFeesAPI(map[common.TokenID]apitypes.BigIntStr{
+					0: apitypes.BigIntStr("11111"),
+					1: apitypes.BigIntStr("21111"),
+					2: apitypes.BigIntStr("31111"),
+				}),
+				TotalFeesUSD:  &f64,
+				StateRoot:     apitypes.BigIntStr("1234"),
+				NumAccounts:   11,
+				ExitRoot:      apitypes.BigIntStr("5678"),
+				ForgeL1TxsNum: &i64,
+				SlotNum:       44,
+				ForgedTxs:     23,
+				TotalItems:    0,
+				FirstItem:     0,
+				LastItem:      0,
+			},
+			CurrentSlot: 22,
+			NextForgers: []NextForgerAPI{
+				{
+					Coordinator: CoordinatorAPI{
+						ItemID:      111,
+						Bidder:      addr,
+						Forger:      addr,
+						EthBlockNum: 566,
+						URL:         "asd",
+						TotalItems:  0,
+						FirstItem:   0,
+						LastItem:    0,
+					},
+					Period: Period{
+						SlotNum:       33,
+						FromBlock:     55,
+						ToBlock:       66,
+						FromTimestamp: time.Now(),
+						ToTimestamp:   time.Now(),
+					},
+				},
+			},
+		},
+		Metrics: MetricsAPI{
+			TransactionsPerBatch: 1.1,
+			TokenAccounts:        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.Network.LastBatch.Timestamp.Unix(),
+		dbStateAPI.Network.LastBatch.Timestamp.Unix())
+	dbStateAPI.Network.LastBatch.Timestamp = stateAPI.Network.LastBatch.Timestamp
+	assert.Equal(t, stateAPI.Network.NextForgers[0].Period.FromTimestamp.Unix(),
+		dbStateAPI.Network.NextForgers[0].Period.FromTimestamp.Unix())
+	dbStateAPI.Network.NextForgers[0].Period.FromTimestamp = stateAPI.Network.NextForgers[0].Period.FromTimestamp
+	assert.Equal(t, stateAPI.Network.NextForgers[0].Period.ToTimestamp.Unix(),
+		dbStateAPI.Network.NextForgers[0].Period.ToTimestamp.Unix())
+	dbStateAPI.Network.NextForgers[0].Period.ToTimestamp = stateAPI.Network.NextForgers[0].Period.ToTimestamp
+	assert.Equal(t, stateAPI, dbStateAPI)
+}

db/historydb/nodeinfo.go

@@ -0,0 +1,173 @@
+package historydb
+
+import (
+	"time"
+
+	ethCommon "github.com/ethereum/go-ethereum/common"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
+	"github.com/hermeznetwork/hermez-node/common"
+	"github.com/hermeznetwork/tracerr"
+	"github.com/russross/meddler"
+)
+
+// 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"`
+	PendingL1Txs  int             `json:"pendingL1Transactions"`
+}
+
+// NodePublicInfo is the configuration and metrics of the node that is exposed via API
+type NodePublicInfo struct {
+	// ForgeDelay in seconds
+	ForgeDelay float64 `json:"forgeDelay"`
+	// PoolLoad amount of transactions in the pool
+	PoolLoad int64 `json:"poolLoad"`
+}
+
+// StateAPI is an object representing the node and network state exposed via the API
+type StateAPI struct {
+	NodePublicInfo    NodePublicInfo           `json:"node"`
+	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
+	MinFeeUSD  float64
+	MaxFeeUSD  float64
+	ForgeDelay float64
+}
+
+// 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 {
+	if stateAPI.Network.LastBatch != nil {
+		stateAPI.Network.LastBatch.CollectedFeesAPI =
+			apitypes.NewCollectedFeesAPI(stateAPI.Network.LastBatch.CollectedFeesDB)
+	}
+	_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

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 	"github.com/iden3/go-merkletree"
@@ -147,6 +147,12 @@ type txWrite struct {
 	Nonce *common.Nonce       `meddler:"nonce"`
 }
 
+// TokenSymbolAndAddr token representation with only Eth addr and symbol
+type TokenSymbolAndAddr struct {
+	Symbol string            `meddler:"symbol"`
+	Addr   ethCommon.Address `meddler:"eth_addr"`
+}
+
 // TokenWithUSD add USD info to common.Token
 type TokenWithUSD struct {
 	ItemID      uint64            `json:"itemId" meddler:"item_id"`
@@ -239,8 +245,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"`
@@ -283,44 +289,35 @@ func (account AccountAPI) MarshalJSON() ([]byte, error) {
 // BatchAPI is a representation of a batch with additional information
 // required by the API, and extracted by joining block table
 type BatchAPI struct {
-	ItemID        uint64                 `json:"itemId" meddler:"item_id"`
+	ItemID           uint64                      `json:"itemId" meddler:"item_id"`
-	BatchNum      common.BatchNum        `json:"batchNum" meddler:"batch_num"`
+	BatchNum         common.BatchNum             `json:"batchNum" meddler:"batch_num"`
-	EthBlockNum   int64                  `json:"ethereumBlockNum" meddler:"eth_block_num"`
+	EthBlockNum      int64                       `json:"ethereumBlockNum" meddler:"eth_block_num"`
-	EthBlockHash  ethCommon.Hash         `json:"ethereumBlockHash" meddler:"hash"`
+	EthBlockHash     ethCommon.Hash              `json:"ethereumBlockHash" meddler:"hash"`
-	Timestamp     time.Time              `json:"timestamp" meddler:"timestamp,utctime"`
+	Timestamp        time.Time                   `json:"timestamp" meddler:"timestamp,utctime"`
-	ForgerAddr    ethCommon.Address      `json:"forgerAddr" meddler:"forger_addr"`
+	ForgerAddr       ethCommon.Address           `json:"forgerAddr" meddler:"forger_addr"`
-	CollectedFees apitypes.CollectedFees `json:"collectedFees" meddler:"fees_collected,json"`
+	CollectedFeesDB  map[common.TokenID]*big.Int `json:"-" meddler:"fees_collected,json"`
-	TotalFeesUSD  *float64               `json:"historicTotalCollectedFeesUSD" meddler:"total_fees_usd"`
+	CollectedFeesAPI apitypes.CollectedFeesAPI   `json:"collectedFees" meddler:"-"`
-	StateRoot     apitypes.BigIntStr     `json:"stateRoot" meddler:"state_root"`
+	TotalFeesUSD     *float64                    `json:"historicTotalCollectedFeesUSD" meddler:"total_fees_usd"`
-	NumAccounts   int                    `json:"numAccounts" meddler:"num_accounts"`
+	StateRoot        apitypes.BigIntStr          `json:"stateRoot" meddler:"state_root"`
-	ExitRoot      apitypes.BigIntStr     `json:"exitRoot" meddler:"exit_root"`
+	NumAccounts      int                         `json:"numAccounts" meddler:"num_accounts"`
-	ForgeL1TxsNum *int64                 `json:"forgeL1TransactionsNum" meddler:"forge_l1_txs_num"`
+	ExitRoot         apitypes.BigIntStr          `json:"exitRoot" meddler:"exit_root"`
-	SlotNum       int64                  `json:"slotNum" meddler:"slot_num"`
+	ForgeL1TxsNum    *int64                      `json:"forgeL1TransactionsNum" meddler:"forge_l1_txs_num"`
-	ForgedTxs     int                    `json:"forgedTransactions" meddler:"forged_txs"`
+	SlotNum          int64                       `json:"slotNum" meddler:"slot_num"`
-	TotalItems    uint64                 `json:"-" meddler:"total_items"`
+	ForgedTxs        int                         `json:"forgedTransactions" meddler:"forged_txs"`
-	FirstItem     uint64                 `json:"-" meddler:"first_item"`
+	TotalItems       uint64                      `json:"-" meddler:"total_items"`
-	LastItem      uint64                 `json:"-" meddler:"last_item"`
+	FirstItem        uint64                      `json:"-" meddler:"first_item"`
+	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"`
+	TokenAccounts          int64   `json:"tokenAccounts"`
-	TotalBJJs             int64   `json:"totalBJJs" meddler:"total_bjjs"`
+	Wallets                int64   `json:"wallets"`
-	AvgTransactionFee     float64 `json:"avgTransactionFee"`
+	AvgTransactionFee      float64 `json:"avgTransactionFee"`
-}
+	EstimatedTimeToForgeL1 float64 `json:"estimatedTimeToForgeL1" meddler:"estimated_time_to_forge_l1"`
-
-// 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 +370,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 +415,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/kvdb/kvdb.go

@@ -316,7 +316,7 @@ func (k *KVDB) ResetFromSynchronizer(batchNum common.BatchNum, synchronizerKVDB
 
 	checkpointPath := path.Join(k.cfg.Path, fmt.Sprintf("%s%d", PathBatchNum, batchNum))
 
-	// copy synchronizer'BatchNumX' to 'BatchNumX'
+	// copy synchronizer 'BatchNumX' to 'BatchNumX'
 	if err := synchronizerKVDB.MakeCheckpointFromTo(batchNum, checkpointPath); err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -458,7 +458,7 @@ func (k *KVDB) CheckpointExists(batchNum common.BatchNum) (bool, error) {
 	if _, err := os.Stat(source); os.IsNotExist(err) {
 		return false, nil
 	} else if err != nil {
-		return false, err
+		return false, tracerr.Wrap(err)
 	}
 	return true, nil
 }
@@ -544,10 +544,12 @@ func (k *KVDB) MakeCheckpointFromTo(fromBatchNum common.BatchNum, dest string) e
 	// synchronizer to the same batchNum
 	k.m.Lock()
 	defer k.m.Unlock()
-	return pebbleMakeCheckpoint(source, dest)
+	return PebbleMakeCheckpoint(source, dest)
 }
 
-func pebbleMakeCheckpoint(source, dest string) error {
+// PebbleMakeCheckpoint is a hepler function to make a pebble checkpoint from
+// source to dest.
+func PebbleMakeCheckpoint(source, dest string) error {
 	// Remove dest folder (if it exists) before doing the checkpoint
 	if _, err := os.Stat(dest); os.IsNotExist(err) {
 	} else if err != nil {

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,58 @@ 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))
+	if feeUSD > l2db.maxFeeUSD {
+		return tracerr.Wrap(fmt.Errorf("tx.feeUSD (%v) > maxFeeUSD (%v)",
+			feeUSD, l2db.maxFeeUSD))
+	}
+
+	// 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 AND NOT external_delete) < $%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 +122,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,13 @@ 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
+	maxFeeUSD    float64
 	apiConnCon   *db.APIConnectionController
 }
 
@@ -32,17 +35,22 @@ 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,
+	maxFeeUSD float64,
 	TTL time.Duration,
 	apiConnCon *db.APIConnectionController,
 ) *L2DB {
 	return &L2DB{
-		db:           db,
+		dbRead:       dbRead,
+		dbWrite:      dbWrite,
 		safetyPeriod: safetyPeriod,
 		ttl:          TTL,
 		maxTxs:       maxTxs,
+		minFeeUSD:    minFeeUSD,
+		maxFeeUSD:    maxFeeUSD,
 		apiConnCon:   apiConnCon,
 	}
 }
@@ -50,12 +58,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,
@@ -63,34 +77,26 @@ func (l2db *L2DB) AddAccountCreationAuth(auth *common.AccountCreationAuth) error
 	return tracerr.Wrap(err)
 }
 
+// AddManyAccountCreationAuth inserts a batch of accounts creation authorization
+// if not exist into the DB
+func (l2db *L2DB) AddManyAccountCreationAuth(auths []common.AccountCreationAuth) error {
+	_, err := sqlx.NamedExec(l2db.dbWrite,
+		`INSERT INTO account_creation_auth (eth_addr, bjj, signature)
+				VALUES (:ethaddr, :bjj, :signature) 
+				ON CONFLICT (eth_addr) DO NOTHING`, auths)
+	return tracerr.Wrap(err)
+}
+
 // GetAccountCreationAuth returns an account creation authorization from the DB
 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 +120,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 +128,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 +171,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 +188,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,8 +206,8 @@ 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",
+		selectPoolTxCommon+"WHERE state = $1 AND NOT external_delete;",
 		common.PoolL2TxStatePending,
 	)
 	return db.SlicePtrsToSlice(txs).([]common.PoolL2Tx), tracerr.Wrap(err)
@@ -218,8 +231,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 +254,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 +276,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 +285,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)
@@ -310,10 +323,10 @@ func (l2db *L2DB) InvalidateOldNonces(updatedAccounts []common.IdxNonce, batchNu
 		return nil
 	}
 	// Fill the batch_num in the query with Sprintf because we are using a
-	// named query which works with slices, and doens't handle an extra
+	// named query which works with slices, and doesn'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 +335,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 +351,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 +367,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, 1000.0, 24*time.Hour, nil)
-	apiConnCon := dbUtils.NewAPICnnectionController(1, time.Second)
+	apiConnCon := dbUtils.NewAPIConnectionController(1, time.Second)
-	l2DBWithACC = NewL2DB(db, 10, 1000, 24*time.Hour, apiConnCon)
+	l2DBWithACC = NewL2DB(db, db, 10, 1000, 0.0, 1000.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.EthAddr, *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,47 @@ 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)
+		assert.Equal(t, auths[i].Signature, auth.Signature)
+		assert.Equal(t, auths[i].Timestamp.Unix(), auths[i].Timestamp.Unix())
+		nameZone, offset := auths[i].Timestamp.Zone()
+		assert.Equal(t, "UTC", nameZone)
+		assert.Equal(t, 0, offset)
+	}
+}
+
+func TestManyAuth(t *testing.T) {
+	test.WipeDB(l2DB.DB())
+	const nAuths = 5
+	chainID := uint16(0)
+	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
+	// Generate authorizations
+	genAuths := test.GenAuths(nAuths, chainID, hermezContractAddr)
+	auths := make([]common.AccountCreationAuth, len(genAuths))
+	// Convert to a non-pointer slice
+	for i := 0; i < len(genAuths); i++ {
+		auths[i] = *genAuths[i]
+	}
+
+	// Add a duplicate one to check the not exist condition
+	err := l2DB.AddAccountCreationAuth(genAuths[0])
+	require.NoError(t, err)
+
+	// Add to the DB
+	err = l2DB.AddManyAccountCreationAuth(auths)
+	require.NoError(t, err)
+
+	// Assert the result
+	for i := 0; i < len(auths); i++ {
+		// Fetch from DB
+		auth, err := l2DB.GetAccountCreationAuth(auths[i].EthAddr)
+		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 +768,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 +804,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

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 )
@@ -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

@@ -1,5 +1,11 @@
 -- +migrate Up
 
+-- NOTE: We use "DECIMAL(78,0)" to encode go *big.Int types.  All the *big.Int
+-- that we deal with represent a value in the SNARK field, which is an integer
+-- of 256 bits.  `log(2**256, 10) = 77.06`: that is, a 256 bit number can have
+-- at most 78 digits, so we use this value to specify the precision in the
+-- PostgreSQL DECIMAL guaranteeing that we will never lose precision.
+
 -- History
 CREATE TABLE block (
     eth_block_num BIGINT PRIMARY KEY,
@@ -22,10 +28,10 @@ CREATE TABLE batch (
     forger_addr BYTEA NOT NULL, -- fake foreign key for coordinator
     fees_collected BYTEA NOT NULL,
     fee_idxs_coordinator BYTEA NOT NULL,
-    state_root BYTEA NOT NULL,
+    state_root DECIMAL(78,0) NOT NULL,
     num_accounts BIGINT NOT NULL,
     last_idx BIGINT NOT NULL,
-    exit_root BYTEA NOT NULL,
+    exit_root DECIMAL(78,0) NOT NULL,
     forge_l1_txs_num BIGINT,
     slot_num BIGINT NOT NULL,
     total_fees_usd NUMERIC
@@ -34,7 +40,7 @@ CREATE TABLE batch (
 CREATE TABLE bid (
     item_id SERIAL PRIMARY KEY,
     slot_num BIGINT NOT NULL,
-    bid_value BYTEA NOT NULL,
+    bid_value DECIMAL(78,0) NOT NULL,
     eth_block_num BIGINT NOT NULL REFERENCES block (eth_block_num) ON DELETE CASCADE,
     bidder_addr BYTEA NOT NULL -- fake foreign key for coordinator
 );
@@ -47,7 +53,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,12 +106,21 @@ 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 DECIMAL(78,0) NOT NULL
+);
+
 CREATE TABLE exit_tree (
     item_id SERIAL PRIMARY KEY,
     batch_num BIGINT REFERENCES batch (batch_num) ON DELETE CASCADE,
     account_idx BIGINT REFERENCES account (idx) ON DELETE CASCADE,
     merkle_proof BYTEA NOT NULL,
-    balance BYTEA NOT NULL,
+    balance DECIMAL(78,0) NOT NULL,
     instant_withdrawn BIGINT REFERENCES block (eth_block_num) ON DELETE SET NULL,
     delayed_withdraw_request BIGINT REFERENCES block (eth_block_num) ON DELETE SET NULL,
     owner BYTEA,
@@ -155,7 +170,7 @@ CREATE TABLE tx (
     to_idx BIGINT NOT NULL,
     to_eth_addr BYTEA,
     to_bjj BYTEA,
-    amount BYTEA NOT NULL,
+    amount DECIMAL(78,0) NOT NULL,
     amount_success BOOLEAN NOT NULL DEFAULT true,
     amount_f NUMERIC NOT NULL,
     token_id INT NOT NULL REFERENCES token (token_id),
@@ -165,7 +180,7 @@ CREATE TABLE tx (
     -- L1
     to_forge_l1_txs_num BIGINT,
     user_origin BOOLEAN,
-    deposit_amount BYTEA,
+    deposit_amount DECIMAL(78,0),
     deposit_amount_success BOOLEAN NOT NULL DEFAULT true,
     deposit_amount_f NUMERIC,
     deposit_amount_usd NUMERIC,
@@ -535,7 +550,7 @@ FOR EACH ROW EXECUTE PROCEDURE forge_l1_user_txs();
 
 CREATE TABLE rollup_vars (
     eth_block_num BIGINT PRIMARY KEY REFERENCES block (eth_block_num) ON DELETE CASCADE,
-    fee_add_token BYTEA NOT NULL,
+    fee_add_token DECIMAL(78,0) NOT NULL,
     forge_l1_timeout BIGINT NOT NULL,
     withdrawal_delay BIGINT NOT NULL,
     buckets BYTEA NOT NULL,
@@ -547,7 +562,7 @@ CREATE TABLE bucket_update (
     eth_block_num BIGINT NOT NULL REFERENCES block (eth_block_num) ON DELETE CASCADE,
     num_bucket BIGINT NOT NULL,
     block_stamp BIGINT NOT NULL,
-    withdrawals BYTEA NOT NULL
+    withdrawals DECIMAL(78,0) NOT NULL
 );
 
 CREATE TABLE token_exchange (
@@ -563,7 +578,7 @@ CREATE TABLE escape_hatch_withdrawal (
     who_addr BYTEA NOT NULL,
     to_addr BYTEA NOT NULL,
     token_addr BYTEA NOT NULL,
-    amount BYTEA NOT NULL
+    amount DECIMAL(78,0) NOT NULL
 );
 
 CREATE TABLE auction_vars (
@@ -601,7 +616,7 @@ CREATE TABLE tx_pool (
     effective_to_eth_addr BYTEA,
     effective_to_bjj BYTEA,
     token_id INT NOT NULL REFERENCES token (token_id) ON DELETE CASCADE,
-    amount BYTEA NOT NULL,
+    amount DECIMAL(78,0) NOT NULL,
     amount_f NUMERIC NOT NULL,
     fee SMALLINT NOT NULL,
     nonce BIGINT NOT NULL,
@@ -615,10 +630,12 @@ CREATE TABLE tx_pool (
     rq_to_eth_addr BYTEA,
     rq_to_bjj BYTEA,
     rq_token_id INT,
-    rq_amount BYTEA,
+    rq_amount DECIMAL(78,0),
     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 +667,57 @@ 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
+
+CREATE VIEW account_state AS SELECT DISTINCT idx,
+first_value(nonce) OVER w AS nonce,
+first_value(balance) OVER w AS balance,
+first_value(eth_block_num) OVER w AS eth_block_num,
+first_value(batch_num) OVER w AS batch_num
+FROM account_update
+window w AS (partition by idx ORDER BY item_id desc);
+
 -- +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
+-- drop views IF EXISTS
-DROP FUNCTION hez_idx;
+DROP VIEW IF EXISTS account_state;
-DROP FUNCTION set_token_usd_update;
+-- functions
-DROP FUNCTION fee_percentage;
+DROP FUNCTION IF EXISTS hez_idx;
-DROP FUNCTION set_tx;
+DROP FUNCTION IF EXISTS set_token_usd_update;
-DROP FUNCTION forge_l1_user_txs;
+DROP FUNCTION IF EXISTS fee_percentage;
-DROP FUNCTION set_pool_tx;
+DROP FUNCTION IF EXISTS set_tx;
--- drop tables
+DROP FUNCTION IF EXISTS forge_l1_user_txs;
-DROP TABLE account_creation_auth;
+DROP FUNCTION IF EXISTS set_pool_tx;
-DROP TABLE tx_pool;
+-- drop tables IF EXISTS
-DROP TABLE auction_vars;
+DROP TABLE IF EXISTS node_info;
-DROP TABLE rollup_vars;
+DROP TABLE IF EXISTS account_creation_auth;
-DROP TABLE escape_hatch_withdrawal;
+DROP TABLE IF EXISTS tx_pool;
-DROP TABLE bucket_update;
+DROP TABLE IF EXISTS auction_vars;
-DROP TABLE token_exchange;
+DROP TABLE IF EXISTS rollup_vars;
-DROP TABLE wdelayer_vars;
+DROP TABLE IF EXISTS escape_hatch_withdrawal;
-DROP TABLE tx;
+DROP TABLE IF EXISTS bucket_update;
-DROP TABLE exit_tree;
+DROP TABLE IF EXISTS token_exchange;
-DROP TABLE account;
+DROP TABLE IF EXISTS wdelayer_vars;
-DROP TABLE token;
+DROP TABLE IF EXISTS tx;
-DROP TABLE bid;
+DROP TABLE IF EXISTS exit_tree;
-DROP TABLE batch;
+DROP TABLE IF EXISTS account_update;
-DROP TABLE coordinator;
+DROP TABLE IF EXISTS account;
-DROP TABLE block;
+DROP TABLE IF EXISTS token;
--- drop sequences
+DROP TABLE IF EXISTS bid;
-DROP SEQUENCE tx_item_id;
+DROP TABLE IF EXISTS batch;
+DROP TABLE IF EXISTS coordinator;
+DROP TABLE IF EXISTS block;
+-- sequences
+DROP SEQUENCE IF EXISTS tx_item_id;

db/statedb/statedb.go

@@ -17,7 +17,8 @@ import (
 var (
 	// ErrStateDBWithoutMT is used when a method that requires a MerkleTree
 	// is called in a StateDB that does not have a MerkleTree defined
-	ErrStateDBWithoutMT = errors.New("Can not call method to use MerkleTree in a StateDB without MerkleTree")
+	ErrStateDBWithoutMT = errors.New(
+		"Can not call method to use MerkleTree in a StateDB without MerkleTree")
 
 	// ErrAccountAlreadyExists is used when CreateAccount is called and the
 	// Account already exists
@@ -28,7 +29,8 @@ var (
 	ErrIdxNotFound = errors.New("Idx can not be found")
 	// ErrGetIdxNoCase is used when trying to get the Idx from EthAddr &
 	// BJJ with not compatible combination
-	ErrGetIdxNoCase = errors.New("Can not get Idx due unexpected combination of ethereum Address & BabyJubJub PublicKey")
+	ErrGetIdxNoCase = errors.New(
+		"Can not get Idx due unexpected combination of ethereum Address & BabyJubJub PublicKey")
 
 	// PrefixKeyIdx is the key prefix for idx in the db
 	PrefixKeyIdx = []byte("i:")
@@ -144,7 +146,8 @@ func NewStateDB(cfg Config) (*StateDB, error) {
 		}
 	}
 	if cfg.Type == TypeTxSelector && cfg.NLevels != 0 {
-		return nil, tracerr.Wrap(fmt.Errorf("invalid StateDB parameters: StateDB type==TypeStateDB can not have nLevels!=0"))
+		return nil, tracerr.Wrap(
+			fmt.Errorf("invalid StateDB parameters: StateDB type==TypeStateDB can not have nLevels!=0"))
 	}
 
 	return &StateDB{
@@ -347,7 +350,8 @@ func GetAccountInTreeDB(sto db.Storage, idx common.Idx) (*common.Account, error)
 // CreateAccount creates a new Account in the StateDB for the given Idx.  If
 // StateDB.MT==nil, MerkleTree is not affected, otherwise updates the
 // MerkleTree, returning a CircomProcessorProof.
-func (s *StateDB) CreateAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
+func (s *StateDB) CreateAccount(idx common.Idx, account *common.Account) (
+	*merkletree.CircomProcessorProof, error) {
 	cpp, err := CreateAccountInTreeDB(s.db.DB(), s.MT, idx, account)
 	if err != nil {
 		return cpp, tracerr.Wrap(err)
@@ -361,7 +365,8 @@ func (s *StateDB) CreateAccount(idx common.Idx, account *common.Account) (*merkl
 // from ExitTree.  Creates a new Account in the StateDB for the given Idx.  If
 // StateDB.MT==nil, MerkleTree is not affected, otherwise updates the
 // MerkleTree, returning a CircomProcessorProof.
-func CreateAccountInTreeDB(sto db.Storage, mt *merkletree.MerkleTree, idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
+func CreateAccountInTreeDB(sto db.Storage, mt *merkletree.MerkleTree, idx common.Idx,
+	account *common.Account) (*merkletree.CircomProcessorProof, error) {
 	// store at the DB the key: v, and value: leaf.Bytes()
 	v, err := account.HashValue()
 	if err != nil {
@@ -410,7 +415,8 @@ func CreateAccountInTreeDB(sto db.Storage, mt *merkletree.MerkleTree, idx common
 // UpdateAccount updates the Account in the StateDB for the given Idx.  If
 // StateDB.mt==nil, MerkleTree is not affected, otherwise updates the
 // MerkleTree, returning a CircomProcessorProof.
-func (s *StateDB) UpdateAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
+func (s *StateDB) UpdateAccount(idx common.Idx, account *common.Account) (
+	*merkletree.CircomProcessorProof, error) {
 	return UpdateAccountInTreeDB(s.db.DB(), s.MT, idx, account)
 }
 
@@ -418,7 +424,8 @@ func (s *StateDB) UpdateAccount(idx common.Idx, account *common.Account) (*merkl
 // from ExitTree.  Updates the Account in the StateDB for the given Idx.  If
 // StateDB.mt==nil, MerkleTree is not affected, otherwise updates the
 // MerkleTree, returning a CircomProcessorProof.
-func UpdateAccountInTreeDB(sto db.Storage, mt *merkletree.MerkleTree, idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
+func UpdateAccountInTreeDB(sto db.Storage, mt *merkletree.MerkleTree, idx common.Idx,
+	account *common.Account) (*merkletree.CircomProcessorProof, error) {
 	// store at the DB the key: v, and value: account.Bytes()
 	v, err := account.HashValue()
 	if err != nil {
@@ -503,7 +510,7 @@ func (l *LocalStateDB) CheckpointExists(batchNum common.BatchNum) (bool, error)
 	return l.db.CheckpointExists(batchNum)
 }
 
-// Reset performs a reset in the LocaStateDB. If fromSynchronizer is true, it
+// Reset performs a reset in the LocalStateDB. If fromSynchronizer is true, it
 // gets the state from LocalStateDB.synchronizerStateDB for the given batchNum.
 // If fromSynchronizer is false, get the state from LocalStateDB checkpoints.
 func (l *LocalStateDB) Reset(batchNum common.BatchNum, fromSynchronizer bool) error {

db/statedb/statedb_test.go

@@ -22,7 +22,8 @@ import (
 
 func newAccount(t *testing.T, i int) *common.Account {
 	var sk babyjub.PrivateKey
-	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	_, err := hex.Decode(sk[:],
+		[]byte("0001020304050607080900010203040506070809000102030405060708090001"))
 	require.NoError(t, err)
 	pk := sk.Public()
 
@@ -371,7 +372,8 @@ func TestCheckpoints(t *testing.T) {
 	dirLocal, err := ioutil.TempDir("", "ldb")
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dirLocal))
-	ldb, err := NewLocalStateDB(Config{Path: dirLocal, Keep: 128, Type: TypeBatchBuilder, NLevels: 32}, sdb)
+	ldb, err := NewLocalStateDB(Config{Path: dirLocal, Keep: 128, Type: TypeBatchBuilder,
+		NLevels: 32}, sdb)
 	require.NoError(t, err)
 
 	// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
@@ -392,7 +394,8 @@ func TestCheckpoints(t *testing.T) {
 	dirLocal2, err := ioutil.TempDir("", "ldb2")
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dirLocal2))
-	ldb2, err := NewLocalStateDB(Config{Path: dirLocal2, Keep: 128, Type: TypeBatchBuilder, NLevels: 32}, sdb)
+	ldb2, err := NewLocalStateDB(Config{Path: dirLocal2, Keep: 128, Type: TypeBatchBuilder,
+		NLevels: 32}, sdb)
 	require.NoError(t, err)
 
 	// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
@@ -471,7 +474,8 @@ func TestCheckAccountsTreeTestVectors(t *testing.T) {
 
 	ay0 := new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(253), nil), big.NewInt(1))
 	// test value from js version (compatibility-canary)
-	assert.Equal(t, "1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", (hex.EncodeToString(ay0.Bytes())))
+	assert.Equal(t, "1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+		(hex.EncodeToString(ay0.Bytes())))
 	bjjPoint0Comp := babyjub.PackSignY(true, ay0)
 	bjj0 := babyjub.PublicKeyComp(bjjPoint0Comp)
 
@@ -530,7 +534,9 @@ func TestCheckAccountsTreeTestVectors(t *testing.T) {
 		require.NoError(t, err)
 	}
 	// root value generated by js version:
-	assert.Equal(t, "17298264051379321456969039521810887093935433569451713402227686942080129181291", sdb.MT.Root().BigInt().String())
+	assert.Equal(t,
+		"13174362770971232417413036794215823584762073355951212910715422236001731746065",
+		sdb.MT.Root().BigInt().String())
 }
 
 // TestListCheckpoints performs almost the same test than kvdb/kvdb_test.go

db/statedb/utils.go

@@ -18,7 +18,8 @@ func concatEthAddrTokenID(addr ethCommon.Address, tokenID common.TokenID) []byte
 	b = append(b[:], tokenID.Bytes()[:]...)
 	return b
 }
-func concatEthAddrBJJTokenID(addr ethCommon.Address, pk babyjub.PublicKeyComp, tokenID common.TokenID) []byte {
+func concatEthAddrBJJTokenID(addr ethCommon.Address, pk babyjub.PublicKeyComp,
+	tokenID common.TokenID) []byte {
 	pkComp := pk
 	var b []byte
 	b = append(b, addr.Bytes()...)
@@ -32,7 +33,8 @@ func concatEthAddrBJJTokenID(addr ethCommon.Address, pk babyjub.PublicKeyComp, t
 // - key: EthAddr & BabyJubJub PublicKey Compressed, value: idx
 // If Idx already exist for the given EthAddr & BJJ, the remaining Idx will be
 // always the smallest one.
-func (s *StateDB) setIdxByEthAddrBJJ(idx common.Idx, addr ethCommon.Address, pk babyjub.PublicKeyComp, tokenID common.TokenID) error {
+func (s *StateDB) setIdxByEthAddrBJJ(idx common.Idx, addr ethCommon.Address,
+	pk babyjub.PublicKeyComp, tokenID common.TokenID) error {
 	oldIdx, err := s.GetIdxByEthAddrBJJ(addr, pk, tokenID)
 	if err == nil {
 		// EthAddr & BJJ already have an Idx
@@ -40,7 +42,8 @@ func (s *StateDB) setIdxByEthAddrBJJ(idx common.Idx, addr ethCommon.Address, pk
 		// if new idx is smaller, store the new one
 		// if new idx is bigger, don't store and return, as the used one will be the old
 		if idx >= oldIdx {
-			log.Debug("StateDB.setIdxByEthAddrBJJ: Idx not stored because there already exist a smaller Idx for the given EthAddr & BJJ")
+			log.Debug("StateDB.setIdxByEthAddrBJJ: Idx not stored because there " +
+				"already exist a smaller Idx for the given EthAddr & BJJ")
 			return nil
 		}
 	}
@@ -80,7 +83,8 @@ func (s *StateDB) setIdxByEthAddrBJJ(idx common.Idx, addr ethCommon.Address, pk
 // GetIdxByEthAddr returns the smallest Idx in the StateDB for the given
 // Ethereum Address. Will return common.Idx(0) and error in case that Idx is
 // not found in the StateDB.
-func (s *StateDB) GetIdxByEthAddr(addr ethCommon.Address, tokenID common.TokenID) (common.Idx, error) {
+func (s *StateDB) GetIdxByEthAddr(addr ethCommon.Address, tokenID common.TokenID) (common.Idx,
+	error) {
 	k := concatEthAddrTokenID(addr, tokenID)
 	b, err := s.db.DB().Get(append(PrefixKeyAddr, k...))
 	if err != nil {
@@ -116,18 +120,22 @@ func (s *StateDB) GetIdxByEthAddrBJJ(addr ethCommon.Address, pk babyjub.PublicKe
 			return common.Idx(0), tracerr.Wrap(ErrIdxNotFound)
 		} else if err != nil {
 			return common.Idx(0),
-				tracerr.Wrap(fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", ErrIdxNotFound, addr.Hex(), pk, tokenID))
+				tracerr.Wrap(fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d",
+					ErrIdxNotFound, addr.Hex(), pk, tokenID))
 		}
 		idx, err := common.IdxFromBytes(b)
 		if err != nil {
 			return common.Idx(0),
-				tracerr.Wrap(fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", err, addr.Hex(), pk, tokenID))
+				tracerr.Wrap(fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d",
+					err, addr.Hex(), pk, tokenID))
 		}
 		return idx, nil
 	}
 	// rest of cases (included case ToEthAddr==0) are not possible
 	return common.Idx(0),
-		tracerr.Wrap(fmt.Errorf("GetIdxByEthAddrBJJ: Not found, %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", ErrGetIdxNoCase, addr.Hex(), pk, tokenID))
+		tracerr.Wrap(
+			fmt.Errorf("GetIdxByEthAddrBJJ: Not found, %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d",
+				ErrGetIdxNoCase, addr.Hex(), pk, tokenID))
 }
 
 // GetTokenIDsFromIdxs returns a map containing the common.TokenID with its
@@ -137,7 +145,9 @@ func (s *StateDB) GetTokenIDsFromIdxs(idxs []common.Idx) (map[common.TokenID]com
 	for i := 0; i < len(idxs); i++ {
 		a, err := s.GetAccount(idxs[i])
 		if err != nil {
-			return nil, tracerr.Wrap(fmt.Errorf("GetTokenIDsFromIdxs error on GetAccount with Idx==%d: %s", idxs[i], err.Error()))
+			return nil,
+				tracerr.Wrap(fmt.Errorf("GetTokenIDsFromIdxs error on GetAccount with Idx==%d: %s",
+					idxs[i], err.Error()))
 		}
 		m[a.TokenID] = idxs[i]
 	}

db/utils.go

@@ -13,9 +13,12 @@ import (
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/jmoiron/sqlx"
-	"github.com/marusama/semaphore/v2"
+
+	//nolint:errcheck // driver for postgres DB
+	_ "github.com/lib/pq"
 	migrate "github.com/rubenv/sql-migrate"
 	"github.com/russross/meddler"
+	"golang.org/x/sync/semaphore"
 )
 
 var migrations *migrate.PackrMigrationSource
@@ -89,14 +92,14 @@ func InitSQLDB(port int, host, user, password, name string) (*sqlx.DB, error) {
 
 // APIConnectionController is used to limit the SQL open connections used by the API
 type APIConnectionController struct {
-	smphr   semaphore.Semaphore
+	smphr   *semaphore.Weighted
 	timeout time.Duration
 }
 
-// NewAPICnnectionController initialize APIConnectionController
+// NewAPIConnectionController initialize APIConnectionController
-func NewAPICnnectionController(maxConnections int, timeout time.Duration) *APIConnectionController {
+func NewAPIConnectionController(maxConnections int, timeout time.Duration) *APIConnectionController {
 	return &APIConnectionController{
-		smphr:   semaphore.New(maxConnections),
+		smphr:   semaphore.NewWeighted(int64(maxConnections)),
 		timeout: timeout,
 	}
 }
@@ -165,7 +168,11 @@ func (b BigIntMeddler) PostRead(fieldPtr, scanTarget interface{}) error {
 		return tracerr.Wrap(fmt.Errorf("BigIntMeddler.PostRead: nil pointer"))
 	}
 	field := fieldPtr.(**big.Int)
-	*field = new(big.Int).SetBytes([]byte(*ptr))
+	var ok bool
+	*field, ok = new(big.Int).SetString(*ptr, 10)
+	if !ok {
+		return tracerr.Wrap(fmt.Errorf("big.Int.SetString failed on \"%v\"", *ptr))
+	}
 	return nil
 }
 
@@ -173,7 +180,7 @@ func (b BigIntMeddler) PostRead(fieldPtr, scanTarget interface{}) error {
 func (b BigIntMeddler) PreWrite(fieldPtr interface{}) (saveValue interface{}, err error) {
 	field := fieldPtr.(*big.Int)
 
-	return field.Bytes(), nil
+	return field.String(), nil
 }
 
 // BigIntNullMeddler encodes or decodes the field value to or from JSON
@@ -198,7 +205,12 @@ func (b BigIntNullMeddler) PostRead(fieldPtr, scanTarget interface{}) error {
 	if ptr == nil {
 		return tracerr.Wrap(fmt.Errorf("BigIntMeddler.PostRead: nil pointer"))
 	}
-	*field = new(big.Int).SetBytes(ptr)
+	var ok bool
+	*field, ok = new(big.Int).SetString(string(ptr), 10)
+	if !ok {
+		return tracerr.Wrap(fmt.Errorf("big.Int.SetString failed on \"%v\"", string(ptr)))
+	}
+
 	return nil
 }
 
@@ -208,7 +220,7 @@ func (b BigIntNullMeddler) PreWrite(fieldPtr interface{}) (saveValue interface{}
 	if field == nil {
 		return nil, nil
 	}
-	return field.Bytes(), nil
+	return field.String(), nil
 }
 
 // SliceToSlicePtrs converts any []Foo to []*Foo

db/utils_test.go

@@ -1,9 +1,13 @@
 package db
 
 import (
+	"math/big"
+	"os"
 	"testing"
 
+	"github.com/russross/meddler"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type foo struct {
@@ -33,3 +37,42 @@ func TestSlicePtrsToSlice(t *testing.T) {
 		assert.Equal(t, *a[i], b[i])
 	}
 }
+
+func TestBigInt(t *testing.T) {
+	pass := os.Getenv("POSTGRES_PASS")
+	db, err := InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
+	require.NoError(t, err)
+	defer func() {
+		_, err := db.Exec("DROP TABLE IF EXISTS test_big_int;")
+		require.NoError(t, err)
+		err = db.Close()
+		require.NoError(t, err)
+	}()
+
+	_, err = db.Exec("DROP TABLE IF EXISTS test_big_int;")
+	require.NoError(t, err)
+
+	_, err = db.Exec(`CREATE TABLE test_big_int (
+		item_id SERIAL PRIMARY KEY,
+		value1 DECIMAL(78, 0) NOT NULL,
+		value2 DECIMAL(78, 0),
+		value3 DECIMAL(78, 0)
+	);`)
+	require.NoError(t, err)
+
+	type Entry struct {
+		ItemID int      `meddler:"item_id"`
+		Value1 *big.Int `meddler:"value1,bigint"`
+		Value2 *big.Int `meddler:"value2,bigintnull"`
+		Value3 *big.Int `meddler:"value3,bigintnull"`
+	}
+
+	entry := Entry{ItemID: 1, Value1: big.NewInt(1234567890), Value2: big.NewInt(9876543210), Value3: nil}
+	err = meddler.Insert(db, "test_big_int", &entry)
+	require.NoError(t, err)
+
+	var dbEntry Entry
+	err = meddler.QueryRow(db, &dbEntry, "SELECT * FROM test_big_int WHERE item_id = 1;")
+	require.NoError(t, err)
+	assert.Equal(t, entry, dbEntry)
+}

eth/auction.go

@@ -70,7 +70,8 @@ type AuctionEventInitialize struct {
 }
 
 // AuctionVariables returns the AuctionVariables from the initialize event
-func (ei *AuctionEventInitialize) AuctionVariables(InitialMinimalBidding *big.Int) *common.AuctionVariables {
+func (ei *AuctionEventInitialize) AuctionVariables(
+	InitialMinimalBidding *big.Int) *common.AuctionVariables {
 	return &common.AuctionVariables{
 		EthBlockNum:        0,
 		DonationAddress:    ei.DonationAddress,
@@ -222,12 +223,15 @@ type AuctionInterface interface {
 	AuctionGetAllocationRatio() ([3]uint16, error)
 	AuctionSetDonationAddress(newDonationAddress ethCommon.Address) (*types.Transaction, error)
 	AuctionGetDonationAddress() (*ethCommon.Address, error)
-	AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address, newBootCoordinatorURL string) (*types.Transaction, error)
+	AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address,
+		newBootCoordinatorURL string) (*types.Transaction, error)
 	AuctionGetBootCoordinator() (*ethCommon.Address, error)
-	AuctionChangeDefaultSlotSetBid(slotSet int64, newInitialMinBid *big.Int) (*types.Transaction, error)
+	AuctionChangeDefaultSlotSetBid(slotSet int64,
+		newInitialMinBid *big.Int) (*types.Transaction, error)
 
 	// Coordinator Management
-	AuctionSetCoordinator(forger ethCommon.Address, coordinatorURL string) (*types.Transaction, error)
+	AuctionSetCoordinator(forger ethCommon.Address, coordinatorURL string) (*types.Transaction,
+		error)
 
 	// Slot Info
 	AuctionGetSlotNumber(blockNum int64) (int64, error)
@@ -237,7 +241,8 @@ type AuctionInterface interface {
 	AuctionGetSlotSet(slot int64) (*big.Int, error)
 
 	// Bidding
-	AuctionBid(amount *big.Int, slot int64, bidAmount *big.Int, deadline *big.Int) (tx *types.Transaction, err error)
+	AuctionBid(amount *big.Int, slot int64, bidAmount *big.Int, deadline *big.Int) (
+		tx *types.Transaction, err error)
 	AuctionMultiBid(amount *big.Int, startingSlot, endingSlot int64, slotSets [6]bool,
 		maxBid, minBid, deadline *big.Int) (tx *types.Transaction, err error)
 
@@ -275,8 +280,10 @@ type AuctionClient struct {
 }
 
 // NewAuctionClient creates a new AuctionClient.  `tokenAddress` is the address of the HEZ tokens.
-func NewAuctionClient(client *EthereumClient, address ethCommon.Address, tokenHEZCfg TokenConfig) (*AuctionClient, error) {
+func NewAuctionClient(client *EthereumClient, address ethCommon.Address,
-	contractAbi, err := abi.JSON(strings.NewReader(string(HermezAuctionProtocol.HermezAuctionProtocolABI)))
+	tokenHEZCfg TokenConfig) (*AuctionClient, error) {
+	contractAbi, err :=
+		abi.JSON(strings.NewReader(string(HermezAuctionProtocol.HermezAuctionProtocolABI)))
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -331,7 +338,8 @@ func (c *AuctionClient) AuctionGetSlotDeadline() (slotDeadline uint8, err error)
 }
 
 // AuctionSetOpenAuctionSlots is the interface to call the smart contract function
-func (c *AuctionClient) AuctionSetOpenAuctionSlots(newOpenAuctionSlots uint16) (tx *types.Transaction, err error) {
+func (c *AuctionClient) AuctionSetOpenAuctionSlots(
+	newOpenAuctionSlots uint16) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -355,7 +363,8 @@ func (c *AuctionClient) AuctionGetOpenAuctionSlots() (openAuctionSlots uint16, e
 }
 
 // AuctionSetClosedAuctionSlots is the interface to call the smart contract function
-func (c *AuctionClient) AuctionSetClosedAuctionSlots(newClosedAuctionSlots uint16) (tx *types.Transaction, err error) {
+func (c *AuctionClient) AuctionSetClosedAuctionSlots(
+	newClosedAuctionSlots uint16) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -379,7 +388,8 @@ func (c *AuctionClient) AuctionGetClosedAuctionSlots() (closedAuctionSlots uint1
 }
 
 // AuctionSetOutbidding is the interface to call the smart contract function
-func (c *AuctionClient) AuctionSetOutbidding(newOutbidding uint16) (tx *types.Transaction, err error) {
+func (c *AuctionClient) AuctionSetOutbidding(newOutbidding uint16) (tx *types.Transaction,
+	err error) {
 	if tx, err = c.client.CallAuth(
 		12500000, //nolint:gomnd
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -403,7 +413,8 @@ func (c *AuctionClient) AuctionGetOutbidding() (outbidding uint16, err error) {
 }
 
 // AuctionSetAllocationRatio is the interface to call the smart contract function
-func (c *AuctionClient) AuctionSetAllocationRatio(newAllocationRatio [3]uint16) (tx *types.Transaction, err error) {
+func (c *AuctionClient) AuctionSetAllocationRatio(
+	newAllocationRatio [3]uint16) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -427,7 +438,8 @@ func (c *AuctionClient) AuctionGetAllocationRatio() (allocationRation [3]uint16,
 }
 
 // AuctionSetDonationAddress is the interface to call the smart contract function
-func (c *AuctionClient) AuctionSetDonationAddress(newDonationAddress ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *AuctionClient) AuctionSetDonationAddress(
+	newDonationAddress ethCommon.Address) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -440,7 +452,8 @@ func (c *AuctionClient) AuctionSetDonationAddress(newDonationAddress ethCommon.A
 }
 
 // AuctionGetDonationAddress is the interface to call the smart contract function
-func (c *AuctionClient) AuctionGetDonationAddress() (donationAddress *ethCommon.Address, err error) {
+func (c *AuctionClient) AuctionGetDonationAddress() (donationAddress *ethCommon.Address,
+	err error) {
 	var _donationAddress ethCommon.Address
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		_donationAddress, err = c.auction.GetDonationAddress(c.opts)
@@ -452,11 +465,13 @@ func (c *AuctionClient) AuctionGetDonationAddress() (donationAddress *ethCommon.
 }
 
 // AuctionSetBootCoordinator is the interface to call the smart contract function
-func (c *AuctionClient) AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address, newBootCoordinatorURL string) (tx *types.Transaction, err error) {
+func (c *AuctionClient) AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address,
+	newBootCoordinatorURL string) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
-			return c.auction.SetBootCoordinator(auth, newBootCoordinator, newBootCoordinatorURL)
+			return c.auction.SetBootCoordinator(auth, newBootCoordinator,
+				newBootCoordinatorURL)
 		},
 	); err != nil {
 		return nil, tracerr.Wrap(fmt.Errorf("Failed setting bootCoordinator: %w", err))
@@ -465,7 +480,8 @@ func (c *AuctionClient) AuctionSetBootCoordinator(newBootCoordinator ethCommon.A
 }
 
 // AuctionGetBootCoordinator is the interface to call the smart contract function
-func (c *AuctionClient) AuctionGetBootCoordinator() (bootCoordinator *ethCommon.Address, err error) {
+func (c *AuctionClient) AuctionGetBootCoordinator() (bootCoordinator *ethCommon.Address,
+	err error) {
 	var _bootCoordinator ethCommon.Address
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		_bootCoordinator, err = c.auction.GetBootCoordinator(c.opts)
@@ -477,7 +493,8 @@ func (c *AuctionClient) AuctionGetBootCoordinator() (bootCoordinator *ethCommon.
 }
 
 // AuctionChangeDefaultSlotSetBid is the interface to call the smart contract function
-func (c *AuctionClient) AuctionChangeDefaultSlotSetBid(slotSet int64, newInitialMinBid *big.Int) (tx *types.Transaction, err error) {
+func (c *AuctionClient) AuctionChangeDefaultSlotSetBid(slotSet int64,
+	newInitialMinBid *big.Int) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -491,7 +508,8 @@ func (c *AuctionClient) AuctionChangeDefaultSlotSetBid(slotSet int64, newInitial
 }
 
 // AuctionGetClaimableHEZ is the interface to call the smart contract function
-func (c *AuctionClient) AuctionGetClaimableHEZ(claimAddress ethCommon.Address) (claimableHEZ *big.Int, err error) {
+func (c *AuctionClient) AuctionGetClaimableHEZ(
+	claimAddress ethCommon.Address) (claimableHEZ *big.Int, err error) {
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		claimableHEZ, err = c.auction.GetClaimableHEZ(c.opts, claimAddress)
 		return tracerr.Wrap(err)
@@ -502,7 +520,8 @@ func (c *AuctionClient) AuctionGetClaimableHEZ(claimAddress ethCommon.Address) (
 }
 
 // AuctionSetCoordinator is the interface to call the smart contract function
-func (c *AuctionClient) AuctionSetCoordinator(forger ethCommon.Address, coordinatorURL string) (tx *types.Transaction, err error) {
+func (c *AuctionClient) AuctionSetCoordinator(forger ethCommon.Address,
+	coordinatorURL string) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -551,7 +570,8 @@ func (c *AuctionClient) AuctionGetSlotSet(slot int64) (slotSet *big.Int, err err
 }
 
 // AuctionGetDefaultSlotSetBid is the interface to call the smart contract function
-func (c *AuctionClient) AuctionGetDefaultSlotSetBid(slotSet uint8) (minBidSlotSet *big.Int, err error) {
+func (c *AuctionClient) AuctionGetDefaultSlotSetBid(slotSet uint8) (minBidSlotSet *big.Int,
+	err error) {
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		minBidSlotSet, err = c.auction.GetDefaultSlotSetBid(c.opts, slotSet)
 		return tracerr.Wrap(err)
@@ -574,7 +594,8 @@ func (c *AuctionClient) AuctionGetSlotNumber(blockNum int64) (slot int64, err er
 }
 
 // AuctionBid is the interface to call the smart contract function
-func (c *AuctionClient) AuctionBid(amount *big.Int, slot int64, bidAmount *big.Int, deadline *big.Int) (tx *types.Transaction, err error) {
+func (c *AuctionClient) AuctionBid(amount *big.Int, slot int64, bidAmount *big.Int,
+	deadline *big.Int) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -586,7 +607,8 @@ func (c *AuctionClient) AuctionBid(amount *big.Int, slot int64, bidAmount *big.I
 			}
 			tokenName := c.tokenHEZCfg.Name
 			tokenAddr := c.tokenHEZCfg.Address
-			digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID, amount, nonce, deadline, tokenName)
+			digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID,
+				amount, nonce, deadline, tokenName)
 			signature, _ := c.client.ks.SignHash(*c.client.account, digest)
 			permit := createPermit(owner, spender, amount, deadline, digest, signature)
 			_slot := big.NewInt(slot)
@@ -599,8 +621,8 @@ func (c *AuctionClient) AuctionBid(amount *big.Int, slot int64, bidAmount *big.I
 }
 
 // AuctionMultiBid is the interface to call the smart contract function
-func (c *AuctionClient) AuctionMultiBid(amount *big.Int, startingSlot, endingSlot int64, slotSets [6]bool,
+func (c *AuctionClient) AuctionMultiBid(amount *big.Int, startingSlot, endingSlot int64,
-	maxBid, minBid, deadline *big.Int) (tx *types.Transaction, err error) {
+	slotSets [6]bool, maxBid, minBid, deadline *big.Int) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		1000000, //nolint:gomnd
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -613,12 +635,14 @@ func (c *AuctionClient) AuctionMultiBid(amount *big.Int, startingSlot, endingSlo
 			tokenName := c.tokenHEZCfg.Name
 			tokenAddr := c.tokenHEZCfg.Address
 
-			digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID, amount, nonce, deadline, tokenName)
+			digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID,
+				amount, nonce, deadline, tokenName)
 			signature, _ := c.client.ks.SignHash(*c.client.account, digest)
 			permit := createPermit(owner, spender, amount, deadline, digest, signature)
 			_startingSlot := big.NewInt(startingSlot)
 			_endingSlot := big.NewInt(endingSlot)
-			return c.auction.ProcessMultiBid(auth, amount, _startingSlot, _endingSlot, slotSets, maxBid, minBid, permit)
+			return c.auction.ProcessMultiBid(auth, amount, _startingSlot, _endingSlot,
+				slotSets, maxBid, minBid, permit)
 		},
 	); err != nil {
 		return nil, tracerr.Wrap(fmt.Errorf("Failed multibid: %w", err))
@@ -627,7 +651,8 @@ func (c *AuctionClient) AuctionMultiBid(amount *big.Int, startingSlot, endingSlo
 }
 
 // AuctionCanForge is the interface to call the smart contract function
-func (c *AuctionClient) AuctionCanForge(forger ethCommon.Address, blockNum int64) (canForge bool, err error) {
+func (c *AuctionClient) AuctionCanForge(forger ethCommon.Address, blockNum int64) (canForge bool,
+	err error) {
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		canForge, err = c.auction.CanForge(c.opts, forger, big.NewInt(blockNum))
 		return tracerr.Wrap(err)
@@ -680,7 +705,8 @@ func (c *AuctionClient) AuctionConstants() (auctionConstants *common.AuctionCons
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
-		auctionConstants.InitialMinimalBidding, err = c.auction.INITIALMINIMALBIDDING(c.opts)
+		auctionConstants.InitialMinimalBidding, err =
+			c.auction.INITIALMINIMALBIDDING(c.opts)
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
@@ -751,21 +777,35 @@ func (c *AuctionClient) AuctionVariables() (auctionVariables *common.AuctionVari
 }
 
 var (
-	logAuctionNewBid                = crypto.Keccak256Hash([]byte("NewBid(uint128,uint128,address)"))
+	logAuctionNewBid = crypto.Keccak256Hash([]byte(
-	logAuctionNewSlotDeadline       = crypto.Keccak256Hash([]byte("NewSlotDeadline(uint8)"))
+		"NewBid(uint128,uint128,address)"))
-	logAuctionNewClosedAuctionSlots = crypto.Keccak256Hash([]byte("NewClosedAuctionSlots(uint16)"))
+	logAuctionNewSlotDeadline = crypto.Keccak256Hash([]byte(
-	logAuctionNewOutbidding         = crypto.Keccak256Hash([]byte("NewOutbidding(uint16)"))
+		"NewSlotDeadline(uint8)"))
-	logAuctionNewDonationAddress    = crypto.Keccak256Hash([]byte("NewDonationAddress(address)"))
+	logAuctionNewClosedAuctionSlots = crypto.Keccak256Hash([]byte(
-	logAuctionNewBootCoordinator    = crypto.Keccak256Hash([]byte("NewBootCoordinator(address,string)"))
+		"NewClosedAuctionSlots(uint16)"))
-	logAuctionNewOpenAuctionSlots   = crypto.Keccak256Hash([]byte("NewOpenAuctionSlots(uint16)"))
+	logAuctionNewOutbidding = crypto.Keccak256Hash([]byte(
-	logAuctionNewAllocationRatio    = crypto.Keccak256Hash([]byte("NewAllocationRatio(uint16[3])"))
+		"NewOutbidding(uint16)"))
-	logAuctionSetCoordinator        = crypto.Keccak256Hash([]byte("SetCoordinator(address,address,string)"))
+	logAuctionNewDonationAddress = crypto.Keccak256Hash([]byte(
-	logAuctionNewForgeAllocated     = crypto.Keccak256Hash([]byte("NewForgeAllocated(address,address,uint128,uint128,uint128,uint128)"))
+		"NewDonationAddress(address)"))
-	logAuctionNewDefaultSlotSetBid  = crypto.Keccak256Hash([]byte("NewDefaultSlotSetBid(uint128,uint128)"))
+	logAuctionNewBootCoordinator = crypto.Keccak256Hash([]byte(
-	logAuctionNewForge              = crypto.Keccak256Hash([]byte("NewForge(address,uint128)"))
+		"NewBootCoordinator(address,string)"))
-	logAuctionHEZClaimed            = crypto.Keccak256Hash([]byte("HEZClaimed(address,uint128)"))
+	logAuctionNewOpenAuctionSlots = crypto.Keccak256Hash([]byte(
-	logAuctionInitialize            = crypto.Keccak256Hash([]byte(
+		"NewOpenAuctionSlots(uint16)"))
-		"InitializeHermezAuctionProtocolEvent(address,address,string,uint16,uint8,uint16,uint16,uint16[3])"))
+	logAuctionNewAllocationRatio = crypto.Keccak256Hash([]byte(
+		"NewAllocationRatio(uint16[3])"))
+	logAuctionSetCoordinator = crypto.Keccak256Hash([]byte(
+		"SetCoordinator(address,address,string)"))
+	logAuctionNewForgeAllocated = crypto.Keccak256Hash([]byte(
+		"NewForgeAllocated(address,address,uint128,uint128,uint128,uint128)"))
+	logAuctionNewDefaultSlotSetBid = crypto.Keccak256Hash([]byte(
+		"NewDefaultSlotSetBid(uint128,uint128)"))
+	logAuctionNewForge = crypto.Keccak256Hash([]byte(
+		"NewForge(address,uint128)"))
+	logAuctionHEZClaimed = crypto.Keccak256Hash([]byte(
+		"HEZClaimed(address,uint128)"))
+	logAuctionInitialize = crypto.Keccak256Hash([]byte(
+		"InitializeHermezAuctionProtocolEvent(address,address,string," +
+			"uint16,uint8,uint16,uint16,uint16[3])"))
 )
 
 // AuctionEventInit returns the initialize event with its corresponding block number
@@ -781,7 +821,8 @@ func (c *AuctionClient) AuctionEventInit() (*AuctionEventInitialize, int64, erro
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(logs) != 1 {
-		return nil, 0, tracerr.Wrap(fmt.Errorf("no event of type InitializeHermezAuctionProtocolEvent found"))
+		return nil, 0,
+			tracerr.Wrap(fmt.Errorf("no event of type InitializeHermezAuctionProtocolEvent found"))
 	}
 	vLog := logs[0]
 	if vLog.Topics[0] != logAuctionInitialize {
@@ -829,7 +870,8 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 
 	for _, vLog := range logs {
 		if blockHash != nil && vLog.BlockHash != *blockHash {
-			log.Errorw("Block hash mismatch", "expected", blockHash.String(), "got", vLog.BlockHash.String())
+			log.Errorw("Block hash mismatch", "expected", blockHash.String(), "got",
+				vLog.BlockHash.String())
 			return nil, tracerr.Wrap(ErrBlockHashMismatchEvent)
 		}
 		switch vLog.Topics[0] {
@@ -840,7 +882,8 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 				Address   ethCommon.Address
 			}
 			var newBid AuctionEventNewBid
-			if err := c.contractAbi.UnpackIntoInterface(&auxNewBid, "NewBid", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&auxNewBid, "NewBid",
+				vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			newBid.BidAmount = auxNewBid.BidAmount
@@ -849,48 +892,60 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 			auctionEvents.NewBid = append(auctionEvents.NewBid, newBid)
 		case logAuctionNewSlotDeadline:
 			var newSlotDeadline AuctionEventNewSlotDeadline
-			if err := c.contractAbi.UnpackIntoInterface(&newSlotDeadline, "NewSlotDeadline", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newSlotDeadline,
+				"NewSlotDeadline", vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewSlotDeadline = append(auctionEvents.NewSlotDeadline, newSlotDeadline)
 		case logAuctionNewClosedAuctionSlots:
 			var newClosedAuctionSlots AuctionEventNewClosedAuctionSlots
-			if err := c.contractAbi.UnpackIntoInterface(&newClosedAuctionSlots, "NewClosedAuctionSlots", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newClosedAuctionSlots,
+				"NewClosedAuctionSlots", vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			auctionEvents.NewClosedAuctionSlots = append(auctionEvents.NewClosedAuctionSlots, newClosedAuctionSlots)
+			auctionEvents.NewClosedAuctionSlots =
+				append(auctionEvents.NewClosedAuctionSlots, newClosedAuctionSlots)
 		case logAuctionNewOutbidding:
 			var newOutbidding AuctionEventNewOutbidding
-			if err := c.contractAbi.UnpackIntoInterface(&newOutbidding, "NewOutbidding", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newOutbidding, "NewOutbidding",
+				vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewOutbidding = append(auctionEvents.NewOutbidding, newOutbidding)
 		case logAuctionNewDonationAddress:
 			var newDonationAddress AuctionEventNewDonationAddress
 			newDonationAddress.NewDonationAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
-			auctionEvents.NewDonationAddress = append(auctionEvents.NewDonationAddress, newDonationAddress)
+			auctionEvents.NewDonationAddress = append(auctionEvents.NewDonationAddress,
+				newDonationAddress)
 		case logAuctionNewBootCoordinator:
 			var newBootCoordinator AuctionEventNewBootCoordinator
-			if err := c.contractAbi.UnpackIntoInterface(&newBootCoordinator, "NewBootCoordinator", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newBootCoordinator,
+				"NewBootCoordinator", vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			newBootCoordinator.NewBootCoordinator = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
-			auctionEvents.NewBootCoordinator = append(auctionEvents.NewBootCoordinator, newBootCoordinator)
+			auctionEvents.NewBootCoordinator = append(auctionEvents.NewBootCoordinator,
+				newBootCoordinator)
 		case logAuctionNewOpenAuctionSlots:
 			var newOpenAuctionSlots AuctionEventNewOpenAuctionSlots
-			if err := c.contractAbi.UnpackIntoInterface(&newOpenAuctionSlots, "NewOpenAuctionSlots", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newOpenAuctionSlots,
+				"NewOpenAuctionSlots", vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			auctionEvents.NewOpenAuctionSlots = append(auctionEvents.NewOpenAuctionSlots, newOpenAuctionSlots)
+			auctionEvents.NewOpenAuctionSlots =
+				append(auctionEvents.NewOpenAuctionSlots, newOpenAuctionSlots)
 		case logAuctionNewAllocationRatio:
 			var newAllocationRatio AuctionEventNewAllocationRatio
-			if err := c.contractAbi.UnpackIntoInterface(&newAllocationRatio, "NewAllocationRatio", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newAllocationRatio,
+				"NewAllocationRatio", vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			auctionEvents.NewAllocationRatio = append(auctionEvents.NewAllocationRatio, newAllocationRatio)
+			auctionEvents.NewAllocationRatio = append(auctionEvents.NewAllocationRatio,
+				newAllocationRatio)
 		case logAuctionSetCoordinator:
 			var setCoordinator AuctionEventSetCoordinator
-			if err := c.contractAbi.UnpackIntoInterface(&setCoordinator, "SetCoordinator", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&setCoordinator,
+				"SetCoordinator", vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			setCoordinator.BidderAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
@@ -898,25 +953,29 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 			auctionEvents.SetCoordinator = append(auctionEvents.SetCoordinator, setCoordinator)
 		case logAuctionNewForgeAllocated:
 			var newForgeAllocated AuctionEventNewForgeAllocated
-			if err := c.contractAbi.UnpackIntoInterface(&newForgeAllocated, "NewForgeAllocated", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newForgeAllocated,
+				"NewForgeAllocated", vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			newForgeAllocated.Bidder = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			newForgeAllocated.Forger = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
 			newForgeAllocated.SlotToForge = new(big.Int).SetBytes(vLog.Topics[3][:]).Int64()
-			auctionEvents.NewForgeAllocated = append(auctionEvents.NewForgeAllocated, newForgeAllocated)
+			auctionEvents.NewForgeAllocated = append(auctionEvents.NewForgeAllocated,
+				newForgeAllocated)
 		case logAuctionNewDefaultSlotSetBid:
 			var auxNewDefaultSlotSetBid struct {
 				SlotSet          *big.Int
 				NewInitialMinBid *big.Int
 			}
 			var newDefaultSlotSetBid AuctionEventNewDefaultSlotSetBid
-			if err := c.contractAbi.UnpackIntoInterface(&auxNewDefaultSlotSetBid, "NewDefaultSlotSetBid", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&auxNewDefaultSlotSetBid,
+				"NewDefaultSlotSetBid", vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			newDefaultSlotSetBid.NewInitialMinBid = auxNewDefaultSlotSetBid.NewInitialMinBid
 			newDefaultSlotSetBid.SlotSet = auxNewDefaultSlotSetBid.SlotSet.Int64()
-			auctionEvents.NewDefaultSlotSetBid = append(auctionEvents.NewDefaultSlotSetBid, newDefaultSlotSetBid)
+			auctionEvents.NewDefaultSlotSetBid =
+				append(auctionEvents.NewDefaultSlotSetBid, newDefaultSlotSetBid)
 		case logAuctionNewForge:
 			var newForge AuctionEventNewForge
 			newForge.Forger = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
@@ -924,7 +983,8 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 			auctionEvents.NewForge = append(auctionEvents.NewForge, newForge)
 		case logAuctionHEZClaimed:
 			var HEZClaimed AuctionEventHEZClaimed
-			if err := c.contractAbi.UnpackIntoInterface(&HEZClaimed, "HEZClaimed", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&HEZClaimed, "HEZClaimed",
+				vLog.Data); err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			HEZClaimed.Owner = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())

eth/auction_test.go

@@ -58,7 +58,8 @@ func TestAuctionConstants(t *testing.T) {
 func TestAuctionVariables(t *testing.T) {
 	INITMINBID := new(big.Int)
 	INITMINBID.SetString(minBidStr, 10)
-	defaultSlotSetBid := [6]*big.Int{INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID}
+	defaultSlotSetBid := [6]*big.Int{INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID,
+		INITMINBID}
 
 	auctionVariables, err := auctionClientTest.AuctionVariables()
 	require.Nil(t, err)
@@ -132,7 +133,8 @@ func TestAuctionSetClosedAuctionSlots(t *testing.T) {
 	require.Nil(t, err)
 	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
 	require.Nil(t, err)
-	assert.Equal(t, newClosedAuctionSlots, auctionEvents.NewClosedAuctionSlots[0].NewClosedAuctionSlots)
+	assert.Equal(t, newClosedAuctionSlots,
+		auctionEvents.NewClosedAuctionSlots[0].NewClosedAuctionSlots)
 	_, err = auctionClientTest.AuctionSetClosedAuctionSlots(closedAuctionSlots)
 	require.Nil(t, err)
 }
@@ -228,7 +230,8 @@ func TestAuctionSetBootCoordinator(t *testing.T) {
 	require.Nil(t, err)
 	assert.Equal(t, newBootCoordinator, auctionEvents.NewBootCoordinator[0].NewBootCoordinator)
 	assert.Equal(t, newBootCoordinatorURL, auctionEvents.NewBootCoordinator[0].NewBootCoordinatorURL)
-	_, err = auctionClientTest.AuctionSetBootCoordinator(bootCoordinatorAddressConst, bootCoordinatorURL)
+	_, err = auctionClientTest.AuctionSetBootCoordinator(bootCoordinatorAddressConst,
+		bootCoordinatorURL)
 	require.Nil(t, err)
 }
 
@@ -342,7 +345,8 @@ func TestAuctionMultiBid(t *testing.T) {
 	budget := new(big.Int)
 	budget.SetString("45200000000000000000", 10)
 	bidderAddress := governanceAddressConst
-	_, err = auctionClientTest.AuctionMultiBid(budget, currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, deadline)
+	_, err = auctionClientTest.AuctionMultiBid(budget, currentSlot+4, currentSlot+10, slotSet,
+		maxBid, minBid, deadline)
 	require.Nil(t, err)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
@@ -383,7 +387,8 @@ func TestAuctionClaimHEZ(t *testing.T) {
 }
 
 func TestAuctionForge(t *testing.T) {
-	auctionClientTestHermez, err := NewAuctionClient(ethereumClientHermez, auctionTestAddressConst, tokenHEZ)
+	auctionClientTestHermez, err := NewAuctionClient(ethereumClientHermez,
+		auctionTestAddressConst, tokenHEZ)
 	require.Nil(t, err)
 	slotConst := 4
 	blockNum := int64(int(blocksPerSlot)*slotConst + int(genesisBlock))

eth/client.go

@@ -64,16 +64,19 @@ type ClientConfig struct {
 }
 
 // NewClient creates a new Client to interact with Ethereum and the Hermez smart contracts.
-func NewClient(client *ethclient.Client, account *accounts.Account, ks *ethKeystore.KeyStore, cfg *ClientConfig) (*Client, error) {
+func NewClient(client *ethclient.Client, account *accounts.Account, ks *ethKeystore.KeyStore,
+	cfg *ClientConfig) (*Client, error) {
 	ethereumClient, err := NewEthereumClient(client, account, ks, &cfg.Ethereum)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	auctionClient, err := NewAuctionClient(ethereumClient, cfg.Auction.Address, cfg.Auction.TokenHEZ)
+	auctionClient, err := NewAuctionClient(ethereumClient, cfg.Auction.Address,
+		cfg.Auction.TokenHEZ)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	rollupClient, err := NewRollupClient(ethereumClient, cfg.Rollup.Address, cfg.Auction.TokenHEZ)
+	rollupClient, err := NewRollupClient(ethereumClient, cfg.Rollup.Address,
+		cfg.Auction.TokenHEZ)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}

eth/ethereum.go

@@ -64,7 +64,8 @@ type EthereumConfig struct {
 	GasPriceDiv  uint64
 }
 
-// EthereumClient is an ethereum client to call Smart Contract methods and check blockchain information.
+// EthereumClient is an ethereum client to call Smart Contract methods and check blockchain
+// information.
 type EthereumClient struct {
 	client  *ethclient.Client
 	chainID *big.Int
@@ -76,7 +77,8 @@ type EthereumClient struct {
 
 // NewEthereumClient creates a EthereumClient instance.  The account is not mandatory (it can
 // be nil).  If the account is nil, CallAuth will fail with ErrAccountNil.
-func NewEthereumClient(client *ethclient.Client, account *accounts.Account, ks *ethKeystore.KeyStore, config *EthereumConfig) (*EthereumClient, error) {
+func NewEthereumClient(client *ethclient.Client, account *accounts.Account,
+	ks *ethKeystore.KeyStore, config *EthereumConfig) (*EthereumClient, error) {
 	if config == nil {
 		config = &EthereumConfig{
 			CallGasLimit: defaultCallGasLimit,
@@ -166,7 +168,8 @@ func (c *EthereumClient) NewAuth() (*bind.TransactOpts, error) {
 // This call requires a valid account with Ether that can be spend during the
 // call.
 func (c *EthereumClient) CallAuth(gasLimit uint64,
-	fn func(*ethclient.Client, *bind.TransactOpts) (*types.Transaction, error)) (*types.Transaction, error) {
+	fn func(*ethclient.Client, *bind.TransactOpts) (*types.Transaction, error)) (*types.Transaction,
+	error) {
 	if c.account == nil {
 		return nil, tracerr.Wrap(ErrAccountNil)
 	}
@@ -212,7 +215,8 @@ func (c *EthereumClient) Call(fn func(*ethclient.Client) error) error {
 }
 
 // EthTransactionReceipt returns the transaction receipt of the given txHash
-func (c *EthereumClient) EthTransactionReceipt(ctx context.Context, txHash ethCommon.Hash) (*types.Receipt, error) {
+func (c *EthereumClient) EthTransactionReceipt(ctx context.Context,
+	txHash ethCommon.Hash) (*types.Receipt, error) {
 	return c.client.TransactionReceipt(ctx, txHash)
 }
 
@@ -228,13 +232,15 @@ func (c *EthereumClient) EthLastBlock() (int64, error) {
 }
 
 // EthHeaderByNumber internally calls ethclient.Client HeaderByNumber
-// func (c *EthereumClient) EthHeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
+// func (c *EthereumClient) EthHeaderByNumber(ctx context.Context, number *big.Int) (*types.Header,
+// 	error) {
 // 	return c.client.HeaderByNumber(ctx, number)
 // }
 
 // EthBlockByNumber internally calls ethclient.Client BlockByNumber and returns
 // *common.Block.  If number == -1, the latests known block is returned.
-func (c *EthereumClient) EthBlockByNumber(ctx context.Context, number int64) (*common.Block, error) {
+func (c *EthereumClient) EthBlockByNumber(ctx context.Context, number int64) (*common.Block,
+	error) {
 	blockNum := big.NewInt(number)
 	if number == -1 {
 		blockNum = nil
@@ -324,5 +330,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/helpers.go

@@ -14,7 +14,8 @@ import (
 func addBlock(url string) {
 	method := "POST"
 
-	payload := strings.NewReader("{\n    \"jsonrpc\":\"2.0\",\n    \"method\":\"evm_mine\",\n    \"params\":[],\n    \"id\":1\n}")
+	payload := strings.NewReader(
+		"{\n    \"jsonrpc\":\"2.0\",\n    \"method\":\"evm_mine\",\n    \"params\":[],\n    \"id\":1\n}")
 
 	client := &http.Client{}
 	req, err := http.NewRequest(method, url, payload)
@@ -45,7 +46,9 @@ func addTime(seconds float64, url string) {
 	secondsStr := strconv.FormatFloat(seconds, 'E', -1, 32)
 
 	method := "POST"
-	payload := strings.NewReader("{\n    \"jsonrpc\":\"2.0\",\n    \"method\":\"evm_increaseTime\",\n    \"params\":[" + secondsStr + "],\n    \"id\":1\n}")
+	payload := strings.NewReader(
+		"{\n    \"jsonrpc\":\"2.0\",\n    \"method\":\"evm_increaseTime\",\n    \"params\":[" +
+			secondsStr + "],\n    \"id\":1\n}")
 
 	client := &http.Client{}
 	req, err := http.NewRequest(method, url, payload)
@@ -66,13 +69,16 @@ func addTime(seconds float64, url string) {
 	}()
 }
 
-func createPermitDigest(tokenAddr, owner, spender ethCommon.Address, chainID, value, nonce, deadline *big.Int, tokenName string) ([]byte, error) {
+func createPermitDigest(tokenAddr, owner, spender ethCommon.Address, chainID, value, nonce,
+	deadline *big.Int, tokenName string) ([]byte, error) {
 	// NOTE: We ignore hash.Write errors because we are writing to a memory
 	// buffer and don't expect any errors to occur.
-	abiPermit := []byte("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")
+	abiPermit :=
+		[]byte("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")
 	hashPermit := sha3.NewLegacyKeccak256()
 	hashPermit.Write(abiPermit) //nolint:errcheck,gosec
-	abiEIP712Domain := []byte("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
+	abiEIP712Domain :=
+		[]byte("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
 	hashEIP712Domain := sha3.NewLegacyKeccak256()
 	hashEIP712Domain.Write(abiEIP712Domain) //nolint:errcheck,gosec
 	var encodeBytes []byte
@@ -124,7 +130,8 @@ func createPermitDigest(tokenAddr, owner, spender ethCommon.Address, chainID, va
 	return hashBytes2.Sum(nil), nil
 }
 
-func createPermit(owner, spender ethCommon.Address, amount, deadline *big.Int, digest, signature []byte) []byte {
+func createPermit(owner, spender ethCommon.Address, amount, deadline *big.Int, digest,
+	signature []byte) []byte {
 	r := signature[0:32]
 	s := signature[32:64]
 	v := signature[64] + byte(27) //nolint:gomnd

eth/main_test.go

@@ -26,7 +26,8 @@ var (
 	mnemonic         = "explain tackle mirror kit van hammer degree position ginger unfair soup bonus"
 )
 
-func genAcc(w *hdwallet.Wallet, ks *keystore.KeyStore, i int) (*accounts.Account, ethCommon.Address) {
+func genAcc(w *hdwallet.Wallet, ks *keystore.KeyStore, i int) (*accounts.Account,
+	ethCommon.Address) {
 	path := hdwallet.MustParseDerivationPath(fmt.Sprintf("m/44'/60'/0'/0/%d", i))
 	account, err := w.Derive(path, false)
 	if err != nil {
@@ -111,7 +112,9 @@ func getEnvVariables() {
 	if err != nil {
 		log.Fatal(errEnvVar)
 	}
-	if auctionAddressStr == "" || auctionTestAddressStr == "" || tokenHEZAddressStr == "" || hermezRollupAddressStr == "" || wdelayerAddressStr == "" || wdelayerTestAddressStr == "" || genesisBlockEnv == "" {
+	if auctionAddressStr == "" || auctionTestAddressStr == "" || tokenHEZAddressStr == "" ||
+		hermezRollupAddressStr == "" || wdelayerAddressStr == "" || wdelayerTestAddressStr == "" ||
+		genesisBlockEnv == "" {
 		log.Fatal(errEnvVar)
 	}
 
@@ -189,7 +192,8 @@ func TestMain(m *testing.M) {
 			log.Fatal(err)
 		}
 
-		ethereumClientEmergencyCouncil, err = NewEthereumClient(ethClient, emergencyCouncilAccount, ks, nil)
+		ethereumClientEmergencyCouncil, err = NewEthereumClient(ethClient,
+			emergencyCouncilAccount, ks, nil)
 		if err != nil {
 			log.Fatal(err)
 		}

eth/rollup.go

@@ -243,13 +243,20 @@ type RollupInterface interface {
 	// Public Functions
 
 	RollupForgeBatch(*RollupForgeBatchArgs, *bind.TransactOpts) (*types.Transaction, error)
-	RollupAddToken(tokenAddress ethCommon.Address, feeAddToken, deadline *big.Int) (*types.Transaction, error)
+	RollupAddToken(tokenAddress ethCommon.Address, feeAddToken,
+		deadline *big.Int) (*types.Transaction, error)
 
-	RollupWithdrawMerkleProof(babyPubKey babyjub.PublicKeyComp, tokenID uint32, numExitRoot, idx int64, amount *big.Int, siblings []*big.Int, instantWithdraw bool) (*types.Transaction, error)
+	RollupWithdrawMerkleProof(babyPubKey babyjub.PublicKeyComp, tokenID uint32, numExitRoot,
-	RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int, tokenID uint32, numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction, error)
+		idx int64, amount *big.Int, siblings []*big.Int, instantWithdraw bool) (*types.Transaction,
+		error)
+	RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int, tokenID uint32,
+		numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction, error)
 
-	RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error)
+	RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int,
-	RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64, deadline *big.Int) (tx *types.Transaction, err error)
+		amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error)
+	RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp, fromIdx int64,
+		depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64,
+		deadline *big.Int) (tx *types.Transaction, err error)
 
 	// Governance Public Functions
 	RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout int64) (*types.Transaction, error)
@@ -287,7 +294,8 @@ type RollupClient struct {
 }
 
 // NewRollupClient creates a new RollupClient
-func NewRollupClient(client *EthereumClient, address ethCommon.Address, tokenHEZCfg TokenConfig) (*RollupClient, error) {
+func NewRollupClient(client *EthereumClient, address ethCommon.Address,
+	tokenHEZCfg TokenConfig) (*RollupClient, error) {
 	contractAbi, err := abi.JSON(strings.NewReader(string(Hermez.HermezABI)))
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -316,18 +324,19 @@ func NewRollupClient(client *EthereumClient, address ethCommon.Address, tokenHEZ
 	}
 	consts, err := c.RollupConstants()
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, tracerr.Wrap(fmt.Errorf("RollupConstants at %v: %w", address, err))
 	}
 	c.consts = consts
 	return c, nil
 }
 
 // RollupForgeBatch is the interface to call the smart contract function
-func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs, auth *bind.TransactOpts) (tx *types.Transaction, err error) {
+func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs,
+	auth *bind.TransactOpts) (tx *types.Transaction, err error) {
 	if auth == nil {
 		auth, err = c.client.NewAuth()
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		auth.GasLimit = 1000000
 	}
@@ -393,7 +402,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
 }
@@ -401,7 +410,8 @@ func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs, auth *bind.T
 // RollupAddToken is the interface to call the smart contract function.
 // `feeAddToken` is the amount of HEZ tokens that will be paid to add the
 // token.  `feeAddToken` must match the public value of the smart contract.
-func (c *RollupClient) RollupAddToken(tokenAddress ethCommon.Address, feeAddToken, deadline *big.Int) (tx *types.Transaction, err error) {
+func (c *RollupClient) RollupAddToken(tokenAddress ethCommon.Address, feeAddToken,
+	deadline *big.Int) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -413,9 +423,11 @@ func (c *RollupClient) RollupAddToken(tokenAddress ethCommon.Address, feeAddToke
 			}
 			tokenName := c.tokenHEZCfg.Name
 			tokenAddr := c.tokenHEZCfg.Address
-			digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID, feeAddToken, nonce, deadline, tokenName)
+			digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID,
+				feeAddToken, nonce, deadline, tokenName)
 			signature, _ := c.client.ks.SignHash(*c.client.account, digest)
-			permit := createPermit(owner, spender, feeAddToken, deadline, digest, signature)
+			permit := createPermit(owner, spender, feeAddToken, deadline, digest,
+				signature)
 
 			return c.hermez.AddToken(auth, tokenAddress, permit)
 		},
@@ -426,7 +438,9 @@ func (c *RollupClient) RollupAddToken(tokenAddress ethCommon.Address, feeAddToke
 }
 
 // RollupWithdrawMerkleProof is the interface to call the smart contract function
-func (c *RollupClient) RollupWithdrawMerkleProof(fromBJJ babyjub.PublicKeyComp, tokenID uint32, numExitRoot, idx int64, amount *big.Int, siblings []*big.Int, instantWithdraw bool) (tx *types.Transaction, err error) {
+func (c *RollupClient) RollupWithdrawMerkleProof(fromBJJ babyjub.PublicKeyComp, tokenID uint32,
+	numExitRoot, idx int64, amount *big.Int, siblings []*big.Int,
+	instantWithdraw bool) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -434,7 +448,8 @@ func (c *RollupClient) RollupWithdrawMerkleProof(fromBJJ babyjub.PublicKeyComp,
 			babyPubKey := new(big.Int).SetBytes(pkCompB)
 			numExitRootB := uint32(numExitRoot)
 			idxBig := big.NewInt(idx)
-			return c.hermez.WithdrawMerkleProof(auth, tokenID, amount, babyPubKey, numExitRootB, siblings, idxBig, instantWithdraw)
+			return c.hermez.WithdrawMerkleProof(auth, tokenID, amount, babyPubKey,
+				numExitRootB, siblings, idxBig, instantWithdraw)
 		},
 	); err != nil {
 		return nil, tracerr.Wrap(fmt.Errorf("Failed update WithdrawMerkleProof: %w", err))
@@ -443,13 +458,17 @@ func (c *RollupClient) RollupWithdrawMerkleProof(fromBJJ babyjub.PublicKeyComp,
 }
 
 // RollupWithdrawCircuit is the interface to call the smart contract function
-func (c *RollupClient) RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int, tokenID uint32, numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction, error) {
+func (c *RollupClient) RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int,
+	tokenID uint32, numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction,
+	error) {
 	log.Error("TODO")
 	return nil, tracerr.Wrap(errTODO)
 }
 
 // RollupL1UserTxERC20ETH is the interface to call the smart contract function
-func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (tx *types.Transaction, err error) {
+func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fromIdx int64,
+	depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (tx *types.Transaction,
+	err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -462,11 +481,11 @@ func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fro
 			}
 			fromIdxBig := big.NewInt(fromIdx)
 			toIdxBig := big.NewInt(toIdx)
-			depositAmountF, err := common.NewFloat16(depositAmount)
+			depositAmountF, err := common.NewFloat40(depositAmount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			amountF, err := common.NewFloat16(amount)
+			amountF, err := common.NewFloat40(amount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
@@ -484,7 +503,9 @@ func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fro
 }
 
 // RollupL1UserTxERC20Permit is the interface to call the smart contract function
-func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64, deadline *big.Int) (tx *types.Transaction, err error) {
+func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp, fromIdx int64,
+	depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64,
+	deadline *big.Int) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -497,11 +518,11 @@ func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp,
 			}
 			fromIdxBig := big.NewInt(fromIdx)
 			toIdxBig := big.NewInt(toIdx)
-			depositAmountF, err := common.NewFloat16(depositAmount)
+			depositAmountF, err := common.NewFloat40(depositAmount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			amountF, err := common.NewFloat16(amount)
+			amountF, err := common.NewFloat40(amount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
@@ -516,11 +537,12 @@ func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp,
 			}
 			tokenName := c.tokenHEZCfg.Name
 			tokenAddr := c.tokenHEZCfg.Address
-			digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID, amount, nonce, deadline, tokenName)
+			digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID,
+				amount, nonce, deadline, tokenName)
 			signature, _ := c.client.ks.SignHash(*c.client.account, digest)
 			permit := createPermit(owner, spender, amount, deadline, digest, signature)
-			return c.hermez.AddL1Transaction(auth, babyPubKey, fromIdxBig, uint16(depositAmountF),
+			return c.hermez.AddL1Transaction(auth, babyPubKey, fromIdxBig,
-				uint16(amountF), tokenID, toIdxBig, permit)
+				uint16(depositAmountF), uint16(amountF), tokenID, toIdxBig, permit)
 		},
 	); err != nil {
 		return nil, tracerr.Wrap(fmt.Errorf("Failed add L1 Tx ERC20Permit: %w", err))
@@ -552,11 +574,13 @@ func (c *RollupClient) RollupLastForgedBatch() (lastForgedBatch int64, err error
 }
 
 // RollupUpdateForgeL1L2BatchTimeout is the interface to call the smart contract function
-func (c *RollupClient) RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout int64) (tx *types.Transaction, err error) {
+func (c *RollupClient) RollupUpdateForgeL1L2BatchTimeout(
+	newForgeL1L2BatchTimeout int64) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
-			return c.hermez.UpdateForgeL1L2BatchTimeout(auth, uint8(newForgeL1L2BatchTimeout))
+			return c.hermez.UpdateForgeL1L2BatchTimeout(auth,
+				uint8(newForgeL1L2BatchTimeout))
 		},
 	); err != nil {
 		return nil, tracerr.Wrap(fmt.Errorf("Failed update ForgeL1L2BatchTimeout: %w", err))
@@ -565,7 +589,8 @@ func (c *RollupClient) RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeou
 }
 
 // RollupUpdateFeeAddToken is the interface to call the smart contract function
-func (c *RollupClient) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *types.Transaction, err error) {
+func (c *RollupClient) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *types.Transaction,
+	err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -600,7 +625,8 @@ func (c *RollupClient) RollupUpdateBucketsParameters(
 }
 
 // RollupUpdateTokenExchange is the interface to call the smart contract function
-func (c *RollupClient) RollupUpdateTokenExchange(addressArray []ethCommon.Address, valueArray []uint64) (tx *types.Transaction, err error) {
+func (c *RollupClient) RollupUpdateTokenExchange(addressArray []ethCommon.Address,
+	valueArray []uint64) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -613,7 +639,8 @@ func (c *RollupClient) RollupUpdateTokenExchange(addressArray []ethCommon.Addres
 }
 
 // RollupUpdateWithdrawalDelay is the interface to call the smart contract function
-func (c *RollupClient) RollupUpdateWithdrawalDelay(newWithdrawalDelay int64) (tx *types.Transaction, err error) {
+func (c *RollupClient) RollupUpdateWithdrawalDelay(newWithdrawalDelay int64) (tx *types.Transaction,
+	err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -639,7 +666,8 @@ func (c *RollupClient) RollupSafeMode() (tx *types.Transaction, err error) {
 }
 
 // RollupInstantWithdrawalViewer is the interface to call the smart contract function
-func (c *RollupClient) RollupInstantWithdrawalViewer(tokenAddress ethCommon.Address, amount *big.Int) (instantAllowed bool, err error) {
+func (c *RollupClient) RollupInstantWithdrawalViewer(tokenAddress ethCommon.Address,
+	amount *big.Int) (instantAllowed bool, err error) {
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		instantAllowed, err = c.hermez.InstantWithdrawalViewer(c.opts, tokenAddress, amount)
 		return tracerr.Wrap(err)
@@ -674,7 +702,8 @@ func (c *RollupClient) RollupConstants() (rollupConstants *common.RollupConstant
 			}
 			newRollupVerifier.MaxTx = rollupVerifier.MaxTx.Int64()
 			newRollupVerifier.NLevels = rollupVerifier.NLevels.Int64()
-			rollupConstants.Verifiers = append(rollupConstants.Verifiers, newRollupVerifier)
+			rollupConstants.Verifiers = append(rollupConstants.Verifiers,
+				newRollupVerifier)
 		}
 		rollupConstants.HermezAuctionContract, err = c.hermez.HermezAuctionContract(c.opts)
 		if err != nil {
@@ -693,19 +722,30 @@ func (c *RollupClient) RollupConstants() (rollupConstants *common.RollupConstant
 }
 
 var (
-	logHermezL1UserTxEvent               = crypto.Keccak256Hash([]byte("L1UserTxEvent(uint32,uint8,bytes)"))
+	logHermezL1UserTxEvent = crypto.Keccak256Hash([]byte(
-	logHermezAddToken                    = crypto.Keccak256Hash([]byte("AddToken(address,uint32)"))
+		"L1UserTxEvent(uint32,uint8,bytes)"))
-	logHermezForgeBatch                  = crypto.Keccak256Hash([]byte("ForgeBatch(uint32,uint16)"))
+	logHermezAddToken = crypto.Keccak256Hash([]byte(
-	logHermezUpdateForgeL1L2BatchTimeout = crypto.Keccak256Hash([]byte("UpdateForgeL1L2BatchTimeout(uint8)"))
+		"AddToken(address,uint32)"))
-	logHermezUpdateFeeAddToken           = crypto.Keccak256Hash([]byte("UpdateFeeAddToken(uint256)"))
+	logHermezForgeBatch = crypto.Keccak256Hash([]byte(
-	logHermezWithdrawEvent               = crypto.Keccak256Hash([]byte("WithdrawEvent(uint48,uint32,bool)"))
+		"ForgeBatch(uint32,uint16)"))
-	logHermezUpdateBucketWithdraw        = crypto.Keccak256Hash([]byte("UpdateBucketWithdraw(uint8,uint256,uint256)"))
+	logHermezUpdateForgeL1L2BatchTimeout = crypto.Keccak256Hash([]byte(
-	logHermezUpdateWithdrawalDelay       = crypto.Keccak256Hash([]byte("UpdateWithdrawalDelay(uint64)"))
+		"UpdateForgeL1L2BatchTimeout(uint8)"))
-	logHermezUpdateBucketsParameters     = crypto.Keccak256Hash([]byte("UpdateBucketsParameters(uint256[4][" +
+	logHermezUpdateFeeAddToken = crypto.Keccak256Hash([]byte(
-		strconv.Itoa(common.RollupConstNumBuckets) + "])"))
+		"UpdateFeeAddToken(uint256)"))
-	logHermezUpdateTokenExchange = crypto.Keccak256Hash([]byte("UpdateTokenExchange(address[],uint64[])"))
+	logHermezWithdrawEvent = crypto.Keccak256Hash([]byte(
-	logHermezSafeMode            = crypto.Keccak256Hash([]byte("SafeMode()"))
+		"WithdrawEvent(uint48,uint32,bool)"))
-	logHermezInitialize          = crypto.Keccak256Hash([]byte("InitializeHermezEvent(uint8,uint256,uint64)"))
+	logHermezUpdateBucketWithdraw = crypto.Keccak256Hash([]byte(
+		"UpdateBucketWithdraw(uint8,uint256,uint256)"))
+	logHermezUpdateWithdrawalDelay = crypto.Keccak256Hash([]byte(
+		"UpdateWithdrawalDelay(uint64)"))
+	logHermezUpdateBucketsParameters = crypto.Keccak256Hash([]byte(
+		"UpdateBucketsParameters(uint256[4][" + strconv.Itoa(common.RollupConstNumBuckets) + "])"))
+	logHermezUpdateTokenExchange = crypto.Keccak256Hash([]byte(
+		"UpdateTokenExchange(address[],uint64[])"))
+	logHermezSafeMode = crypto.Keccak256Hash([]byte(
+		"SafeMode()"))
+	logHermezInitialize = crypto.Keccak256Hash([]byte(
+		"InitializeHermezEvent(uint8,uint256,uint64)"))
 )
 
 // RollupEventInit returns the initialize event with its corresponding block number
@@ -729,7 +769,8 @@ func (c *RollupClient) RollupEventInit() (*RollupEventInitialize, int64, error)
 	}
 
 	var rollupInit RollupEventInitialize
-	if err := c.contractAbi.UnpackIntoInterface(&rollupInit, "InitializeHermezEvent", vLog.Data); err != nil {
+	if err := c.contractAbi.UnpackIntoInterface(&rollupInit, "InitializeHermezEvent",
+		vLog.Data); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	return &rollupInit, int64(vLog.BlockNumber), tracerr.Wrap(err)
@@ -810,7 +851,8 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			var updateForgeL1L2BatchTimeout struct {
 				NewForgeL1L2BatchTimeout uint8
 			}
-			err := c.contractAbi.UnpackIntoInterface(&updateForgeL1L2BatchTimeout, "UpdateForgeL1L2BatchTimeout", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&updateForgeL1L2BatchTimeout,
+				"UpdateForgeL1L2BatchTimeout", vLog.Data)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
@@ -838,14 +880,16 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 		case logHermezUpdateBucketWithdraw:
 			var updateBucketWithdrawAux rollupEventUpdateBucketWithdrawAux
 			var updateBucketWithdraw RollupEventUpdateBucketWithdraw
-			err := c.contractAbi.UnpackIntoInterface(&updateBucketWithdrawAux, "UpdateBucketWithdraw", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&updateBucketWithdrawAux,
+				"UpdateBucketWithdraw", vLog.Data)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			updateBucketWithdraw.Withdrawals = updateBucketWithdrawAux.Withdrawals
 			updateBucketWithdraw.NumBucket = int(new(big.Int).SetBytes(vLog.Topics[1][:]).Int64())
 			updateBucketWithdraw.BlockStamp = new(big.Int).SetBytes(vLog.Topics[2][:]).Int64()
-			rollupEvents.UpdateBucketWithdraw = append(rollupEvents.UpdateBucketWithdraw, updateBucketWithdraw)
+			rollupEvents.UpdateBucketWithdraw =
+				append(rollupEvents.UpdateBucketWithdraw, updateBucketWithdraw)
 
 		case logHermezUpdateWithdrawalDelay:
 			var withdrawalDelay RollupEventUpdateWithdrawalDelay
@@ -857,7 +901,8 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 		case logHermezUpdateBucketsParameters:
 			var bucketsParametersAux rollupEventUpdateBucketsParametersAux
 			var bucketsParameters RollupEventUpdateBucketsParameters
-			err := c.contractAbi.UnpackIntoInterface(&bucketsParametersAux, "UpdateBucketsParameters", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&bucketsParametersAux,
+				"UpdateBucketsParameters", vLog.Data)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
@@ -867,7 +912,8 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 				bucketsParameters.ArrayBuckets[i].BlockWithdrawalRate = bucket[2]
 				bucketsParameters.ArrayBuckets[i].MaxWithdrawals = bucket[3]
 			}
-			rollupEvents.UpdateBucketsParameters = append(rollupEvents.UpdateBucketsParameters, bucketsParameters)
+			rollupEvents.UpdateBucketsParameters =
+				append(rollupEvents.UpdateBucketsParameters, bucketsParameters)
 		case logHermezUpdateTokenExchange:
 			var tokensExchange RollupEventUpdateTokenExchange
 			err := c.contractAbi.UnpackIntoInterface(&tokensExchange, "UpdateTokenExchange", vLog.Data)
@@ -899,7 +945,8 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 
 // RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the
 // Rollup Smart Contract in the given transaction, and the sender address.
-func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsLen uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error) {
+func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash,
+	l1UserTxsLen uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error) {
 	tx, _, err := c.client.client.TransactionByHash(context.Background(), ethTxHash)
 	if err != nil {
 		return nil, nil, tracerr.Wrap(fmt.Errorf("TransactionByHash: %w", err))
@@ -914,7 +961,8 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 	if err != nil {
 		return nil, nil, tracerr.Wrap(err)
 	}
-	sender, err := c.client.client.TransactionSender(context.Background(), tx, receipt.Logs[0].BlockHash, receipt.Logs[0].Index)
+	sender, err := c.client.client.TransactionSender(context.Background(), tx,
+		receipt.Logs[0].BlockHash, receipt.Logs[0].Index)
 	if err != nil {
 		return nil, nil, tracerr.Wrap(err)
 	}
@@ -939,9 +987,9 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 		FeeIdxCoordinator:     []common.Idx{},
 	}
 	nLevels := c.consts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels
-	lenL1L2TxsBytes := int((nLevels/8)*2 + 2 + 1)
+	lenL1L2TxsBytes := int((nLevels/8)*2 + common.Float40BytesLength + 1) //nolint:gomnd
 	numBytesL1TxUser := int(l1UserTxsLen) * lenL1L2TxsBytes
-	numTxsL1Coord := len(aux.EncodedL1CoordinatorTx) / common.L1CoordinatorTxBytesLen
+	numTxsL1Coord := len(aux.EncodedL1CoordinatorTx) / common.RollupConstL1CoordinatorTotalBytes
 	numBytesL1TxCoord := numTxsL1Coord * lenL1L2TxsBytes
 	numBeginL2Tx := numBytesL1TxCoord + numBytesL1TxUser
 	l1UserTxsData := []byte{}
@@ -949,7 +997,9 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 		l1UserTxsData = aux.L1L2TxsData[:numBytesL1TxUser]
 	}
 	for i := 0; i < int(l1UserTxsLen); i++ {
-		l1Tx, err := common.L1TxFromDataAvailability(l1UserTxsData[i*lenL1L2TxsBytes:(i+1)*lenL1L2TxsBytes], uint32(nLevels))
+		l1Tx, err :=
+			common.L1TxFromDataAvailability(l1UserTxsData[i*lenL1L2TxsBytes:(i+1)*lenL1L2TxsBytes],
+				uint32(nLevels))
 		if err != nil {
 			return nil, nil, tracerr.Wrap(err)
 		}
@@ -961,14 +1011,17 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 	}
 	numTxsL2 := len(l2TxsData) / lenL1L2TxsBytes
 	for i := 0; i < numTxsL2; i++ {
-		l2Tx, err := common.L2TxFromBytesDataAvailability(l2TxsData[i*lenL1L2TxsBytes:(i+1)*lenL1L2TxsBytes], int(nLevels))
+		l2Tx, err :=
+			common.L2TxFromBytesDataAvailability(l2TxsData[i*lenL1L2TxsBytes:(i+1)*lenL1L2TxsBytes],
+				int(nLevels))
 		if err != nil {
 			return nil, nil, tracerr.Wrap(err)
 		}
 		rollupForgeBatchArgs.L2TxsData = append(rollupForgeBatchArgs.L2TxsData, *l2Tx)
 	}
 	for i := 0; i < numTxsL1Coord; i++ {
-		bytesL1Coordinator := aux.EncodedL1CoordinatorTx[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
+		bytesL1Coordinator :=
+			aux.EncodedL1CoordinatorTx[i*common.RollupConstL1CoordinatorTotalBytes : (i+1)*common.RollupConstL1CoordinatorTotalBytes] //nolint:lll
 		var signature []byte
 		v := bytesL1Coordinator[0]
 		s := bytesL1Coordinator[1:33]
@@ -981,24 +1034,29 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 			return nil, nil, tracerr.Wrap(err)
 		}
 		rollupForgeBatchArgs.L1CoordinatorTxs = append(rollupForgeBatchArgs.L1CoordinatorTxs, *l1Tx)
-		rollupForgeBatchArgs.L1CoordinatorTxsAuths = append(rollupForgeBatchArgs.L1CoordinatorTxsAuths, signature)
+		rollupForgeBatchArgs.L1CoordinatorTxsAuths =
+			append(rollupForgeBatchArgs.L1CoordinatorTxsAuths, signature)
 	}
 	lenFeeIdxCoordinatorBytes := int(nLevels / 8) //nolint:gomnd
 	numFeeIdxCoordinator := len(aux.FeeIdxCoordinator) / lenFeeIdxCoordinatorBytes
 	for i := 0; i < numFeeIdxCoordinator; i++ {
 		var paddedFeeIdx [6]byte
-		// TODO: This check is not necessary: the first case will always work.  Test it before removing the if.
+		// TODO: This check is not necessary: the first case will always work.  Test it
+		// before removing the if.
 		if lenFeeIdxCoordinatorBytes < common.IdxBytesLen {
-			copy(paddedFeeIdx[6-lenFeeIdxCoordinatorBytes:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
+			copy(paddedFeeIdx[6-lenFeeIdxCoordinatorBytes:],
+				aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
 		} else {
-			copy(paddedFeeIdx[:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
+			copy(paddedFeeIdx[:],
+				aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
 		}
 		feeIdxCoordinator, err := common.IdxFromBytes(paddedFeeIdx[:])
 		if err != nil {
 			return nil, nil, tracerr.Wrap(err)
 		}
 		if feeIdxCoordinator != common.Idx(0) {
-			rollupForgeBatchArgs.FeeIdxCoordinator = append(rollupForgeBatchArgs.FeeIdxCoordinator, feeIdxCoordinator)
+			rollupForgeBatchArgs.FeeIdxCoordinator =
+				append(rollupForgeBatchArgs.FeeIdxCoordinator, feeIdxCoordinator)
 		}
 	}
 	return &rollupForgeBatchArgs, &sender, nil

eth/rollup_test.go

@@ -116,7 +116,8 @@ func TestRollupForgeBatch(t *testing.T) {
 	minBid.SetString("11000000000000000000", 10)
 	budget := new(big.Int)
 	budget.SetString("45200000000000000000", 10)
-	_, err = auctionClient.AuctionMultiBid(budget, currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, deadline)
+	_, err = auctionClient.AuctionMultiBid(budget, currentSlot+4, currentSlot+10, slotSet,
+		maxBid, minBid, deadline)
 	require.NoError(t, err)
 
 	// Add Blocks
@@ -128,12 +129,18 @@ func TestRollupForgeBatch(t *testing.T) {
 
 	// Forge Batch 1
 	args := new(RollupForgeBatchArgs)
-	args.FeeIdxCoordinator = []common.Idx{} // When encoded, 64 times the 0 idx means that no idx to collect fees is specified.
+	// When encoded, 64 times the 0 idx means that no idx to collect fees is specified.
-	l1CoordinatorBytes, err := hex.DecodeString("1c660323607bb113e586183609964a333d07ebe4bef3be82ec13af453bae9590bd7711cdb6abf42f176eadfbe5506fbef5e092e5543733f91b0061d9a7747fa10694a915a6470fa230de387b51e6f4db0b09787867778687b55197ad6d6a86eac000000001")
+	args.FeeIdxCoordinator = []common.Idx{}
+	l1CoordinatorBytes, err := hex.DecodeString(
+		"1c660323607bb113e586183609964a333d07ebe4bef3be82ec13af453bae9590bd7711cdb6abf" +
+			"42f176eadfbe5506fbef5e092e5543733f91b0061d9a7747fa10694a915a6470fa230" +
+			"de387b51e6f4db0b09787867778687b55197ad6d6a86eac000000001")
 	require.NoError(t, err)
-	numTxsL1 := len(l1CoordinatorBytes) / common.L1CoordinatorTxBytesLen
+	numTxsL1 := len(l1CoordinatorBytes) / common.RollupConstL1CoordinatorTotalBytes
 	for i := 0; i < numTxsL1; i++ {
-		bytesL1Coordinator := l1CoordinatorBytes[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
+		bytesL1Coordinator :=
+			l1CoordinatorBytes[i*common.RollupConstL1CoordinatorTotalBytes : (i+1)*
+				common.RollupConstL1CoordinatorTotalBytes]
 		var signature []byte
 		v := bytesL1Coordinator[0]
 		s := bytesL1Coordinator[1:33]
@@ -149,9 +156,12 @@ func TestRollupForgeBatch(t *testing.T) {
 	args.L1UserTxs = []common.L1Tx{}
 	args.L2TxsData = []common.L2Tx{}
 	newStateRoot := new(big.Int)
-	newStateRoot.SetString("18317824016047294649053625209337295956588174734569560016974612130063629505228", 10)
+	newStateRoot.SetString(
+		"18317824016047294649053625209337295956588174734569560016974612130063629505228",
+		10)
 	newExitRoot := new(big.Int)
-	bytesNumExitRoot, err := hex.DecodeString("10a89d5fe8d488eda1ba371d633515739933c706c210c604f5bd209180daa43b")
+	bytesNumExitRoot, err := hex.DecodeString(
+		"10a89d5fe8d488eda1ba371d633515739933c706c210c604f5bd209180daa43b")
 	require.NoError(t, err)
 	newExitRoot.SetBytes(bytesNumExitRoot)
 	args.NewLastIdx = int64(300)
@@ -206,7 +216,8 @@ func TestRollupUpdateForgeL1L2BatchTimeout(t *testing.T) {
 	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
 	require.NoError(t, err)
 
-	assert.Equal(t, newForgeL1L2BatchTimeout, rollupEvents.UpdateForgeL1L2BatchTimeout[0].NewForgeL1L2BatchTimeout)
+	assert.Equal(t, newForgeL1L2BatchTimeout,
+		rollupEvents.UpdateForgeL1L2BatchTimeout[0].NewForgeL1L2BatchTimeout)
 }
 
 func TestRollupUpdateFeeAddToken(t *testing.T) {
@@ -248,7 +259,8 @@ func TestRollupUpdateWithdrawalDelay(t *testing.T) {
 	require.NoError(t, err)
 	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
 	require.NoError(t, err)
-	assert.Equal(t, newWithdrawalDelay, int64(rollupEvents.UpdateWithdrawalDelay[0].NewWithdrawalDelay))
+	assert.Equal(t, newWithdrawalDelay,
+		int64(rollupEvents.UpdateWithdrawalDelay[0].NewWithdrawalDelay))
 }
 
 func TestRollupUpdateTokenExchange(t *testing.T) {
@@ -287,7 +299,8 @@ func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
+	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -299,11 +312,13 @@ func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) {
-	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	key := genKeysBjj(1)
 	fromIdxInt64 := int64(0)
@@ -319,7 +334,8 @@ func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
+	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -331,11 +347,13 @@ func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux2.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	key := genKeysBjj(3)
 	fromIdxInt64 := int64(0)
@@ -351,7 +369,8 @@ func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
+	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -363,11 +382,13 @@ func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxETHDeposit(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(256)
 	toIdxInt64 := int64(0)
@@ -383,7 +404,8 @@ func TestRollupL1UserTxETHDeposit(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
+	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -394,11 +416,13 @@ func TestRollupL1UserTxETHDeposit(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20Deposit(t *testing.T) {
-	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(257)
 	toIdxInt64 := int64(0)
@@ -413,7 +437,8 @@ func TestRollupL1UserTxERC20Deposit(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
+	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -424,11 +449,13 @@ func TestRollupL1UserTxERC20Deposit(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux2.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(258)
 	toIdxInt64 := int64(0)
@@ -442,7 +469,8 @@ func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
+	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -453,11 +481,13 @@ func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxETHDepositTransfer(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(256)
 	toIdxInt64 := int64(257)
@@ -473,7 +503,8 @@ func TestRollupL1UserTxETHDepositTransfer(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
+	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -484,11 +515,13 @@ func TestRollupL1UserTxETHDepositTransfer(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) {
-	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(257)
 	toIdxInt64 := int64(258)
@@ -503,7 +536,8 @@ func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
+	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -514,11 +548,13 @@ func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux2.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(258)
 	toIdxInt64 := int64(259)
@@ -533,7 +569,8 @@ func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
+	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -544,11 +581,13 @@ func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(256)
 	toIdxInt64 := int64(257)
@@ -564,7 +603,8 @@ func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
+	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -575,11 +615,13 @@ func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) {
-	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(257)
 	toIdxInt64 := int64(258)
@@ -594,7 +636,8 @@ func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
+	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -605,11 +648,13 @@ func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux2.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(258)
 	toIdxInt64 := int64(259)
@@ -624,7 +669,8 @@ func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
+	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -635,11 +681,13 @@ func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxETHForceTransfer(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(256)
 	toIdxInt64 := int64(257)
@@ -654,7 +702,8 @@ func TestRollupL1UserTxETHForceTransfer(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
+	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -665,11 +714,13 @@ func TestRollupL1UserTxETHForceTransfer(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) {
-	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(257)
 	toIdxInt64 := int64(258)
@@ -683,7 +734,8 @@ func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
+	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -694,11 +746,13 @@ func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux2.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(259)
 	toIdxInt64 := int64(260)
@@ -712,7 +766,8 @@ func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
+	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -723,11 +778,13 @@ func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxETHForceExit(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(256)
 	toIdxInt64 := int64(1)
@@ -742,7 +799,8 @@ func TestRollupL1UserTxETHForceExit(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
+	_, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -753,11 +811,13 @@ func TestRollupL1UserTxETHForceExit(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20ForceExit(t *testing.T) {
-	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(257)
 	toIdxInt64 := int64(1)
@@ -771,7 +831,8 @@ func TestRollupL1UserTxERC20ForceExit(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
+	_, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -782,11 +843,13 @@ func TestRollupL1UserTxERC20ForceExit(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux2.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) {
-	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
+	rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst,
+		tokenHEZ)
 	require.NoError(t, err)
 	fromIdxInt64 := int64(258)
 	toIdxInt64 := int64(1)
@@ -802,7 +865,8 @@ func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) {
 	}
 	L1UserTxs = append(L1UserTxs, l1Tx)
 
-	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
+	_, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64,
+		l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
@@ -813,7 +877,8 @@ func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) {
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
 	assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
 	assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
-	assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
+	assert.Equal(t, rollupClientAux.client.account.Address,
+		rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
 }
 
 func TestRollupForgeBatch2(t *testing.T) {
@@ -829,7 +894,8 @@ func TestRollupForgeBatch2(t *testing.T) {
 
 	// Forge Batch 3
 	args := new(RollupForgeBatchArgs)
-	args.FeeIdxCoordinator = []common.Idx{} // When encoded, 64 times the 0 idx means that no idx to collect fees is specified.
+	// When encoded, 64 times the 0 idx means that no idx to collect fees is specified.
+	args.FeeIdxCoordinator = []common.Idx{}
 	args.L1CoordinatorTxs = argsForge.L1CoordinatorTxs
 	args.L1CoordinatorTxsAuths = argsForge.L1CoordinatorTxsAuths
 	for i := 0; i < len(L1UserTxs); i++ {
@@ -837,14 +903,19 @@ func TestRollupForgeBatch2(t *testing.T) {
 		l1UserTx.EffectiveAmount = l1UserTx.Amount
 		l1Bytes, err := l1UserTx.BytesDataAvailability(uint32(nLevels))
 		require.NoError(t, err)
-		l1UserTxDataAvailability, err := common.L1TxFromDataAvailability(l1Bytes, uint32(nLevels))
+		l1UserTxDataAvailability, err := common.L1TxFromDataAvailability(l1Bytes,
+			uint32(nLevels))
 		require.NoError(t, err)
 		args.L1UserTxs = append(args.L1UserTxs, *l1UserTxDataAvailability)
 	}
 	newStateRoot := new(big.Int)
-	newStateRoot.SetString("18317824016047294649053625209337295956588174734569560016974612130063629505228", 10)
+	newStateRoot.SetString(
+		"18317824016047294649053625209337295956588174734569560016974612130063629505228",
+		10)
 	newExitRoot := new(big.Int)
-	newExitRoot.SetString("1114281409737474688393837964161044726766678436313681099613347372031079422302", 10)
+	newExitRoot.SetString(
+		"1114281409737474688393837964161044726766678436313681099613347372031079422302",
+		10)
 	amount := new(big.Int)
 	amount.SetString("79000000", 10)
 	l2Tx := common.L2Tx{
@@ -904,7 +975,8 @@ func TestRollupWithdrawMerkleProof(t *testing.T) {
 	require.NoError(t, err)
 
 	var pkComp babyjub.PublicKeyComp
-	pkCompBE, err := hex.DecodeString("adc3b754f8da621967b073a787bef8eec7052f2ba712b23af57d98f65beea8b2")
+	pkCompBE, err :=
+		hex.DecodeString("adc3b754f8da621967b073a787bef8eec7052f2ba712b23af57d98f65beea8b2")
 	require.NoError(t, err)
 	pkCompLE := common.SwapEndianness(pkCompBE)
 	copy(pkComp[:], pkCompLE)
@@ -914,16 +986,20 @@ func TestRollupWithdrawMerkleProof(t *testing.T) {
 	numExitRoot := int64(3)
 	fromIdx := int64(256)
 	amount, _ := new(big.Int).SetString("20000000000000000000", 10)
-	// siblingBytes0, err := new(big.Int).SetString("19508838618377323910556678335932426220272947530531646682154552299216398748115", 10)
+	// siblingBytes0, err := new(big.Int).SetString(
+	// 		"19508838618377323910556678335932426220272947530531646682154552299216398748115",
+	// 		10)
 	// require.NoError(t, err)
-	// siblingBytes1, err := new(big.Int).SetString("15198806719713909654457742294233381653226080862567104272457668857208564789571", 10)
+	// siblingBytes1, err := new(big.Int).SetString(
+	// 	"15198806719713909654457742294233381653226080862567104272457668857208564789571", 10)
 	// require.NoError(t, err)
 	var siblings []*big.Int
 	// siblings = append(siblings, siblingBytes0)
 	// siblings = append(siblings, siblingBytes1)
 	instantWithdraw := true
 
-	_, err = rollupClientAux.RollupWithdrawMerkleProof(pkComp, tokenID, numExitRoot, fromIdx, amount, siblings, instantWithdraw)
+	_, err = rollupClientAux.RollupWithdrawMerkleProof(pkComp, tokenID, numExitRoot, fromIdx,
+		amount, siblings, instantWithdraw)
 	require.NoError(t, err)
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()

eth/wdelayer.go

@@ -132,7 +132,8 @@ type WDelayerInterface interface {
 	WDelayerDepositInfo(owner, token ethCommon.Address) (depositInfo DepositState, err error)
 	WDelayerDeposit(onwer, token ethCommon.Address, amount *big.Int) (*types.Transaction, error)
 	WDelayerWithdrawal(owner, token ethCommon.Address) (*types.Transaction, error)
-	WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address, amount *big.Int) (*types.Transaction, error)
+	WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address,
+		amount *big.Int) (*types.Transaction, error)
 
 	WDelayerEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*WDelayerEvents, error)
 	WDelayerConstants() (*common.WDelayerConstants, error)
@@ -143,7 +144,8 @@ type WDelayerInterface interface {
 // Implementation
 //
 
-// WDelayerClient is the implementation of the interface to the WithdrawDelayer Smart Contract in ethereum.
+// WDelayerClient is the implementation of the interface to the WithdrawDelayer
+// Smart Contract in ethereum.
 type WDelayerClient struct {
 	client      *EthereumClient
 	address     ethCommon.Address
@@ -172,7 +174,8 @@ func NewWDelayerClient(client *EthereumClient, address ethCommon.Address) (*WDel
 }
 
 // WDelayerGetHermezGovernanceAddress is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerGetHermezGovernanceAddress() (hermezGovernanceAddress *ethCommon.Address, err error) {
+func (c *WDelayerClient) WDelayerGetHermezGovernanceAddress() (
+	hermezGovernanceAddress *ethCommon.Address, err error) {
 	var _hermezGovernanceAddress ethCommon.Address
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		_hermezGovernanceAddress, err = c.wdelayer.GetHermezGovernanceAddress(c.opts)
@@ -184,7 +187,8 @@ func (c *WDelayerClient) WDelayerGetHermezGovernanceAddress() (hermezGovernanceA
 }
 
 // WDelayerTransferGovernance is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerTransferGovernance(newAddress ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *WDelayerClient) WDelayerTransferGovernance(newAddress ethCommon.Address) (
+	tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -210,7 +214,8 @@ func (c *WDelayerClient) WDelayerClaimGovernance() (tx *types.Transaction, err e
 }
 
 // WDelayerGetEmergencyCouncil is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerGetEmergencyCouncil() (emergencyCouncilAddress *ethCommon.Address, err error) {
+func (c *WDelayerClient) WDelayerGetEmergencyCouncil() (emergencyCouncilAddress *ethCommon.Address,
+	err error) {
 	var _emergencyCouncilAddress ethCommon.Address
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		_emergencyCouncilAddress, err = c.wdelayer.GetEmergencyCouncil(c.opts)
@@ -222,7 +227,8 @@ func (c *WDelayerClient) WDelayerGetEmergencyCouncil() (emergencyCouncilAddress
 }
 
 // WDelayerTransferEmergencyCouncil is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerTransferEmergencyCouncil(newAddress ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *WDelayerClient) WDelayerTransferEmergencyCouncil(newAddress ethCommon.Address) (
+	tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -271,7 +277,8 @@ func (c *WDelayerClient) WDelayerGetWithdrawalDelay() (withdrawalDelay int64, er
 }
 
 // WDelayerGetEmergencyModeStartingTime is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerGetEmergencyModeStartingTime() (emergencyModeStartingTime int64, err error) {
+func (c *WDelayerClient) WDelayerGetEmergencyModeStartingTime() (emergencyModeStartingTime int64,
+	err error) {
 	var _emergencyModeStartingTime uint64
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		_emergencyModeStartingTime, err = c.wdelayer.GetEmergencyModeStartingTime(c.opts)
@@ -296,7 +303,8 @@ func (c *WDelayerClient) WDelayerEnableEmergencyMode() (tx *types.Transaction, e
 }
 
 // WDelayerChangeWithdrawalDelay is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerChangeWithdrawalDelay(newWithdrawalDelay uint64) (tx *types.Transaction, err error) {
+func (c *WDelayerClient) WDelayerChangeWithdrawalDelay(newWithdrawalDelay uint64) (
+	tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -309,7 +317,8 @@ func (c *WDelayerClient) WDelayerChangeWithdrawalDelay(newWithdrawalDelay uint64
 }
 
 // WDelayerDepositInfo is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerDepositInfo(owner, token ethCommon.Address) (depositInfo DepositState, err error) {
+func (c *WDelayerClient) WDelayerDepositInfo(owner, token ethCommon.Address) (
+	depositInfo DepositState, err error) {
 	if err := c.client.Call(func(ec *ethclient.Client) error {
 		amount, depositTimestamp, err := c.wdelayer.DepositInfo(c.opts, owner, token)
 		depositInfo.Amount = amount
@@ -322,7 +331,8 @@ func (c *WDelayerClient) WDelayerDepositInfo(owner, token ethCommon.Address) (de
 }
 
 // WDelayerDeposit is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerDeposit(owner, token ethCommon.Address, amount *big.Int) (tx *types.Transaction, err error) {
+func (c *WDelayerClient) WDelayerDeposit(owner, token ethCommon.Address, amount *big.Int) (
+	tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -335,7 +345,8 @@ func (c *WDelayerClient) WDelayerDeposit(owner, token ethCommon.Address, amount
 }
 
 // WDelayerWithdrawal is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerWithdrawal(owner, token ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *WDelayerClient) WDelayerWithdrawal(owner, token ethCommon.Address) (tx *types.Transaction,
+	err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -348,7 +359,8 @@ func (c *WDelayerClient) WDelayerWithdrawal(owner, token ethCommon.Address) (tx
 }
 
 // WDelayerEscapeHatchWithdrawal is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address, amount *big.Int) (tx *types.Transaction, err error) {
+func (c *WDelayerClient) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address,
+	amount *big.Int) (tx *types.Transaction, err error) {
 	if tx, err = c.client.CallAuth(
 		0,
 		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
@@ -384,14 +396,21 @@ func (c *WDelayerClient) WDelayerConstants() (constants *common.WDelayerConstant
 }
 
 var (
-	logWDelayerDeposit                    = crypto.Keccak256Hash([]byte("Deposit(address,address,uint192,uint64)"))
+	logWDelayerDeposit = crypto.Keccak256Hash([]byte(
-	logWDelayerWithdraw                   = crypto.Keccak256Hash([]byte("Withdraw(address,address,uint192)"))
+		"Deposit(address,address,uint192,uint64)"))
-	logWDelayerEmergencyModeEnabled       = crypto.Keccak256Hash([]byte("EmergencyModeEnabled()"))
+	logWDelayerWithdraw = crypto.Keccak256Hash([]byte(
-	logWDelayerNewWithdrawalDelay         = crypto.Keccak256Hash([]byte("NewWithdrawalDelay(uint64)"))
+		"Withdraw(address,address,uint192)"))
-	logWDelayerEscapeHatchWithdrawal      = crypto.Keccak256Hash([]byte("EscapeHatchWithdrawal(address,address,address,uint256)"))
+	logWDelayerEmergencyModeEnabled = crypto.Keccak256Hash([]byte(
-	logWDelayerNewEmergencyCouncil        = crypto.Keccak256Hash([]byte("NewEmergencyCouncil(address)"))
+		"EmergencyModeEnabled()"))
-	logWDelayerNewHermezGovernanceAddress = crypto.Keccak256Hash([]byte("NewHermezGovernanceAddress(address)"))
+	logWDelayerNewWithdrawalDelay = crypto.Keccak256Hash([]byte(
-	logWDelayerInitialize                 = crypto.Keccak256Hash([]byte(
+		"NewWithdrawalDelay(uint64)"))
+	logWDelayerEscapeHatchWithdrawal = crypto.Keccak256Hash([]byte(
+		"EscapeHatchWithdrawal(address,address,address,uint256)"))
+	logWDelayerNewEmergencyCouncil = crypto.Keccak256Hash([]byte(
+		"NewEmergencyCouncil(address)"))
+	logWDelayerNewHermezGovernanceAddress = crypto.Keccak256Hash([]byte(
+		"NewHermezGovernanceAddress(address)"))
+	logWDelayerInitialize = crypto.Keccak256Hash([]byte(
 		"InitializeWithdrawalDelayerEvent(uint64,address,address)"))
 )
 
@@ -483,42 +502,51 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64,
 
 		case logWDelayerEmergencyModeEnabled:
 			var emergencyModeEnabled WDelayerEventEmergencyModeEnabled
-			wdelayerEvents.EmergencyModeEnabled = append(wdelayerEvents.EmergencyModeEnabled, emergencyModeEnabled)
+			wdelayerEvents.EmergencyModeEnabled =
+				append(wdelayerEvents.EmergencyModeEnabled, emergencyModeEnabled)
 
 		case logWDelayerNewWithdrawalDelay:
 			var withdrawalDelay WDelayerEventNewWithdrawalDelay
-			err := c.contractAbi.UnpackIntoInterface(&withdrawalDelay, "NewWithdrawalDelay", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&withdrawalDelay,
+				"NewWithdrawalDelay", vLog.Data)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			wdelayerEvents.NewWithdrawalDelay = append(wdelayerEvents.NewWithdrawalDelay, withdrawalDelay)
+			wdelayerEvents.NewWithdrawalDelay =
+				append(wdelayerEvents.NewWithdrawalDelay, withdrawalDelay)
 
 		case logWDelayerEscapeHatchWithdrawal:
 			var escapeHatchWithdrawal WDelayerEventEscapeHatchWithdrawal
-			err := c.contractAbi.UnpackIntoInterface(&escapeHatchWithdrawal, "EscapeHatchWithdrawal", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&escapeHatchWithdrawal,
+				"EscapeHatchWithdrawal", vLog.Data)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
 			escapeHatchWithdrawal.Who = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			escapeHatchWithdrawal.To = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
 			escapeHatchWithdrawal.Token = ethCommon.BytesToAddress(vLog.Topics[3].Bytes())
-			wdelayerEvents.EscapeHatchWithdrawal = append(wdelayerEvents.EscapeHatchWithdrawal, escapeHatchWithdrawal)
+			wdelayerEvents.EscapeHatchWithdrawal =
+				append(wdelayerEvents.EscapeHatchWithdrawal, escapeHatchWithdrawal)
 
 		case logWDelayerNewEmergencyCouncil:
 			var emergencyCouncil WDelayerEventNewEmergencyCouncil
-			err := c.contractAbi.UnpackIntoInterface(&emergencyCouncil, "NewEmergencyCouncil", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&emergencyCouncil,
+				"NewEmergencyCouncil", vLog.Data)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			wdelayerEvents.NewEmergencyCouncil = append(wdelayerEvents.NewEmergencyCouncil, emergencyCouncil)
+			wdelayerEvents.NewEmergencyCouncil =
+				append(wdelayerEvents.NewEmergencyCouncil, emergencyCouncil)
 
 		case logWDelayerNewHermezGovernanceAddress:
 			var governanceAddress WDelayerEventNewHermezGovernanceAddress
-			err := c.contractAbi.UnpackIntoInterface(&governanceAddress, "NewHermezGovernanceAddress", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&governanceAddress,
+				"NewHermezGovernanceAddress", vLog.Data)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			wdelayerEvents.NewHermezGovernanceAddress = append(wdelayerEvents.NewHermezGovernanceAddress, governanceAddress)
+			wdelayerEvents.NewHermezGovernanceAddress =
+				append(wdelayerEvents.NewHermezGovernanceAddress, governanceAddress)
 		}
 	}
 	return &wdelayerEvents, nil

eth/wdelayer_test.go

@@ -54,7 +54,8 @@ func TestWDelayerSetHermezGovernanceAddress(t *testing.T) {
 	require.Nil(t, err)
 	wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
 	require.Nil(t, err)
-	assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezGovernanceAddress[0].NewHermezGovernanceAddress)
+	assert.Equal(t, auxAddressConst,
+		wdelayerEvents.NewHermezGovernanceAddress[0].NewHermezGovernanceAddress)
 	_, err = wdelayerClientAux.WDelayerTransferGovernance(governanceAddressConst)
 	require.Nil(t, err)
 	_, err = wdelayerClientTest.WDelayerClaimGovernance()
@@ -68,7 +69,8 @@ func TestWDelayerGetEmergencyCouncil(t *testing.T) {
 }
 
 func TestWDelayerSetEmergencyCouncil(t *testing.T) {
-	wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil, wdelayerTestAddressConst)
+	wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil,
+		wdelayerTestAddressConst)
 	require.Nil(t, err)
 	wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
 	require.Nil(t, err)
@@ -200,13 +202,18 @@ func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {
 func TestWDelayerEscapeHatchWithdrawal(t *testing.T) {
 	amount := new(big.Int)
 	amount.SetString("10000000000000000", 10)
-	wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil, wdelayerTestAddressConst)
+	wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil,
+		wdelayerTestAddressConst)
 	require.Nil(t, err)
-	_, err = wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
+	_, err =
+		wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst,
+			tokenHEZAddressConst, amount)
 	require.Contains(t, err.Error(), "NO_MAX_EMERGENCY_MODE_TIME")
 	seconds := maxEmergencyModeTime.Seconds()
 	addTime(seconds, ethClientDialURL)
-	_, err = wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
+	_, err =
+		wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst,
+			tokenHEZAddressConst, amount)
 	require.Nil(t, err)
 	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 	require.Nil(t, err)

go.mod

@@ -6,31 +6,29 @@ require (
 	github.com/BurntSushi/toml v0.3.1
 	github.com/dghubble/sling v1.3.0
 	github.com/ethereum/go-ethereum v1.9.25
-	github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 // indirect
 	github.com/getkin/kin-openapi v0.22.0
 	github.com/gin-contrib/cors v1.3.1
 	github.com/gin-gonic/gin v1.5.0
 	github.com/gobuffalo/packr/v2 v2.8.1
 	github.com/hermeznetwork/tracerr v0.3.1-0.20210120162744-5da60b576169
-	github.com/iden3/go-iden3-crypto v0.0.6-0.20201221160344-58e589b6eb4c
+	github.com/iden3/go-iden3-crypto v0.0.6-0.20210308142348-8f85683b2cef
-	github.com/iden3/go-merkletree v0.0.0-20210119155851-bb53e6ad1a12
+	github.com/iden3/go-merkletree v0.0.0-20210308143313-8b63ca866189
 	github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a
 	github.com/jmoiron/sqlx v1.2.1-0.20200615141059-0794cb1f47ee
 	github.com/joho/godotenv v1.3.0
 	github.com/lib/pq v1.8.0
-	github.com/marusama/semaphore/v2 v2.4.1
 	github.com/mattn/go-sqlite3 v2.0.3+incompatible
 	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/sirupsen/logrus v1.5.0 // indirect
-	github.com/status-im/keycard-go v0.0.0-20190424133014-d95853db0f48 // indirect
 	github.com/stretchr/testify v1.6.1
 	github.com/urfave/cli/v2 v2.2.0
 	go.uber.org/zap v1.16.0
 	golang.org/x/crypto v0.0.0-20201217014255-9d1352758620
 	golang.org/x/net v0.0.0-20200822124328-c89045814202
+	golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9
 	gopkg.in/go-playground/validator.v9 v9.29.1
 )