Make proposal

README.md

@@ -4,10 +4,6 @@ Go implementation of the Hermez node.
 
 ## Developing
 
-### Go version
-
-The `hermez-node` has been tested with go version 1.14
-
 ### Unit testing
 
 Running the unit tests requires a connection to a PostgreSQL database.  You can
@@ -15,7 +11,7 @@ start PostgreSQL with docker easily this way (where `yourpasswordhere` should
 be your password):
 
 ```
-POSTGRES_PASS=yourpasswordhere; sudo docker run --rm --name hermez-db-test -p 5432:5432 -e POSTGRES_DB=hermez -e POSTGRES_USER=hermez -e POSTGRES_PASSWORD="$POSTGRES_PASS" -d postgres
+POSTGRES_PASS=yourpasswordhere sudo docker run --rm --name hermez-db-test -p 5432:5432 -e POSTGRES_DB=hermez -e POSTGRES_USER=hermez -e POSTGRES_PASSWORD="$POSTGRES_PASS" -d postgres
 ```
 
 Afterwards, run the tests with the password as env var:

api/account.go

@@ -4,7 +4,10 @@ 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) {
@@ -20,6 +23,16 @@ 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)
 }
 
@@ -44,6 +57,26 @@ func (a *API) getAccounts(c *gin.Context) {
 		return
 	}
 
+	// Get balances from stateDB
+	if err := a.s.LastRead(func(sdb *statedb.Last) error {
+		for x, apiAccount := range apiAccounts {
+			idx, err := stringToIdx(string(apiAccount.Idx), "Account Idx")
+			if err != nil {
+				return tracerr.Wrap(err)
+			}
+			account, err := sdb.GetAccount(*idx)
+			if err != nil {
+				return tracerr.Wrap(err)
+			}
+			apiAccounts[x].Balance = apitypes.NewBigIntStr(account.Balance)
+			apiAccounts[x].Nonce = account.Nonce
+		}
+		return nil
+	}); err != nil {
+		retSQLErr(err, c)
+		return
+	}
+
 	// Build succesfull response
 	type accountResponse struct {
 		Accounts     []historydb.AccountAPI `json:"accounts"`

api/api.go

@@ -9,6 +9,7 @@ import (
 	"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"
 )
 
@@ -33,6 +34,7 @@ type Status struct {
 type API struct {
 	h             *historydb.HistoryDB
 	cg            *configAPI
+	s             *statedb.StateDB
 	l2            *l2db.L2DB
 	status        Status
 	chainID       uint16
@@ -44,6 +46,7 @@ func NewAPI(
 	coordinatorEndpoints, explorerEndpoints bool,
 	server *gin.Engine,
 	hdb *historydb.HistoryDB,
+	sdb *statedb.StateDB,
 	l2db *l2db.L2DB,
 	config *Config,
 ) (*API, error) {
@@ -63,6 +66,7 @@ func NewAPI(
 			AuctionConstants:  config.AuctionConstants,
 			WDelayerConstants: config.WDelayerConstants,
 		},
+		s:             sdb,
 		l2:            l2db,
 		status:        Status{},
 		chainID:       config.ChainID,

api/api_test.go

@@ -8,7 +8,6 @@ import (
 	"io"
 	"io/ioutil"
 	"math/big"
-	"net"
 	"net/http"
 	"os"
 	"strconv"
@@ -23,6 +22,7 @@ import (
 	"github.com/hermeznetwork/hermez-node/db"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
+	"github.com/hermeznetwork/hermez-node/db/statedb"
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/hermez-node/test"
 	"github.com/hermeznetwork/hermez-node/test/til"
@@ -39,8 +39,8 @@ type Pendinger interface {
 	New() Pendinger
 }
 
-const apiAddr = ":4010"
+const apiPort = ":4010"
-const apiURL = "http://localhost" + apiAddr + "/"
+const apiURL = "http://localhost" + apiPort + "/"
 
 var SetBlockchain = `
 	Type: Blockchain
@@ -202,7 +202,7 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 	apiConnCon := db.NewAPICnnectionController(1, time.Second)
-	hdb := historydb.NewHistoryDB(database, database, apiConnCon)
+	hdb := historydb.NewHistoryDB(database, apiConnCon)
 	if err != nil {
 		panic(err)
 	}
@@ -216,8 +216,12 @@ func TestMain(m *testing.M) {
 			panic(err)
 		}
 	}()
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeTxSelector, 0)
+	if err != nil {
+		panic(err)
+	}
 	// L2DB
-	l2DB := l2db.NewL2DB(database, database, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
+	l2DB := l2db.NewL2DB(database, 10, 1000, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB()) // this will clean HistoryDB and L2DB
 	// Config (smart contract constants)
 	chainID := uint16(0)
@@ -235,6 +239,7 @@ func TestMain(m *testing.M) {
 		true,
 		apiGin,
 		hdb,
+		sdb,
 		l2DB,
 		&_config,
 	)
@@ -242,14 +247,9 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 	// Start server
-	listener, err := net.Listen("tcp", apiAddr) //nolint:gosec
+	server := &http.Server{Addr: apiPort, Handler: apiGin}
-	if err != nil {
-		panic(err)
-	}
-	server := &http.Server{Handler: apiGin}
 	go func() {
-		if err := server.Serve(listener); err != nil &&
+		if err := server.ListenAndServe(); err != nil && tracerr.Unwrap(err) != http.ErrServerClosed {
-			tracerr.Unwrap(err) != http.ErrServerClosed {
 			panic(err)
 		}
 	}()
@@ -350,6 +350,19 @@ 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)
@@ -516,41 +529,13 @@ 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:         accounts,
+		accounts:         genTestAccounts(commonAccounts, testTokens),
 		txs:              testTxs,
 		exits:            testExits,
 		poolTxsToSend:    poolTxsToSend,
@@ -597,10 +582,10 @@ func TestTimeout(t *testing.T) {
 	databaseTO, err := db.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	apiConnConTO := db.NewAPICnnectionController(1, 100*time.Millisecond)
-	hdbTO := historydb.NewHistoryDB(databaseTO, databaseTO, apiConnConTO)
+	hdbTO := historydb.NewHistoryDB(databaseTO, apiConnConTO)
 	require.NoError(t, err)
 	// L2DB
-	l2DBTO := l2db.NewL2DB(databaseTO, databaseTO, 10, 1000, 1.0, 24*time.Hour, apiConnConTO)
+	l2DBTO := l2db.NewL2DB(databaseTO, 10, 1000, 24*time.Hour, apiConnConTO)
 
 	// API
 	apiGinTO := gin.Default()
@@ -615,12 +600,9 @@ func TestTimeout(t *testing.T) {
 		<-finishWait
 	})
 	// Start server
-	serverTO := &http.Server{Handler: apiGinTO}
+	serverTO := &http.Server{Addr: ":4444", Handler: apiGinTO}
-	listener, err := net.Listen("tcp", ":4444") //nolint:gosec
-	require.NoError(t, err)
 	go func() {
-		if err := serverTO.Serve(listener); err != nil &&
+		if err := serverTO.ListenAndServe(); err != nil && tracerr.Unwrap(err) != http.ErrServerClosed {
-			tracerr.Unwrap(err) != http.ErrServerClosed {
 			require.NoError(t, err)
 		}
 	}()
@@ -630,6 +612,7 @@ func TestTimeout(t *testing.T) {
 		true,
 		apiGinTO,
 		hdbTO,
+		nil,
 		l2DBTO,
 		&_config,
 	)

api/handlers.go

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

api/state.go

@@ -3,7 +3,6 @@ package api
 import (
 	"database/sql"
 	"fmt"
-	"math"
 	"math/big"
 	"net/http"
 	"time"
@@ -298,17 +297,10 @@ func (a *API) UpdateRecommendedFee() error {
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	var minFeeUSD float64
-	if a.l2 != nil {
-		minFeeUSD = a.l2.MinFeeUSD()
-	}
 	a.status.Lock()
-	a.status.RecommendedFee.ExistingAccount =
+	a.status.RecommendedFee.ExistingAccount = feeExistingAccount
-		math.Max(feeExistingAccount, minFeeUSD)
+	a.status.RecommendedFee.CreatesAccount = createAccountExtraFeePercentage * feeExistingAccount
-	a.status.RecommendedFee.CreatesAccount =
+	a.status.RecommendedFee.CreatesAccountAndRegister = createAccountInternalExtraFeePercentage * feeExistingAccount
-		math.Max(createAccountExtraFeePercentage*feeExistingAccount, minFeeUSD)
-	a.status.RecommendedFee.CreatesAccountAndRegister =
-		math.Max(createAccountInternalExtraFeePercentage*feeExistingAccount, minFeeUSD)
 	a.status.Unlock()
 	return nil
 }

api/state_test.go

@@ -131,7 +131,7 @@ func TestUpdateNetworkInfo(t *testing.T) {
 func TestUpdateMetrics(t *testing.T) {
 	// Update Metrics needs api.status.Network.LastBatch.BatchNum to be updated
 	lastBlock := tc.blocks[3]
-	lastBatchNum := common.BatchNum(12)
+	lastBatchNum := common.BatchNum(3)
 	currentSlotNum := int64(1)
 	err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
 	assert.NoError(t, err)
@@ -149,11 +149,7 @@ func TestUpdateMetrics(t *testing.T) {
 func TestUpdateRecommendedFee(t *testing.T) {
 	err := api.UpdateRecommendedFee()
 	assert.NoError(t, err)
-	var minFeeUSD float64
+	assert.Greater(t, api.status.RecommendedFee.ExistingAccount, float64(0))
-	if api.l2 != nil {
-		minFeeUSD = api.l2.MinFeeUSD()
-	}
-	assert.Greater(t, api.status.RecommendedFee.ExistingAccount, minFeeUSD)
 	assert.Equal(t, api.status.RecommendedFee.CreatesAccount,
 		api.status.RecommendedFee.ExistingAccount*createAccountExtraFeePercentage)
 	assert.Equal(t, api.status.RecommendedFee.CreatesAccountAndRegister,
@@ -162,7 +158,7 @@ func TestUpdateRecommendedFee(t *testing.T) {
 
 func TestGetState(t *testing.T) {
 	lastBlock := tc.blocks[3]
-	lastBatchNum := common.BatchNum(12)
+	lastBatchNum := common.BatchNum(3)
 	currentSlotNum := int64(1)
 	api.SetRollupVariables(tc.rollupVars)
 	api.SetWDelayerVariables(tc.wdelayerVars)

api/swagger.yml

@@ -2916,7 +2916,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 + [5 bytes] depositAmountFloat40 + [5 bytes] amountFloat40 + [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 + [2 bytes] depositAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx).
               example: 72
             maxL1UserTx:
               type: integer

api/txspool.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"errors"
-	"fmt"
 	"math/big"
 	"net/http"
 
@@ -28,7 +27,6 @@ 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)
@@ -171,21 +169,16 @@ func (a *API) verifyPoolL2TxWrite(txw *l2db.PoolL2TxWrite) error {
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
+	// Get public key
+	account, err := a.s.LastGetAccount(poolTx.FromIdx)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
 	// Validate feeAmount
 	_, err = common.CalcFeeAmount(poolTx.Amount, poolTx.Fee)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	// Get public key
-	account, err := a.h.GetCommonAccountAPI(poolTx.FromIdx)
-	if err != nil {
-		return tracerr.Wrap(err)
-	}
-	// Validate TokenID
-	if poolTx.TokenID != account.TokenID {
-		return tracerr.Wrap(fmt.Errorf("tx.TokenID (%v) != account.TokenID (%v)",
-			poolTx.TokenID, account.TokenID))
-	}
 	// Check signature
 	if !poolTx.VerifySignature(a.chainID, account.BJJ) {
 		return tracerr.Wrap(errors.New("wrong signature"))

api/txspool_test.go

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

batchbuilder/batchbuilder.go

@@ -2,7 +2,6 @@ package batchbuilder
 
 import (
 	"github.com/hermeznetwork/hermez-node/common"
-	"github.com/hermeznetwork/hermez-node/db/kvdb"
 	"github.com/hermeznetwork/hermez-node/db/statedb"
 	"github.com/hermeznetwork/hermez-node/txprocessor"
 	"github.com/hermeznetwork/tracerr"
@@ -29,14 +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) {
-	localStateDB, err := statedb.NewLocalStateDB(
+	localStateDB, err := statedb.NewLocalStateDB(dbpath, 128, synchronizerStateDB,
-		statedb.Config{
+		statedb.TypeBatchBuilder, int(nLevels))
-			Path:    dbpath,
-			Keep:    kvdb.DefaultKeep,
-			Type:    statedb.TypeBatchBuilder,
-			NLevels: int(nLevels),
-		},
-		synchronizerStateDB)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -54,7 +47,7 @@ func NewBatchBuilder(dbpath string, synchronizerStateDB *statedb.StateDB, batchN
 // copy of the rollup state from the Synchronizer at that `batchNum`, otherwise
 // it can just roll back the internal copy.
 func (bb *BatchBuilder) Reset(batchNum common.BatchNum, fromSynchronizer bool) error {
-	return tracerr.Wrap(bb.localStateDB.Reset(batchNum, fromSynchronizer))
+	return bb.localStateDB.Reset(batchNum, fromSynchronizer)
 }
 
 // BuildBatch takes the transactions and returns the common.ZKInputs of the next batch
@@ -64,10 +57,7 @@ func (bb *BatchBuilder) BuildBatch(coordIdxs []common.Idx, configBatch *ConfigBa
 	tp := txprocessor.NewTxProcessor(bbStateDB, configBatch.TxProcessorConfig)
 
 	ptOut, err := tp.ProcessTxs(coordIdxs, l1usertxs, l1coordinatortxs, pooll2txs)
-	if err != nil {
+	return ptOut.ZKInputs, tracerr.Wrap(err)
-		return nil, tracerr.Wrap(err)
-	}
-	return ptOut.ZKInputs, nil
 }
 
 // LocalStateDB returns the underlying LocalStateDB

batchbuilder/batchbuilder_test.go

@@ -15,7 +15,7 @@ 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(dir, 128, statedb.TypeBatchBuilder, 0)
 	assert.Nil(t, err)
 
 	bbDir, err := ioutil.TempDir("", "tmpBatchBuilderDB")

cli/node/.gitignore

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

cli/node/README.md

@@ -2,10 +2,6 @@
 
 This is the main cli for the node
 
-## Go version
-
-The `hermez-node` has been tested with go version 1.14
-
 ## Usage
 
 ```
@@ -69,64 +65,29 @@ 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:
-```
-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:
-```
-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:
 ```
-./node --mode sync --cfg cfg.buidler.toml run
+go run . --mode sync --cfg cfg.buidler.toml run
 ```
 
 Run the node in mode coordinator:
 ```
-./node --mode coord --cfg cfg.buidler.toml run
+go run . --mode coord --cfg cfg.buidler.toml run
 ```
 
 Import an ethereum private key into the keystore:
 ```
-./node --mode coord --cfg cfg.buidler.toml importkey --privatekey  0x618b35096c477aab18b11a752be619f0023a539bb02dd6c813477a6211916cde
+go run . --mode coord --cfg cfg.buidler.toml importkey --privatekey  0x618b35096c477aab18b11a752be619f0023a539bb02dd6c813477a6211916cde
 ```
 
 Generate a new BabyJubJub key pair:
 ```
-./node --mode coord --cfg cfg.buidler.toml genbjj
+go run . --mode coord --cfg cfg.buidler.toml genbjj
 ```
 
-Wipe the entier SQL database (this will destroy all synchronized and pool
+Wipe the entier SQL database (this will destroy all synchronized and pool data):
-data):
 ```
-./node --mode coord --cfg cfg.buidler.toml wipesql
+go run . --mode coord --cfg cfg.buidler.toml wipesql
-```
-
-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).
-```
-./node --mode coord --cfg cfg.buidler.toml discard --block 8061330
 ```

cli/node/cfg.buidler.toml

@@ -20,16 +20,11 @@ Path = "/tmp/iden3-test/hermez/statedb"
 Keep = 256
 
 [PostgreSQL]
-PortWrite     = 5432
+Port     = 5432
-HostWrite     = "localhost"
+Host     = "localhost"
-UserWrite     = "hermez"
+User     = "hermez"
-PasswordWrite = "yourpasswordhere"
+Password = "yourpasswordhere"
-NameWrite     = "hermez"
+Name     = "hermez"
-# PortRead     = 5432
-# HostRead     = "localhost"
-# UserRead     = "hermez"
-# PasswordRead = "yourpasswordhere"
-# NameRead     = "hermez"
 
 [Web3]
 URL = "http://localhost:8545"
@@ -46,21 +41,15 @@ TokenHEZ = "0x5D94e3e7aeC542aB0F9129B9a7BAdeb5B3Ca0f77"
 TokenHEZName = "Hermez Network Token"
 
 [Coordinator]
-ForgerAddress = "0x05c23b938a85ab26A36E6314a0D02080E9ca6BeD" # Non-Boot Coordinator
+# ForgerAddress = "0x05c23b938a85ab26A36E6314a0D02080E9ca6BeD" # Non-Boot Coordinator
 # ForgerAddressPrivateKey = "0x30f5fddb34cd4166adb2c6003fa6b18f380fd2341376be42cf1c7937004ac7a3"
-# ForgerAddress = "0xb4124ceb3451635dacedd11767f004d8a28c6ee7" # Boot Coordinator
+ForgerAddress = "0xb4124ceb3451635dacedd11767f004d8a28c6ee7" # Boot Coordinator
 # ForgerAddressPrivateKey = "0xa8a54b2d8197bc0b19bb8a084031be71835580a01e70a45a13babd16c9bc1563"
 ConfirmBlocks = 10
-L1BatchTimeoutPerc = 0.6
+L1BatchTimeoutPerc = 0.999
-StartSlotBlocksDelay = 2
-ScheduleBatchBlocksAheadCheck = 3
-SendBatchBlocksMarginCheck = 1
 ProofServerPollInterval = "1s"
 ForgeRetryInterval = "500ms"
 SyncRetryInterval = "1s"
-ForgeDelay = "10s"
-ForgeNoTxsDelay = "0s"
-PurgeByExtDelInterval = "1m"
 
 [Coordinator.FeeAccount]
 Address = "0x56232B1c5B10038125Bc7345664B4AFD745bcF8E"
@@ -71,7 +60,6 @@ BJJ = "0x1b176232f78ba0d388ecc5f4896eca2d3b3d4f272092469f559247297f5c0c13"
 [Coordinator.L2DB]
 SafetyPeriod = 10
 MaxTxs       = 512
-MinFeeUSD    = 0.0
 TTL          = "24h"
 PurgeBatchDelay = 10
 InvalidateBatchDelay = 20
@@ -92,28 +80,21 @@ MaxTx = 512
 NLevels = 32
 
 [Coordinator.EthClient]
+ReceiptTimeout      = "60s"
+ReceiptLoopInterval = "500ms"
 CheckLoopInterval = "500ms"
 Attempts = 4
 AttemptsDelay = "500ms"
-TxResendTimeout = "2m"
+CallGasLimit = 300000
-NoReuseNonce = false
+GasPriceDiv = 100
-MaxGasPrice = "5000000000"
-GasPriceIncPerc = 10
 
 [Coordinator.EthClient.Keystore]
 Path = "/tmp/iden3-test/hermez/ethkeystore"
 Password = "yourpasswordhere"
 
-[Coordinator.EthClient.ForgeBatchGasCost]
-Fixed = 500000
-L1UserTx = 8000
-L1CoordTx = 9000
-L2Tx = 1
-
 [Coordinator.API]
 Coordinator = true
 
 [Coordinator.Debug]
 BatchPath = "/tmp/iden3-test/hermez/batchesdebug"
 LightScrypt = true
-# RollupVerifierIndex = 0

cli/node/main.go

@@ -11,13 +11,10 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"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/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"
 )
 
@@ -26,7 +23,6 @@ const (
 	flagMode  = "mode"
 	flagSK    = "privatekey"
 	flagYes   = "yes"
-	flagBlock = "block"
 	modeSync  = "sync"
 	modeCoord = "coord"
 )
@@ -91,11 +87,11 @@ func cmdWipeSQL(c *cli.Context) error {
 		}
 	}
 	db, err := dbUtils.ConnectSQLDB(
-		cfg.PostgreSQL.PortWrite,
+		cfg.PostgreSQL.Port,
-		cfg.PostgreSQL.HostWrite,
+		cfg.PostgreSQL.Host,
-		cfg.PostgreSQL.UserWrite,
+		cfg.PostgreSQL.User,
-		cfg.PostgreSQL.PasswordWrite,
+		cfg.PostgreSQL.Password,
-		cfg.PostgreSQL.NameWrite,
+		cfg.PostgreSQL.Name,
 	)
 	if err != nil {
 		return tracerr.Wrap(err)
@@ -143,67 +139,6 @@ func cmdRun(c *cli.Context) error {
 	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.TTL.Duration,
-		nil,
-	)
-	if err := l2DB.Reorg(batchNum); err != nil {
-		return tracerr.Wrap(fmt.Errorf("l2DB.Reorg: %w", err))
-	}
-
-	return nil
-}
-
 // Config is the configuration of the hermez node execution
 type Config struct {
 	mode node.Mode
@@ -304,18 +239,6 @@ func main() {
 			Usage:   "Run the hermez-node in the indicated mode",
 			Action:  cmdRun,
 		},
-		{
-			Name:    "discard",
-			Aliases: []string{},
-			Usage:   "Discard blocks up to a specified block number",
-			Action:  cmdDiscard,
-			Flags: []cli.Flag{
-				&cli.Int64Flag{
-					Name:     flagBlock,
-					Usage:    "last block number to keep",
-					Required: false,
-				}},
-		},
 	}
 
 	err := app.Run(os.Args)

common/account.go

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

common/accountcreationauths.go

@@ -17,11 +17,6 @@ const AccountCreationAuthMsg = "I authorize this babyjubjub key for hermez rollu
 // EthMsgPrefix is the prefix for message signing at the Ethereum ecosystem
 const EthMsgPrefix = "\x19Ethereum Signed Message:\n"
 
-var (
-	// EmptyEthSignature is an ethereum signature of all zeroes
-	EmptyEthSignature = make([]byte, 65)
-)
-
 // AccountCreationAuth authorizations sent by users to the L2DB, to be used for
 // account creations when necessary
 type AccountCreationAuth struct {

common/batch.go

@@ -27,24 +27,6 @@ type Batch struct {
 	TotalFeesUSD       *float64             `meddler:"total_fees_usd"`
 }
 
-// NewEmptyBatch creates a new empty batch
-func NewEmptyBatch() *Batch {
-	return &Batch{
-		BatchNum:           0,
-		EthBlockNum:        0,
-		ForgerAddr:         ethCommon.Address{},
-		CollectedFees:      make(map[TokenID]*big.Int),
-		FeeIdxsCoordinator: make([]Idx, 0),
-		StateRoot:          big.NewInt(0),
-		NumAccounts:        0,
-		LastIdx:            0,
-		ExitRoot:           big.NewInt(0),
-		ForgeL1TxsNum:      nil,
-		SlotNum:            0,
-		TotalFeesUSD:       nil,
-	}
-}
-
 // BatchNum identifies a batch
 type BatchNum int64
 
@@ -77,7 +59,6 @@ type BatchData struct {
 	L1CoordinatorTxs []L1Tx
 	L2Txs            []L2Tx
 	CreatedAccounts  []Account
-	UpdatedAccounts  []AccountUpdate
 	ExitTree         []ExitInfo
 	Batch            Batch
 }

common/ethauction.go

@@ -33,8 +33,7 @@ func (c *AuctionConstants) SlotNum(blockNum int64) int64 {
 	if blockNum >= c.GenesisBlockNum {
 		return (blockNum - c.GenesisBlockNum) / int64(c.BlocksPerSlot)
 	}
-	// This result will be negative
+	return -1
-	return (blockNum - c.GenesisBlockNum) / int64(c.BlocksPerSlot)
 }
 
 // SlotBlocks returns the first and the last block numbers included in that slot

common/ethrollup.go

@@ -24,8 +24,8 @@ const (
 	// RollupConstL1CoordinatorTotalBytes [4 bytes] token + [32 bytes] babyjub + [65 bytes] compressedSignature
 	RollupConstL1CoordinatorTotalBytes = 101
 	// RollupConstL1UserTotalBytes [20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6 bytes] fromIdx +
-	// [5 bytes] depositAmountFloat40 + [5 bytes] amountFloat40 + [4 bytes] tokenId + [6 bytes] toIdx
+	// [2 bytes] depositAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx
-	RollupConstL1UserTotalBytes = 78
+	RollupConstL1UserTotalBytes = 72
 	// 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

common/float16.go

@@ -0,0 +1,131 @@
+// 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

@@ -0,0 +1,132 @@
+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

@@ -1,103 +0,0 @@
-// Package common Float40 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")
-)
-
-// 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, 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)
-	thres := big.NewInt(0x08_00_00_00_00)
-	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, ErrFloat40E31
-	}
-	if m.Cmp(thres) >= 0 {
-		return 0, ErrFloat40NotEnoughPrecission
-	}
-	r := new(big.Int).Add(m,
-		new(big.Int).Mul(e, thres))
-	return Float40(r.Uint64()), nil
-}

common/float40_test.go

@@ -1,95 +0,0 @@
-package common
-
-import (
-	"math/big"
-	"testing"
-
-	"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], err)
-	}
-}
-
-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,11 +11,18 @@ 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 (32 bytes) for L1Tx is the Keccak256 (ethereum) hash of:
+	// TxID (12 bytes) for L1Tx is:
 	// bytes:  |  1   |        8        |    2     |      1      |
 	// values: | type | ToForgeL1TxsNum | Position | 0 (padding) |
 	// where type:
@@ -172,38 +179,45 @@ 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:  225 bits // 29 bytes in *big.Int representation
+// Total bits compressed data:  241 bits // 31 bytes in *big.Int representation
 func (tx L1Tx) TxCompressedData(chainID uint16) (*big.Int, error) {
-	var b [29]byte
+	amountFloat16, err := NewFloat16(tx.Amount)
+	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[11:17], toIdxBytes[:])
+	copy(b[13:19], toIdxBytes[:])
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[17:23], fromIdxBytes[:])
+	copy(b[19:25], fromIdxBytes[:])
-	binary.BigEndian.PutUint16(b[23:25], chainID)
+	binary.BigEndian.PutUint16(b[25:27], chainID)
-	copy(b[25:29], SignatureConstantBytes[:])
+	copy(b[27:31], SignatureConstantBytes[:])
 
 	bi := new(big.Int).SetBytes(b[:])
 	return bi, nil
 }
 
 // BytesDataAvailability encodes a L1Tx into []byte for the Data Availability
-// [ fromIdx | toIdx | amountFloat40 | Fee ]
+// [ fromIdx | toIdx | amountFloat16 | Fee ]
 func (tx *L1Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 	idxLen := nLevels / 8 //nolint:gomnd
 
-	b := make([]byte, ((nLevels*2)+40+8)/8) //nolint:gomnd
+	b := make([]byte, ((nLevels*2)+16+8)/8) //nolint:gomnd
 
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
@@ -217,17 +231,13 @@ func (tx *L1Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 	copy(b[idxLen:idxLen*2], toIdxBytes[6-idxLen:])
 
 	if tx.EffectiveAmount != nil {
-		amountFloat40, err := NewFloat40(tx.EffectiveAmount)
+		amountFloat16, err := NewFloat16(tx.EffectiveAmount)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
-		amountFloat40Bytes, err := amountFloat40.Bytes()
+		copy(b[idxLen*2:idxLen*2+2], amountFloat16.Bytes())
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-		copy(b[idxLen*2:idxLen*2+Float40BytesLength], amountFloat40Bytes)
 	}
-	// fee = 0 (as is L1Tx)
+	// fee = 0 (as is L1Tx) b[10:11]
 	return b[:], nil
 }
 
@@ -237,7 +247,7 @@ func L1TxFromDataAvailability(b []byte, nLevels uint32) (*L1Tx, error) {
 
 	fromIdxBytes := b[0:idxLen]
 	toIdxBytes := b[idxLen : idxLen*2]
-	amountBytes := b[idxLen*2 : idxLen*2+Float40BytesLength]
+	amountBytes := b[idxLen*2 : idxLen*2+2]
 
 	l1tx := L1Tx{}
 	fromIdx, err := IdxFromBytes(ethCommon.LeftPadBytes(fromIdxBytes, 6))
@@ -250,8 +260,8 @@ func L1TxFromDataAvailability(b []byte, nLevels uint32) (*L1Tx, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	l1tx.ToIdx = toIdx
-	l1tx.EffectiveAmount, err = Float40FromBytes(amountBytes).BigInt()
+	l1tx.EffectiveAmount = Float16FromBytes(amountBytes).BigInt()
-	return &l1tx, err
+	return &l1tx, nil
 }
 
 // BytesGeneric returns the generic representation of a L1Tx. This method is
@@ -259,7 +269,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 [RollupConstL1UserTotalBytes]byte
+	var b [L1UserTxBytesLen]byte
 	copy(b[0:20], tx.FromEthAddr.Bytes())
 	if tx.FromBJJ != EmptyBJJComp {
 		pkCompL := tx.FromBJJ
@@ -271,33 +281,22 @@ 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)
 	}
-	depositAmountFloat40Bytes, err := depositAmountFloat40.Bytes()
+	copy(b[58:60], depositAmountFloat16.Bytes())
+	amountFloat16, err := NewFloat16(tx.Amount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[58:63], depositAmountFloat40Bytes)
+	copy(b[60:62], amountFloat16.Bytes())
-
+	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[72:78], toIdxBytes[:])
+	copy(b[66:72], toIdxBytes[:])
 	return b[:], nil
 }
 
@@ -314,7 +313,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 [RollupConstL1CoordinatorTotalBytes]byte
+	var b [L1CoordinatorTxBytesLen]byte
 	v := compressedSignatureBytes[64]
 	s := compressedSignatureBytes[32:64]
 	r := compressedSignatureBytes[0:32]
@@ -330,7 +329,7 @@ func (tx *L1Tx) BytesCoordinatorTx(compressedSignatureBytes []byte) ([]byte, err
 
 // L1UserTxFromBytes decodes a L1Tx from []byte
 func L1UserTxFromBytes(b []byte) (*L1Tx, error) {
-	if len(b) != RollupConstL1UserTotalBytes {
+	if len(b) != L1UserTxBytesLen {
 		return nil, tracerr.Wrap(fmt.Errorf("Can not parse L1Tx bytes, expected length %d, current: %d", 68, len(b)))
 	}
 
@@ -348,19 +347,13 @@ func L1UserTxFromBytes(b []byte) (*L1Tx, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	tx.FromIdx = fromIdx
-	tx.DepositAmount, err = Float40FromBytes(b[58:63]).BigInt()
+	tx.DepositAmount = Float16FromBytes(b[58:60]).BigInt()
+	tx.Amount = Float16FromBytes(b[60:62]).BigInt()
+	tx.TokenID, err = TokenIDFromBytes(b[62:66])
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	tx.Amount, err = Float40FromBytes(b[63:68]).BigInt()
+	tx.ToIdx, err = IdxFromBytes(b[66:72])
-	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)
 	}
@@ -375,7 +368,7 @@ func signHash(data []byte) []byte {
 
 // L1CoordinatorTxFromBytes decodes a L1Tx from []byte
 func L1CoordinatorTxFromBytes(b []byte, chainID *big.Int, hermezAddress ethCommon.Address) (*L1Tx, error) {
-	if len(b) != RollupConstL1CoordinatorTotalBytes {
+	if len(b) != L1CoordinatorTxBytesLen {
 		return nil, tracerr.Wrap(fmt.Errorf("Can not parse L1CoordinatorTx bytes, expected length %d, current: %d", 101, len(b)))
 	}
 

common/l1tx_test.go

@@ -50,110 +50,64 @@ func TestNewL1CoordinatorTx(t *testing.T) {
 }
 
 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: (1 << 48) - 1,
+		FromIdx: 2,
-		ToIdx:   (1 << 48) - 1,
+		ToIdx:   3,
-		Amount:  amount,
+		Amount:  big.NewInt(4),
-		TokenID: (1 << 32) - 1,
+		TokenID: 5,
 	}
-	txCompressedData, err := tx.TxCompressedData(uint16((1 << 16) - 1))
+	chainID := uint16(0)
+	txCompressedData, err := tx.TxCompressedData(chainID)
 	assert.NoError(t, err)
-	expectedStr := "ffffffffffffffffffffffffffffffffffffc60be60f"
-	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
 
-	tx = L1Tx{
+	// test vector value generated from javascript implementation
-		FromIdx: 0,
+	expectedStr := "7307597389635308713748674793997299267459594577423"
-		ToIdx:   0,
+	assert.Equal(t, expectedStr, txCompressedData.String())
-		Amount:  big.NewInt(0),
+	assert.Equal(t, "0500040000000000030000000000020000c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
-		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{
-		ToIdx:           (1 << 16) - 1,
+		FromIdx: 2,
-		FromIdx:         (1 << 16) - 1,
+		ToIdx:   3,
-		EffectiveAmount: amount,
+		Amount:  big.NewInt(4),
+		TokenID: 5,
 	}
-	txCompressedData, err := tx.BytesDataAvailability(16)
+	txCompressedData, err := tx.BytesDataAvailability(32)
 	assert.NoError(t, err)
-	assert.Equal(t, "ffffffffffffffffff00", hex.EncodeToString(txCompressedData))
+	assert.Equal(t, "0000000200000003000000", hex.EncodeToString(txCompressedData))
-	l1tx, err := L1TxFromDataAvailability(txCompressedData, 16)
-	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:           (1 << 32) - 1,
+		FromIdx:         2,
-		FromIdx:         (1 << 32) - 1,
+		ToIdx:           3,
-		EffectiveAmount: amount,
+		EffectiveAmount: big.NewInt(4),
+		TokenID:         5,
 	}
 	txCompressedData, err = tx.BytesDataAvailability(32)
 	assert.NoError(t, err)
-	assert.Equal(t, "ffffffffffffffffffffffffff00", hex.EncodeToString(txCompressedData))
+	assert.Equal(t, "0000000200000003000400", hex.EncodeToString(txCompressedData))
-	l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
+}
+
+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{
-		ToIdx:           0,
+		FromIdx:         2,
-		FromIdx:         0,
+		ToIdx:           3,
-		EffectiveAmount: big.NewInt(0),
+		EffectiveAmount: big.NewInt(4),
 	}
 	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)
@@ -218,10 +172,12 @@ func TestL1TxByteParsersCompatibility(t *testing.T) {
 		UserOrigin:    true,
 	}
 
+	expected, err := utils.HexDecode("85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a000001c638db8be880f00020039c0000053cb88d")
+	require.NoError(t, err)
+
 	encodedData, err := l1Tx.BytesUser()
 	require.NoError(t, err)
-	expected := "85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a000001c638db52540be400459682f0000020039c0000053cb88d"
+	assert.Equal(t, expected, encodedData)
-	assert.Equal(t, expected, hex.EncodeToString(encodedData))
 }
 
 func TestL1CoordinatorTxByteParsers(t *testing.T) {

common/l2tx.go

@@ -89,15 +89,11 @@ func (tx L2Tx) CalculateTxID() ([TxIDLen]byte, error) {
 	// TokenID
 	b = append(b, tx.TokenID.Bytes()[:]...)
 	// Amount
-	amountFloat40, err := NewFloat40(tx.Amount)
+	amountFloat16, err := NewFloat16(tx.Amount)
 	if err != nil {
 		return txID, tracerr.Wrap(fmt.Errorf("%s: %d", err, tx.Amount))
 	}
-	amountFloat40Bytes, err := amountFloat40.Bytes()
+	b = append(b, amountFloat16.Bytes()...)
-	if err != nil {
-		return txID, tracerr.Wrap(err)
-	}
-	b = append(b, amountFloat40Bytes...)
 	// Nonce
 	nonceBytes, err := tx.Nonce.Bytes()
 	if err != nil {
@@ -174,11 +170,11 @@ func TxIDsFromL2Txs(txs []L2Tx) []TxID {
 }
 
 // BytesDataAvailability encodes a L2Tx into []byte for the Data Availability
-// [ fromIdx | toIdx | amountFloat40 | Fee ]
+// [ fromIdx | toIdx | amountFloat16 | Fee ]
 func (tx L2Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 	idxLen := nLevels / 8 //nolint:gomnd
 
-	b := make([]byte, ((nLevels*2)+40+8)/8) //nolint:gomnd
+	b := make([]byte, ((nLevels*2)+16+8)/8) //nolint:gomnd
 
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
@@ -192,16 +188,13 @@ func (tx L2Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 	}
 	copy(b[idxLen:idxLen*2], toIdxBytes[6-idxLen:])
 
-	amountFloat40, err := NewFloat40(tx.Amount)
+	amountFloat16, err := NewFloat16(tx.Amount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	amountFloat40Bytes, err := amountFloat40.Bytes()
+
-	if err != nil {
+	copy(b[idxLen*2:idxLen*2+2], amountFloat16.Bytes())
-		return nil, tracerr.Wrap(err)
+	b[idxLen*2+2] = byte(tx.Fee)
-	}
-	copy(b[idxLen*2:idxLen*2+Float40BytesLength], amountFloat40Bytes)
-	b[idxLen*2+Float40BytesLength] = byte(tx.Fee)
 
 	return b[:], nil
 }
@@ -226,10 +219,7 @@ func L2TxFromBytesDataAvailability(b []byte, nLevels int) (*L2Tx, error) {
 		return nil, tracerr.Wrap(err)
 	}
 
-	tx.Amount, err = Float40FromBytes(b[idxLen*2 : idxLen*2+Float40BytesLength]).BigInt()
+	tx.Amount = Float16FromBytes(b[idxLen*2 : idxLen*2+2]).BigInt()
-	if err != nil {
+	tx.Fee = FeeSelector(b[idxLen*2+2])
-		return nil, tracerr.Wrap(err)
-	}
-	tx.Fee = FeeSelector(b[idxLen*2+Float40BytesLength])
 	return tx, nil
 }

common/l2tx_test.go

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

common/pooll2tx.go

@@ -36,7 +36,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"`
+	Amount    *big.Int              `meddler:"amount,bigint"` // TODO: change to float16
 	Fee       FeeSelector           `meddler:"fee"`
 	Nonce     Nonce                 `meddler:"nonce"` // effective 40 bits used
 	State     PoolL2TxState         `meddler:"state"`
@@ -53,7 +53,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"`
+	RqAmount          *big.Int              `meddler:"rq_amount,bigintnull"` // TODO: change to float16
 	RqFee             FeeSelector           `meddler:"rq_fee,zeroisnull"`
 	RqNonce           Nonce                 `meddler:"rq_nonce,zeroisnull"` // effective 48 bits used
 	AbsoluteFee       float64               `meddler:"fee_usd,zeroisnull"`
@@ -122,13 +122,18 @@ 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:  225 bits // 29 bytes in *big.Int representation
+// Total bits compressed data:  241 bits // 31 bytes in *big.Int representation
 func (tx *PoolL2Tx) TxCompressedData(chainID uint16) (*big.Int, error) {
-	var b [29]byte
+	amountFloat16, err := NewFloat16(tx.Amount)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	var b [31]byte
 
 	toBJJSign := byte(0)
 	pkSign, _ := babyjub.UnpackSignY(tx.ToBJJ)
@@ -144,18 +149,19 @@ 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[11:17], toIdxBytes[:])
+	copy(b[13:19], toIdxBytes[:])
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[17:23], fromIdxBytes[:])
+	copy(b[19:25], fromIdxBytes[:])
-	binary.BigEndian.PutUint16(b[23:25], chainID)
+	binary.BigEndian.PutUint16(b[25:27], chainID)
-	copy(b[25:29], SignatureConstantBytes[:])
+	copy(b[27:31], SignatureConstantBytes[:])
 
 	bi := new(big.Int).SetBytes(b[:])
 	return bi, nil
@@ -164,9 +170,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 [29]byte
+	var b [31]byte
-	binary.BigEndian.PutUint16(b[23:25], chainID)
+	binary.BigEndian.PutUint16(b[25:27], chainID)
-	copy(b[25:29], SignatureConstantBytes[:])
+	copy(b[27:31], SignatureConstantBytes[:])
 	bi := new(big.Int).SetBytes(b[:])
 	return bi
 }
@@ -176,24 +182,19 @@ func TxCompressedDataEmpty(chainID uint16) *big.Int {
 // [ 8 bits  ] userFee // 1 byte
 // [ 40 bits ] nonce // 5 bytes
 // [ 32 bits ] tokenID // 4 bytes
-// [ 40 bits ] amountFloat40 // 5 bytes
+// [ 16 bits ] amountFloat16 // 2 bytes
 // [ 48 bits ] toIdx // 6 bytes
 // [ 48 bits ] fromIdx // 6 bytes
-// Total bits compressed data:  217 bits // 28 bytes in *big.Int representation
+// Total bits compressed data:  193 bits // 25 bytes in *big.Int representation
 func (tx *PoolL2Tx) TxCompressedDataV2() (*big.Int, error) {
 	if tx.Amount == nil {
 		tx.Amount = big.NewInt(0)
 	}
-	amountFloat40, err := NewFloat40(tx.Amount)
+	amountFloat16, err := NewFloat16(tx.Amount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	amountFloat40Bytes, err := amountFloat40.Bytes()
+	var b [25]byte
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-
-	var b [28]byte
 	toBJJSign := byte(0)
 	if tx.ToBJJ != EmptyBJJComp {
 		sign, _ := babyjub.UnpackSignY(tx.ToBJJ)
@@ -209,17 +210,17 @@ func (tx *PoolL2Tx) TxCompressedDataV2() (*big.Int, error) {
 	}
 	copy(b[2:7], nonceBytes[:])
 	copy(b[7:11], tx.TokenID.Bytes())
-	copy(b[11:16], amountFloat40Bytes)
+	copy(b[11:13], amountFloat16.Bytes())
 	toIdxBytes, err := tx.ToIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[16:22], toIdxBytes[:])
+	copy(b[13:19], toIdxBytes[:])
 	fromIdxBytes, err := tx.FromIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[22:28], fromIdxBytes[:])
+	copy(b[19:25], fromIdxBytes[:])
 
 	bi := new(big.Int).SetBytes(b[:])
 	return bi, nil
@@ -235,24 +236,19 @@ func (tx *PoolL2Tx) TxCompressedDataV2() (*big.Int, error) {
 // [ 8 bits  ] rqUserFee // 1 byte
 // [ 40 bits ] rqNonce // 5 bytes
 // [ 32 bits ] rqTokenID // 4 bytes
-// [ 40 bits ] rqAmountFloat40 // 5 bytes
+// [ 16 bits ] rqAmountFloat16 // 2 bytes
 // [ 48 bits ] rqToIdx // 6 bytes
 // [ 48 bits ] rqFromIdx // 6 bytes
-// Total bits compressed data:  217 bits // 28 bytes in *big.Int representation
+// Total bits compressed data:  193 bits // 25 bytes in *big.Int representation
 func (tx *PoolL2Tx) RqTxCompressedDataV2() (*big.Int, error) {
 	if tx.RqAmount == nil {
 		tx.RqAmount = big.NewInt(0)
 	}
-	amountFloat40, err := NewFloat40(tx.RqAmount)
+	amountFloat16, err := NewFloat16(tx.RqAmount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	amountFloat40Bytes, err := amountFloat40.Bytes()
+	var b [25]byte
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-
-	var b [28]byte
 	rqToBJJSign := byte(0)
 	if tx.RqToBJJ != EmptyBJJComp {
 		sign, _ := babyjub.UnpackSignY(tx.RqToBJJ)
@@ -268,17 +264,17 @@ func (tx *PoolL2Tx) RqTxCompressedDataV2() (*big.Int, error) {
 	}
 	copy(b[2:7], nonceBytes[:])
 	copy(b[7:11], tx.RqTokenID.Bytes())
-	copy(b[11:16], amountFloat40Bytes)
+	copy(b[11:13], amountFloat16.Bytes())
 	toIdxBytes, err := tx.RqToIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[16:22], toIdxBytes[:])
+	copy(b[13:19], toIdxBytes[:])
 	fromIdxBytes, err := tx.RqFromIdx.Bytes()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[22:28], fromIdxBytes[:])
+	copy(b[19:25], fromIdxBytes[:])
 
 	bi := new(big.Int).SetBytes(b[:])
 	return bi, nil
@@ -291,22 +287,7 @@ func (tx *PoolL2Tx) HashToSign(chainID uint16) (*big.Int, error) {
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-
-	// 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)
 	toEthAddr := EthAddrToBigInt(tx.ToEthAddr)
-	copy(e1B[5:25], toEthAddr.Bytes())
-	e1 := new(big.Int).SetBytes(e1B[:])
-
 	rqToEthAddr := EthAddrToBigInt(tx.RqToEthAddr)
 
 	_, toBJJY := babyjub.UnpackSignY(tx.ToBJJ)
@@ -318,7 +299,7 @@ func (tx *PoolL2Tx) HashToSign(chainID uint16) (*big.Int, error) {
 
 	_, rqToBJJY := babyjub.UnpackSignY(tx.RqToBJJ)
 
-	return poseidon.Hash([]*big.Int{toCompressedData, e1, toBJJY, rqTxCompressedDataV2, rqToEthAddr, rqToBJJY})
+	return poseidon.Hash([]*big.Int{toCompressedData, toEthAddr, toBJJY, rqTxCompressedDataV2, rqToEthAddr, rqToBJJY})
 }
 
 // VerifySignature returns true if the signature verification is correct for the given PublicKeyComp

common/pooll2tx_test.go

@@ -21,104 +21,80 @@ func TestNewPoolL2Tx(t *testing.T) {
 	}
 	poolL2Tx, err := NewPoolL2Tx(poolL2Tx)
 	assert.NoError(t, err)
-	assert.Equal(t, "0x022669acda59b827d20ef5354a3eebd1dffb3972b0a6bf89d18bfd2efa0ab9f41e", poolL2Tx.TxID.String())
+	assert.Equal(t, "0x02fb52b5d0b9ef2626c11701bb751b2720c76d59946b9a48146ac153bb6e63bf6a", poolL2Tx.TxID.String())
 }
 
-func TestTxCompressedDataAndTxCompressedDataV2JSVectors(t *testing.T) {
+func TestTxCompressedData(t *testing.T) {
-	// test vectors values generated from javascript implementation
+	chainID := uint16(0)
-	var skPositive babyjub.PrivateKey // 'Positive' refers to the sign
+	var sk babyjub.PrivateKey
-	_, err := hex.Decode(skPositive[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	_, err := hex.Decode(sk[:], []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: (1 << 48) - 1,
-		ToIdx:   (1 << 48) - 1,
-		Amount:  amount,
-		TokenID: (1 << 32) - 1,
-		Nonce:   (1 << 40) - 1,
-		Fee:     (1 << 3) - 1,
-		ToBJJ:   skPositive.Public().Compress(),
-	}
-	txCompressedData, err := tx.TxCompressedData(uint16((1 << 16) - 1))
-	require.NoError(t, err)
-	expectedStr := "0107ffffffffffffffffffffffffffffffffffffffffffffffc60be60f"
-	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
-
-	txCompressedDataV2, err := tx.TxCompressedDataV2()
-	require.NoError(t, err)
-	expectedStr = "0107ffffffffffffffffffffffffffffffffffffffffffffffffffff"
-	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedDataV2.Bytes()))
-
-	tx = PoolL2Tx{
-		FromIdx: 0,
-		ToIdx:   0,
-		Amount:  big.NewInt(0),
-		TokenID: 0,
-		Nonce:   0,
-		Fee:     0,
-		ToBJJ:   skNegative.Public().Compress(),
-	}
-	txCompressedData, err = tx.TxCompressedData(uint16(0))
-	require.NoError(t, err)
-	expectedStr = "c60be60f"
-	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
-
-	txCompressedDataV2, err = tx.TxCompressedDataV2()
-	require.NoError(t, err)
-	assert.Equal(t, "0", txCompressedDataV2.String())
-
-	amount, ok = new(big.Int).SetString("63000000000000000", 10)
-	require.True(t, ok)
-	tx = PoolL2Tx{
-		FromIdx: 324,
-		ToIdx:   256,
-		Amount:  amount,
-		TokenID: 123,
-		Nonce:   76,
-		Fee:     214,
-		ToBJJ:   skNegative.Public().Compress(),
-	}
-	txCompressedData, err = tx.TxCompressedData(uint16(1))
-	require.NoError(t, err)
-	expectedStr = "d6000000004c0000007b0000000001000000000001440001c60be60f"
-	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
-
-	txCompressedDataV2, err = tx.TxCompressedDataV2()
-	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,
+		Amount:  big.NewInt(4),
-		Nonce:   5,
+		TokenID: 5,
-		Fee:     6,
+		Nonce:   6,
-		ToBJJ:   skPositive.Public().Compress(),
+		ToBJJ:   sk.Public().Compress(),
 	}
-	txCompressedData, err = tx.TxCompressedData(uint16(0))
+	txCompressedData, err := tx.TxCompressedData(chainID)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	expectedStr = "01060000000005000000040000000000030000000000020000c60be60f"
+	// test vector value generated from javascript implementation
-	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
+	expectedStr := "1766847064778421992193717128424891165872736891548909569553540445094274575"
+	assert.Equal(t, expectedStr, txCompressedData.String())
+	assert.Equal(t, "010000000000060000000500040000000000030000000000020000c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
+	// using a different chainID
+	txCompressedData, err = tx.TxCompressedData(uint16(100))
+	assert.NoError(t, err)
+	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,
+		RqToIdx:   8,
+		RqAmount:  big.NewInt(9),
+		RqTokenID: 10,
+		RqNonce:   11,
+		RqFee:     12,
+		RqToBJJ:   sk.Public().Compress(),
+	}
+	rqTxCompressedData, err := tx.RqTxCompressedDataV2()
+	assert.NoError(t, err)
+	// test vector value generated from javascript implementation
+	expectedStr = "6571340879233176732837827812956721483162819083004853354503"
+	assert.Equal(t, expectedStr, rqTxCompressedData.String())
+	assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(rqTxCompressedData.Bytes()))
+}
+
+func TestTxCompressedDataV2(t *testing.T) {
+	var sk babyjub.PrivateKey
+	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
+	assert.NoError(t, err)
+	tx := PoolL2Tx{
+		FromIdx: 7,
+		ToIdx:   8,
+		Amount:  big.NewInt(9),
+		TokenID: 10,
+		Nonce:   11,
+		Fee:     12,
+		ToBJJ:   sk.Public().Compress(),
+	}
+	txCompressedData, err := tx.TxCompressedDataV2()
+	assert.NoError(t, err)
+	// test vector value generated from javascript implementation
+	expectedStr := "6571340879233176732837827812956721483162819083004853354503"
+	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()))
 }
 
 func TestRqTxCompressedDataV2(t *testing.T) {
@@ -137,16 +113,19 @@ func TestRqTxCompressedDataV2(t *testing.T) {
 	txCompressedData, err := tx.RqTxCompressedDataV2()
 	assert.NoError(t, err)
 	// test vector value generated from javascript implementation
-	expectedStr := "110248805340524920412994530176819463725852160917809517418728390663"
+	expectedStr := "6571340879233176732837827812956721483162819083004853354503"
 	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, "010c000000000b0000000a0000000009000000000008000000000007", hex.EncodeToString(txCompressedData.Bytes()))
+	assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", 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,
@@ -157,7 +136,7 @@ func TestHashToSign(t *testing.T) {
 	}
 	toSign, err := tx.HashToSign(chainID)
 	assert.NoError(t, err)
-	assert.Equal(t, "2d49ce1d4136e06f64e3eb1f79a346e6ee3e93ceeac909a57806a8d87005c263", hex.EncodeToString(toSign.Bytes()))
+	assert.Equal(t, "1469900657138253851938022936440971384682713995864967090251961124784132925291", toSign.String())
 }
 
 func TestVerifyTxSignature(t *testing.T) {
@@ -177,7 +156,7 @@ func TestVerifyTxSignature(t *testing.T) {
 	}
 	toSign, err := tx.HashToSign(chainID)
 	assert.NoError(t, err)
-	assert.Equal(t, "1571327027383224465388301747239444557034990637650927918405777653988509342917", toSign.String())
+	assert.Equal(t, "18645218094210271622244722988708640202588315450486586312909439859037906375295", toSign.String())
 
 	sig := sk.SignPoseidon(toSign)
 	tx.Signature = sig.Compress()

common/utils.go

@@ -62,17 +62,3 @@ 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/zk.go

@@ -102,8 +102,6 @@ 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]
@@ -114,8 +112,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 float40
+	// DepositAmountF encoded as float16
-	DepositAmountF []*big.Int `json:"loadAmountF"` // uint40, len: [maxTx]
+	DepositAmountF []*big.Int `json:"loadAmountF"` // uint16, len: [maxTx]
 	// FromEthAddr
 	FromEthAddr []*big.Int `json:"fromEthAddr"` // ethCommon.Address, len: [maxTx]
 	// FromBJJCompressed boolean encoded where each value is a *big.Int
@@ -328,7 +326,6 @@ 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)
 
@@ -479,8 +476,8 @@ func (z ZKInputs) ToHashGlobalData() ([]byte, error) {
 	copy(newExitRoot, z.Metadata.NewExitRootRaw.Bytes())
 	b = append(b, newExitRoot...)
 
-	// [MAX_L1_TX * (2 * MAX_NLEVELS + 528) bits] L1TxsData
+	// [MAX_L1_TX * (2 * MAX_NLEVELS + 480) bits] L1TxsData
-	l1TxDataLen := (2*z.Metadata.MaxLevels + 528)
+	l1TxDataLen := (2*z.Metadata.MaxLevels + 480)
 	l1TxsDataLen := (z.Metadata.MaxL1Tx * l1TxDataLen)
 	l1TxsData := make([]byte, l1TxsDataLen/8) //nolint:gomnd
 	for i := 0; i < len(z.Metadata.L1TxsData); i++ {
@@ -497,9 +494,9 @@ func (z ZKInputs) ToHashGlobalData() ([]byte, error) {
 	}
 	b = append(b, l1TxsDataAvailability...)
 
-	// [MAX_TX*(2*NLevels + 48) bits] L2TxsData
+	// [MAX_TX*(2*NLevels + 24) bits] L2TxsData
 	var l2TxsData []byte
-	l2TxDataLen := 2*z.Metadata.NLevels + 48 //nolint:gomnd
+	l2TxDataLen := 2*z.Metadata.NLevels + 24 //nolint:gomnd
 	l2TxsDataLen := (z.Metadata.MaxTx * l2TxDataLen)
 	expectedL2TxsDataLen := l2TxsDataLen / 8 //nolint:gomnd
 	for i := 0; i < len(z.Metadata.L2TxsData); i++ {

config/config.go

@@ -3,7 +3,6 @@ package config
 import (
 	"fmt"
 	"io/ioutil"
-	"math/big"
 	"time"
 
 	"github.com/BurntSushi/toml"
@@ -35,15 +34,6 @@ 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"`
-}
-
 // Coordinator is the coordinator specific configuration.
 type Coordinator struct {
 	// ForgerAddress is the address under which this coordinator is forging
@@ -61,85 +51,33 @@ type Coordinator struct {
 	// L1BatchTimeoutPerc is the portion of the range before the L1Batch
 	// timeout that will trigger a schedule to forge an L1Batch
 	L1BatchTimeoutPerc float64 `validate:"required"`
-	// StartSlotBlocksDelay is the number of blocks of delay to wait before
-	// starting the pipeline when we reach a slot in which we can forge.
-	StartSlotBlocksDelay int64
-	// ScheduleBatchBlocksAheadCheck is the number of blocks ahead in which
-	// the forger address is checked to be allowed to forge (apart from
-	// 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
-	// 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.
-	ScheduleBatchBlocksAheadCheck int64
-	// SendBatchBlocksMarginCheck is the number of margin blocks ahead in
-	// which the coordinator is also checked to be allowed to forge, apart
-	// 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
-	// if we can't forge at block 15.
-	SendBatchBlocksMarginCheck int64
 	// ProofServerPollInterval is the waiting interval between polling the
 	// ProofServer while waiting for a particular status
 	ProofServerPollInterval Duration `validate:"required"`
 	// 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:"-"`
 	// 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 maximum number of pending L2Txs that can be
+		// MaxTxs is the number of L2Txs that once reached triggers
-		// stored in the pool.  Once this number of pending L2Txs is
+		// deletion of old L2Txs
-		// reached, inserts to the pool will be denied until some of
-		// the pending txs are forged.
 		MaxTxs uint32 `validate:"required"`
-		// MinFeeUSD is the minimum fee in USD that a tx must pay in
-		// order to be accepted into the pool.  Txs with lower than
-		// minimum fee will be rejected at the API level.
-		MinFeeUSD float64
 		// TTL is the Time To Live for L2Txs in the pool.  Once MaxTxs
 		// L2Txs is reached, L2Txs older than TTL will be deleted.
 		TTL Duration `validate:"required"`
-		// PurgeBatchDelay is the delay between batches to purge
+		// PurgeBatchDelay is the delay between batches to purge outdated transactions
-		// outdated transactions.  Oudated 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
+		// InvalidateBatchDelay is the delay between batches to mark invalid transactions
-		// invalid transactions due to nonce lower than the account
-		// nonce.
 		InvalidateBatchDelay int64 `validate:"required"`
-		// PurgeBlockDelay is the delay between blocks to purge
+		// PurgeBlockDelay is the delay between blocks to purge outdated transactions
-		// outdated transactions.  Oudated 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
+		// InvalidateBlockDelay is the delay between blocks to mark invalid transactions
-		// invalid transactions due to nonce lower than the account
-		// nonce.
 		InvalidateBlockDelay int64 `validate:"required"`
 	} `validate:"required"`
 	TxSelector struct {
@@ -152,6 +90,7 @@ type Coordinator struct {
 	} `validate:"required"`
 	ServerProofs []ServerProof `validate:"required"`
 	Circuit      struct {
+		// VerifierIdx uint8  `validate:"required"`
 		// MaxTx is the maximum number of txs supported by the circuit
 		MaxTx int64 `validate:"required"`
 		// NLevels is the maximum number of merkle tree levels
@@ -159,13 +98,12 @@ type Coordinator struct {
 		NLevels int64 `validate:"required"`
 	} `validate:"required"`
 	EthClient struct {
-		// MaxGasPrice is the maximum gas price allowed for ethereum
+		// CallGasLimit is the default gas limit set for ethereum
-		// transactions
+		// calls, except for methods  where a particular gas limit is
-		MaxGasPrice *big.Int `validate:"required"`
+		// harcoded because it's known to be a big value
-		// GasPriceIncPerc is the percentage increase of gas price set
+		CallGasLimit uint64 `validate:"required"`
-		// in an ethereum transaction from the suggested gas price by
+		// GasPriceDiv is the gas price division
-		// the ehtereum node
+		GasPriceDiv uint64 `validate:"required"`
-		GasPriceIncPerc int64
 		// CheckLoopInterval is the waiting interval between receipt
 		// checks of ethereum transactions in the TxManager
 		CheckLoopInterval Duration `validate:"required"`
@@ -175,13 +113,6 @@ type Coordinator struct {
 		// AttemptsDelay is delay between attempts do do an eth client
 		// RPC call
 		AttemptsDelay Duration `validate:"required"`
-		// TxResendTimeout is the timeout after which a non-mined
-		// ethereum transaction will be resent (reusing the nonce) with
-		// a newly calculated gas price
-		TxResendTimeout Duration `validate:"required"`
-		// NoReuseNonce disables reusing nonces of pending transactions for
-		// new replacement transactions
-		NoReuseNonce bool
 		// Keystore is the ethereum keystore where private keys are kept
 		Keystore struct {
 			// Path to the keystore
@@ -189,9 +120,6 @@ 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 {
 		// Coordinator enables the coordinator API endpoints
@@ -204,10 +132,6 @@ type Coordinator struct {
 		// LightScrypt if set, uses light parameters for the ethereum
 		// keystore encryption algorithm.
 		LightScrypt bool
-		// RollupVerifierIndex is the index of the verifier to use in
-		// the Rollup smart contract.  The verifier chosen by index
-		// must match with the Circuit parameters.
-		RollupVerifierIndex *int
 	}
 }
 
@@ -227,30 +151,17 @@ type Node struct {
 		// Keep is the number of checkpoints to keep
 		Keep int `validate:"required"`
 	} `validate:"required"`
-	// It's possible to use diferentiated SQL connections for read/write.
-	// If the read configuration is not provided, the write one it's going to be used
-	// for both reads and writes
 	PostgreSQL struct {
-		// Port of the PostgreSQL write server
+		// Port of the PostgreSQL server
-		PortWrite int `validate:"required"`
+		Port int `validate:"required"`
-		// Host of the PostgreSQL write server
+		// Host of the PostgreSQL server
-		HostWrite string `validate:"required"`
+		Host string `validate:"required"`
-		// User of the PostgreSQL write server
+		// User of the PostgreSQL server
-		UserWrite string `validate:"required"`
+		User string `validate:"required"`
-		// Password of the PostgreSQL write server
+		// Password of the PostgreSQL server
-		PasswordWrite string `validate:"required"`
+		Password string `validate:"required"`
-		// Name of the PostgreSQL write server database
+		// Name of the PostgreSQL server database
-		NameWrite string `validate:"required"`
+		Name string `validate:"required"`
-		// Port of the PostgreSQL read server
-		PortRead int
-		// Host of the PostgreSQL read server
-		HostRead string
-		// User of the PostgreSQL read server
-		UserRead string
-		// Password of the PostgreSQL read server
-		PasswordRead string
-		// Name of the PostgreSQL read server database
-		NameRead string
 	} `validate:"required"`
 	Web3 struct {
 		// URL is the URL of the web3 ethereum-node RPC server

coordinator/batch.go

@@ -47,8 +47,6 @@ type Debug struct {
 	MineBlockNum int64
 	// SendBlockNum is the blockNum when the batch was sent to ethereum
 	SendBlockNum int64
-	// ResendNum is the number of times the tx has been resent
-	ResendNum int
 	// LastScheduledL1BatchBlockNum is the blockNum when the last L1Batch
 	// was scheduled
 	LastScheduledL1BatchBlockNum int64
@@ -66,17 +64,10 @@ type Debug struct {
 	// StartToSendDelay is the delay between starting a batch and sending
 	// it to ethereum, in seconds
 	StartToSendDelay float64
-	// StartToMineDelay is the delay between starting a batch and having
-	// it mined in seconds
-	StartToMineDelay float64
-	// SendToMineDelay is the delay between sending a batch tx and having
-	// it mined in seconds
-	SendToMineDelay float64
 }
 
 // BatchInfo contans the Batch information
 type BatchInfo struct {
-	PipelineNum           int
 	BatchNum              common.BatchNum
 	ServerProof           prover.Client
 	ZKInputs              *common.ZKInputs
@@ -91,16 +82,9 @@ type BatchInfo struct {
 	CoordIdxs             []common.Idx
 	ForgeBatchArgs        *eth.RollupForgeBatchArgs
 	// FeesInfo
-	EthTx    *types.Transaction
+	EthTx   *types.Transaction
-	EthTxErr error
+	Receipt *types.Receipt
-	// SendTimestamp  the time of batch sent to ethereum
+	Debug   Debug
-	SendTimestamp time.Time
-	Receipt       *types.Receipt
-	// Fail is true if:
-	// - The receipt status is failed
-	// - A previous parent batch is failed
-	Fail  bool
-	Debug Debug
 }
 
 // DebugStore is a debug function to store the BatchInfo as a json text file in

coordinator/coordinator.go

@@ -3,15 +3,14 @@ package coordinator
 import (
 	"context"
 	"fmt"
-	"math/big"
 	"os"
+	"strings"
 	"sync"
 	"time"
 
 	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,9 +23,7 @@ import (
 )
 
 var (
-	errLastL1BatchNotSynced  = fmt.Errorf("last L1Batch not synced yet")
+	errLastL1BatchNotSynced = fmt.Errorf("last L1Batch not synced yet")
-	errForgeNoTxsBeforeDelay = fmt.Errorf("no txs to forge and we haven't reached the forge no txs delay")
-	errForgeBeforeDelay      = fmt.Errorf("we haven't reached the forge delay")
 )
 
 const (
@@ -45,81 +42,26 @@ type Config struct {
 	// L1BatchTimeoutPerc is the portion of the range before the L1Batch
 	// timeout that will trigger a schedule to forge an L1Batch
 	L1BatchTimeoutPerc float64
-	// StartSlotBlocksDelay is the number of blocks of delay to wait before
-	// starting the pipeline when we reach a slot in which we can forge.
-	StartSlotBlocksDelay int64
-	// ScheduleBatchBlocksAheadCheck is the number of blocks ahead in which
-	// the forger address is checked to be allowed to forge (apart from
-	// 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
-	// 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.
-	ScheduleBatchBlocksAheadCheck int64
-	// SendBatchBlocksMarginCheck is the number of margin blocks ahead in
-	// which the coordinator is also checked to be allowed to forge, apart
-	// 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
-	// 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.
-	SendBatchBlocksMarginCheck int64
 	// EthClientAttempts is the number of attempts to do an eth client RPC
 	// call before giving up
 	EthClientAttempts int
 	// 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
 	// 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
-	// EthTxResendTimeout is the timeout after which a non-mined ethereum
-	// transaction will be resent (reusing the nonce) with a newly
-	// calculated gas price
-	EthTxResendTimeout time.Duration
-	// EthNoReuseNonce disables reusing nonces of pending transactions for
-	// new replacement transactions
-	EthNoReuseNonce bool
-	// 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
 	// DebugBatchPath if set, specifies the path where batchInfo is stored
 	// in JSON in every step/update of the pipeline
-	DebugBatchPath string
+	DebugBatchPath    string
-	Purger         PurgerCfg
+	Purger            PurgerCfg
-	// VerifierIdx is the index of the verifier contract registered in the
+	VerifierIdx       uint8
-	// smart contract
-	VerifierIdx uint8
-	// ForgeBatchGasCost contains the cost of each action in the
-	// ForgeBatch transaction.
-	ForgeBatchGasCost config.ForgeBatchGasCost
 	TxProcessorConfig txprocessor.Config
 }
 
@@ -132,22 +74,15 @@ func (c *Config) debugBatchStore(batchInfo *BatchInfo) {
 	}
 }
 
-type fromBatch struct {
-	BatchNum   common.BatchNum
-	ForgerAddr ethCommon.Address
-	StateRoot  *big.Int
-}
-
 // Coordinator implements the Coordinator type
 type Coordinator struct {
 	// State
-	pipelineNum       int       // Pipeline sequential number.  The first pipeline is 1
+	pipelineBatchNum common.BatchNum // batchNum from which we started the pipeline
-	pipelineFromBatch fromBatch // batch from which we started the pipeline
+	provers          []prover.Client
-	provers           []prover.Client
+	consts           synchronizer.SCConsts
-	consts            synchronizer.SCConsts
+	vars             synchronizer.SCVariables
-	vars              synchronizer.SCVariables
+	stats            synchronizer.Stats
-	stats             synchronizer.Stats
+	started          bool
-	started           bool
 
 	cfg Config
 
@@ -161,17 +96,7 @@ type Coordinator struct {
 	wg     sync.WaitGroup
 	cancel context.CancelFunc
 
-	// mutexL2DBUpdateDelete protects updates to the L2DB so that
+	pipeline *Pipeline
-	// 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
 
 	purger    *Purger
 	txManager *TxManager
@@ -214,15 +139,10 @@ func NewCoordinator(cfg Config,
 
 	ctx, cancel := context.WithCancel(context.Background())
 	c := Coordinator{
-		pipelineNum: 0,
+		pipelineBatchNum: -1,
-		pipelineFromBatch: fromBatch{
+		provers:          serverProofs,
-			BatchNum:   0,
+		consts:           *scConsts,
-			ForgerAddr: ethCommon.Address{},
+		vars:             *initSCVars,
-			StateRoot:  big.NewInt(0),
-		},
-		provers: serverProofs,
-		consts:  *scConsts,
-		vars:    *initSCVars,
 
 		cfg: cfg,
 
@@ -263,10 +183,8 @@ func (c *Coordinator) BatchBuilder() *batchbuilder.BatchBuilder {
 }
 
 func (c *Coordinator) newPipeline(ctx context.Context) (*Pipeline, error) {
-	c.pipelineNum++
+	return NewPipeline(ctx, c.cfg, c.historyDB, c.l2DB, c.txSelector,
-	return NewPipeline(ctx, c.cfg, c.pipelineNum, c.historyDB, c.l2DB, c.txSelector,
+		c.batchBuilder, c.purger, 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
@@ -287,9 +205,6 @@ type MsgSyncReorg struct {
 // MsgStopPipeline indicates a signal to reset the pipeline
 type MsgStopPipeline struct {
 	Reason string
-	// FailedBatchNum indicates the first batchNum that failed in the
-	// pipeline.  If FailedBatchNum is 0, it should be ignored.
-	FailedBatchNum common.BatchNum
 }
 
 // SendMsg is a thread safe method to pass a message to the Coordinator
@@ -300,36 +215,27 @@ func (c *Coordinator) SendMsg(ctx context.Context, msg interface{}) {
 	}
 }
 
-func updateSCVars(vars *synchronizer.SCVariables, update synchronizer.SCVariablesPtr) {
-	if update.Rollup != nil {
-		vars.Rollup = *update.Rollup
-	}
-	if update.Auction != nil {
-		vars.Auction = *update.Auction
-	}
-	if update.WDelayer != nil {
-		vars.WDelayer = *update.WDelayer
-	}
-}
-
 func (c *Coordinator) syncSCVars(vars synchronizer.SCVariablesPtr) {
-	updateSCVars(&c.vars, vars)
+	if vars.Rollup != nil {
+		c.vars.Rollup = *vars.Rollup
+	}
+	if vars.Auction != nil {
+		c.vars.Auction = *vars.Auction
+	}
+	if vars.WDelayer != nil {
+		c.vars.WDelayer = *vars.WDelayer
+	}
 }
 
 func canForge(auctionConstants *common.AuctionConstants, auctionVars *common.AuctionVariables,
 	currentSlot *common.Slot, nextSlot *common.Slot, addr ethCommon.Address, blockNum int64) bool {
-	if blockNum < auctionConstants.GenesisBlockNum {
-		log.Infow("canForge: requested blockNum is < genesis", "blockNum", blockNum,
-			"genesis", auctionConstants.GenesisBlockNum)
-		return false
-	}
 	var slot *common.Slot
 	if currentSlot.StartBlock <= blockNum && blockNum <= currentSlot.EndBlock {
 		slot = currentSlot
 	} else if nextSlot.StartBlock <= blockNum && blockNum <= nextSlot.EndBlock {
 		slot = nextSlot
 	} else {
-		log.Warnw("canForge: requested blockNum is outside current and next slot",
+		log.Warnw("Coordinator: requested blockNum for canForge is outside slot",
 			"blockNum", blockNum, "currentSlot", currentSlot,
 			"nextSlot", nextSlot,
 		)
@@ -338,23 +244,16 @@ func canForge(auctionConstants *common.AuctionConstants, auctionVars *common.Auc
 	anyoneForge := false
 	if !slot.ForgerCommitment &&
 		auctionConstants.RelativeBlock(blockNum) >= int64(auctionVars.SlotDeadline) {
-		log.Debugw("canForge: anyone can forge in the current slot (slotDeadline passed)",
+		log.Debugw("Coordinator: anyone can forge in the current slot (slotDeadline passed)",
 			"block", blockNum)
 		anyoneForge = true
 	}
 	if slot.Forger == addr || anyoneForge {
 		return true
 	}
-	log.Debugw("canForge: can't forge", "slot.Forger", slot.Forger)
 	return false
 }
 
-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)
-}
-
 func (c *Coordinator) canForge() bool {
 	blockNum := c.stats.Eth.LastBlock.Num + 1
 	return canForge(&c.consts.Auction, &c.vars.Auction,
@@ -363,51 +262,21 @@ func (c *Coordinator) canForge() bool {
 }
 
 func (c *Coordinator) syncStats(ctx context.Context, stats *synchronizer.Stats) error {
-	nextBlock := c.stats.Eth.LastBlock.Num + 1
+	canForge := c.canForge()
-	canForge := c.canForgeAt(nextBlock)
-	if c.cfg.ScheduleBatchBlocksAheadCheck != 0 && canForge {
-		canForge = c.canForgeAt(nextBlock + c.cfg.ScheduleBatchBlocksAheadCheck)
-	}
 	if c.pipeline == nil {
-		relativeBlock := c.consts.Auction.RelativeBlock(nextBlock)
+		if canForge {
-		if canForge && relativeBlock < c.cfg.StartSlotBlocksDelay {
-			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)
+				stats.Eth.LastBlock.Num+1, "batch", stats.Sync.LastBatch)
-			fromBatch := fromBatch{
+			batchNum := common.BatchNum(stats.Sync.LastBatch)
-				BatchNum:   stats.Sync.LastBatch.BatchNum,
-				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)
 			}
-			c.pipelineFromBatch = fromBatch
+			if err := c.pipeline.Start(batchNum, stats, &c.vars); err != nil {
-			// 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 {
@@ -417,12 +286,25 @@ func (c *Coordinator) syncStats(ctx context.Context, stats *synchronizer.Stats)
 		}
 	}
 	if c.pipeline == nil {
-		if _, err := c.purger.InvalidateMaybe(c.l2DB, c.txSelector.LocalAccountsDB(),
+		// Mark invalid in Pool due to forged L2Txs
-			stats.Sync.LastBlock.Num, int64(stats.Sync.LastBatch.BatchNum)); err != nil {
+		// 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, stats.Sync.LastBatch) {
+			if err := c.txSelector.Reset(common.BatchNum(stats.Sync.LastBatch)); err != nil {
+				return tracerr.Wrap(err)
+			}
+		}
+		_, err := c.purger.InvalidateMaybe(c.l2DB, c.txSelector.LocalAccountsDB(),
+			stats.Sync.LastBlock.Num, stats.Sync.LastBatch)
+		if err != nil {
 			return tracerr.Wrap(err)
 		}
-		if _, err := c.purger.PurgeMaybe(c.l2DB, stats.Sync.LastBlock.Num,
+		_, err = c.purger.PurgeMaybe(c.l2DB, stats.Sync.LastBlock.Num, stats.Sync.LastBatch)
-			int64(stats.Sync.LastBatch.BatchNum)); err != nil {
+		if err != nil {
 			return tracerr.Wrap(err)
 		}
 	}
@@ -449,43 +331,33 @@ func (c *Coordinator) handleReorg(ctx context.Context, msg *MsgSyncReorg) error
 	if c.pipeline != nil {
 		c.pipeline.SetSyncStatsVars(ctx, &msg.Stats, &msg.Vars)
 	}
-	if c.stats.Sync.LastBatch.ForgerAddr != c.cfg.ForgerAddress &&
+	if common.BatchNum(c.stats.Sync.LastBatch) < c.pipelineBatchNum {
-		(c.stats.Sync.LastBatch.StateRoot == nil || c.pipelineFromBatch.StateRoot == nil ||
+		// There's been a reorg and the batch from which the pipeline
-			c.stats.Sync.LastBatch.StateRoot.Cmp(c.pipelineFromBatch.StateRoot) != 0) {
+		// was started was in a block that was discarded.  The batch
-		// There's been a reorg and the batch state root from which the
+		// may not be in the main chain, so we stop the pipeline as a
-		// pipeline was started has changed (probably because it was in
+		// precaution (it will be started again once the node is in
-		// a block that was discarded), and it was sent by a different
+		// sync).
-		// coordinator than us.  That batch may never be in the main
+		log.Infow("Coordinator.handleReorg StopPipeline sync.LastBatch < c.pipelineBatchNum",
-		// chain, so we stop the pipeline  (it will be started again
+			"sync.LastBatch", c.stats.Sync.LastBatch,
-		// once the node is in sync).
+			"c.pipelineBatchNum", c.pipelineBatchNum)
-		log.Infow("Coordinator.handleReorg StopPipeline sync.LastBatch.ForgerAddr != cfg.ForgerAddr "+
+		if err := c.handleStopPipeline(ctx, "reorg"); err != nil {
-			"& sync.LastBatch.StateRoot != pipelineFromBatch.StateRoot",
-			"sync.LastBatch.StateRoot", c.stats.Sync.LastBatch.StateRoot,
-			"pipelineFromBatch.StateRoot", c.pipelineFromBatch.StateRoot)
-		c.txManager.DiscardPipeline(ctx, c.pipelineNum)
-		if err := c.handleStopPipeline(ctx, "reorg", 0); err != nil {
 			return tracerr.Wrap(err)
 		}
 	}
 	return nil
 }
 
-// handleStopPipeline handles stopping the pipeline.  If failedBatchNum is 0,
+func (c *Coordinator) handleStopPipeline(ctx context.Context, reason string) error {
-// the next pipeline will start from the last state of the synchronizer,
+	if err := c.l2DB.Reorg(common.BatchNum(c.stats.Sync.LastBatch)); err != nil {
-// otherwise, it will state from failedBatchNum-1.
+		return tracerr.Wrap(err)
-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
 	}
 	if c.pipeline != nil {
 		c.pipeline.Stop(c.ctx)
 		c.pipeline = nil
 	}
-	if err := c.l2DB.Reorg(batchNum); err != nil {
+	if strings.Contains(reason, common.AuctionErrMsgCannotForge) { //nolint:staticcheck
-		return tracerr.Wrap(err)
+		// TODO: Check that we are in a slot in which we can't forge
 	}
-	c.lastNonFailedBatchNum = batchNum
 	return nil
 }
 
@@ -501,7 +373,7 @@ func (c *Coordinator) handleMsg(ctx context.Context, msg interface{}) error {
 		}
 	case MsgStopPipeline:
 		log.Infow("Coordinator received MsgStopPipeline", "reason", msg.Reason)
-		if err := c.handleStopPipeline(ctx, msg.Reason, msg.FailedBatchNum); err != nil {
+		if err := c.handleStopPipeline(ctx, msg.Reason); err != nil {
 			return tracerr.Wrap(fmt.Errorf("Coordinator.handleStopPipeline: %w", err))
 		}
 	default:
@@ -524,7 +396,7 @@ func (c *Coordinator) Start() {
 
 	c.wg.Add(1)
 	go func() {
-		timer := time.NewTimer(longWaitDuration)
+		waitDuration := longWaitDuration
 		for {
 			select {
 			case <-c.ctx.Done():
@@ -536,45 +408,23 @@ func (c *Coordinator) Start() {
 					continue
 				} else if err != nil {
 					log.Errorw("Coordinator.handleMsg", "err", err)
-					if !timer.Stop() {
+					waitDuration = c.cfg.SyncRetryInterval
-						<-timer.C
-					}
-					timer.Reset(c.cfg.SyncRetryInterval)
 					continue
 				}
-			case <-timer.C:
+				waitDuration = longWaitDuration
-				timer.Reset(longWaitDuration)
+			case <-time.After(waitDuration):
 				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)
-					if !timer.Stop() {
+					waitDuration = c.cfg.SyncRetryInterval
-						<-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

@@ -97,16 +97,15 @@ func newTestModules(t *testing.T) modules {
 	syncDBPath, err = ioutil.TempDir("", "tmpSyncDB")
 	require.NoError(t, err)
 	deleteme = append(deleteme, syncDBPath)
-	syncStateDB, err := statedb.NewStateDB(statedb.Config{Path: syncDBPath, Keep: 128,
+	syncStateDB, err := statedb.NewStateDB(syncDBPath, 128, statedb.TypeSynchronizer, 48)
-		Type: statedb.TypeSynchronizer, NLevels: 48})
 	assert.NoError(t, err)
 
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	test.WipeDB(db)
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
-	historyDB := historydb.NewHistoryDB(db, db, nil)
+	historyDB := historydb.NewHistoryDB(db, nil)
 
 	txSelDBPath, err = ioutil.TempDir("", "tmpTxSelDB")
 	require.NoError(t, err)
@@ -261,8 +260,8 @@ func TestCoordinatorFlow(t *testing.T) {
 			var stats synchronizer.Stats
 			stats.Eth.LastBlock = *ethClient.CtlLastBlock()
 			stats.Sync.LastBlock = stats.Eth.LastBlock
-			stats.Eth.LastBatchNum = ethClient.CtlLastForgedBatch()
+			stats.Eth.LastBatch = ethClient.CtlLastForgedBatch()
-			stats.Sync.LastBatch.BatchNum = common.BatchNum(stats.Eth.LastBatchNum)
+			stats.Sync.LastBatch = stats.Eth.LastBatch
 			canForge, err := ethClient.AuctionCanForge(forger, blockNum+1)
 			require.NoError(t, err)
 			var slot common.Slot
@@ -279,7 +278,7 @@ func TestCoordinatorFlow(t *testing.T) {
 			// Copy stateDB to synchronizer if there was a new batch
 			source := fmt.Sprintf("%v/BatchNum%v", batchBuilderDBPath, stats.Sync.LastBatch)
 			dest := fmt.Sprintf("%v/BatchNum%v", syncDBPath, stats.Sync.LastBatch)
-			if stats.Sync.LastBatch.BatchNum != 0 {
+			if stats.Sync.LastBatch != 0 {
 				if _, err := os.Stat(dest); os.IsNotExist(err) {
 					log.Infow("Making pebble checkpoint for sync",
 						"source", source, "dest", dest)

coordinator/pipeline.go

@@ -2,7 +2,6 @@ package coordinator
 
 import (
 	"context"
-	"database/sql"
 	"fmt"
 	"math/big"
 	"sync"
@@ -25,36 +24,25 @@ type statsVars struct {
 	Vars  synchronizer.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
 
 	// state
-	state         state
+	batchNum                     common.BatchNum
-	started       bool
+	lastScheduledL1BatchBlockNum int64
-	rw            sync.RWMutex
+	lastForgeL1TxsNum            int64
-	errAtBatchNum common.BatchNum
+	started                      bool
-	lastForgeTime time.Time
 
-	proversPool           *ProversPool
+	proversPool  *ProversPool
-	provers               []prover.Client
+	provers      []prover.Client
-	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
@@ -65,29 +53,14 @@ type Pipeline struct {
 	cancel context.CancelFunc
 }
 
-func (p *Pipeline) setErrAtBatchNum(batchNum common.BatchNum) {
-	p.rw.Lock()
-	defer p.rw.Unlock()
-	p.errAtBatchNum = batchNum
-}
-
-func (p *Pipeline) getErrAtBatchNum() common.BatchNum {
-	p.rw.RLock()
-	defer p.rw.RUnlock()
-	return p.errAtBatchNum
-}
-
 // NewPipeline creates a new Pipeline
 func NewPipeline(ctx context.Context,
 	cfg Config,
-	num int, // Pipeline sequential number
 	historyDB *historydb.HistoryDB,
 	l2DB *l2db.L2DB,
 	txSelector *txselector.TxSelector,
 	batchBuilder *batchbuilder.BatchBuilder,
-	mutexL2DBUpdateDelete *sync.Mutex,
 	purger *Purger,
-	coord *Coordinator,
 	txManager *TxManager,
 	provers []prover.Client,
 	scConsts *synchronizer.SCConsts,
@@ -106,20 +79,17 @@ func NewPipeline(ctx context.Context,
 		return nil, tracerr.Wrap(fmt.Errorf("no provers in the pool"))
 	}
 	return &Pipeline{
-		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,
+		txManager:    txManager,
-		purger:                purger,
+		consts:       *scConsts,
-		coord:                 coord,
+		statsVarsCh:  make(chan statsVars, queueLen),
-		txManager:             txManager,
-		consts:                *scConsts,
-		statsVarsCh:           make(chan statsVars, queueLen),
 	}, nil
 }
 
@@ -134,76 +104,53 @@ 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 {
-	p.state = state{
+	p.batchNum = batchNum
-		batchNum:                     batchNum,
+	p.lastForgeL1TxsNum = stats.Sync.LastForgeL1TxsNum
-		lastForgeL1TxsNum:            stats.Sync.LastForgeL1TxsNum,
-		lastScheduledL1BatchBlockNum: 0,
-		lastSlotForged:               -1,
-	}
 	p.stats = *stats
 	p.vars = *vars
+	p.lastScheduledL1BatchBlockNum = 0
 
-	// Reset the StateDB in TxSelector and BatchBuilder from the
+	err := p.txSelector.Reset(p.batchNum)
-	// synchronizer only if the checkpoint we reset from either:
-	// a. Doesn't exist in the TxSelector/BatchBuilder
-	// b. The batch has already been synced by the synchronizer and has a
-	//    different MTRoot than the BatchBuilder
-	// Otherwise, reset from the local checkpoint.
-
-	// First attempt to reset from local checkpoint if such checkpoint exists
-	existsTxSelector, err := p.txSelector.LocalAccountsDB().CheckpointExists(p.state.batchNum)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	fromSynchronizerTxSelector := !existsTxSelector
+	err = p.batchBuilder.Reset(p.batchNum, true)
-	if err := p.txSelector.Reset(p.state.batchNum, fromSynchronizerTxSelector); err != nil {
-		return tracerr.Wrap(err)
-	}
-	existsBatchBuilder, err := p.batchBuilder.LocalStateDB().CheckpointExists(p.state.batchNum)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	fromSynchronizerBatchBuilder := !existsBatchBuilder
-	if err := p.batchBuilder.Reset(p.state.batchNum, fromSynchronizerBatchBuilder); err != nil {
-		return tracerr.Wrap(err)
-	}
-
-	// After reset, check that if the batch exists in the historyDB, the
-	// stateRoot matches with the local one, if not, force a reset from
-	// synchronizer
-	batch, err := p.historyDB.GetBatch(p.state.batchNum)
-	if tracerr.Unwrap(err) == sql.ErrNoRows {
-		// nothing to do
-	} else if err != nil {
-		return tracerr.Wrap(err)
-	} else {
-		localStateRoot := p.batchBuilder.LocalStateDB().MT.Root().BigInt()
-		if batch.StateRoot.Cmp(localStateRoot) != 0 {
-			log.Debugw("localStateRoot (%v) != historyDB stateRoot (%v).  "+
-				"Forcing reset from Synchronizer", localStateRoot, batch.StateRoot)
-			// StateRoot from synchronizer doesn't match StateRoot
-			// from batchBuilder, force a reset from synchronizer
-			if err := p.txSelector.Reset(p.state.batchNum, true); err != nil {
-				return tracerr.Wrap(err)
-			}
-			if err := p.batchBuilder.Reset(p.state.batchNum, true); err != nil {
-				return tracerr.Wrap(err)
-			}
-		}
-	}
 	return nil
 }
 
 func (p *Pipeline) syncSCVars(vars synchronizer.SCVariablesPtr) {
-	updateSCVars(&p.vars, vars)
+	if vars.Rollup != nil {
+		p.vars.Rollup = *vars.Rollup
+	}
+	if vars.Auction != nil {
+		p.vars.Auction = *vars.Auction
+	}
+	if vars.WDelayer != nil {
+		p.vars.WDelayer = *vars.WDelayer
+	}
 }
 
-// handleForgeBatch waits for an available proof server, calls p.forgeBatch to
+// handleForgeBatch calls p.forgeBatch to forge the batch and get the zkInputs,
-// forge the batch and get the zkInputs, and then  sends the zkInputs to the
+// and then waits for an available proof server and sends the zkInputs to it so
-// selected proof server so that the proof computation begins.
+// that the proof computation begins.
-func (p *Pipeline) handleForgeBatch(ctx context.Context,
+func (p *Pipeline) handleForgeBatch(ctx context.Context, batchNum common.BatchNum) (*BatchInfo, error) {
-	batchNum common.BatchNum) (batchInfo *BatchInfo, err error) {
+	batchInfo, err := p.forgeBatch(batchNum)
-	// 1. Wait for an available serverProof (blocking call)
+	if ctx.Err() != nil {
+		return nil, ctx.Err()
+	} else if err != nil {
+		if tracerr.Unwrap(err) == errLastL1BatchNotSynced {
+			log.Warnw("forgeBatch: scheduled L1Batch too early", "err", err,
+				"lastForgeL1TxsNum", p.lastForgeL1TxsNum,
+				"syncLastForgeL1TxsNum", p.stats.Sync.LastForgeL1TxsNum)
+		} else {
+			log.Errorw("forgeBatch", "err", err)
+		}
+		return nil, err
+	}
+	// 6. Wait for an available server proof (blocking call)
 	serverProof, err := p.proversPool.Get(ctx)
 	if ctx.Err() != nil {
 		return nil, ctx.Err()
@@ -211,43 +158,13 @@ func (p *Pipeline) handleForgeBatch(ctx context.Context,
 		log.Errorw("proversPool.Get", "err", err)
 		return nil, err
 	}
-	defer func() {
-		// If we encounter any error (notice that this function returns
-		// errors to notify that a batch is not forged not only because
-		// of unexpected errors but also due to benign causes), add the
-		// serverProof back to the pool
-		if err != nil {
-			p.proversPool.Add(ctx, serverProof)
-		}
-	}()
-
-	// 2. Forge the batch internally (make a selection of txs and prepare
-	// all the smart contract arguments)
-	p.mutexL2DBUpdateDelete.Lock()
-	batchInfo, err = p.forgeBatch(batchNum)
-	p.mutexL2DBUpdateDelete.Unlock()
-	if ctx.Err() != nil {
-		return nil, ctx.Err()
-	} else if err != nil {
-		if tracerr.Unwrap(err) == errLastL1BatchNotSynced {
-			log.Warnw("forgeBatch: scheduled L1Batch too early", "err", err,
-				"lastForgeL1TxsNum", p.state.lastForgeL1TxsNum,
-				"syncLastForgeL1TxsNum", p.stats.Sync.LastForgeL1TxsNum)
-		} else if tracerr.Unwrap(err) == errForgeNoTxsBeforeDelay ||
-			tracerr.Unwrap(err) == errForgeBeforeDelay {
-			// no log
-		} else {
-			log.Errorw("forgeBatch", "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
+		p.proversPool.Add(ctx, serverProof)
 		return nil, err
 	}
 	return batchInfo, nil
@@ -271,7 +188,7 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 
 	p.wg.Add(1)
 	go func() {
-		timer := time.NewTimer(zeroDuration)
+		waitDuration := zeroDuration
 		for {
 			select {
 			case <-p.ctx.Done():
@@ -281,42 +198,18 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 			case statsVars := <-p.statsVarsCh:
 				p.stats = statsVars.Stats
 				p.syncSCVars(statsVars.Vars)
-			case <-timer.C:
+			case <-time.After(waitDuration):
-				timer.Reset(p.cfg.ForgeRetryInterval)
+				batchNum = p.batchNum + 1
-				// Once errAtBatchNum != 0, we stop forging
+				if batchInfo, err := p.handleForgeBatch(p.ctx, batchNum); err != nil {
-				// batches because there's been an error and we
+					waitDuration = p.cfg.SyncRetryInterval
-				// wait for the pipeline to be stopped.
-				if p.getErrAtBatchNum() != 0 {
 					continue
+				} else {
+					p.batchNum = batchNum
+					select {
+					case batchChSentServerProof <- batchInfo:
+					case <-p.ctx.Done():
+					}
 				}
-				batchNum = p.state.batchNum + 1
-				batchInfo, err := p.handleForgeBatch(p.ctx, batchNum)
-				if p.ctx.Err() != nil {
-					continue
-				} else if tracerr.Unwrap(err) == errLastL1BatchNotSynced ||
-					tracerr.Unwrap(err) == errForgeNoTxsBeforeDelay ||
-					tracerr.Unwrap(err) == errForgeBeforeDelay {
-					continue
-				} else if err != nil {
-					p.setErrAtBatchNum(batchNum)
-					p.coord.SendMsg(p.ctx, MsgStopPipeline{
-						Reason: fmt.Sprintf(
-							"Pipeline.handleForgBatch: %v", err),
-						FailedBatchNum: 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)
 			}
 		}
 	}()
@@ -330,27 +223,16 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 				p.wg.Done()
 				return
 			case batchInfo := <-batchChSentServerProof:
-				// 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 {
-					continue
-				}
 				err := p.waitServerProof(p.ctx, batchInfo)
+				// We are done with this serverProof, add it back to the pool
+				p.proversPool.Add(p.ctx, batchInfo.ServerProof)
+				batchInfo.ServerProof = nil
 				if p.ctx.Err() != nil {
 					continue
 				} else if err != nil {
 					log.Errorw("waitServerProof", "err", err)
-					p.setErrAtBatchNum(batchInfo.BatchNum)
-					p.coord.SendMsg(p.ctx, MsgStopPipeline{
-						Reason: fmt.Sprintf(
-							"Pipeline.waitServerProof: %v", err),
-						FailedBatchNum: batchInfo.BatchNum,
-					})
 					continue
 				}
-				// We are done with this serverProof, add it back to the pool
-				p.proversPool.Add(p.ctx, batchInfo.ServerProof)
 				p.txManager.AddBatch(p.ctx, batchInfo)
 			}
 		}
@@ -400,10 +282,9 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo, e
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	// Structure to accumulate data and metadata of the batch
+
-	now := time.Now()
+	batchInfo = &BatchInfo{BatchNum: batchNum} // to accumulate metadata of the batch
-	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{
@@ -417,26 +298,22 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo, e
 	var auths [][]byte
 	var coordIdxs []common.Idx
 
-	// Check if the slot is not yet fulfilled
-	slotCommitted := false
-	if p.stats.Sync.Auction.CurrentSlot.ForgerCommitment ||
-		p.stats.Sync.Auction.CurrentSlot.SlotNum == p.state.lastSlotForged {
-		slotCommitted = true
-	}
-
-	// If we haven't reached the ForgeDelay, skip forging the batch
-	if slotCommitted && now.Sub(p.lastForgeTime) < p.cfg.ForgeDelay {
-		return nil, errForgeBeforeDelay
-	}
-
 	// 1. Decide if we forge L2Tx or L1+L2Tx
 	if p.shouldL1L2Batch(batchInfo) {
 		batchInfo.L1Batch = true
-		if p.state.lastForgeL1TxsNum != p.stats.Sync.LastForgeL1TxsNum {
+		defer func() {
+			// If there's no error, update the parameters related
+			// to the last L1Batch forged
+			if err == nil {
+				p.lastScheduledL1BatchBlockNum = p.stats.Eth.LastBlock.Num + 1
+				p.lastForgeL1TxsNum++
+			}
+		}()
+		if p.lastForgeL1TxsNum != p.stats.Sync.LastForgeL1TxsNum {
 			return nil, tracerr.Wrap(errLastL1BatchNotSynced)
 		}
 		// 2a: L1+L2 txs
-		l1UserTxs, err := p.historyDB.GetUnforgedL1UserTxs(p.state.lastForgeL1TxsNum + 1)
+		l1UserTxs, err := p.historyDB.GetUnforgedL1UserTxs(p.lastForgeL1TxsNum + 1)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
@@ -455,43 +332,6 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo, e
 		l1UserTxsExtra = nil
 	}
 
-	// If there are no txs to forge, no l1UserTxs in the open queue to
-	// freeze, and we haven't reached the ForgeNoTxsDelay, skip forging the
-	// batch.
-	if slotCommitted && now.Sub(p.lastForgeTime) < p.cfg.ForgeNoTxsDelay {
-		noTxs := false
-		if len(l1UserTxsExtra) == 0 && len(l1CoordTxs) == 0 && len(poolL2Txs) == 0 {
-			if batchInfo.L1Batch {
-				// Query the L1UserTxs in the queue following
-				// the one we are trying to forge.
-				nextL1UserTxs, err := p.historyDB.GetUnforgedL1UserTxs(
-					p.state.lastForgeL1TxsNum + 1)
-				if err != nil {
-					return nil, tracerr.Wrap(err)
-				}
-				// If there are future L1UserTxs, we forge a
-				// batch to advance the queues and forge the
-				// L1UserTxs in the future.  Otherwise, skip.
-				if len(nextL1UserTxs) == 0 {
-					noTxs = true
-				}
-			} else {
-				noTxs = true
-			}
-		}
-		if noTxs {
-			if err := p.txSelector.Reset(batchInfo.BatchNum-1, false); err != nil {
-				return nil, tracerr.Wrap(err)
-			}
-			return nil, errForgeNoTxsBeforeDelay
-		}
-	}
-
-	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.L1CoordTxs = l1CoordTxs
@@ -536,8 +376,6 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo, e
 	p.cfg.debugBatchStore(batchInfo)
 	log.Infow("Pipeline: batch forged internally", "batch", batchInfo.BatchNum)
 
-	p.state.lastSlotForged = p.stats.Sync.Auction.CurrentSlot.SlotNum
-
 	return batchInfo, nil
 }
 
@@ -559,12 +397,12 @@ func (p *Pipeline) waitServerProof(ctx context.Context, batchInfo *BatchInfo) er
 func (p *Pipeline) shouldL1L2Batch(batchInfo *BatchInfo) bool {
 	// Take the lastL1BatchBlockNum as the biggest between the last
 	// scheduled one, and the synchronized one.
-	lastL1BatchBlockNum := p.state.lastScheduledL1BatchBlockNum
+	lastL1BatchBlockNum := p.lastScheduledL1BatchBlockNum
 	if p.stats.Sync.LastL1BatchBlock > lastL1BatchBlockNum {
 		lastL1BatchBlockNum = p.stats.Sync.LastL1BatchBlock
 	}
 	// Set Debug information
-	batchInfo.Debug.LastScheduledL1BatchBlockNum = p.state.lastScheduledL1BatchBlockNum
+	batchInfo.Debug.LastScheduledL1BatchBlockNum = p.lastScheduledL1BatchBlockNum
 	batchInfo.Debug.LastL1BatchBlock = p.stats.Sync.LastL1BatchBlock
 	batchInfo.Debug.LastL1BatchBlockDelta = p.stats.Eth.LastBlock.Num + 1 - lastL1BatchBlockNum
 	batchInfo.Debug.L1BatchBlockScheduleDeadline =

coordinator/pipeline_test.go

@@ -25,14 +25,6 @@ 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))
@@ -85,7 +77,7 @@ func TestPipelineShouldL1L2Batch(t *testing.T) {
 	//
 	// Scheduled L1Batch
 	//
-	pipeline.state.lastScheduledL1BatchBlockNum = startBlock
+	pipeline.lastScheduledL1BatchBlockNum = startBlock
 	stats.Sync.LastL1BatchBlock = startBlock - 10
 
 	// We are are one block before the timeout range * 0.5
@@ -136,11 +128,6 @@ 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("10941365282189107056349764238909072001483688090878331371699519307087372995595")
 
 	ethAddTokens(blocks, ethClient)
 	err = ethClient.CtlAddBlocks(blocks)
@@ -185,7 +172,7 @@ func TestPipelineForgeBatchWithTxs(t *testing.T) {
 	// users with positive balances
 	tilCtx := preloadSync(t, ethClient, sync, modules.historyDB, modules.stateDB)
 	syncStats := sync.Stats()
-	batchNum := syncStats.Sync.LastBatch.BatchNum
+	batchNum := common.BatchNum(syncStats.Sync.LastBatch)
 	syncSCVars := sync.SCVars()
 
 	pipeline, err := coord.newPipeline(ctx)

coordinator/purger.go

@@ -13,23 +13,13 @@ import (
 
 // PurgerCfg is the purger configuration
 type PurgerCfg struct {
-	// PurgeBatchDelay is the delay between batches to purge outdated
+	// PurgeBatchDelay is the delay between batches to purge outdated transactions
-	// transactions.  Oudated 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
+	// InvalidateBatchDelay is the delay between batches to mark invalid transactions
-	// transactions due to nonce lower than the account nonce.
 	InvalidateBatchDelay int64
-	// PurgeBlockDelay is the delay between blocks to purge outdated
+	// PurgeBlockDelay is the delay between blocks to purge outdated transactions
-	// transactions.  Oudated 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
+	// InvalidateBlockDelay is the delay between blocks to mark invalid transactions
-	// transactions due to nonce lower than the account nonce.
 	InvalidateBlockDelay int64
 }
 

coordinator/purger_test.go

@@ -21,21 +21,19 @@ 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, db, 10, 100, 0.0, 24*time.Hour, nil)
+	return l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
 }
 
 func newStateDB(t *testing.T) *statedb.LocalStateDB {
 	syncDBPath, err := ioutil.TempDir("", "tmpSyncDB")
 	require.NoError(t, err)
 	deleteme = append(deleteme, syncDBPath)
-	syncStateDB, err := statedb.NewStateDB(statedb.Config{Path: syncDBPath, Keep: 128,
+	syncStateDB, err := statedb.NewStateDB(syncDBPath, 128, statedb.TypeSynchronizer, 48)
-		Type: statedb.TypeSynchronizer, NLevels: 48})
 	assert.NoError(t, err)
 	stateDBPath, err := ioutil.TempDir("", "tmpStateDB")
 	require.NoError(t, err)
 	deleteme = append(deleteme, stateDBPath)
-	stateDB, err := statedb.NewLocalStateDB(statedb.Config{Path: stateDBPath, Keep: 128,
+	stateDB, err := statedb.NewLocalStateDB(stateDBPath, 128, syncStateDB, statedb.TypeTxSelector, 0)
-		Type: statedb.TypeTxSelector, NLevels: 0}, syncStateDB)
 	require.NoError(t, err)
 	return stateDB
 }

coordinator/txmanager.go

@@ -4,13 +4,11 @@ import (
 	"context"
 	"fmt"
 	"math/big"
-	"strings"
 	"time"
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
@@ -37,20 +35,12 @@ type TxManager struct {
 	vars        synchronizer.SCVariables
 	statsVarsCh chan statsVars
 
-	discardPipelineCh chan int // int refers to the pipelineNum
+	queue []*BatchInfo
-
-	minPipelineNum int
-	queue          Queue
 	// lastSuccessBatch stores the last BatchNum that who's forge call was confirmed
 	lastSuccessBatch common.BatchNum
-	// lastPendingBatch common.BatchNum
+	lastPendingBatch common.BatchNum
-	// accNonce is the account nonce in the last mined block (due to mined txs)
+	lastSuccessNonce uint64
-	accNonce uint64
+	lastPendingNonce uint64
-	// 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
-
-	lastSentL1BatchBlockNum int64
 }
 
 // NewTxManager creates a new TxManager
@@ -64,19 +54,26 @@ func NewTxManager(ctx context.Context, cfg *Config, ethClient eth.ClientInterfac
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	accNonce, err := ethClient.EthNonceAt(ctx, *address, nil)
+	lastSuccessNonce, err := ethClient.EthNonceAt(ctx, *address, nil)
 	if err != nil {
 		return nil, err
 	}
-	log.Infow("TxManager started", "nonce", accNonce)
+	lastPendingNonce, err := ethClient.EthPendingNonceAt(ctx, *address)
+	if err != nil {
+		return nil, err
+	}
+	if lastSuccessNonce != lastPendingNonce {
+		return nil, tracerr.Wrap(fmt.Errorf("lastSuccessNonce (%v) != lastPendingNonce (%v)",
+			lastSuccessNonce, lastPendingNonce))
+	}
+	log.Infow("TxManager started", "nonce", lastSuccessNonce)
 	return &TxManager{
-		cfg:               *cfg,
+		cfg:         *cfg,
-		ethClient:         ethClient,
+		ethClient:   ethClient,
-		l2DB:              l2DB,
+		l2DB:        l2DB,
-		coord:             coord,
+		coord:       coord,
-		batchCh:           make(chan *BatchInfo, queueLen),
+		batchCh:     make(chan *BatchInfo, queueLen),
-		statsVarsCh:       make(chan statsVars, queueLen),
+		statsVarsCh: make(chan statsVars, queueLen),
-		discardPipelineCh: make(chan int, queueLen),
 		account: accounts.Account{
 			Address: *address,
 		},
@@ -85,10 +82,8 @@ func NewTxManager(ctx context.Context, cfg *Config, ethClient eth.ClientInterfac
 
 		vars: *initSCVars,
 
-		minPipelineNum: 0,
+		lastSuccessNonce: lastSuccessNonce,
-		queue:          NewQueue(),
+		lastPendingNonce: lastPendingNonce,
-		accNonce:       accNonce,
-		accNextNonce:   accNonce,
 	}, nil
 }
 
@@ -109,33 +104,28 @@ func (t *TxManager) SetSyncStatsVars(ctx context.Context, stats *synchronizer.St
 	}
 }
 
-// DiscardPipeline is a thread safe method to notify about a discarded pipeline
+func (t *TxManager) syncSCVars(vars synchronizer.SCVariablesPtr) {
-// due to a reorg
+	if vars.Rollup != nil {
-func (t *TxManager) DiscardPipeline(ctx context.Context, pipelineNum int) {
+		t.vars.Rollup = *vars.Rollup
-	select {
+	}
-	case t.discardPipelineCh <- pipelineNum:
+	if vars.Auction != nil {
-	case <-ctx.Done():
+		t.vars.Auction = *vars.Auction
+	}
+	if vars.WDelayer != nil {
+		t.vars.WDelayer = *vars.WDelayer
 	}
 }
 
-func (t *TxManager) syncSCVars(vars synchronizer.SCVariablesPtr) {
-	updateSCVars(&t.vars, vars)
-}
-
 // NewAuth generates a new auth object for an ethereum transaction
-func (t *TxManager) NewAuth(ctx context.Context, batchInfo *BatchInfo) (*bind.TransactOpts, error) {
+func (t *TxManager) NewAuth(ctx context.Context) (*bind.TransactOpts, error) {
 	gasPrice, err := t.ethClient.EthSuggestGasPrice(ctx)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	if t.cfg.GasPriceIncPerc != 0 {
+	inc := new(big.Int).Set(gasPrice)
-		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)
@@ -143,95 +133,42 @@ func (t *TxManager) NewAuth(ctx context.Context, batchInfo *BatchInfo) (*bind.Tr
 		return nil, tracerr.Wrap(err)
 	}
 	auth.Value = big.NewInt(0) // in wei
-
+	// TODO: Calculate GasLimit based on the contents of the ForgeBatchArgs
-	gasLimit := t.cfg.ForgeBatchGasCost.Fixed +
+	auth.GasLimit = 1000000
-		uint64(len(batchInfo.L1UserTxsExtra))*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
 
 	return auth, nil
 }
 
-func (t *TxManager) shouldSendRollupForgeBatch(batchInfo *BatchInfo) error {
+func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchInfo) error {
-	nextBlock := t.stats.Eth.LastBlock.Num + 1
+	// TODO: Check if we can forge in the next blockNum, abort if we can't
-	if !t.canForgeAt(nextBlock) {
+	batchInfo.Debug.Status = StatusSent
-		return tracerr.Wrap(fmt.Errorf("can't forge in the next block: %v", nextBlock))
+	batchInfo.Debug.SendBlockNum = t.stats.Eth.LastBlock.Num + 1
-	}
+	batchInfo.Debug.SendTimestamp = time.Now()
-	if t.mustL1L2Batch(nextBlock) && !batchInfo.L1Batch {
+	batchInfo.Debug.StartToSendDelay = batchInfo.Debug.SendTimestamp.Sub(
-		return tracerr.Wrap(fmt.Errorf("can't forge non-L1Batch in the next block: %v", nextBlock))
+		batchInfo.Debug.StartTimestamp).Seconds()
-	}
-	margin := t.cfg.SendBatchBlocksMarginCheck
-	if margin != 0 {
-		if !t.canForgeAt(nextBlock + margin) {
-			return tracerr.Wrap(fmt.Errorf("can't forge after %v blocks: %v",
-				margin, nextBlock))
-		}
-		if t.mustL1L2Batch(nextBlock+margin) && !batchInfo.L1Batch {
-			return tracerr.Wrap(fmt.Errorf("can't forge non-L1Batch after %v blocks: %v",
-				margin, nextBlock))
-		}
-	}
-	return nil
-}
-
-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 percentages we divide by 100
-	r.Div(r, big.NewInt(100)) //nolit:gomnd
-	return r.Add(v, r)
-}
-
-func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchInfo, resend bool) error {
 	var ethTx *types.Transaction
 	var err error
-	auth, err := t.NewAuth(ctx, batchInfo)
+	auth, err := t.NewAuth(ctx)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	auth.Nonce = big.NewInt(int64(t.accNextNonce))
+	auth.Nonce = big.NewInt(int64(t.lastPendingNonce))
-	if resend {
+	t.lastPendingNonce++
-		auth.Nonce = big.NewInt(int64(batchInfo.EthTx.Nonce()))
-	}
 	for attempt := 0; attempt < t.cfg.EthClientAttempts; attempt++ {
-		if auth.GasPrice.Cmp(t.cfg.MaxGasPrice) > 0 {
-			return tracerr.Wrap(fmt.Errorf("calculated gasPrice (%v) > maxGasPrice (%v)",
-				auth.GasPrice, t.cfg.MaxGasPrice))
-		}
-		// RollupForgeBatch() calls ethclient.SendTransaction()
 		ethTx, err = t.ethClient.RollupForgeBatch(batchInfo.ForgeBatchArgs, auth)
-		// We check the errors via strings because we match the
+		if err != nil {
-		// definition of the error from geth, with the string returned
+			// if strings.Contains(err.Error(), common.AuctionErrMsgCannotForge) {
-		// via RPC obtained by the client.
+			// 	log.Errorw("TxManager ethClient.RollupForgeBatch", "err", err,
-		if err == nil {
+			// 		"block", t.stats.Eth.LastBlock.Num+1)
-			break
+			// 	return tracerr.Wrap(err)
-		} 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 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 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 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 {
 			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():
@@ -242,29 +179,10 @@ func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchIn
 	if err != nil {
 		return tracerr.Wrap(fmt.Errorf("reached max attempts for ethClient.RollupForgeBatch: %w", err))
 	}
-	if !resend {
-		t.accNextNonce = auth.Nonce.Uint64() + 1
-	}
 	batchInfo.EthTx = ethTx
-	log.Infow("TxManager ethClient.RollupForgeBatch", "batch", batchInfo.BatchNum, "tx", ethTx.Hash())
+	log.Infow("TxManager ethClient.RollupForgeBatch", "batch", batchInfo.BatchNum, "tx", ethTx.Hash().Hex())
-	now := time.Now()
-	batchInfo.SendTimestamp = now
-
-	if resend {
-		batchInfo.Debug.ResendNum++
-	}
-	batchInfo.Debug.Status = StatusSent
-	batchInfo.Debug.SendBlockNum = t.stats.Eth.LastBlock.Num + 1
-	batchInfo.Debug.SendTimestamp = batchInfo.SendTimestamp
-	batchInfo.Debug.StartToSendDelay = batchInfo.Debug.SendTimestamp.Sub(
-		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 {
 		return tracerr.Wrap(err)
 	}
@@ -307,20 +225,13 @@ func (t *TxManager) checkEthTransactionReceipt(ctx context.Context, batchInfo *B
 func (t *TxManager) handleReceipt(ctx context.Context, batchInfo *BatchInfo) (*int64, error) {
 	receipt := batchInfo.Receipt
 	if receipt != nil {
-		if batchInfo.EthTx.Nonce()+1 > t.accNonce {
-			t.accNonce = batchInfo.EthTx.Nonce() + 1
-		}
 		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,
+			log.Warnw("TxManager receipt status is failed", "tx", receipt.TxHash.Hex(),
 				"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 {
@@ -328,17 +239,6 @@ func (t *TxManager) handleReceipt(ctx context.Context, batchInfo *BatchInfo) (*i
 			batchInfo.Debug.MineBlockNum = receipt.BlockNumber.Int64()
 			batchInfo.Debug.StartToMineBlocksDelay = batchInfo.Debug.MineBlockNum -
 				batchInfo.Debug.StartBlockNum
-			if batchInfo.Debug.StartToMineDelay == 0 {
-				if block, err := t.ethClient.EthBlockByNumber(ctx,
-					receipt.BlockNumber.Int64()); err != nil {
-					log.Warnw("TxManager: ethClient.EthBlockByNumber", "err", err)
-				} else {
-					batchInfo.Debug.SendToMineDelay = block.Timestamp.Sub(
-						batchInfo.Debug.SendTimestamp).Seconds()
-					batchInfo.Debug.StartToMineDelay = block.Timestamp.Sub(
-						batchInfo.Debug.StartTimestamp).Seconds()
-				}
-			}
 			t.cfg.debugBatchStore(batchInfo)
 			if batchInfo.BatchNum > t.lastSuccessBatch {
 				t.lastSuccessBatch = batchInfo.BatchNum
@@ -350,72 +250,11 @@ func (t *TxManager) handleReceipt(ctx context.Context, batchInfo *BatchInfo) (*i
 	return nil, nil
 }
 
-// TODO:
-// - After sending a message: CancelPipeline, stop all consecutive pending Batches (transactions)
-
-// Queue of BatchInfos
-type Queue struct {
-	list []*BatchInfo
-	// nonceByBatchNum map[common.BatchNum]uint64
-	next int
-}
-
-// NewQueue returns a new queue
-func NewQueue() Queue {
-	return Queue{
-		list: make([]*BatchInfo, 0),
-		// nonceByBatchNum: make(map[common.BatchNum]uint64),
-		next: 0,
-	}
-}
-
-// Len is the length of the queue
-func (q *Queue) Len() int {
-	return len(q.list)
-}
-
-// At returns the BatchInfo at position (or nil if position is out of bounds)
-func (q *Queue) At(position int) *BatchInfo {
-	if position >= len(q.list) {
-		return nil
-	}
-	return q.list[position]
-}
-
-// Next returns the next BatchInfo (or nil if queue is empty)
-func (q *Queue) Next() (int, *BatchInfo) {
-	if len(q.list) == 0 {
-		return 0, nil
-	}
-	defer func() { q.next = (q.next + 1) % len(q.list) }()
-	return q.next, q.list[q.next]
-}
-
-// Remove removes the BatchInfo at position
-func (q *Queue) Remove(position int) {
-	// batchInfo := q.list[position]
-	// delete(q.nonceByBatchNum, batchInfo.BatchNum)
-	q.list = append(q.list[:position], q.list[position+1:]...)
-	if len(q.list) == 0 {
-		q.next = 0
-	} else {
-		q.next = position % len(q.list)
-	}
-}
-
-// Push adds a new BatchInfo
-func (q *Queue) Push(batchInfo *BatchInfo) {
-	q.list = append(q.list, batchInfo)
-	// q.nonceByBatchNum[batchInfo.BatchNum] = batchInfo.EthTx.Nonce()
-}
-
-// func (q *Queue) NonceByBatchNum(batchNum common.BatchNum) (uint64, bool) {
-// 	nonce, ok := q.nonceByBatchNum[batchNum]
-// 	return nonce, ok
-// }
-
 // Run the TxManager
 func (t *TxManager) Run(ctx context.Context) {
+	next := 0
+	waitDuration := longWaitDuration
+
 	var statsVars statsVars
 	select {
 	case statsVars = <-t.statsVarsCh:
@@ -424,9 +263,8 @@ func (t *TxManager) Run(ctx context.Context) {
 	t.stats = statsVars.Stats
 	t.syncSCVars(statsVars.Vars)
 	log.Infow("TxManager: received initial statsVars",
-		"block", t.stats.Eth.LastBlock.Num, "batch", t.stats.Eth.LastBatchNum)
+		"block", t.stats.Eth.LastBlock.Num, "batch", t.stats.Eth.LastBatch)
 
-	timer := time.NewTimer(longWaitDuration)
 	for {
 		select {
 		case <-ctx.Done():
@@ -435,27 +273,8 @@ func (t *TxManager) Run(ctx context.Context) {
 		case statsVars := <-t.statsVarsCh:
 			t.stats = statsVars.Stats
 			t.syncSCVars(statsVars.Vars)
-		case pipelineNum := <-t.discardPipelineCh:
-			t.minPipelineNum = pipelineNum + 1
-			if err := t.removeBadBatchInfos(ctx); ctx.Err() != nil {
-				continue
-			} else if err != nil {
-				log.Errorw("TxManager: removeBadBatchInfos", "err", err)
-				continue
-			}
 		case batchInfo := <-t.batchCh:
-			if batchInfo.PipelineNum < t.minPipelineNum {
+			if err := t.sendRollupForgeBatch(ctx, batchInfo); ctx.Err() != nil {
-				log.Warnw("TxManager: batchInfo received pipelineNum < minPipelineNum",
-					"num", batchInfo.PipelineNum, "minNum", t.minPipelineNum)
-			}
-			if err := t.shouldSendRollupForgeBatch(batchInfo); err != nil {
-				log.Warnw("TxManager: shouldSend", "err", err,
-					"batch", batchInfo.BatchNum)
-				t.coord.SendMsg(ctx, MsgStopPipeline{
-					Reason: fmt.Sprintf("forgeBatch shouldSend: %v", err)})
-				continue
-			}
-			if err := t.sendRollupForgeBatch(ctx, batchInfo, false); ctx.Err() != nil {
 				continue
 			} else if err != nil {
 				// If we reach here it's because our ethNode has
@@ -463,24 +282,19 @@ func (t *TxManager) Run(ctx context.Context) {
 				// ethereum.  This could be due to the ethNode
 				// failure, or an invalid transaction (that
 				// can't be mined)
-				log.Warnw("TxManager: forgeBatch send failed", "err", err,
+				t.coord.SendMsg(ctx, MsgStopPipeline{Reason: fmt.Sprintf("forgeBatch send: %v", err)})
-					"batch", batchInfo.BatchNum)
-				t.coord.SendMsg(ctx, MsgStopPipeline{
-					Reason: fmt.Sprintf("forgeBatch send: %v", err)})
 				continue
 			}
-			t.queue.Push(batchInfo)
+			t.queue = append(t.queue, batchInfo)
-			if !timer.Stop() {
+			waitDuration = t.cfg.TxManagerCheckInterval
-				<-timer.C
+		case <-time.After(waitDuration):
-			}
+			if len(t.queue) == 0 {
-			timer.Reset(t.cfg.TxManagerCheckInterval)
+				waitDuration = longWaitDuration
-		case <-timer.C:
-			queuePosition, batchInfo := t.queue.Next()
-			if batchInfo == nil {
-				timer.Reset(longWaitDuration)
 				continue
 			}
-			timer.Reset(t.cfg.TxManagerCheckInterval)
+			current := next
+			next = (current + 1) % len(t.queue)
+			batchInfo := t.queue[current]
 			if err := t.checkEthTransactionReceipt(ctx, batchInfo); ctx.Err() != nil {
 				continue
 			} else if err != nil { //nolint:staticcheck
@@ -490,8 +304,7 @@ func (t *TxManager) Run(ctx context.Context) {
 				// if it was not mined, mined and succesfull or
 				// mined and failed.  This could be due to the
 				// ethNode failure.
-				t.coord.SendMsg(ctx, MsgStopPipeline{
+				t.coord.SendMsg(ctx, MsgStopPipeline{Reason: fmt.Sprintf("forgeBatch receipt: %v", err)})
-					Reason: fmt.Sprintf("forgeBatch receipt: %v", err)})
 			}
 
 			confirm, err := t.handleReceipt(ctx, batchInfo)
@@ -499,106 +312,32 @@ func (t *TxManager) Run(ctx context.Context) {
 				continue
 			} else if err != nil { //nolint:staticcheck
 				// Transaction was rejected
-				if err := t.removeBadBatchInfos(ctx); ctx.Err() != nil {
+				t.queue = append(t.queue[:current], t.queue[current+1:]...)
-					continue
+				if len(t.queue) == 0 {
-				} else if err != nil {
+					next = 0
-					log.Errorw("TxManager: removeBadBatchInfos", "err", err)
+				} else {
-					continue
+					next = current % len(t.queue)
 				}
-				t.coord.SendMsg(ctx, MsgStopPipeline{
+				t.coord.SendMsg(ctx, MsgStopPipeline{Reason: fmt.Sprintf("forgeBatch reject: %v", err)})
-					Reason: fmt.Sprintf("forgeBatch reject: %v", err)})
-				continue
 			}
-			now := time.Now()
-			if !t.cfg.EthNoReuseNonce && confirm == nil &&
-				now.Sub(batchInfo.SendTimestamp) > t.cfg.EthTxResendTimeout {
-				log.Infow("TxManager: forgeBatch tx not been mined timeout, resending",
-					"tx", batchInfo.EthTx.Hash(), "batch", batchInfo.BatchNum)
-				if err := t.sendRollupForgeBatch(ctx, batchInfo, true); ctx.Err() != nil {
-					continue
-				} else if err != nil {
-					// If we reach here it's because our ethNode has
-					// been unable to send the transaction to
-					// ethereum.  This could be due to the ethNode
-					// failure, or an invalid transaction (that
-					// can't be mined)
-					log.Warnw("TxManager: forgeBatch resend failed", "err", err,
-						"batch", batchInfo.BatchNum)
-					t.coord.SendMsg(ctx, MsgStopPipeline{
-						Reason: fmt.Sprintf("forgeBatch resend: %v", err)})
-					continue
-				}
-			}
-
 			if confirm != nil && *confirm >= t.cfg.ConfirmBlocks {
-				log.Debugw("TxManager: forgeBatch tx confirmed",
+				log.Debugw("TxManager tx for RollupForgeBatch confirmed",
-					"tx", batchInfo.EthTx.Hash(), "batch", batchInfo.BatchNum)
+					"batch", batchInfo.BatchNum)
-				t.queue.Remove(queuePosition)
+				t.queue = append(t.queue[:current], t.queue[current+1:]...)
+				if len(t.queue) == 0 {
+					next = 0
+				} else {
+					next = current % len(t.queue)
+				}
 			}
 		}
 	}
 }
 
-func (t *TxManager) removeBadBatchInfos(ctx context.Context) error {
+// nolint reason: this function will be used in the future
-	next := 0
+//nolint:unused
-	for {
+func (t *TxManager) canForge(stats *synchronizer.Stats, blockNum int64) bool {
-		batchInfo := t.queue.At(next)
-		if batchInfo == nil {
-			break
-		}
-		if err := t.checkEthTransactionReceipt(ctx, batchInfo); ctx.Err() != nil {
-			return nil
-		} else if err != nil {
-			// 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
-			// mined and failed.  This could be due to the
-			// ethNode failure.
-			next++
-			continue
-		}
-		confirm, err := t.handleReceipt(ctx, batchInfo)
-		if ctx.Err() != nil {
-			return nil
-		} else if err != nil {
-			// Transaction was rejected
-			if t.minPipelineNum <= batchInfo.PipelineNum {
-				t.minPipelineNum = batchInfo.PipelineNum + 1
-			}
-			t.queue.Remove(next)
-			continue
-		}
-		// If tx is pending but is from a cancelled pipeline, remove it
-		// from the queue
-		if confirm == nil {
-			if batchInfo.PipelineNum < t.minPipelineNum {
-				t.queue.Remove(next)
-				continue
-			}
-		}
-		next++
-	}
-	accNonce, err := t.ethClient.EthNonceAt(ctx, t.account.Address, nil)
-	if err != nil {
-		return err
-	}
-	if !t.cfg.EthNoReuseNonce {
-		t.accNextNonce = accNonce
-	}
-	return nil
-}
-
-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,
+		&stats.Sync.Auction.CurrentSlot, &stats.Sync.Auction.NextSlot,
 		t.cfg.ForgerAddress, blockNum)
 }
-
-func (t *TxManager) mustL1L2Batch(blockNum int64) bool {
-	lastL1BatchBlockNum := t.lastSentL1BatchBlockNum
-	if t.stats.Sync.LastL1BatchBlock > lastL1BatchBlockNum {
-		lastL1BatchBlockNum = t.stats.Sync.LastL1BatchBlock
-	}
-	return blockNum-lastL1BatchBlockNum >= t.vars.Rollup.ForgeL1L2BatchTimeout-1
-}

coordinator/txmanager_test.go

@@ -1,15 +0,0 @@
-package coordinator
-
-import (
-	"math/big"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAddPerc(t *testing.T) {
-	assert.Equal(t, "110", addPerc(big.NewInt(100), 10).String())
-	assert.Equal(t, "101", addPerc(big.NewInt(100), 1).String())
-	assert.Equal(t, "12", addPerc(big.NewInt(10), 20).String())
-	assert.Equal(t, "1500", addPerc(big.NewInt(1000), 50).String())
-}

db/historydb/apiqueries.go

@@ -34,7 +34,7 @@ func (hdb *HistoryDB) GetBatchAPI(batchNum common.BatchNum) (*BatchAPI, error) {
 	defer hdb.apiConnCon.Release()
 	batch := &BatchAPI{}
 	return batch, tracerr.Wrap(meddler.QueryRow(
-		hdb.dbRead, batch,
+		hdb.db, batch,
 		`SELECT batch.item_id, batch.batch_num, batch.eth_block_num,
 		batch.forger_addr, batch.fees_collected, batch.total_fees_usd, batch.state_root,
 		batch.num_accounts, batch.exit_root, batch.forge_l1_txs_num, batch.slot_num,
@@ -133,10 +133,10 @@ func (hdb *HistoryDB) GetBatchesAPI(
 		queryStr += " DESC "
 	}
 	queryStr += fmt.Sprintf("LIMIT %d;", *limit)
-	query = hdb.dbRead.Rebind(queryStr)
+	query = hdb.db.Rebind(queryStr)
 	// log.Debug(query)
 	batchPtrs := []*BatchAPI{}
-	if err := meddler.QueryAll(hdb.dbRead, &batchPtrs, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.db, &batchPtrs, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	batches := db.SlicePtrsToSlice(batchPtrs).([]BatchAPI)
@@ -156,7 +156,7 @@ func (hdb *HistoryDB) GetBestBidAPI(slotNum *int64) (BidAPI, error) {
 	}
 	defer hdb.apiConnCon.Release()
 	err = meddler.QueryRow(
-		hdb.dbRead, bid, `SELECT bid.*, block.timestamp, coordinator.forger_addr, coordinator.url 
+		hdb.db, 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
@@ -212,9 +212,9 @@ func (hdb *HistoryDB) GetBestBidsAPI(
 	if limit != nil {
 		queryStr += fmt.Sprintf("LIMIT %d;", *limit)
 	}
-	query = hdb.dbRead.Rebind(queryStr)
+	query = hdb.db.Rebind(queryStr)
 	bidPtrs := []*BidAPI{}
-	if err := meddler.QueryAll(hdb.dbRead, &bidPtrs, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.db, &bidPtrs, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	// log.Debug(query)
@@ -296,9 +296,9 @@ func (hdb *HistoryDB) GetBidsAPI(
 	if err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
-	query = hdb.dbRead.Rebind(query)
+	query = hdb.db.Rebind(query)
 	bids := []*BidAPI{}
-	if err := meddler.QueryAll(hdb.dbRead, &bids, query, argsQ...); err != nil {
+	if err := meddler.QueryAll(hdb.db, &bids, query, argsQ...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(bids) == 0 {
@@ -384,9 +384,9 @@ func (hdb *HistoryDB) GetTokensAPI(
 	if err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
-	query = hdb.dbRead.Rebind(query)
+	query = hdb.db.Rebind(query)
 	tokens := []*TokenWithUSD{}
-	if err := meddler.QueryAll(hdb.dbRead, &tokens, query, argsQ...); err != nil {
+	if err := meddler.QueryAll(hdb.db, &tokens, query, argsQ...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(tokens) == 0 {
@@ -408,7 +408,7 @@ func (hdb *HistoryDB) GetTxAPI(txID common.TxID) (*TxAPI, error) {
 	defer hdb.apiConnCon.Release()
 	tx := &TxAPI{}
 	err = meddler.QueryRow(
-		hdb.dbRead, tx, `SELECT tx.item_id, tx.is_l1, tx.id, tx.type, tx.position, 
+		hdb.db, 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 +541,10 @@ func (hdb *HistoryDB) GetTxsAPI(
 		queryStr += " DESC "
 	}
 	queryStr += fmt.Sprintf("LIMIT %d;", *limit)
-	query = hdb.dbRead.Rebind(queryStr)
+	query = hdb.db.Rebind(queryStr)
 	// log.Debug(query)
 	txsPtrs := []*TxAPI{}
-	if err := meddler.QueryAll(hdb.dbRead, &txsPtrs, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.db, &txsPtrs, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	txs := db.SlicePtrsToSlice(txsPtrs).([]TxAPI)
@@ -564,7 +564,7 @@ func (hdb *HistoryDB) GetExitAPI(batchNum *uint, idx *common.Idx) (*ExitAPI, err
 	defer hdb.apiConnCon.Release()
 	exit := &ExitAPI{}
 	err = meddler.QueryRow(
-		hdb.dbRead, exit, `SELECT exit_tree.item_id, exit_tree.batch_num,
+		hdb.db, 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 +685,10 @@ func (hdb *HistoryDB) GetExitsAPI(
 		queryStr += " DESC "
 	}
 	queryStr += fmt.Sprintf("LIMIT %d;", *limit)
-	query = hdb.dbRead.Rebind(queryStr)
+	query = hdb.db.Rebind(queryStr)
 	// log.Debug(query)
 	exits := []*ExitAPI{}
-	if err := meddler.QueryAll(hdb.dbRead, &exits, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.db, &exits, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(exits) == 0 {
@@ -707,7 +707,7 @@ func (hdb *HistoryDB) GetBucketUpdatesAPI() ([]BucketUpdateAPI, error) {
 	defer hdb.apiConnCon.Release()
 	var bucketUpdates []*BucketUpdateAPI
 	err = meddler.QueryAll(
-		hdb.dbRead, &bucketUpdates,
+		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) 
@@ -772,10 +772,10 @@ func (hdb *HistoryDB) GetCoordinatorsAPI(
 		queryStr += " DESC "
 	}
 	queryStr += fmt.Sprintf("LIMIT %d;", *limit)
-	query = hdb.dbRead.Rebind(queryStr)
+	query = hdb.db.Rebind(queryStr)
 
 	coordinators := []*CoordinatorAPI{}
-	if err := meddler.QueryAll(hdb.dbRead, &coordinators, query, args...); err != nil {
+	if err := meddler.QueryAll(hdb.db, &coordinators, query, args...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(coordinators) == 0 {
@@ -795,7 +795,7 @@ func (hdb *HistoryDB) GetAuctionVarsAPI() (*common.AuctionVariables, error) {
 	defer hdb.apiConnCon.Release()
 	auctionVars := &common.AuctionVariables{}
 	err = meddler.QueryRow(
-		hdb.dbRead, auctionVars, `SELECT * FROM auction_vars;`,
+		hdb.db, auctionVars, `SELECT * FROM auction_vars;`,
 	)
 	return auctionVars, tracerr.Wrap(err)
 }
@@ -816,7 +816,7 @@ func (hdb *HistoryDB) GetAuctionVarsUntilSetSlotNumAPI(slotNum int64, maxItems i
 		ORDER BY default_slot_set_bid_slot_num DESC
 		LIMIT $2;
 	`
-	err = meddler.QueryAll(hdb.dbRead, &auctionVars, query, slotNum, maxItems)
+	err = meddler.QueryAll(hdb.db, &auctionVars, query, slotNum, maxItems)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -832,19 +832,11 @@ func (hdb *HistoryDB) GetAccountAPI(idx common.Idx) (*AccountAPI, error) {
 	}
 	defer hdb.apiConnCon.Release()
 	account := &AccountAPI{}
-	err = meddler.QueryRow(hdb.dbRead, account, `SELECT account.item_id, hez_idx(account.idx, 
+	err = meddler.QueryRow(hdb.db, 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.eth_addr as token_eth_addr, token.name, token.symbol, token.decimals, token.usd, token.usd_update 
-		token.usd_update, account_update.nonce, account_update.balance 
+	FROM account INNER JOIN token ON account.token_id = token.token_id WHERE idx = $1;`, idx)
-		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)
@@ -872,13 +864,8 @@ 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, 
-	account_update.nonce, account_update.balance, COUNT(*) OVER() AS total_items
+	COUNT(*) OVER() AS total_items
-	FROM account inner JOIN (
+	FROM account INNER JOIN token ON account.token_id = token.token_id `
-		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
@@ -927,10 +914,10 @@ func (hdb *HistoryDB) GetAccountsAPI(
 	if err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
-	query = hdb.dbRead.Rebind(query)
+	query = hdb.db.Rebind(query)
 
 	accounts := []*AccountAPI{}
-	if err := meddler.QueryAll(hdb.dbRead, &accounts, query, argsQ...); err != nil {
+	if err := meddler.QueryAll(hdb.db, &accounts, query, argsQ...); err != nil {
 		return nil, 0, tracerr.Wrap(err)
 	}
 	if len(accounts) == 0 {
@@ -952,19 +939,11 @@ func (hdb *HistoryDB) GetMetricsAPI(lastBatchNum common.BatchNum) (*Metrics, err
 	metricsTotals := &MetricsTotals{}
 	metrics := &Metrics{}
 	err = meddler.QueryRow(
-		hdb.dbRead, metricsTotals, `SELECT
+		hdb.db, metricsTotals, `SELECT COUNT(tx.*) as total_txs,
-		COALESCE (MIN(batch.batch_num), 0) as batch_num,
+		COALESCE (MIN(tx.batch_num), 0) as batch_num, COALESCE (MIN(block.timestamp), 
-		COALESCE (MIN(block.timestamp), NOW()) AS min_timestamp, 
+		NOW()) AS min_timestamp, COALESCE (MAX(block.timestamp), NOW()) AS max_timestamp
-		COALESCE (MAX(block.timestamp), NOW()) AS max_timestamp
+		FROM tx INNER JOIN block ON tx.eth_block_num = block.eth_block_num
-		FROM batch INNER JOIN block ON batch.eth_block_num = block.eth_block_num
+		WHERE block.timestamp >= NOW() - INTERVAL '24 HOURS';`)
-		WHERE block.timestamp >= NOW() - INTERVAL '24 HOURS' and batch.batch_num <= $1;`, lastBatchNum)
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-
-	err = meddler.QueryRow(
-		hdb.dbRead, metricsTotals, `SELECT COUNT(*) as total_txs
-		FROM tx	WHERE tx.batch_num between $1 AND $2;`, metricsTotals.FirstBatchNum, lastBatchNum)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -985,13 +964,12 @@ func (hdb *HistoryDB) GetMetricsAPI(lastBatchNum common.BatchNum) (*Metrics, err
 	}
 
 	err = meddler.QueryRow(
-		hdb.dbRead, metricsTotals, `SELECT COUNT(*) AS total_batches, 
+		hdb.db, metricsTotals, `SELECT COUNT(*) AS total_batches, 
 		COALESCE (SUM(total_fees_usd), 0) AS total_fees FROM batch 
-		WHERE batch_num between $1 and $2;`, metricsTotals.FirstBatchNum, lastBatchNum)
+		WHERE batch_num > $1;`, metricsTotals.FirstBatchNum)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-
 	if metricsTotals.TotalBatches > 0 {
 		metrics.BatchFrequency = seconds / float64(metricsTotals.TotalBatches)
 	} else {
@@ -1003,7 +981,7 @@ func (hdb *HistoryDB) GetMetricsAPI(lastBatchNum common.BatchNum) (*Metrics, err
 		metrics.AvgTransactionFee = 0
 	}
 	err = meddler.QueryRow(
-		hdb.dbRead, metrics,
+		hdb.db, metrics,
 		`SELECT COUNT(*) AS total_bjjs, COUNT(DISTINCT(bjj)) AS total_accounts FROM account;`)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -1022,7 +1000,7 @@ func (hdb *HistoryDB) GetAvgTxFeeAPI() (float64, error) {
 	defer hdb.apiConnCon.Release()
 	metricsTotals := &MetricsTotals{}
 	err = meddler.QueryRow(
-		hdb.dbRead, metricsTotals, `SELECT COUNT(tx.*) as total_txs, 
+		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';`)
@@ -1030,7 +1008,7 @@ func (hdb *HistoryDB) GetAvgTxFeeAPI() (float64, error) {
 		return 0, tracerr.Wrap(err)
 	}
 	err = meddler.QueryRow(
-		hdb.dbRead, metricsTotals, `SELECT COUNT(*) AS total_batches, 
+		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 {
@@ -1046,18 +1024,3 @@ func (hdb *HistoryDB) GetAvgTxFeeAPI() (float64, error) {
 
 	return avgTransactionFee, nil
 }
-
-// GetCommonAccountAPI returns the account associated to an account idx
-func (hdb *HistoryDB) GetCommonAccountAPI(idx common.Idx) (*common.Account, error) {
-	cancel, err := hdb.apiConnCon.Acquire()
-	defer cancel()
-	if err != nil {
-		return nil, tracerr.Wrap(err)
-	}
-	defer hdb.apiConnCon.Release()
-	account := &common.Account{}
-	err = meddler.QueryRow(
-		hdb.dbRead, account, `SELECT * FROM account WHERE idx = $1;`, idx,
-	)
-	return account, tracerr.Wrap(err)
-}

db/historydb/historydb.go

@@ -27,35 +27,30 @@ const (
 
 // HistoryDB persist the historic of the rollup
 type HistoryDB struct {
-	dbRead     *sqlx.DB
+	db         *sqlx.DB
-	dbWrite    *sqlx.DB
 	apiConnCon *db.APIConnectionController
 }
 
 // NewHistoryDB initialize the DB
-func NewHistoryDB(dbRead, dbWrite *sqlx.DB, apiConnCon *db.APIConnectionController) *HistoryDB {
+func NewHistoryDB(db *sqlx.DB, apiConnCon *db.APIConnectionController) *HistoryDB {
-	return &HistoryDB{
+	return &HistoryDB{db: db, apiConnCon: apiConnCon}
-		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.dbWrite
+	return hdb.db
 }
 
 // AddBlock insert a block into the DB
-func (hdb *HistoryDB) AddBlock(block *common.Block) error { return hdb.addBlock(hdb.dbWrite, block) }
+func (hdb *HistoryDB) AddBlock(block *common.Block) error { return hdb.addBlock(hdb.db, 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.dbWrite, blocks))
+	return tracerr.Wrap(hdb.addBlocks(hdb.db, blocks))
 }
 
 func (hdb *HistoryDB) addBlocks(d meddler.DB, blocks []common.Block) error {
@@ -66,7 +61,7 @@ func (hdb *HistoryDB) addBlocks(d meddler.DB, blocks []common.Block) error {
 			timestamp,
 			hash
 		) VALUES %s;`,
-		blocks,
+		blocks[:],
 	))
 }
 
@@ -74,7 +69,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.dbRead, block,
+		hdb.db, block,
 		"SELECT * FROM block WHERE eth_block_num = $1;", blockNum,
 	)
 	return block, tracerr.Wrap(err)
@@ -84,7 +79,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.dbRead, &blocks,
+		hdb.db, &blocks,
 		"SELECT * FROM block ORDER BY eth_block_num;",
 	)
 	return db.SlicePtrsToSlice(blocks).([]common.Block), tracerr.Wrap(err)
@@ -94,7 +89,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.dbRead, &blocks,
+		hdb.db, &blocks,
 		"SELECT * FROM block WHERE $1 <= eth_block_num AND eth_block_num < $2 ORDER BY eth_block_num;",
 		from, to,
 	)
@@ -105,13 +100,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.dbRead, block, "SELECT * FROM block ORDER BY eth_block_num DESC LIMIT 1;",
+		hdb.db, 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.dbWrite, batch) }
+func (hdb *HistoryDB) AddBatch(batch *common.Batch) error { return hdb.addBatch(hdb.db, 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
@@ -134,9 +129,9 @@ func (hdb *HistoryDB) addBatch(d meddler.DB, batch *common.Batch) error {
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
-		query = hdb.dbWrite.Rebind(query)
+		query = hdb.db.Rebind(query)
 		if err := meddler.QueryAll(
-			hdb.dbWrite, &tokenPrices, query, args...,
+			hdb.db, &tokenPrices, query, args...,
 		); err != nil {
 			return tracerr.Wrap(err)
 		}
@@ -158,7 +153,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.dbWrite, batches))
+	return tracerr.Wrap(hdb.addBatches(hdb.db, batches))
 }
 func (hdb *HistoryDB) addBatches(d meddler.DB, batches []common.Batch) error {
 	for i := 0; i < len(batches); i++ {
@@ -169,24 +164,11 @@ func (hdb *HistoryDB) addBatches(d meddler.DB, batches []common.Batch) error {
 	return nil
 }
 
-// GetBatch returns the batch with the given batchNum
-func (hdb *HistoryDB) GetBatch(batchNum common.BatchNum) (*common.Batch, error) {
-	var batch common.Batch
-	err := meddler.QueryRow(
-		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
-}
-
 // GetAllBatches retrieve all batches from the DB
 func (hdb *HistoryDB) GetAllBatches() ([]common.Batch, error) {
 	var batches []*common.Batch
 	err := meddler.QueryAll(
-		hdb.dbRead, &batches,
+		hdb.db, &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
@@ -199,7 +181,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.dbRead, &batches,
+		hdb.db, &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;`,
@@ -211,7 +193,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.dbRead.QueryRow(
+	row := hdb.db.QueryRow(
 		`SELECT eth_block_num FROM batch
 		WHERE slot_num = $1 ORDER BY batch_num ASC LIMIT 1;`, slotNum,
 	)
@@ -221,26 +203,14 @@ 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.dbRead.QueryRow("SELECT batch_num FROM batch ORDER BY batch_num DESC LIMIT 1;")
+	row := hdb.db.QueryRow("SELECT batch_num FROM batch ORDER BY batch_num DESC LIMIT 1;")
 	var batchNum common.BatchNum
 	return batchNum, tracerr.Wrap(row.Scan(&batchNum))
 }
 
-// GetLastBatch returns the last forged batch
-func (hdb *HistoryDB) GetLastBatch() (*common.Batch, error) {
-	var batch common.Batch
-	err := meddler.QueryRow(
-		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
-}
-
 // GetLastL1BatchBlockNum returns the blockNum of the latest forged l1Batch
 func (hdb *HistoryDB) GetLastL1BatchBlockNum() (int64, error) {
-	row := hdb.dbRead.QueryRow(`SELECT eth_block_num FROM batch
+	row := hdb.db.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
@@ -250,7 +220,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.dbRead.QueryRow("SELECT MAX(forge_l1_txs_num) FROM batch;")
+	row := hdb.db.QueryRow("SELECT MAX(forge_l1_txs_num) FROM batch;")
 	lastL1TxsNum := new(int64)
 	return lastL1TxsNum, tracerr.Wrap(row.Scan(&lastL1TxsNum))
 }
@@ -261,15 +231,15 @@ func (hdb *HistoryDB) GetLastL1TxsNum() (*int64, error) {
 func (hdb *HistoryDB) Reorg(lastValidBlock int64) error {
 	var err error
 	if lastValidBlock < 0 {
-		_, err = hdb.dbWrite.Exec("DELETE FROM block;")
+		_, err = hdb.db.Exec("DELETE FROM block;")
 	} else {
-		_, err = hdb.dbWrite.Exec("DELETE FROM block WHERE eth_block_num > $1;", lastValidBlock)
+		_, err = hdb.db.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.dbWrite, bids) }
+func (hdb *HistoryDB) AddBids(bids []common.Bid) error { return hdb.addBids(hdb.db, bids) }
 func (hdb *HistoryDB) addBids(d meddler.DB, bids []common.Bid) error {
 	if len(bids) == 0 {
 		return nil
@@ -278,7 +248,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[:],
 	))
 }
 
@@ -286,7 +256,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.dbRead, &bids,
+		hdb.db, &bids,
 		`SELECT bid.slot_num, bid.bid_value, bid.eth_block_num, bid.bidder_addr FROM bid
 		ORDER BY item_id;`,
 	)
@@ -297,7 +267,7 @@ func (hdb *HistoryDB) GetAllBids() ([]common.Bid, error) {
 func (hdb *HistoryDB) GetBestBidCoordinator(slotNum int64) (*common.BidCoordinator, error) {
 	bidCoord := &common.BidCoordinator{}
 	err := meddler.QueryRow(
-		hdb.dbRead, bidCoord,
+		hdb.db, bidCoord,
 		`SELECT (
 			SELECT default_slot_set_bid
 			FROM auction_vars
@@ -320,7 +290,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.dbWrite, coordinators))
+	return tracerr.Wrap(hdb.addCoordinators(hdb.db, coordinators))
 }
 func (hdb *HistoryDB) addCoordinators(d meddler.DB, coordinators []common.Coordinator) error {
 	if len(coordinators) == 0 {
@@ -329,13 +299,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.dbWrite, exitTree))
+	return tracerr.Wrap(hdb.addExitTree(hdb.db, exitTree))
 }
 func (hdb *HistoryDB) addExitTree(d meddler.DB, exitTree []common.ExitInfo) error {
 	if len(exitTree) == 0 {
@@ -345,7 +315,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[:],
 	))
 }
 
@@ -423,13 +393,11 @@ 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.dbWrite, "token", token))
+	return tracerr.Wrap(meddler.Insert(hdb.db, "token", token))
 }
 
 // AddTokens insert tokens into the DB
-func (hdb *HistoryDB) AddTokens(tokens []common.Token) error {
+func (hdb *HistoryDB) AddTokens(tokens []common.Token) error { return hdb.addTokens(hdb.db, tokens) }
-	return hdb.addTokens(hdb.dbWrite, tokens)
-}
 func (hdb *HistoryDB) addTokens(d meddler.DB, tokens []common.Token) error {
 	if len(tokens) == 0 {
 		return nil
@@ -450,17 +418,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.  Value is the price in
+// UpdateTokenValue updates the USD value of a token
-// USD of a normalized token (1 token = 10^decimals units)
 func (hdb *HistoryDB) UpdateTokenValue(tokenSymbol string, value float64) error {
 	// Sanitize symbol
 	tokenSymbol = strings.ToValidUTF8(tokenSymbol, " ")
 
-	_, err := hdb.dbWrite.Exec(
+	_, err := hdb.db.Exec(
 		"UPDATE token SET usd = $1 WHERE symbol = $2;",
 		value, tokenSymbol,
 	)
@@ -471,7 +438,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.dbRead, token, `SELECT * FROM token WHERE token_id = $1;`, tokenID,
+		hdb.db, token, `SELECT * FROM token WHERE token_id = $1;`, tokenID,
 	)
 	return token, tracerr.Wrap(err)
 }
@@ -480,7 +447,7 @@ func (hdb *HistoryDB) GetToken(tokenID common.TokenID) (*TokenWithUSD, error) {
 func (hdb *HistoryDB) GetAllTokens() ([]TokenWithUSD, error) {
 	var tokens []*TokenWithUSD
 	err := meddler.QueryAll(
-		hdb.dbRead, &tokens,
+		hdb.db, &tokens,
 		"SELECT * FROM token ORDER BY token_id;",
 	)
 	return db.SlicePtrsToSlice(tokens).([]TokenWithUSD), tracerr.Wrap(err)
@@ -489,7 +456,7 @@ func (hdb *HistoryDB) GetAllTokens() ([]TokenWithUSD, error) {
 // GetTokenSymbols returns all the token symbols from the DB
 func (hdb *HistoryDB) GetTokenSymbols() ([]string, error) {
 	var tokenSymbols []string
-	rows, err := hdb.dbRead.Query("SELECT symbol FROM token;")
+	rows, err := hdb.db.Query("SELECT symbol FROM token;")
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -507,7 +474,7 @@ func (hdb *HistoryDB) GetTokenSymbols() ([]string, error) {
 
 // AddAccounts insert accounts into the DB
 func (hdb *HistoryDB) AddAccounts(accounts []common.Account) error {
-	return tracerr.Wrap(hdb.addAccounts(hdb.dbWrite, accounts))
+	return tracerr.Wrap(hdb.addAccounts(hdb.db, accounts))
 }
 func (hdb *HistoryDB) addAccounts(d meddler.DB, accounts []common.Account) error {
 	if len(accounts) == 0 {
@@ -522,7 +489,7 @@ func (hdb *HistoryDB) addAccounts(d meddler.DB, accounts []common.Account) error
 			bjj,
 			eth_addr
 		) VALUES %s;`,
-		accounts,
+		accounts[:],
 	))
 }
 
@@ -530,49 +497,18 @@ 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.dbRead, &accs,
+		hdb.db, &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.dbWrite, l1txs))
+	return tracerr.Wrap(hdb.addL1Txs(hdb.db, l1txs))
 }
 
 // addL1Txs inserts L1 txs to the DB. USD and DepositAmountUSD will be set automatically before storing the tx.
@@ -626,7 +562,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.dbWrite, l2txs))
+	return tracerr.Wrap(hdb.addL2Txs(hdb.db, l2txs))
 }
 
 // addL2Txs inserts L2 txs to the DB. TokenID, USD and FeeUSD will be set automatically before storing the tx.
@@ -685,7 +621,7 @@ func (hdb *HistoryDB) addTxs(d meddler.DB, txs []txWrite) error {
 			fee,
 			nonce
 		) VALUES %s;`,
-		txs,
+		txs[:],
 	))
 }
 
@@ -693,7 +629,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.dbRead, &exits,
+		hdb.db, &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;`,
@@ -705,7 +641,7 @@ func (hdb *HistoryDB) GetAllExits() ([]common.ExitInfo, error) {
 func (hdb *HistoryDB) GetAllL1UserTxs() ([]common.L1Tx, error) {
 	var txs []*common.L1Tx
 	err := meddler.QueryAll(
-		hdb.dbRead, &txs, // Note that '\x' gets parsed as a big.Int with value = 0
+		hdb.db, &txs, // Note that '\x' gets parsed as a big.Int with value = 0
 		`SELECT tx.id, tx.to_forge_l1_txs_num, tx.position, tx.user_origin,
 		tx.from_idx, tx.effective_from_idx, tx.from_eth_addr, tx.from_bjj, tx.to_idx, tx.token_id,
 		tx.amount, (CASE WHEN tx.batch_num IS NULL THEN NULL WHEN tx.amount_success THEN tx.amount ELSE '\x' END) AS effective_amount,
@@ -722,7 +658,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.dbRead, &txs,
+		hdb.db, &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,
@@ -737,7 +673,7 @@ func (hdb *HistoryDB) GetAllL1CoordinatorTxs() ([]common.L1Tx, error) {
 func (hdb *HistoryDB) GetAllL2Txs() ([]common.L2Tx, error) {
 	var txs []*common.L2Tx
 	err := meddler.QueryAll(
-		hdb.dbRead, &txs,
+		hdb.db, &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
@@ -750,7 +686,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.dbRead, &txs, // only L1 user txs can have batch_num set to null
+		hdb.db, &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,
@@ -767,7 +703,7 @@ func (hdb *HistoryDB) GetUnforgedL1UserTxs(toForgeL1TxsNum int64) ([]common.L1Tx
 
 // GetLastTxsPosition for a given to_forge_l1_txs_num
 func (hdb *HistoryDB) GetLastTxsPosition(toForgeL1TxsNum int64) (int, error) {
-	row := hdb.dbRead.QueryRow(
+	row := hdb.db.QueryRow(
 		"SELECT position FROM tx WHERE to_forge_l1_txs_num = $1 ORDER BY position DESC;",
 		toForgeL1TxsNum,
 	)
@@ -781,15 +717,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.dbRead, &rollup,
+	if err := meddler.QueryRow(hdb.db, &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.dbRead, &auction,
+	if err := meddler.QueryRow(hdb.db, &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.dbRead, &wDelayer,
+	if err := meddler.QueryRow(hdb.db, &wDelayer,
 		"SELECT * FROM wdelayer_vars ORDER BY eth_block_num DESC LIMIT 1;"); err != nil {
 		return nil, nil, nil, tracerr.Wrap(err)
 	}
@@ -820,7 +756,7 @@ func (hdb *HistoryDB) addBucketUpdates(d meddler.DB, bucketUpdates []common.Buck
 		 	block_stamp,
 		 	withdrawals
 		) VALUES %s;`,
-		bucketUpdates,
+		bucketUpdates[:],
 	))
 }
 
@@ -834,7 +770,7 @@ func (hdb *HistoryDB) AddBucketUpdatesTest(d meddler.DB, bucketUpdates []common.
 func (hdb *HistoryDB) GetAllBucketUpdates() ([]common.BucketUpdate, error) {
 	var bucketUpdates []*common.BucketUpdate
 	err := meddler.QueryAll(
-		hdb.dbRead, &bucketUpdates,
+		hdb.db, &bucketUpdates,
 		`SELECT eth_block_num, num_bucket, block_stamp, withdrawals  
 		FROM bucket_update ORDER BY item_id;`,
 	)
@@ -852,7 +788,7 @@ func (hdb *HistoryDB) addTokenExchanges(d meddler.DB, tokenExchanges []common.To
     			eth_addr,
     			value_usd
 		) VALUES %s;`,
-		tokenExchanges,
+		tokenExchanges[:],
 	))
 }
 
@@ -860,7 +796,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.dbRead, &tokenExchanges,
+		hdb.db, &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)
@@ -880,7 +816,7 @@ func (hdb *HistoryDB) addEscapeHatchWithdrawals(d meddler.DB,
 			token_addr,
 			amount
 		) VALUES %s;`,
-		escapeHatchWithdrawals,
+		escapeHatchWithdrawals[:],
 	))
 }
 
@@ -888,7 +824,7 @@ func (hdb *HistoryDB) addEscapeHatchWithdrawals(d meddler.DB,
 func (hdb *HistoryDB) GetAllEscapeHatchWithdrawals() ([]common.WDelayerEscapeHatchWithdrawal, error) {
 	var escapeHatchWithdrawals []*common.WDelayerEscapeHatchWithdrawal
 	err := meddler.QueryAll(
-		hdb.dbRead, &escapeHatchWithdrawals,
+		hdb.db, &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),
@@ -901,7 +837,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.dbWrite.Beginx()
+	txn, err := hdb.db.Beginx()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -985,7 +921,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.dbWrite.Beginx()
+	txn, err := hdb.db.Beginx()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1057,11 +993,6 @@ 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 {
@@ -1143,7 +1074,7 @@ func (hdb *HistoryDB) AddBlockSCData(blockData *common.BlockData) (err error) {
 func (hdb *HistoryDB) GetCoordinatorAPI(bidderAddr ethCommon.Address) (*CoordinatorAPI, error) {
 	coordinator := &CoordinatorAPI{}
 	err := meddler.QueryRow(
-		hdb.dbRead, coordinator,
+		hdb.db, coordinator,
 		"SELECT * FROM coordinator WHERE bidder_addr = $1 ORDER BY item_id DESC LIMIT 1;",
 		bidderAddr,
 	)
@@ -1152,14 +1083,14 @@ func (hdb *HistoryDB) GetCoordinatorAPI(bidderAddr ethCommon.Address) (*Coordina
 
 // AddAuctionVars insert auction vars into the DB
 func (hdb *HistoryDB) AddAuctionVars(auctionVars *common.AuctionVariables) error {
-	return tracerr.Wrap(meddler.Insert(hdb.dbWrite, "auction_vars", auctionVars))
+	return tracerr.Wrap(meddler.Insert(hdb.db, "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.dbRead, &tokens,
+		hdb.db, &tokens,
 		"SELECT * FROM TOKEN",
 	); err != nil {
 		return nil, tracerr.Wrap(err)

db/historydb/historydb_test.go

@@ -39,12 +39,12 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
-	historyDB = NewHistoryDB(db, db, nil)
+	historyDB = NewHistoryDB(db, nil)
 	if err != nil {
 		panic(err)
 	}
 	apiConnCon := dbUtils.NewAPICnnectionController(1, time.Second)
-	historyDBWithACC = NewHistoryDB(db, db, apiConnCon)
+	historyDBWithACC = NewHistoryDB(db, apiConnCon)
 	// Run tests
 	result := m.Run()
 	// Close DB
@@ -203,10 +203,6 @@ func TestBatches(t *testing.T) {
 	fetchedLastBatchNum, err := historyDB.GetLastBatchNum()
 	assert.NoError(t, err)
 	assert.Equal(t, batches[len(batches)-1].BatchNum, fetchedLastBatchNum)
-	// Test GetLastBatch
-	fetchedLastBatch, err := historyDB.GetLastBatch()
-	assert.NoError(t, err)
-	assert.Equal(t, &batches[len(batches)-1], fetchedLastBatch)
 	// Test GetLastL1TxsNum
 	fetchedLastL1TxsNum, err := historyDB.GetLastL1TxsNum()
 	assert.NoError(t, err)
@@ -215,12 +211,6 @@ func TestBatches(t *testing.T) {
 	fetchedLastL1BatchBlockNum, err := historyDB.GetLastL1BatchBlockNum()
 	assert.NoError(t, err)
 	assert.Equal(t, lastL1BatchBlockNum, fetchedLastL1BatchBlockNum)
-	// Test GetBatch
-	fetchedBatch, err := historyDB.GetBatch(1)
-	require.NoError(t, err)
-	assert.Equal(t, &batches[0], fetchedBatch)
-	_, err = historyDB.GetBatch(common.BatchNum(len(batches) + 1))
-	assert.Equal(t, sql.ErrNoRows, tracerr.Unwrap(err))
 }
 
 func TestBids(t *testing.T) {
@@ -377,22 +367,6 @@ 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) {
@@ -637,10 +611,10 @@ func TestTxs(t *testing.T) {
 	assert.Equal(t, common.TxTypeExit, dbL2Txs[3].Type)
 
 	// Tx ID
-	assert.Equal(t, "0x024e555248100b69a8aabf6d31719b9fe8a60dcc6c3407904a93c8d2d9ade18ee5", dbL2Txs[0].TxID.String())
+	assert.Equal(t, "0x02d709307533c4e3c03f20751fc4d72bc18b225d14f9616525540a64342c7c350d", dbL2Txs[0].TxID.String())
-	assert.Equal(t, "0x021ae87ca34d50ff35d98dfc0d7c95f2bf2e4ffeebb82ea71f43a8b0dfa5d36d89", dbL2Txs[1].TxID.String())
+	assert.Equal(t, "0x02e88bc5503f282cca045847668511290e642410a459bb67b1fafcd1b6097c149c", dbL2Txs[1].TxID.String())
-	assert.Equal(t, "0x024abce7f3f2382dc520ed557593f11dea1ee197e55b60402e664facc27aa19774", dbL2Txs[2].TxID.String())
+	assert.Equal(t, "0x027911262b43315c0b24942a02fe228274b6e4d57a476bfcdd7a324b3091362c7d", dbL2Txs[2].TxID.String())
-	assert.Equal(t, "0x02f921ad9e7a6e59606570fe12a7dde0e36014197de0363b9b45e5097d6f2b1dd0", dbL2Txs[3].TxID.String())
+	assert.Equal(t, "0x02f572b63f2a5c302e1b9337ea6944bfbac3d199e4ddd262b5a53759c72ec10ee6", dbL2Txs[3].TxID.String())
 
 	// Tx From and To IDx
 	assert.Equal(t, dbL2Txs[0].ToIdx, dbL2Txs[2].FromIdx)
@@ -817,11 +791,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.dbWrite, &blocks[1].Block)
+	err = historyDB.addBlock(historyDB.db, &blocks[1].Block)
 	require.NoError(t, err)
-	err = historyDB.addBatch(historyDB.dbWrite, &blocks[1].Rollup.Batches[0].Batch)
+	err = historyDB.addBatch(historyDB.db, &blocks[1].Rollup.Batches[0].Batch)
 	require.NoError(t, err)
-	err = historyDB.addAccounts(historyDB.dbWrite, blocks[1].Rollup.Batches[0].CreatedAccounts)
+	err = historyDB.addAccounts(historyDB.db, 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
@@ -831,7 +805,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.dbWrite, l1Txs)
+	err = historyDB.setExtraInfoForgedL1UserTxs(historyDB.db, l1Txs)
 	require.NoError(t, err)
 
 	dbL1Txs, err := historyDB.GetAllL1UserTxs()
@@ -918,10 +892,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.dbWrite, &block.Block)
+	err = historyDB.addBlock(historyDB.db, &block.Block)
 	require.NoError(t, err)
 
-	err = historyDB.updateExitTree(historyDB.dbWrite, block.Block.Num,
+	err = historyDB.updateExitTree(historyDB.db, block.Block.Num,
 		block.Rollup.Withdrawals, block.WDelayer.Withdrawals)
 	require.NoError(t, err)
 
@@ -951,10 +925,10 @@ func TestUpdateExitTree(t *testing.T) {
 			Token:  tokenAddr,
 			Amount: big.NewInt(80),
 		})
-	err = historyDB.addBlock(historyDB.dbWrite, &block.Block)
+	err = historyDB.addBlock(historyDB.db, &block.Block)
 	require.NoError(t, err)
 
-	err = historyDB.updateExitTree(historyDB.dbWrite, block.Block.Num,
+	err = historyDB.updateExitTree(historyDB.db, block.Block.Num,
 		block.Rollup.Withdrawals, block.WDelayer.Withdrawals)
 	require.NoError(t, err)
 
@@ -997,7 +971,7 @@ func TestGetBestBidCoordinator(t *testing.T) {
 			URL:         "bar",
 		},
 	}
-	err = historyDB.addCoordinators(historyDB.dbWrite, coords)
+	err = historyDB.addCoordinators(historyDB.db, coords)
 	require.NoError(t, err)
 
 	bids := []common.Bid{
@@ -1015,7 +989,7 @@ func TestGetBestBidCoordinator(t *testing.T) {
 		},
 	}
 
-	err = historyDB.addBids(historyDB.dbWrite, bids)
+	err = historyDB.addBids(historyDB.db, bids)
 	require.NoError(t, err)
 
 	forger10, err := historyDB.GetBestBidCoordinator(10)
@@ -1053,7 +1027,7 @@ func TestAddBucketUpdates(t *testing.T) {
 			Withdrawals: big.NewInt(42),
 		},
 	}
-	err := historyDB.addBucketUpdates(historyDB.dbWrite, bucketUpdates)
+	err := historyDB.addBucketUpdates(historyDB.db, bucketUpdates)
 	require.NoError(t, err)
 	dbBucketUpdates, err := historyDB.GetAllBucketUpdates()
 	require.NoError(t, err)
@@ -1078,7 +1052,7 @@ func TestAddTokenExchanges(t *testing.T) {
 			ValueUSD:    67890,
 		},
 	}
-	err := historyDB.addTokenExchanges(historyDB.dbWrite, tokenExchanges)
+	err := historyDB.addTokenExchanges(historyDB.db, tokenExchanges)
 	require.NoError(t, err)
 	dbTokenExchanges, err := historyDB.GetAllTokenExchanges()
 	require.NoError(t, err)
@@ -1107,7 +1081,7 @@ func TestAddEscapeHatchWithdrawals(t *testing.T) {
 			Amount:      big.NewInt(20003),
 		},
 	}
-	err := historyDB.addEscapeHatchWithdrawals(historyDB.dbWrite, escapeHatchWithdrawals)
+	err := historyDB.addEscapeHatchWithdrawals(historyDB.db, escapeHatchWithdrawals)
 	require.NoError(t, err)
 	dbEscapeHatchWithdrawals, err := historyDB.GetAllEscapeHatchWithdrawals()
 	require.NoError(t, err)
@@ -1175,12 +1149,16 @@ func TestGetMetricsAPI(t *testing.T) {
 	res, err := historyDBWithACC.GetMetricsAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
-	assert.Equal(t, float64(numTx)/float64(numBatches), res.TransactionsPerBatch)
+	assert.Equal(t, float64(numTx)/float64(numBatches-1), res.TransactionsPerBatch)
 
 	// Frequency is not exactly the desired one, some decimals may appear
-	// There is a -2 as time for first and last batch is not taken into account
+	assert.GreaterOrEqual(t, res.BatchFrequency, float64(frequency))
-	assert.InEpsilon(t, float64(frequency)*float64(numBatches-2)/float64(numBatches), res.BatchFrequency, 0.01)
+	assert.Less(t, res.BatchFrequency, float64(frequency+1))
-	assert.InEpsilon(t, float64(numTx)/float64(frequency*blockNum-frequency), res.TransactionsPerSecond, 0.01)
+	// Truncate frecuency into an int to do an exact check
+	assert.Equal(t, frequency, int(res.BatchFrequency))
+	// This may also be different in some decimals
+	// Truncate it to the third decimal to compare
+	assert.Equal(t, math.Trunc((float64(numTx)/float64(frequency*blockNum-frequency))/0.001)*0.001, math.Trunc(res.TransactionsPerSecond/0.001)*0.001)
 	assert.Equal(t, int64(3), res.TotalAccounts)
 	assert.Equal(t, int64(3), res.TotalBJJs)
 	// Til does not set fees
@@ -1207,8 +1185,7 @@ func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {
 	set = append(set, til.Instruction{Typ: til.TypeNewBlock})
 
 	// Transfers
-	const numBlocks int = 30
+	for x := 0; x < 6000; x++ {
-	for x := 0; x < numBlocks; x++ {
 		set = append(set, til.Instruction{
 			Typ:           common.TxTypeTransfer,
 			TokenID:       common.TokenID(0),
@@ -1232,20 +1209,19 @@ func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {
 	err = tc.FillBlocksExtra(blocks, &tilCfgExtra)
 	require.NoError(t, err)
 
-	const numBatches int = 2 + numBlocks
+	const numBatches int = 6002
-	const blockNum = 4 + numBlocks
+	const numTx int = 6003
+	const blockNum = 6005 - 1
 
 	// Sanity check
 	require.Equal(t, blockNum, len(blocks))
 
 	// Adding one batch per block
 	// batch frequency can be chosen
-	const blockTime time.Duration = 3600 * time.Second
+	const frequency int = 15
-	now := time.Now()
-	require.NoError(t, err)
 
 	for i := range blocks {
-		blocks[i].Block.Timestamp = now.Add(-time.Duration(len(blocks)-1-i) * blockTime)
+		blocks[i].Block.Timestamp = time.Now().Add(-time.Second * time.Duration(frequency*(len(blocks)-i)))
 		err = historyDB.AddBlockSCData(&blocks[i])
 		assert.NoError(t, err)
 	}
@@ -1253,10 +1229,16 @@ func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {
 	res, err := historyDBWithACC.GetMetricsAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
-	assert.InEpsilon(t, 1.0, res.TransactionsPerBatch, 0.1)
+	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, res.BatchFrequency, float64(blockTime/time.Second), 0.1)
+	// Frequency is not exactly the desired one, some decimals may appear
-	assert.InEpsilon(t, 1.0/float64(blockTime/time.Second), res.TransactionsPerSecond, 0.1)
+	assert.GreaterOrEqual(t, res.BatchFrequency, float64(frequency))
+	assert.Less(t, res.BatchFrequency, float64(frequency+1))
+	// Truncate frecuency into an int to do an exact check
+	assert.Equal(t, frequency, int(res.BatchFrequency))
+	// This may also be different in some decimals
+	// Truncate it to the third decimal to compare
+	assert.Equal(t, math.Trunc((float64(numTx)/float64(frequency*blockNum-frequency))/0.001)*0.001, math.Trunc(res.TransactionsPerSecond/0.001)*0.001)
 	assert.Equal(t, int64(3), res.TotalAccounts)
 	assert.Equal(t, int64(3), res.TotalBJJs)
 	// Til does not set fees

db/historydb/views.go

@@ -239,8 +239,8 @@ type AccountAPI struct {
 	BatchNum         common.BatchNum     `meddler:"batch_num"`
 	PublicKey        apitypes.HezBJJ     `meddler:"bjj"`
 	EthAddr          apitypes.HezEthAddr `meddler:"eth_addr"`
-	Nonce            common.Nonce        `meddler:"nonce"`   // max of 40 bits used
+	Nonce            common.Nonce        `meddler:"-"` // max of 40 bits used
-	Balance          *apitypes.BigIntStr `meddler:"balance"` // max of 192 bits used
+	Balance          *apitypes.BigIntStr `meddler:"-"` // max of 192 bits used
 	TotalItems       uint64              `meddler:"total_items"`
 	FirstItem        uint64              `meddler:"first_item"`
 	LastItem         uint64              `meddler:"last_item"`

db/kvdb/kvdb.go

@@ -27,8 +27,6 @@ const (
 	// PathLast defines the subpath of the last Batch in the subpath
 	// of the StateDB
 	PathLast = "last"
-	// DefaultKeep is the default value for the Keep parameter
-	DefaultKeep = 128
 )
 
 var (
@@ -36,18 +34,16 @@ var (
 	KeyCurrentBatch = []byte("k:currentbatch")
 	// keyCurrentIdx is used as key in the db to store the CurrentIdx
 	keyCurrentIdx = []byte("k:idx")
-	// ErrNoLast is returned when the KVDB has been configured to not have
-	// a Last checkpoint but a Last method is used
-	ErrNoLast = fmt.Errorf("no last checkpoint")
 )
 
 // KVDB represents the Key-Value DB object
 type KVDB struct {
-	cfg Config
+	path string
-	db  *pebble.Storage
+	db   *pebble.Storage
 	// CurrentIdx holds the current Idx that the BatchBuilder is using
 	CurrentIdx   common.Idx
 	CurrentBatch common.BatchNum
+	keep         int
 	m            sync.Mutex
 	last         *Last
 }
@@ -65,13 +61,13 @@ func (k *Last) setNew() error {
 	defer k.rw.Unlock()
 	if k.db != nil {
 		k.db.Close()
-		k.db = nil
 	}
 	lastPath := path.Join(k.path, PathLast)
-	if err := os.RemoveAll(lastPath); err != nil {
+	err := os.RemoveAll(lastPath)
+	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	db, err := pebble.NewPebbleStorage(lastPath, false)
+	db, err := pebble.NewPebbleStorage(path.Join(k.path, lastPath), false)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -84,7 +80,6 @@ func (k *Last) set(kvdb *KVDB, batchNum common.BatchNum) error {
 	defer k.rw.Unlock()
 	if k.db != nil {
 		k.db.Close()
-		k.db = nil
 	}
 	lastPath := path.Join(k.path, PathLast)
 	if err := kvdb.MakeCheckpointFromTo(batchNum, lastPath); err != nil {
@@ -101,48 +96,26 @@ func (k *Last) set(kvdb *KVDB, batchNum common.BatchNum) error {
 func (k *Last) close() {
 	k.rw.Lock()
 	defer k.rw.Unlock()
-	if k.db != nil {
+	k.db.Close()
-		k.db.Close()
-		k.db = nil
-	}
-}
-
-// Config of the KVDB
-type Config struct {
-	// Path where the checkpoints will be stored
-	Path string
-	// Keep is the number of old checkpoints to keep.  If 0, all
-	// checkpoints are kept.
-	Keep int
-	// At every checkpoint, check that there are no gaps between the
-	// checkpoints
-	NoGapsCheck bool
-	// NoLast skips having an opened DB with a checkpoint to the last
-	// batchNum for thread-safe reads.
-	NoLast bool
 }
 
 // NewKVDB creates a new KVDB, allowing to use an in-memory or in-disk storage.
 // Checkpoints older than the value defined by `keep` will be deleted.
-// func NewKVDB(pathDB string, keep int) (*KVDB, error) {
+func NewKVDB(pathDB string, keep int) (*KVDB, error) {
-func NewKVDB(cfg Config) (*KVDB, error) {
 	var sto *pebble.Storage
 	var err error
-	sto, err = pebble.NewPebbleStorage(path.Join(cfg.Path, PathCurrent), false)
+	sto, err = pebble.NewPebbleStorage(path.Join(pathDB, PathCurrent), false)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
 
-	var last *Last
-	if !cfg.NoLast {
-		last = &Last{
-			path: cfg.Path,
-		}
-	}
 	kvdb := &KVDB{
-		cfg:  cfg,
+		path: pathDB,
 		db:   sto,
-		last: last,
+		keep: keep,
+		last: &Last{
+			path: pathDB,
+		},
 	}
 	// load currentBatch
 	kvdb.CurrentBatch, err = kvdb.GetCurrentBatch()
@@ -160,32 +133,29 @@ func NewKVDB(cfg Config) (*KVDB, error) {
 }
 
 // LastRead is a thread-safe method to query the last KVDB
-func (k *KVDB) LastRead(fn func(db *pebble.Storage) error) error {
+func (kvdb *KVDB) LastRead(fn func(db *pebble.Storage) error) error {
-	if k.last == nil {
+	kvdb.last.rw.RLock()
-		return tracerr.Wrap(ErrNoLast)
+	defer kvdb.last.rw.RUnlock()
-	}
+	return fn(kvdb.last.db)
-	k.last.rw.RLock()
-	defer k.last.rw.RUnlock()
-	return fn(k.last.db)
 }
 
 // DB returns the *pebble.Storage from the KVDB
-func (k *KVDB) DB() *pebble.Storage {
+func (kvdb *KVDB) DB() *pebble.Storage {
-	return k.db
+	return kvdb.db
 }
 
 // StorageWithPrefix returns the db.Storage with the given prefix from the
 // current KVDB
-func (k *KVDB) StorageWithPrefix(prefix []byte) db.Storage {
+func (kvdb *KVDB) StorageWithPrefix(prefix []byte) db.Storage {
-	return k.db.WithPrefix(prefix)
+	return kvdb.db.WithPrefix(prefix)
 }
 
 // Reset resets the KVDB to the checkpoint at the given batchNum. Reset does
 // not delete the checkpoints between old current and the new current, those
 // checkpoints will remain in the storage, and eventually will be deleted when
 // MakeCheckpoint overwrites them.
-func (k *KVDB) Reset(batchNum common.BatchNum) error {
+func (kvdb *KVDB) Reset(batchNum common.BatchNum) error {
-	return k.reset(batchNum, true)
+	return kvdb.reset(batchNum, true)
 }
 
 // reset resets the KVDB to the checkpoint at the given batchNum. Reset does
@@ -193,19 +163,21 @@ func (k *KVDB) Reset(batchNum common.BatchNum) error {
 // checkpoints will remain in the storage, and eventually will be deleted when
 // MakeCheckpoint overwrites them.  `closeCurrent` will close the currently
 // opened db before doing the reset.
-func (k *KVDB) reset(batchNum common.BatchNum, closeCurrent bool) error {
+func (kvdb *KVDB) reset(batchNum common.BatchNum, closeCurrent bool) error {
-	currentPath := path.Join(k.cfg.Path, PathCurrent)
+	currentPath := path.Join(kvdb.path, PathCurrent)
 
-	if closeCurrent && k.db != nil {
+	if closeCurrent {
-		k.db.Close()
+		if err := kvdb.db.Pebble().Close(); err != nil {
-		k.db = nil
+			return tracerr.Wrap(err)
+		}
 	}
 	// remove 'current'
-	if err := os.RemoveAll(currentPath); err != nil {
+	err := os.RemoveAll(currentPath)
+	if err != nil {
 		return tracerr.Wrap(err)
 	}
 	// remove all checkpoints > batchNum
-	list, err := k.ListCheckpoints()
+	list, err := kvdb.ListCheckpoints()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -218,7 +190,7 @@ func (k *KVDB) reset(batchNum common.BatchNum, closeCurrent bool) error {
 		}
 	}
 	for _, bn := range list[start:] {
-		if err := k.DeleteCheckpoint(common.BatchNum(bn)); err != nil {
+		if err := kvdb.DeleteCheckpoint(common.BatchNum(bn)); err != nil {
 			return tracerr.Wrap(err)
 		}
 	}
@@ -229,27 +201,23 @@ func (k *KVDB) reset(batchNum common.BatchNum, closeCurrent bool) error {
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
-		k.db = sto
+		kvdb.db = sto
-		k.CurrentIdx = common.RollupConstReservedIDx // 255
+		kvdb.CurrentIdx = common.RollupConstReservedIDx // 255
-		k.CurrentBatch = 0
+		kvdb.CurrentBatch = 0
-		if k.last != nil {
+		if err := kvdb.last.setNew(); err != nil {
-			if err := k.last.setNew(); err != nil {
+			return tracerr.Wrap(err)
-				return tracerr.Wrap(err)
-			}
 		}
 
 		return nil
 	}
 
 	// copy 'batchNum' to 'current'
-	if err := k.MakeCheckpointFromTo(batchNum, currentPath); err != nil {
+	if err := kvdb.MakeCheckpointFromTo(batchNum, currentPath); err != nil {
 		return tracerr.Wrap(err)
 	}
 	// copy 'batchNum' to 'last'
-	if k.last != nil {
+	if err := kvdb.last.set(kvdb, batchNum); err != nil {
-		if err := k.last.set(k, batchNum); err != nil {
+		return tracerr.Wrap(err)
-			return tracerr.Wrap(err)
-		}
 	}
 
 	// open the new 'current'
@@ -257,15 +225,15 @@ func (k *KVDB) reset(batchNum common.BatchNum, closeCurrent bool) error {
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	k.db = sto
+	kvdb.db = sto
 
 	// get currentBatch num
-	k.CurrentBatch, err = k.GetCurrentBatch()
+	kvdb.CurrentBatch, err = kvdb.GetCurrentBatch()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
 	// idx is obtained from the statedb reset
-	k.CurrentIdx, err = k.GetCurrentIdx()
+	kvdb.CurrentIdx, err = kvdb.GetCurrentIdx()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -275,28 +243,28 @@ func (k *KVDB) reset(batchNum common.BatchNum, closeCurrent bool) error {
 
 // ResetFromSynchronizer performs a reset in the KVDB getting the state from
 // synchronizerKVDB for the given batchNum.
-func (k *KVDB) ResetFromSynchronizer(batchNum common.BatchNum, synchronizerKVDB *KVDB) error {
+func (kvdb *KVDB) ResetFromSynchronizer(batchNum common.BatchNum, synchronizerKVDB *KVDB) error {
 	if synchronizerKVDB == nil {
 		return tracerr.Wrap(fmt.Errorf("synchronizerKVDB can not be nil"))
 	}
 
-	currentPath := path.Join(k.cfg.Path, PathCurrent)
+	currentPath := path.Join(kvdb.path, PathCurrent)
-	if k.db != nil {
+	if err := kvdb.db.Pebble().Close(); err != nil {
-		k.db.Close()
+		return tracerr.Wrap(err)
-		k.db = nil
 	}
 
 	// remove 'current'
-	if err := os.RemoveAll(currentPath); err != nil {
+	err := os.RemoveAll(currentPath)
+	if err != nil {
 		return tracerr.Wrap(err)
 	}
 	// remove all checkpoints
-	list, err := k.ListCheckpoints()
+	list, err := kvdb.ListCheckpoints()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
 	for _, bn := range list {
-		if err := k.DeleteCheckpoint(common.BatchNum(bn)); err != nil {
+		if err := kvdb.DeleteCheckpoint(common.BatchNum(bn)); err != nil {
 			return tracerr.Wrap(err)
 		}
 	}
@@ -307,14 +275,14 @@ func (k *KVDB) ResetFromSynchronizer(batchNum common.BatchNum, synchronizerKVDB
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
-		k.db = sto
+		kvdb.db = sto
-		k.CurrentIdx = common.RollupConstReservedIDx // 255
+		kvdb.CurrentIdx = common.RollupConstReservedIDx // 255
-		k.CurrentBatch = 0
+		kvdb.CurrentBatch = 0
 
 		return nil
 	}
 
-	checkpointPath := path.Join(k.cfg.Path, fmt.Sprintf("%s%d", PathBatchNum, batchNum))
+	checkpointPath := path.Join(kvdb.path, fmt.Sprintf("%s%d", PathBatchNum, batchNum))
 
 	// copy synchronizer'BatchNumX' to 'BatchNumX'
 	if err := synchronizerKVDB.MakeCheckpointFromTo(batchNum, checkpointPath); err != nil {
@@ -322,7 +290,7 @@ func (k *KVDB) ResetFromSynchronizer(batchNum common.BatchNum, synchronizerKVDB
 	}
 
 	// copy 'BatchNumX' to 'current'
-	err = k.MakeCheckpointFromTo(batchNum, currentPath)
+	err = kvdb.MakeCheckpointFromTo(batchNum, currentPath)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -332,15 +300,15 @@ func (k *KVDB) ResetFromSynchronizer(batchNum common.BatchNum, synchronizerKVDB
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	k.db = sto
+	kvdb.db = sto
 
 	// get currentBatch num
-	k.CurrentBatch, err = k.GetCurrentBatch()
+	kvdb.CurrentBatch, err = kvdb.GetCurrentBatch()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
 	// get currentIdx
-	k.CurrentIdx, err = k.GetCurrentIdx()
+	kvdb.CurrentIdx, err = kvdb.GetCurrentIdx()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -349,8 +317,8 @@ func (k *KVDB) ResetFromSynchronizer(batchNum common.BatchNum, synchronizerKVDB
 }
 
 // GetCurrentBatch returns the current BatchNum stored in the KVDB
-func (k *KVDB) GetCurrentBatch() (common.BatchNum, error) {
+func (kvdb *KVDB) GetCurrentBatch() (common.BatchNum, error) {
-	cbBytes, err := k.db.Get(KeyCurrentBatch)
+	cbBytes, err := kvdb.db.Get(KeyCurrentBatch)
 	if tracerr.Unwrap(err) == db.ErrNotFound {
 		return 0, nil
 	}
@@ -361,12 +329,12 @@ func (k *KVDB) GetCurrentBatch() (common.BatchNum, error) {
 }
 
 // setCurrentBatch stores the current BatchNum in the KVDB
-func (k *KVDB) setCurrentBatch() error {
+func (kvdb *KVDB) setCurrentBatch() error {
-	tx, err := k.db.NewTx()
+	tx, err := kvdb.db.NewTx()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	err = tx.Put(KeyCurrentBatch, k.CurrentBatch.Bytes())
+	err = tx.Put(KeyCurrentBatch, kvdb.CurrentBatch.Bytes())
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -377,9 +345,9 @@ func (k *KVDB) setCurrentBatch() error {
 }
 
 // GetCurrentIdx returns the stored Idx from the KVDB, which is the last Idx
-// used for an Account in the k.
+// used for an Account in the KVDB.
-func (k *KVDB) GetCurrentIdx() (common.Idx, error) {
+func (kvdb *KVDB) GetCurrentIdx() (common.Idx, error) {
-	idxBytes, err := k.db.Get(keyCurrentIdx)
+	idxBytes, err := kvdb.db.Get(keyCurrentIdx)
 	if tracerr.Unwrap(err) == db.ErrNotFound {
 		return common.RollupConstReservedIDx, nil // 255, nil
 	}
@@ -390,10 +358,10 @@ func (k *KVDB) GetCurrentIdx() (common.Idx, error) {
 }
 
 // SetCurrentIdx stores Idx in the KVDB
-func (k *KVDB) SetCurrentIdx(idx common.Idx) error {
+func (kvdb *KVDB) SetCurrentIdx(idx common.Idx) error {
-	k.CurrentIdx = idx
+	kvdb.CurrentIdx = idx
 
-	tx, err := k.db.NewTx()
+	tx, err := kvdb.db.NewTx()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -413,64 +381,49 @@ func (k *KVDB) SetCurrentIdx(idx common.Idx) error {
 
 // MakeCheckpoint does a checkpoint at the given batchNum in the defined path.
 // Internally this advances & stores the current BatchNum, and then stores a
-// Checkpoint of the current state of the k.
+// Checkpoint of the current state of the KVDB.
-func (k *KVDB) MakeCheckpoint() error {
+func (kvdb *KVDB) MakeCheckpoint() error {
 	// advance currentBatch
-	k.CurrentBatch++
+	kvdb.CurrentBatch++
 
-	checkpointPath := path.Join(k.cfg.Path, fmt.Sprintf("%s%d", PathBatchNum, k.CurrentBatch))
+	checkpointPath := path.Join(kvdb.path, fmt.Sprintf("%s%d", PathBatchNum, kvdb.CurrentBatch))
 
-	if err := k.setCurrentBatch(); err != nil {
+	if err := kvdb.setCurrentBatch(); err != nil {
 		return tracerr.Wrap(err)
 	}
 
 	// if checkpoint BatchNum already exist in disk, delete it
-	if _, err := os.Stat(checkpointPath); os.IsNotExist(err) {
+	if _, err := os.Stat(checkpointPath); !os.IsNotExist(err) {
-	} else if err != nil {
+		err := os.RemoveAll(checkpointPath)
-		return tracerr.Wrap(err)
+		if err != nil {
-	} else {
-		if err := os.RemoveAll(checkpointPath); err != nil {
 			return tracerr.Wrap(err)
 		}
+	} else if err != nil && !os.IsNotExist(err) {
+		return tracerr.Wrap(err)
 	}
 
 	// execute Checkpoint
-	if err := k.db.Pebble().Checkpoint(checkpointPath); err != nil {
+	if err := kvdb.db.Pebble().Checkpoint(checkpointPath); err != nil {
 		return tracerr.Wrap(err)
 	}
 	// copy 'CurrentBatch' to 'last'
-	if k.last != nil {
+	if err := kvdb.last.set(kvdb, kvdb.CurrentBatch); err != nil {
-		if err := k.last.set(k, k.CurrentBatch); err != nil {
+		return tracerr.Wrap(err)
-			return tracerr.Wrap(err)
-		}
 	}
 	// delete old checkpoints
-	if err := k.deleteOldCheckpoints(); err != nil {
+	if err := kvdb.deleteOldCheckpoints(); err != nil {
 		return tracerr.Wrap(err)
 	}
 
 	return nil
 }
 
-// CheckpointExists returns true if the checkpoint exists
-func (k *KVDB) CheckpointExists(batchNum common.BatchNum) (bool, error) {
-	source := path.Join(k.cfg.Path, fmt.Sprintf("%s%d", PathBatchNum, batchNum))
-	if _, err := os.Stat(source); os.IsNotExist(err) {
-		return false, nil
-	} else if err != nil {
-		return false, err
-	}
-	return true, nil
-}
-
 // DeleteCheckpoint removes if exist the checkpoint of the given batchNum
-func (k *KVDB) DeleteCheckpoint(batchNum common.BatchNum) error {
+func (kvdb *KVDB) DeleteCheckpoint(batchNum common.BatchNum) error {
-	checkpointPath := path.Join(k.cfg.Path, fmt.Sprintf("%s%d", PathBatchNum, batchNum))
+	checkpointPath := path.Join(kvdb.path, fmt.Sprintf("%s%d", PathBatchNum, batchNum))
 
 	if _, err := os.Stat(checkpointPath); os.IsNotExist(err) {
 		return tracerr.Wrap(fmt.Errorf("Checkpoint with batchNum %d does not exist in DB", batchNum))
-	} else if err != nil {
-		return tracerr.Wrap(err)
 	}
 
 	return os.RemoveAll(checkpointPath)
@@ -478,8 +431,8 @@ func (k *KVDB) DeleteCheckpoint(batchNum common.BatchNum) error {
 
 // ListCheckpoints returns the list of batchNums of the checkpoints, sorted.
 // If there's a gap between the list of checkpoints, an error is returned.
-func (k *KVDB) ListCheckpoints() ([]int, error) {
+func (kvdb *KVDB) ListCheckpoints() ([]int, error) {
-	files, err := ioutil.ReadDir(k.cfg.Path)
+	files, err := ioutil.ReadDir(kvdb.path)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -496,12 +449,12 @@ func (k *KVDB) ListCheckpoints() ([]int, error) {
 		}
 	}
 	sort.Ints(checkpoints)
-	if !k.cfg.NoGapsCheck && len(checkpoints) > 0 {
+	if len(checkpoints) > 0 {
 		first := checkpoints[0]
 		for _, checkpoint := range checkpoints[1:] {
 			first++
 			if checkpoint != first {
-				log.Errorw("gap between checkpoints", "checkpoints", checkpoints)
+				log.Errorw("GAP", "checkpoints", checkpoints)
 				return nil, tracerr.Wrap(fmt.Errorf("checkpoint gap at %v", checkpoint))
 			}
 		}
@@ -511,14 +464,14 @@ func (k *KVDB) ListCheckpoints() ([]int, error) {
 
 // deleteOldCheckpoints deletes old checkpoints when there are more than
 // `s.keep` checkpoints
-func (k *KVDB) deleteOldCheckpoints() error {
+func (kvdb *KVDB) deleteOldCheckpoints() error {
-	list, err := k.ListCheckpoints()
+	list, err := kvdb.ListCheckpoints()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	if k.cfg.Keep > 0 && len(list) > k.cfg.Keep {
+	if len(list) > kvdb.keep {
-		for _, checkpoint := range list[:len(list)-k.cfg.Keep] {
+		for _, checkpoint := range list[:len(list)-kvdb.keep] {
-			if err := k.DeleteCheckpoint(common.BatchNum(checkpoint)); err != nil {
+			if err := kvdb.DeleteCheckpoint(common.BatchNum(checkpoint)); err != nil {
 				return tracerr.Wrap(err)
 			}
 		}
@@ -529,40 +482,43 @@ func (k *KVDB) deleteOldCheckpoints() error {
 // MakeCheckpointFromTo makes a checkpoint from the current db at fromBatchNum
 // to the dest folder.  This method is locking, so it can be called from
 // multiple places at the same time.
-func (k *KVDB) MakeCheckpointFromTo(fromBatchNum common.BatchNum, dest string) error {
+func (kvdb *KVDB) MakeCheckpointFromTo(fromBatchNum common.BatchNum, dest string) error {
-	source := path.Join(k.cfg.Path, fmt.Sprintf("%s%d", PathBatchNum, fromBatchNum))
+	source := path.Join(kvdb.path, fmt.Sprintf("%s%d", PathBatchNum, fromBatchNum))
 	if _, err := os.Stat(source); os.IsNotExist(err) {
 		// if kvdb does not have checkpoint at batchNum, return err
 		return tracerr.Wrap(fmt.Errorf("Checkpoint \"%v\" does not exist", source))
-	} else if err != nil {
-		return tracerr.Wrap(err)
 	}
 	// By locking we allow calling MakeCheckpointFromTo from multiple
 	// places at the same time for the same stateDB.  This allows the
 	// synchronizer to do a reset to a batchNum at the same time as the
 	// pipeline is doing a txSelector.Reset and batchBuilder.Reset from
 	// synchronizer to the same batchNum
-	k.m.Lock()
+	kvdb.m.Lock()
-	defer k.m.Unlock()
+	defer kvdb.m.Unlock()
 	return pebbleMakeCheckpoint(source, 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) {
+	if _, err := os.Stat(dest); !os.IsNotExist(err) {
-	} else if err != nil {
+		err := os.RemoveAll(dest)
-		return tracerr.Wrap(err)
+		if err != nil {
-	} else {
-		if err := os.RemoveAll(dest); err != nil {
 			return tracerr.Wrap(err)
 		}
+	} else if err != nil && !os.IsNotExist(err) {
+		return tracerr.Wrap(err)
 	}
 
 	sto, err := pebble.NewPebbleStorage(source, false)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	defer sto.Close()
+	defer func() {
+		errClose := sto.Pebble().Close()
+		if errClose != nil {
+			log.Errorw("Pebble.Close", "err", errClose)
+		}
+	}()
 
 	// execute Checkpoint
 	err = sto.Pebble().Checkpoint(dest)
@@ -574,12 +530,7 @@ func pebbleMakeCheckpoint(source, dest string) error {
 }
 
 // Close the DB
-func (k *KVDB) Close() {
+func (kvdb *KVDB) Close() {
-	if k.db != nil {
+	kvdb.db.Close()
-		k.db.Close()
+	kvdb.last.close()
-		k.db = nil
-	}
-	if k.last != nil {
-		k.last.close()
-	}
 }

db/kvdb/kvdb_test.go

@@ -37,7 +37,7 @@ func TestCheckpoints(t *testing.T) {
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dir))
 
-	db, err := NewKVDB(Config{Path: dir, Keep: 128})
+	db, err := NewKVDB(dir, 128)
 	require.NoError(t, err)
 
 	// add test key-values
@@ -72,7 +72,7 @@ func TestCheckpoints(t *testing.T) {
 	err = db.Reset(3)
 	require.NoError(t, err)
 
-	printCheckpoints(t, db.cfg.Path)
+	printCheckpoints(t, db.path)
 
 	// check that currentBatch is as expected after Reset
 	cb, err = db.GetCurrentBatch()
@@ -99,7 +99,7 @@ func TestCheckpoints(t *testing.T) {
 	dirLocal, err := ioutil.TempDir("", "ldb")
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dirLocal))
-	ldb, err := NewKVDB(Config{Path: dirLocal, Keep: 128})
+	ldb, err := NewKVDB(dirLocal, 128)
 	require.NoError(t, err)
 
 	// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
@@ -120,7 +120,7 @@ func TestCheckpoints(t *testing.T) {
 	dirLocal2, err := ioutil.TempDir("", "ldb2")
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dirLocal2))
-	ldb2, err := NewKVDB(Config{Path: dirLocal2, Keep: 128})
+	ldb2, err := NewKVDB(dirLocal2, 128)
 	require.NoError(t, err)
 
 	// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
@@ -139,9 +139,9 @@ func TestCheckpoints(t *testing.T) {
 
 	debug := false
 	if debug {
-		printCheckpoints(t, db.cfg.Path)
+		printCheckpoints(t, db.path)
-		printCheckpoints(t, ldb.cfg.Path)
+		printCheckpoints(t, ldb.path)
-		printCheckpoints(t, ldb2.cfg.Path)
+		printCheckpoints(t, ldb2.path)
 	}
 }
 
@@ -150,7 +150,7 @@ func TestListCheckpoints(t *testing.T) {
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dir))
 
-	db, err := NewKVDB(Config{Path: dir, Keep: 128})
+	db, err := NewKVDB(dir, 128)
 	require.NoError(t, err)
 
 	numCheckpoints := 16
@@ -181,7 +181,7 @@ func TestDeleteOldCheckpoints(t *testing.T) {
 	defer require.NoError(t, os.RemoveAll(dir))
 
 	keep := 16
-	db, err := NewKVDB(Config{Path: dir, Keep: keep})
+	db, err := NewKVDB(dir, keep)
 	require.NoError(t, err)
 
 	numCheckpoints := 32
@@ -202,7 +202,7 @@ func TestGetCurrentIdx(t *testing.T) {
 	defer require.NoError(t, os.RemoveAll(dir))
 
 	keep := 16
-	db, err := NewKVDB(Config{Path: dir, Keep: keep})
+	db, err := NewKVDB(dir, keep)
 	require.NoError(t, err)
 
 	idx, err := db.GetCurrentIdx()
@@ -211,7 +211,7 @@ func TestGetCurrentIdx(t *testing.T) {
 
 	db.Close()
 
-	db, err = NewKVDB(Config{Path: dir, Keep: keep})
+	db, err = NewKVDB(dir, keep)
 	require.NoError(t, err)
 
 	idx, err = db.GetCurrentIdx()
@@ -227,7 +227,7 @@ func TestGetCurrentIdx(t *testing.T) {
 
 	db.Close()
 
-	db, err = NewKVDB(Config{Path: dir, Keep: keep})
+	db, err = NewKVDB(dir, keep)
 	require.NoError(t, err)
 
 	idx, err = db.GetCurrentIdx()

db/l2db/apiqueries.go

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

db/l2db/l2db.go

@@ -21,12 +21,10 @@ 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 {
-	dbRead       *sqlx.DB
+	db           *sqlx.DB
-	dbWrite      *sqlx.DB
 	safetyPeriod common.BatchNum
 	ttl          time.Duration
 	maxTxs       uint32 // limit of txs that are accepted in the pool
-	minFeeUSD    float64
 	apiConnCon   *db.APIConnectionController
 }
 
@@ -34,20 +32,17 @@ 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(
-	dbRead, dbWrite *sqlx.DB,
+	db *sqlx.DB,
 	safetyPeriod common.BatchNum,
 	maxTxs uint32,
-	minFeeUSD float64,
 	TTL time.Duration,
 	apiConnCon *db.APIConnectionController,
 ) *L2DB {
 	return &L2DB{
-		dbRead:       dbRead,
+		db:           db,
-		dbWrite:      dbWrite,
 		safetyPeriod: safetyPeriod,
 		ttl:          TTL,
 		maxTxs:       maxTxs,
-		minFeeUSD:    minFeeUSD,
 		apiConnCon:   apiConnCon,
 	}
 }
@@ -55,18 +50,12 @@ 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.dbWrite
+	return l2db.db
-}
-
-// 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.dbWrite.Exec(
+	_, err := l2db.db.Exec(
 		`INSERT INTO account_creation_auth (eth_addr, bjj, signature)
 		VALUES ($1, $2, $3);`,
 		auth.EthAddr, auth.BJJ, auth.Signature,
@@ -78,12 +67,30 @@ func (l2db *L2DB) AddAccountCreationAuth(auth *common.AccountCreationAuth) error
 func (l2db *L2DB) GetAccountCreationAuth(addr ethCommon.Address) (*common.AccountCreationAuth, error) {
 	auth := new(common.AccountCreationAuth)
 	return auth, tracerr.Wrap(meddler.QueryRow(
-		l2db.dbRead, auth,
+		l2db.db, 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 {
@@ -107,7 +114,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.dbWrite, query, txUpdates); err != nil {
+		if _, err := sqlx.NamedExec(l2db.db, query, txUpdates); err != nil {
 			return tracerr.Wrap(err)
 		}
 	}
@@ -115,8 +122,9 @@ func (l2db *L2DB) UpdateTxsInfo(txs []common.PoolL2Tx) error {
 	return nil
 }
 
-// NewPoolL2TxWriteFromPoolL2Tx creates a new PoolL2TxWrite from a PoolL2Tx
+// AddTxTest inserts a tx into the L2DB. This is useful for test purposes,
-func NewPoolL2TxWriteFromPoolL2Tx(tx *common.PoolL2Tx) *PoolL2TxWrite {
+// but in production txs will only be inserted through the API
+func (l2db *L2DB) AddTxTest(tx *common.PoolL2Tx) error {
 	// transform tx from *common.PoolL2Tx to PoolL2TxWrite
 	insertTx := &PoolL2TxWrite{
 		TxID:      tx.TxID,
@@ -158,15 +166,8 @@ func NewPoolL2TxWriteFromPoolL2Tx(tx *common.PoolL2Tx) *PoolL2TxWrite {
 	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.dbWrite, "tx_pool", insertTx))
+	return tracerr.Wrap(meddler.Insert(l2db.db, "tx_pool", insertTx))
 }
 
 // selectPoolTxCommon select part of queries to get common.PoolL2Tx
@@ -175,15 +176,14 @@ 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) /
+fee_percentage(tx_pool.fee::NUMERIC) * token.usd * tx_pool.amount_f AS fee_usd, token.usd_update  
-	(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.dbRead, tx,
+		l2db.db, tx,
 		selectPoolTxCommon+"WHERE tx_id = $1;",
 		txID,
 	))
@@ -193,7 +193,7 @@ func (l2db *L2DB) GetTx(txID common.TxID) (*common.PoolL2Tx, error) {
 func (l2db *L2DB) GetPendingTxs() ([]common.PoolL2Tx, error) {
 	var txs []*common.PoolL2Tx
 	err := meddler.QueryAll(
-		l2db.dbRead, &txs,
+		l2db.db, &txs,
 		selectPoolTxCommon+"WHERE state = $1",
 		common.PoolL2TxStatePending,
 	)
@@ -218,8 +218,8 @@ func (l2db *L2DB) StartForging(txIDs []common.TxID, batchNum common.BatchNum) er
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	query = l2db.dbWrite.Rebind(query)
+	query = l2db.db.Rebind(query)
-	_, err = l2db.dbWrite.Exec(query, args...)
+	_, err = l2db.db.Exec(query, args...)
 	return tracerr.Wrap(err)
 }
 
@@ -241,8 +241,8 @@ func (l2db *L2DB) DoneForging(txIDs []common.TxID, batchNum common.BatchNum) err
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	query = l2db.dbWrite.Rebind(query)
+	query = l2db.db.Rebind(query)
-	_, err = l2db.dbWrite.Exec(query, args...)
+	_, err = l2db.db.Exec(query, args...)
 	return tracerr.Wrap(err)
 }
 
@@ -263,8 +263,8 @@ func (l2db *L2DB) InvalidateTxs(txIDs []common.TxID, batchNum common.BatchNum) e
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	query = l2db.dbWrite.Rebind(query)
+	query = l2db.db.Rebind(query)
-	_, err = l2db.dbWrite.Exec(query, args...)
+	_, err = l2db.db.Exec(query, args...)
 	return tracerr.Wrap(err)
 }
 
@@ -272,7 +272,7 @@ func (l2db *L2DB) InvalidateTxs(txIDs []common.TxID, batchNum common.BatchNum) e
 // of unique FromIdx
 func (l2db *L2DB) GetPendingUniqueFromIdxs() ([]common.Idx, error) {
 	var idxs []common.Idx
-	rows, err := l2db.dbRead.Query(`SELECT DISTINCT from_idx FROM tx_pool
+	rows, err := l2db.db.Query(`SELECT DISTINCT from_idx FROM tx_pool
 		WHERE state = $1;`, common.PoolL2TxStatePending)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -313,7 +313,7 @@ func (l2db *L2DB) InvalidateOldNonces(updatedAccounts []common.IdxNonce, batchNu
 	// named query which works with slices, and doens't handle an extra
 	// individual argument.
 	query := fmt.Sprintf(invalidateOldNoncesQuery, batchNum)
-	if _, err := sqlx.NamedExec(l2db.dbWrite, query, updatedAccounts); err != nil {
+	if _, err := sqlx.NamedExec(l2db.db, query, updatedAccounts); err != nil {
 		return tracerr.Wrap(err)
 	}
 	return nil
@@ -322,11 +322,10 @@ 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.dbWrite.Exec(
+	_, err := l2db.db.Exec(
-		`UPDATE tx_pool SET batch_num = NULL, state = $1
+		`UPDATE tx_pool SET batch_num = NULL, state = $1 
-		WHERE (state = $2 OR state = $3 OR state = $4) AND batch_num > $5`,
+		WHERE (state = $2 OR state = $3) AND batch_num > $4`,
 		common.PoolL2TxStatePending,
-		common.PoolL2TxStateForging,
 		common.PoolL2TxStateForged,
 		common.PoolL2TxStateInvalid,
 		lastValidBatch,
@@ -338,7 +337,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.dbWrite.Exec(
+	_, err = l2db.db.Exec(
 		`DELETE FROM tx_pool WHERE (
 			batch_num < $1 AND (state = $2 OR state = $3)
 		) OR (
@@ -354,14 +353,3 @@ 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 (
-	"database/sql"
+	"math"
-	"fmt"
+	"math/big"
 	"os"
 	"testing"
 	"time"
@@ -20,14 +20,12 @@ 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) {
@@ -37,11 +35,11 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
-	l2DB = NewL2DB(db, db, 10, 1000, 0.0, 24*time.Hour, nil)
+	l2DB = NewL2DB(db, 10, 1000, 24*time.Hour, nil)
 	apiConnCon := dbUtils.NewAPICnnectionController(1, time.Second)
-	l2DBWithACC = NewL2DB(db, db, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
+	l2DBWithACC = NewL2DB(db, 10, 1000, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB())
-	historyDB = historydb.NewHistoryDB(db, db, nil)
+	historyDB = historydb.NewHistoryDB(db, nil)
 	// Run tests
 	result := m.Run()
 	// Close DB
@@ -60,10 +58,10 @@ func prepareHistoryDB(historyDB *historydb.HistoryDB) error {
 
 			AddToken(1)
 			AddToken(2)
-			CreateAccountDeposit(1) A: 20000
+			CreateAccountDeposit(1) A: 2000
-			CreateAccountDeposit(2) A: 20000
+			CreateAccountDeposit(2) A: 2000
-			CreateAccountDeposit(1) B: 10000
+			CreateAccountDeposit(1) B: 1000
-			CreateAccountDeposit(2) B: 10000
+			CreateAccountDeposit(2) B: 1000
 			> batchL1 
 			> batchL1
 			> block
@@ -84,23 +82,15 @@ 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] {
-		if err := historyDB.AddBlockSCData(&blocks[i]); err != nil {
+		err = historyDB.AddBlockSCData(&blocks[i])
+		if err != nil {
 			return tracerr.Wrap(err)
 		}
 		for _, batch := range blocks[i].Rollup.Batches {
@@ -116,38 +106,39 @@ 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
+		}
-			err := historyDB.UpdateTokenValue(readToken.Symbol, *readToken.USD)
+		// Set value to the tokens (tokens have no symbol)
-			if err != nil {
+		tokenSymbol := ""
-				return tracerr.Wrap(err)
+		err := historyDB.UpdateTokenValue(tokenSymbol, value)
-			}
+		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: 6000 (126)
+			PoolTransfer(1) A-B: 6 (4)
-			PoolTransfer(2) A-B: 3000 (126)
+			PoolTransfer(2) A-B: 3 (1)
-			PoolTransfer(1) B-A: 5000 (126)
+			PoolTransfer(1) B-A: 5 (2)
-			PoolTransfer(2) B-A: 10000 (126)
+			PoolTransfer(2) B-A: 10 (3)
-			PoolTransfer(1) A-B: 7000 (126)
+			PoolTransfer(1) A-B: 7 (2)
-			PoolTransfer(2) A-B: 2000 (126)
+			PoolTransfer(2) A-B: 2 (1)
-			PoolTransfer(1) B-A: 8000 (126)
+			PoolTransfer(1) B-A: 8 (2)
-			PoolTransfer(2) B-A: 1000 (126)
+			PoolTransfer(2) B-A: 1 (1)
-			PoolTransfer(1) A-B: 3000 (126)
+			PoolTransfer(1) A-B: 3 (1)
-			PoolTransferToEthAddr(2) B-A: 5000 (126)
+			PoolTransferToEthAddr(2) B-A: 5 (2)
-			PoolTransferToBJJ(2) B-A: 5000 (126)
+			PoolTransferToBJJ(2) B-A: 5 (2)
 
-			PoolExit(1) A: 5000 (126)
+			PoolExit(1) A: 5 (2)
-			PoolExit(2) B: 3000 (126)
+			PoolExit(2) B: 3 (1)
 		`
 	poolL2Txs, err := tc.GeneratePoolL2Txs(setPool)
 	if err != nil {
@@ -162,74 +153,25 @@ func TestAddTxTest(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		fetchedTx, err := l2DB.GetTx(poolL2Txs[i].TxID)
-		require.NoError(t, err)
+		assert.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()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
 		require.NoError(t, err)
@@ -243,7 +185,7 @@ func TestUpdateTxsInfo(t *testing.T) {
 
 	for i := range poolL2Txs {
 		fetchedTx, err := l2DB.GetTx(poolL2Txs[i].TxID)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		assert.Equal(t, "test", fetchedTx.Info)
 	}
 }
@@ -261,8 +203,9 @@ 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
-		amountUSD := common.TokensToUSD(expected.Amount, token.Decimals, *token.USD)
+		f := new(big.Float).SetInt(expected.Amount)
-		expected.AbsoluteFee = amountUSD * expected.Fee.Percentage()
+		amountF, _ := f.Float64()
+		expected.AbsoluteFee = *token.USD * amountF * expected.Fee.Percentage()
 		test.AssertUSD(t, &expected.AbsoluteFee, &actual.AbsoluteFee)
 	}
 	assert.Equal(t, expected, actual)
@@ -287,28 +230,19 @@ func TestGetPending(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	var pendingTxs []*common.PoolL2Tx
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		pendingTxs = append(pendingTxs, &poolL2Txs[i])
 	}
 	fetchedTxs, err := l2DB.GetPendingTxs()
-	require.NoError(t, err)
+	assert.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) {
@@ -319,13 +253,13 @@ func TestStartForging(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	var startForgingTxIDs []common.TxID
 	randomizer := 0
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		if poolL2Txs[i].State == common.PoolL2TxStatePending && randomizer%2 == 0 {
 			startForgingTxIDs = append(startForgingTxIDs, poolL2Txs[i].TxID)
 		}
@@ -333,11 +267,11 @@ func TestStartForging(t *testing.T) {
 	}
 	// Start forging txs
 	err = l2DB.StartForging(startForgingTxIDs, fakeBatchNum)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range startForgingTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		assert.Equal(t, common.PoolL2TxStateForging, fetchedTx.State)
 		assert.Equal(t, &fakeBatchNum, fetchedTx.BatchNum)
 	}
@@ -351,13 +285,13 @@ func TestDoneForging(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	var startForgingTxIDs []common.TxID
 	randomizer := 0
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		if poolL2Txs[i].State == common.PoolL2TxStatePending && randomizer%2 == 0 {
 			startForgingTxIDs = append(startForgingTxIDs, poolL2Txs[i].TxID)
 		}
@@ -365,7 +299,7 @@ func TestDoneForging(t *testing.T) {
 	}
 	// Start forging txs
 	err = l2DB.StartForging(startForgingTxIDs, fakeBatchNum)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	var doneForgingTxIDs []common.TxID
 	randomizer = 0
@@ -377,12 +311,12 @@ func TestDoneForging(t *testing.T) {
 	}
 	// Done forging txs
 	err = l2DB.DoneForging(doneForgingTxIDs, fakeBatchNum)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range doneForgingTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		assert.Equal(t, common.PoolL2TxStateForged, fetchedTx.State)
 		assert.Equal(t, &fakeBatchNum, fetchedTx.BatchNum)
 	}
@@ -396,13 +330,13 @@ func TestInvalidate(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	var invalidTxIDs []common.TxID
 	randomizer := 0
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		if poolL2Txs[i].State != common.PoolL2TxStateInvalid && randomizer%2 == 0 {
 			randomizer++
 			invalidTxIDs = append(invalidTxIDs, poolL2Txs[i].TxID)
@@ -410,11 +344,11 @@ func TestInvalidate(t *testing.T) {
 	}
 	// Invalidate txs
 	err = l2DB.InvalidateTxs(invalidTxIDs, fakeBatchNum)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range invalidTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		assert.Equal(t, common.PoolL2TxStateInvalid, fetchedTx.State)
 		assert.Equal(t, &fakeBatchNum, fetchedTx.BatchNum)
 	}
@@ -428,7 +362,7 @@ func TestInvalidateOldNonces(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	// Update Accounts currentNonce
 	var updateAccounts []common.IdxNonce
 	var currentNonce = common.Nonce(1)
@@ -445,13 +379,13 @@ func TestInvalidateOldNonces(t *testing.T) {
 			invalidTxIDs = append(invalidTxIDs, poolL2Txs[i].TxID)
 		}
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	}
 	// sanity check
 	require.Greater(t, len(invalidTxIDs), 0)
 
 	err = l2DB.InvalidateOldNonces(updateAccounts, fakeBatchNum)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range invalidTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
@@ -473,7 +407,7 @@ func TestReorg(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	reorgedTxIDs := []common.TxID{}
 	nonReorgedTxIDs := []common.TxID{}
@@ -484,7 +418,7 @@ func TestReorg(t *testing.T) {
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		if poolL2Txs[i].State == common.PoolL2TxStatePending && randomizer%2 == 0 {
 			startForgingTxIDs = append(startForgingTxIDs, poolL2Txs[i].TxID)
 			allTxRandomize = append(allTxRandomize, poolL2Txs[i].TxID)
@@ -496,7 +430,7 @@ func TestReorg(t *testing.T) {
 	}
 	// Start forging txs
 	err = l2DB.StartForging(startForgingTxIDs, lastValidBatch)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	var doneForgingTxIDs []common.TxID
 	randomizer = 0
@@ -521,22 +455,22 @@ func TestReorg(t *testing.T) {
 
 	// Invalidate txs BEFORE reorgBatch --> nonReorg
 	err = l2DB.InvalidateTxs(invalidTxIDs, lastValidBatch)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	// Done forging txs in reorgBatch --> Reorg
 	err = l2DB.DoneForging(doneForgingTxIDs, reorgBatch)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	err = l2DB.Reorg(lastValidBatch)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	for _, id := range reorgedTxIDs {
 		tx, err := l2DBWithACC.GetTxAPI(id)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		assert.Nil(t, tx.BatchNum)
 		assert.Equal(t, common.PoolL2TxStatePending, tx.State)
 	}
 	for _, id := range nonReorgedTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		assert.Equal(t, lastValidBatch, *fetchedTx.BatchNum)
 	}
 }
@@ -553,7 +487,7 @@ func TestReorg2(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	reorgedTxIDs := []common.TxID{}
 	nonReorgedTxIDs := []common.TxID{}
@@ -564,7 +498,7 @@ func TestReorg2(t *testing.T) {
 	// Add txs to DB
 	for i := range poolL2Txs {
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		if poolL2Txs[i].State == common.PoolL2TxStatePending && randomizer%2 == 0 {
 			startForgingTxIDs = append(startForgingTxIDs, poolL2Txs[i].TxID)
 			allTxRandomize = append(allTxRandomize, poolL2Txs[i].TxID)
@@ -576,7 +510,7 @@ func TestReorg2(t *testing.T) {
 	}
 	// Start forging txs
 	err = l2DB.StartForging(startForgingTxIDs, lastValidBatch)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	var doneForgingTxIDs []common.TxID
 	randomizer = 0
@@ -598,22 +532,22 @@ func TestReorg2(t *testing.T) {
 	}
 	// Done forging txs BEFORE reorgBatch --> nonReorg
 	err = l2DB.DoneForging(doneForgingTxIDs, lastValidBatch)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	// Invalidate txs in reorgBatch --> Reorg
 	err = l2DB.InvalidateTxs(invalidTxIDs, reorgBatch)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	err = l2DB.Reorg(lastValidBatch)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	for _, id := range reorgedTxIDs {
 		tx, err := l2DBWithACC.GetTxAPI(id)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		assert.Nil(t, tx.BatchNum)
 		assert.Equal(t, common.PoolL2TxStatePending, tx.State)
 	}
 	for _, id := range nonReorgedTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		assert.Equal(t, lastValidBatch, *fetchedTx.BatchNum)
 	}
 }
@@ -629,7 +563,7 @@ func TestPurge(t *testing.T) {
 	var poolL2Tx []common.PoolL2Tx
 	for i := 0; i < generateTx; i++ {
 		poolL2TxAux, err := generatePoolL2Txs()
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		poolL2Tx = append(poolL2Tx, poolL2TxAux...)
 	}
 
@@ -656,39 +590,39 @@ func TestPurge(t *testing.T) {
 			deletedIDs = append(deletedIDs, poolL2Tx[i].TxID)
 		}
 		err := l2DB.AddTxTest(&tx)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	}
 	// Set batchNum keeped txs
 	for i := range keepedIDs {
-		_, err = l2DB.dbWrite.Exec(
+		_, err = l2DB.db.Exec(
 			"UPDATE tx_pool SET batch_num = $1 WHERE tx_id = $2;",
 			safeBatchNum, keepedIDs[i],
 		)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	}
 	// Start forging txs and set batchNum
 	err = l2DB.StartForging(doneForgingTxIDs, toDeleteBatchNum)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	// Done forging txs and set batchNum
 	err = l2DB.DoneForging(doneForgingTxIDs, toDeleteBatchNum)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	// Invalidate txs and set batchNum
 	err = l2DB.InvalidateTxs(invalidTxIDs, toDeleteBatchNum)
-	require.NoError(t, err)
+	assert.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.dbWrite.Exec(
+		_, err = l2DB.db.Exec(
 			"UPDATE tx_pool SET timestamp = $1, state = $2 WHERE tx_id = $3;",
 			deleteTimestamp, common.PoolL2TxStatePending, id,
 		)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	}
 
 	// Purge txs
 	err = l2DB.Purge(safeBatchNum)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	// Check results
 	for _, id := range deletedIDs {
 		_, err := l2DB.GetTx(id)
@@ -696,7 +630,7 @@ func TestPurge(t *testing.T) {
 	}
 	for _, id := range keepedIDs {
 		_, err := l2DB.GetTx(id)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	}
 }
 
@@ -710,10 +644,10 @@ func TestAuth(t *testing.T) {
 	for i := 0; i < len(auths); i++ {
 		// Add to the DB
 		err := l2DB.AddAccountCreationAuth(auths[i])
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		// Fetch from DB
 		auth, err := l2DB.GetAccountCreationAuth(auths[i].EthAddr)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		// Check fetched vs generated
 		assert.Equal(t, auths[i].EthAddr, auth.EthAddr)
 		assert.Equal(t, auths[i].BJJ, auth.BJJ)
@@ -731,7 +665,7 @@ func TestAddGet(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	poolL2Txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	// We will work with only 3 txs
 	require.GreaterOrEqual(t, len(poolL2Txs), 3)
@@ -767,56 +701,3 @@ func TestAddGet(t *testing.T) {
 		assert.Equal(t, txs[i], *dbTx)
 	}
 }
-
-func TestPurgeByExternalDelete(t *testing.T) {
-	err := prepareHistoryDB(historyDB)
-	if err != nil {
-		log.Error("Error prepare historyDB", err)
-	}
-	txs, err := generatePoolL2Txs()
-	require.NoError(t, err)
-
-	// We will work with 8 txs
-	require.GreaterOrEqual(t, len(txs), 8)
-	txs = txs[:8]
-	for i := range txs {
-		require.NoError(t, l2DB.AddTxTest(&txs[i]))
-	}
-
-	// We will recreate this scenario:
-	// tx index, status , external_delete
-	// 0       , pending, false
-	// 1       , pending, false
-	// 2       , pending, true // will be deleted
-	// 3       , pending, true // will be deleted
-	// 4       , fging  , false
-	// 5       , fging  , false
-	// 6       , fging  , true
-	// 7       , fging  , true
-
-	require.NoError(t, l2DB.StartForging(
-		[]common.TxID{txs[4].TxID, txs[5].TxID, txs[6].TxID, txs[7].TxID},
-		1))
-	_, err = l2DB.dbWrite.Exec(
-		`UPDATE tx_pool SET external_delete = true WHERE
-			tx_id IN ($1, $2, $3, $4)
-		;`,
-		txs[2].TxID, txs[3].TxID, txs[6].TxID, txs[7].TxID,
-	)
-	require.NoError(t, err)
-	require.NoError(t, l2DB.PurgeByExternalDelete())
-
-	// Query txs that are have been not deleted
-	for _, i := range []int{0, 1, 4, 5, 6, 7} {
-		txID := txs[i].TxID
-		_, err := l2DB.GetTx(txID)
-		require.NoError(t, err)
-	}
-
-	// Query txs that have been deleted
-	for _, i := range []int{2, 3} {
-		txID := txs[i].TxID
-		_, err := l2DB.GetTx(txID)
-		require.Equal(t, sql.ErrNoRows, tracerr.Unwrap(err))
-	}
-}

db/l2db/views.go

@@ -34,7 +34,6 @@ 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

db/migrations/0001.sql

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

db/statedb/statedb.go

@@ -52,40 +52,19 @@ const (
 	// TypeBatchBuilder defines a StateDB used by the BatchBuilder, that
 	// generates the ExitTree and the ZKInput when processing the txs
 	TypeBatchBuilder = "batchbuilder"
-	// MaxNLevels is the maximum value of NLevels for the merkle tree,
-	// which comes from the fact that AccountIdx has 48 bits.
-	MaxNLevels = 48
 )
 
 // TypeStateDB determines the type of StateDB
 type TypeStateDB string
 
-// Config of the StateDB
-type Config struct {
-	// Path where the checkpoints will be stored
-	Path string
-	// Keep is the number of old checkpoints to keep.  If 0, all
-	// checkpoints are kept.
-	Keep int
-	// NoLast skips having an opened DB with a checkpoint to the last
-	// batchNum for thread-safe reads.
-	NoLast bool
-	// Type of StateDB (
-	Type TypeStateDB
-	// NLevels is the number of merkle tree levels in case the Type uses a
-	// merkle tree.  If the Type doesn't use a merkle tree, NLevels should
-	// be 0.
-	NLevels int
-	// At every checkpoint, check that there are no gaps between the
-	// checkpoints
-	noGapsCheck bool
-}
-
 // StateDB represents the StateDB object
 type StateDB struct {
-	cfg Config
+	path    string
-	db  *kvdb.KVDB
+	Typ     TypeStateDB
-	MT  *merkletree.MerkleTree
+	db      *kvdb.KVDB
+	nLevels int
+	MT      *merkletree.MerkleTree
+	keep    int
 }
 
 // Last offers a subset of view methods of the StateDB that can be
@@ -125,40 +104,36 @@ func (s *Last) GetAccounts() ([]common.Account, error) {
 // NewStateDB creates a new StateDB, allowing to use an in-memory or in-disk
 // storage.  Checkpoints older than the value defined by `keep` will be
 // deleted.
-// func NewStateDB(pathDB string, keep int, typ TypeStateDB, nLevels int) (*StateDB, error) {
+func NewStateDB(pathDB string, keep int, typ TypeStateDB, nLevels int) (*StateDB, error) {
-func NewStateDB(cfg Config) (*StateDB, error) {
 	var kv *kvdb.KVDB
 	var err error
 
-	kv, err = kvdb.NewKVDB(kvdb.Config{Path: cfg.Path, Keep: cfg.Keep,
+	kv, err = kvdb.NewKVDB(pathDB, keep)
-		NoGapsCheck: cfg.noGapsCheck, NoLast: cfg.NoLast})
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
 
 	var mt *merkletree.MerkleTree = nil
-	if cfg.Type == TypeSynchronizer || cfg.Type == TypeBatchBuilder {
+	if typ == TypeSynchronizer || typ == TypeBatchBuilder {
-		mt, err = merkletree.NewMerkleTree(kv.StorageWithPrefix(PrefixKeyMT), cfg.NLevels)
+		mt, err = merkletree.NewMerkleTree(kv.StorageWithPrefix(PrefixKeyMT), nLevels)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
 	}
-	if cfg.Type == TypeTxSelector && cfg.NLevels != 0 {
+	if typ == TypeTxSelector && nLevels != 0 {
 		return nil, tracerr.Wrap(fmt.Errorf("invalid StateDB parameters: StateDB type==TypeStateDB can not have nLevels!=0"))
 	}
 
 	return &StateDB{
-		cfg: cfg,
+		path:    pathDB,
-		db:  kv,
+		db:      kv,
-		MT:  mt,
+		nLevels: nLevels,
+		MT:      mt,
+		Typ:     typ,
+		keep:    keep,
 	}, nil
 }
 
-// Type returns the StateDB configured Type
-func (s *StateDB) Type() TypeStateDB {
-	return s.cfg.Type
-}
-
 // LastRead is a thread-safe method to query the last checkpoint of the StateDB
 // via the Last type methods
 func (s *StateDB) LastRead(fn func(sdbLast *Last) error) error {
@@ -204,7 +179,7 @@ func (s *StateDB) LastGetCurrentBatch() (common.BatchNum, error) {
 func (s *StateDB) LastMTGetRoot() (*big.Int, error) {
 	var root *big.Int
 	if err := s.LastRead(func(sdb *Last) error {
-		mt, err := merkletree.NewMerkleTree(sdb.DB().WithPrefix(PrefixKeyMT), s.cfg.NLevels)
+		mt, err := merkletree.NewMerkleTree(sdb.DB().WithPrefix(PrefixKeyMT), s.nLevels)
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
@@ -220,7 +195,7 @@ func (s *StateDB) LastMTGetRoot() (*big.Int, error) {
 // Internally this advances & stores the current BatchNum, and then stores a
 // Checkpoint of the current state of the StateDB.
 func (s *StateDB) MakeCheckpoint() error {
-	log.Debugw("Making StateDB checkpoint", "batch", s.CurrentBatch()+1, "type", s.cfg.Type)
+	log.Debugw("Making StateDB checkpoint", "batch", s.CurrentBatch()+1, "type", s.Typ)
 	return s.db.MakeCheckpoint()
 }
 
@@ -255,8 +230,8 @@ func (s *StateDB) SetCurrentIdx(idx common.Idx) error {
 // those checkpoints will remain in the storage, and eventually will be
 // deleted when MakeCheckpoint overwrites them.
 func (s *StateDB) Reset(batchNum common.BatchNum) error {
-	log.Debugw("Making StateDB Reset", "batch", batchNum, "type", s.cfg.Type)
+	err := s.db.Reset(batchNum)
-	if err := s.db.Reset(batchNum); err != nil {
+	if err != nil {
 		return tracerr.Wrap(err)
 	}
 	if s.MT != nil {
@@ -267,6 +242,7 @@ func (s *StateDB) Reset(batchNum common.BatchNum) error {
 		}
 		s.MT = mt
 	}
+	log.Debugw("Making StateDB Reset", "batch", batchNum)
 	return nil
 }
 
@@ -485,10 +461,9 @@ type LocalStateDB struct {
 // NewLocalStateDB returns a new LocalStateDB connected to the given
 // synchronizerDB.  Checkpoints older than the value defined by `keep` will be
 // deleted.
-func NewLocalStateDB(cfg Config, synchronizerDB *StateDB) (*LocalStateDB, error) {
+func NewLocalStateDB(path string, keep int, synchronizerDB *StateDB, typ TypeStateDB,
-	cfg.noGapsCheck = true
+	nLevels int) (*LocalStateDB, error) {
-	cfg.NoLast = true
+	s, err := NewStateDB(path, keep, typ, nLevels)
-	s, err := NewStateDB(cfg)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -498,24 +473,18 @@ func NewLocalStateDB(cfg Config, synchronizerDB *StateDB) (*LocalStateDB, error)
 	}, nil
 }
 
-// CheckpointExists returns true if the checkpoint exists
-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
 // 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 {
 	if fromSynchronizer {
-		log.Debugw("Making StateDB ResetFromSynchronizer", "batch", batchNum, "type", l.cfg.Type)
+		err := l.db.ResetFromSynchronizer(batchNum, l.synchronizerStateDB.db)
-		if err := l.db.ResetFromSynchronizer(batchNum, l.synchronizerStateDB.db); err != nil {
+		if err != nil {
 			return tracerr.Wrap(err)
 		}
 		// open the MT for the current s.db
 		if l.MT != nil {
-			mt, err := merkletree.NewMerkleTree(l.db.StorageWithPrefix(PrefixKeyMT),
+			mt, err := merkletree.NewMerkleTree(l.db.StorageWithPrefix(PrefixKeyMT), l.MT.MaxLevels())
-				l.MT.MaxLevels())
 			if err != nil {
 				return tracerr.Wrap(err)
 			}

db/statedb/statedb_test.go

@@ -45,7 +45,7 @@ func TestNewStateDBIntermediateState(t *testing.T) {
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := NewStateDB(Config{Path: dir, Keep: 128, Type: TypeTxSelector, NLevels: 0})
+	sdb, err := NewStateDB(dir, 128, TypeTxSelector, 0)
 	require.NoError(t, err)
 
 	// test values
@@ -78,7 +78,7 @@ func TestNewStateDBIntermediateState(t *testing.T) {
 
 	// call NewStateDB which should get the db at the last checkpoint state
 	// executing a Reset (discarding the last 'testkey0'&'testvalue0' data)
-	sdb, err = NewStateDB(Config{Path: dir, Keep: 128, Type: TypeTxSelector, NLevels: 0})
+	sdb, err = NewStateDB(dir, 128, TypeTxSelector, 0)
 	require.NoError(t, err)
 	v, err = sdb.db.DB().Get(k0)
 	assert.NotNil(t, err)
@@ -116,7 +116,7 @@ func TestNewStateDBIntermediateState(t *testing.T) {
 	bn, err := sdb.getCurrentBatch()
 	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(0), bn)
-	err = sdb.MakeCheckpoint()
+	err = sdb.db.MakeCheckpoint()
 	require.NoError(t, err)
 	bn, err = sdb.getCurrentBatch()
 	require.NoError(t, err)
@@ -158,7 +158,7 @@ func TestNewStateDBIntermediateState(t *testing.T) {
 
 	// call NewStateDB which should get the db at the last checkpoint state
 	// executing a Reset (discarding the last 'testkey1'&'testvalue1' data)
-	sdb, err = NewStateDB(Config{Path: dir, Keep: 128, Type: TypeTxSelector, NLevels: 0})
+	sdb, err = NewStateDB(dir, 128, TypeTxSelector, 0)
 	require.NoError(t, err)
 
 	bn, err = sdb.getCurrentBatch()
@@ -182,7 +182,7 @@ func TestStateDBWithoutMT(t *testing.T) {
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := NewStateDB(Config{Path: dir, Keep: 128, Type: TypeTxSelector, NLevels: 0})
+	sdb, err := NewStateDB(dir, 128, TypeTxSelector, 0)
 	require.NoError(t, err)
 
 	// create test accounts
@@ -236,7 +236,7 @@ func TestStateDBWithMT(t *testing.T) {
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := NewStateDB(Config{Path: dir, Keep: 128, Type: TypeSynchronizer, NLevels: 32})
+	sdb, err := NewStateDB(dir, 128, TypeSynchronizer, 32)
 	require.NoError(t, err)
 
 	// create test accounts
@@ -290,7 +290,7 @@ func TestCheckpoints(t *testing.T) {
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := NewStateDB(Config{Path: dir, Keep: 128, Type: TypeSynchronizer, NLevels: 32})
+	sdb, err := NewStateDB(dir, 128, TypeSynchronizer, 32)
 	require.NoError(t, err)
 
 	err = sdb.Reset(0)
@@ -335,7 +335,7 @@ func TestCheckpoints(t *testing.T) {
 		assert.Equal(t, common.BatchNum(i+1), cb)
 	}
 
-	// printCheckpoints(t, sdb.cfg.Path)
+	// printCheckpoints(t, sdb.path)
 
 	// reset checkpoint
 	err = sdb.Reset(3)
@@ -371,7 +371,7 @@ 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(dirLocal, 128, sdb, TypeBatchBuilder, 32)
 	require.NoError(t, err)
 
 	// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
@@ -392,26 +392,28 @@ 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(dirLocal2, 128, sdb, TypeBatchBuilder, 32)
 	require.NoError(t, err)
 
 	// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
 	err = ldb2.Reset(4, true)
 	require.NoError(t, err)
 	// check that currentBatch is 4 after the Reset
-	cb = ldb2.CurrentBatch()
+	cb, err = ldb2.db.GetCurrentBatch()
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(4), cb)
 	// advance one checkpoint in ldb2
-	err = ldb2.MakeCheckpoint()
+	err = ldb2.db.MakeCheckpoint()
+	require.NoError(t, err)
+	cb, err = ldb2.db.GetCurrentBatch()
 	require.NoError(t, err)
-	cb = ldb2.CurrentBatch()
 	assert.Equal(t, common.BatchNum(5), cb)
 
 	debug := false
 	if debug {
-		printCheckpoints(t, sdb.cfg.Path)
+		printCheckpoints(t, sdb.path)
-		printCheckpoints(t, ldb.cfg.Path)
+		printCheckpoints(t, ldb.path)
-		printCheckpoints(t, ldb2.cfg.Path)
+		printCheckpoints(t, ldb2.path)
 	}
 }
 
@@ -419,7 +421,7 @@ func TestStateDBGetAccounts(t *testing.T) {
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
 
-	sdb, err := NewStateDB(Config{Path: dir, Keep: 128, Type: TypeTxSelector, NLevels: 0})
+	sdb, err := NewStateDB(dir, 128, TypeTxSelector, 0)
 	require.NoError(t, err)
 
 	// create test accounts
@@ -466,7 +468,7 @@ func TestCheckAccountsTreeTestVectors(t *testing.T) {
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := NewStateDB(Config{Path: dir, Keep: 128, Type: TypeSynchronizer, NLevels: 32})
+	sdb, err := NewStateDB(dir, 128, TypeSynchronizer, 32)
 	require.NoError(t, err)
 
 	ay0 := new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(253), nil), big.NewInt(1))
@@ -540,7 +542,7 @@ func TestListCheckpoints(t *testing.T) {
 	require.NoError(t, err)
 	defer require.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := NewStateDB(Config{Path: dir, Keep: 128, Type: TypeSynchronizer, NLevels: 32})
+	sdb, err := NewStateDB(dir, 128, TypeSynchronizer, 32)
 	require.NoError(t, err)
 
 	numCheckpoints := 16
@@ -573,7 +575,7 @@ func TestDeleteOldCheckpoints(t *testing.T) {
 	defer require.NoError(t, os.RemoveAll(dir))
 
 	keep := 16
-	sdb, err := NewStateDB(Config{Path: dir, Keep: keep, Type: TypeSynchronizer, NLevels: 32})
+	sdb, err := NewStateDB(dir, keep, TypeSynchronizer, 32)
 	require.NoError(t, err)
 
 	numCheckpoints := 32
@@ -594,7 +596,7 @@ func TestCurrentIdx(t *testing.T) {
 	defer require.NoError(t, os.RemoveAll(dir))
 
 	keep := 16
-	sdb, err := NewStateDB(Config{Path: dir, Keep: keep, Type: TypeSynchronizer, NLevels: 32})
+	sdb, err := NewStateDB(dir, keep, TypeSynchronizer, 32)
 	require.NoError(t, err)
 
 	idx := sdb.CurrentIdx()
@@ -602,7 +604,7 @@ func TestCurrentIdx(t *testing.T) {
 
 	sdb.Close()
 
-	sdb, err = NewStateDB(Config{Path: dir, Keep: keep, Type: TypeSynchronizer, NLevels: 32})
+	sdb, err = NewStateDB(dir, keep, TypeSynchronizer, 32)
 	require.NoError(t, err)
 
 	idx = sdb.CurrentIdx()
@@ -616,30 +618,9 @@ func TestCurrentIdx(t *testing.T) {
 
 	sdb.Close()
 
-	sdb, err = NewStateDB(Config{Path: dir, Keep: keep, Type: TypeSynchronizer, NLevels: 32})
+	sdb, err = NewStateDB(dir, keep, TypeSynchronizer, 32)
 	require.NoError(t, err)
 
 	idx = sdb.CurrentIdx()
 	assert.Equal(t, common.Idx(255), idx)
 }
-
-func TestResetFromBadCheckpoint(t *testing.T) {
-	dir, err := ioutil.TempDir("", "tmpdb")
-	require.NoError(t, err)
-	defer require.NoError(t, os.RemoveAll(dir))
-
-	keep := 16
-	sdb, err := NewStateDB(Config{Path: dir, Keep: keep, Type: TypeSynchronizer, NLevels: 32})
-	require.NoError(t, err)
-
-	err = sdb.MakeCheckpoint()
-	require.NoError(t, err)
-	err = sdb.MakeCheckpoint()
-	require.NoError(t, err)
-	err = sdb.MakeCheckpoint()
-	require.NoError(t, err)
-
-	// reset from a checkpoint that doesn't exist
-	err = sdb.Reset(10)
-	require.Error(t, err)
-}

db/statedb/utils_test.go

@@ -18,7 +18,7 @@ func TestGetIdx(t *testing.T) {
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := NewStateDB(Config{Path: dir, Keep: 128, Type: TypeTxSelector, NLevels: 0})
+	sdb, err := NewStateDB(dir, 128, TypeTxSelector, 0)
 	assert.NoError(t, err)
 
 	var sk babyjub.PrivateKey

db/utils.go

@@ -13,9 +13,9 @@ import (
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/jmoiron/sqlx"
+	"github.com/marusama/semaphore/v2"
 	migrate "github.com/rubenv/sql-migrate"
 	"github.com/russross/meddler"
-	"golang.org/x/sync/semaphore"
 )
 
 var migrations *migrate.PackrMigrationSource
@@ -89,14 +89,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.Weighted
+	smphr   semaphore.Semaphore
 	timeout time.Duration
 }
 
 // NewAPICnnectionController initialize APIConnectionController
 func NewAPICnnectionController(maxConnections int, timeout time.Duration) *APIConnectionController {
 	return &APIConnectionController{
-		smphr:   semaphore.NewWeighted(int64(maxConnections)),
+		smphr:   semaphore.New(maxConnections),
 		timeout: timeout,
 	}
 }

eth/auction.go

@@ -254,7 +254,7 @@ type AuctionInterface interface {
 	//
 
 	AuctionConstants() (*common.AuctionConstants, error)
-	AuctionEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*AuctionEvents, error)
+	AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *ethCommon.Hash, error)
 	AuctionEventInit() (*AuctionEventInitialize, int64, error)
 }
 
@@ -797,22 +797,15 @@ func (c *AuctionClient) AuctionEventInit() (*AuctionEventInitialize, int64, erro
 }
 
 // AuctionEventsByBlock returns the events in a block that happened in the
-// Auction Smart Contract.
+// Auction Smart Contract and the blockHash where the eents happened.  If there
-// To query by blockNum, set blockNum >= 0 and blockHash == nil.
+// are no events in that block, blockHash is nil.
-// To query by blockHash set blockHash != nil, and blockNum will be ignored.
+func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *ethCommon.Hash, error) {
-// If there are no events in that block the result is nil.
-func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
-	blockHash *ethCommon.Hash) (*AuctionEvents, error) {
 	var auctionEvents AuctionEvents
+	var blockHash *ethCommon.Hash
 
-	var blockNumBigInt *big.Int
-	if blockHash == nil {
-		blockNumBigInt = big.NewInt(blockNum)
-	}
 	query := ethereum.FilterQuery{
-		BlockHash: blockHash,
+		FromBlock: big.NewInt(blockNum),
-		FromBlock: blockNumBigInt,
+		ToBlock:   big.NewInt(blockNum),
-		ToBlock:   blockNumBigInt,
 		Addresses: []ethCommon.Address{
 			c.address,
 		},
@@ -821,16 +814,15 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 
 	logs, err := c.client.client.FilterLogs(context.TODO(), query)
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(err)
 	}
-	if len(logs) == 0 {
+	if len(logs) > 0 {
-		return nil, nil
+		blockHash = &logs[0].BlockHash
 	}
-
 	for _, vLog := range logs {
-		if blockHash != nil && vLog.BlockHash != *blockHash {
+		if vLog.BlockHash != *blockHash {
 			log.Errorw("Block hash mismatch", "expected", blockHash.String(), "got", vLog.BlockHash.String())
-			return nil, tracerr.Wrap(ErrBlockHashMismatchEvent)
+			return nil, nil, tracerr.Wrap(ErrBlockHashMismatchEvent)
 		}
 		switch vLog.Topics[0] {
 		case logAuctionNewBid:
@@ -841,7 +833,7 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 			}
 			var newBid AuctionEventNewBid
 			if err := c.contractAbi.UnpackIntoInterface(&auxNewBid, "NewBid", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			newBid.BidAmount = auxNewBid.BidAmount
 			newBid.Slot = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
@@ -850,19 +842,19 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 		case logAuctionNewSlotDeadline:
 			var newSlotDeadline AuctionEventNewSlotDeadline
 			if err := c.contractAbi.UnpackIntoInterface(&newSlotDeadline, "NewSlotDeadline", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, 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 {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewClosedAuctionSlots = append(auctionEvents.NewClosedAuctionSlots, newClosedAuctionSlots)
 		case logAuctionNewOutbidding:
 			var newOutbidding AuctionEventNewOutbidding
 			if err := c.contractAbi.UnpackIntoInterface(&newOutbidding, "NewOutbidding", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewOutbidding = append(auctionEvents.NewOutbidding, newOutbidding)
 		case logAuctionNewDonationAddress:
@@ -872,26 +864,26 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 		case logAuctionNewBootCoordinator:
 			var newBootCoordinator AuctionEventNewBootCoordinator
 			if err := c.contractAbi.UnpackIntoInterface(&newBootCoordinator, "NewBootCoordinator", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			newBootCoordinator.NewBootCoordinator = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			auctionEvents.NewBootCoordinator = append(auctionEvents.NewBootCoordinator, newBootCoordinator)
 		case logAuctionNewOpenAuctionSlots:
 			var newOpenAuctionSlots AuctionEventNewOpenAuctionSlots
 			if err := c.contractAbi.UnpackIntoInterface(&newOpenAuctionSlots, "NewOpenAuctionSlots", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewOpenAuctionSlots = append(auctionEvents.NewOpenAuctionSlots, newOpenAuctionSlots)
 		case logAuctionNewAllocationRatio:
 			var newAllocationRatio AuctionEventNewAllocationRatio
 			if err := c.contractAbi.UnpackIntoInterface(&newAllocationRatio, "NewAllocationRatio", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewAllocationRatio = append(auctionEvents.NewAllocationRatio, newAllocationRatio)
 		case logAuctionSetCoordinator:
 			var setCoordinator AuctionEventSetCoordinator
 			if err := c.contractAbi.UnpackIntoInterface(&setCoordinator, "SetCoordinator", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			setCoordinator.BidderAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			setCoordinator.ForgerAddress = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
@@ -899,7 +891,7 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 		case logAuctionNewForgeAllocated:
 			var newForgeAllocated AuctionEventNewForgeAllocated
 			if err := c.contractAbi.UnpackIntoInterface(&newForgeAllocated, "NewForgeAllocated", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			newForgeAllocated.Bidder = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			newForgeAllocated.Forger = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
@@ -912,7 +904,7 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 			}
 			var newDefaultSlotSetBid AuctionEventNewDefaultSlotSetBid
 			if err := c.contractAbi.UnpackIntoInterface(&auxNewDefaultSlotSetBid, "NewDefaultSlotSetBid", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			newDefaultSlotSetBid.NewInitialMinBid = auxNewDefaultSlotSetBid.NewInitialMinBid
 			newDefaultSlotSetBid.SlotSet = auxNewDefaultSlotSetBid.SlotSet.Int64()
@@ -925,11 +917,11 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64,
 		case logAuctionHEZClaimed:
 			var HEZClaimed AuctionEventHEZClaimed
 			if err := c.contractAbi.UnpackIntoInterface(&HEZClaimed, "HEZClaimed", vLog.Data); err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			HEZClaimed.Owner = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			auctionEvents.HEZClaimed = append(auctionEvents.HEZClaimed, HEZClaimed)
 		}
 	}
-	return &auctionEvents, nil
+	return &auctionEvents, blockHash, nil
 }

eth/auction_test.go

@@ -88,7 +88,7 @@ func TestAuctionSetSlotDeadline(t *testing.T) {
 	assert.Equal(t, newSlotDeadline, slotDeadline)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, newSlotDeadline, auctionEvents.NewSlotDeadline[0].NewSlotDeadline)
 }
@@ -109,7 +109,7 @@ func TestAuctionSetOpenAuctionSlots(t *testing.T) {
 	assert.Equal(t, newOpenAuctionSlots, openAuctionSlots)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, newOpenAuctionSlots, auctionEvents.NewOpenAuctionSlots[0].NewOpenAuctionSlots)
 }
@@ -130,7 +130,7 @@ func TestAuctionSetClosedAuctionSlots(t *testing.T) {
 	assert.Equal(t, newClosedAuctionSlots, closedAuctionSlots)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, newClosedAuctionSlots, auctionEvents.NewClosedAuctionSlots[0].NewClosedAuctionSlots)
 	_, err = auctionClientTest.AuctionSetClosedAuctionSlots(closedAuctionSlots)
@@ -153,7 +153,7 @@ func TestAuctionSetOutbidding(t *testing.T) {
 	assert.Equal(t, newOutbidding, outbidding)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, newOutbidding, auctionEvents.NewOutbidding[0].NewOutbidding)
 	_, err = auctionClientTest.AuctionSetOutbidding(outbiddingConst)
@@ -176,7 +176,7 @@ func TestAuctionSetAllocationRatio(t *testing.T) {
 	assert.Equal(t, newAllocationRatio, allocationRatio)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, newAllocationRatio, auctionEvents.NewAllocationRatio[0].NewAllocationRatio)
 	_, err = auctionClientTest.AuctionSetAllocationRatio(allocationRatioConst)
@@ -205,7 +205,7 @@ func TestAuctionSetDonationAddress(t *testing.T) {
 	assert.Equal(t, &newDonationAddress, donationAddress)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, newDonationAddress, auctionEvents.NewDonationAddress[0].NewDonationAddress)
 	_, err = auctionClientTest.AuctionSetDonationAddress(donationAddressConst)
@@ -224,7 +224,7 @@ func TestAuctionSetBootCoordinator(t *testing.T) {
 	assert.Equal(t, &newBootCoordinator, bootCoordinator)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, newBootCoordinator, auctionEvents.NewBootCoordinator[0].NewBootCoordinator)
 	assert.Equal(t, newBootCoordinatorURL, auctionEvents.NewBootCoordinator[0].NewBootCoordinatorURL)
@@ -261,7 +261,7 @@ func TestAuctionChangeDefaultSlotSetBid(t *testing.T) {
 	assert.Equal(t, minBid, newInitialMinBid)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, slotSet, auctionEvents.NewDefaultSlotSetBid[0].SlotSet)
 	assert.Equal(t, newInitialMinBid, auctionEvents.NewDefaultSlotSetBid[0].NewInitialMinBid)
@@ -287,7 +287,7 @@ func TestAuctionRegisterCoordinator(t *testing.T) {
 	require.Nil(t, err)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, forgerAddress, auctionEvents.SetCoordinator[0].ForgerAddress)
 	assert.Equal(t, bidderAddress, auctionEvents.SetCoordinator[0].BidderAddress)
@@ -306,7 +306,7 @@ func TestAuctionBid(t *testing.T) {
 	require.Nil(t, err)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, bidAmount, auctionEvents.NewBid[0].BidAmount)
 	assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
@@ -346,7 +346,7 @@ func TestAuctionMultiBid(t *testing.T) {
 	require.Nil(t, err)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
 	assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
@@ -376,7 +376,7 @@ func TestAuctionClaimHEZ(t *testing.T) {
 	require.Nil(t, err)
 	currentBlockNum, err := auctionClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	auctionEvents, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum, nil)
+	auctionEvents, _, err := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, amount, auctionEvents.HEZClaimed[0].Amount)
 	assert.Equal(t, governanceAddressConst, auctionEvents.HEZClaimed[0].Owner)

eth/ethereum.go

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

eth/rollup.go

@@ -264,7 +264,7 @@ type RollupInterface interface {
 	//
 
 	RollupConstants() (*common.RollupConstants, error)
-	RollupEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*RollupEvents, error)
+	RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error)
 	RollupForgeBatchArgs(ethCommon.Hash, uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error)
 	RollupEventInit() (*RollupEventInitialize, int64, error)
 }
@@ -316,7 +316,7 @@ func NewRollupClient(client *EthereumClient, address ethCommon.Address, tokenHEZ
 	}
 	consts, err := c.RollupConstants()
 	if err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("RollupConstants at %v: %w", address, err))
+		return nil, tracerr.Wrap(err)
 	}
 	c.consts = consts
 	return c, nil
@@ -327,7 +327,7 @@ func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs, auth *bind.T
 	if auth == nil {
 		auth, err = c.client.NewAuth()
 		if err != nil {
-			return nil, tracerr.Wrap(err)
+			return nil, err
 		}
 		auth.GasLimit = 1000000
 	}
@@ -393,7 +393,7 @@ func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs, auth *bind.T
 		l1CoordinatorBytes, l1l2TxData, feeIdxCoordinator, args.VerifierIdx, args.L1Batch,
 		args.ProofA, args.ProofB, args.ProofC)
 	if err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("Hermez.ForgeBatch: %w", err))
+		return nil, tracerr.Wrap(fmt.Errorf("Failed Hermez.ForgeBatch: %w", err))
 	}
 	return tx, nil
 }
@@ -462,11 +462,11 @@ func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fro
 			}
 			fromIdxBig := big.NewInt(fromIdx)
 			toIdxBig := big.NewInt(toIdx)
-			depositAmountF, err := common.NewFloat40(depositAmount)
+			depositAmountF, err := common.NewFloat16(depositAmount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			amountF, err := common.NewFloat40(amount)
+			amountF, err := common.NewFloat16(amount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
@@ -497,11 +497,11 @@ func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp,
 			}
 			fromIdxBig := big.NewInt(fromIdx)
 			toIdxBig := big.NewInt(toIdx)
-			depositAmountF, err := common.NewFloat40(depositAmount)
+			depositAmountF, err := common.NewFloat16(depositAmount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			amountF, err := common.NewFloat40(amount)
+			amountF, err := common.NewFloat16(amount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
@@ -735,40 +735,31 @@ func (c *RollupClient) RollupEventInit() (*RollupEventInitialize, int64, error)
 	return &rollupInit, int64(vLog.BlockNumber), tracerr.Wrap(err)
 }
 
-// RollupEventsByBlock returns the events in a block that happened in the
+// RollupEventsByBlock returns the events in a block that happened in the Rollup Smart Contract
-// Rollup Smart Contract.
+func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error) {
-// To query by blockNum, set blockNum >= 0 and blockHash == nil.
-// To query by blockHash set blockHash != nil, and blockNum will be ignored.
-// If there are no events in that block the result is nil.
-func (c *RollupClient) RollupEventsByBlock(blockNum int64,
-	blockHash *ethCommon.Hash) (*RollupEvents, error) {
 	var rollupEvents RollupEvents
+	var blockHash *ethCommon.Hash
 
-	var blockNumBigInt *big.Int
-	if blockHash == nil {
-		blockNumBigInt = big.NewInt(blockNum)
-	}
 	query := ethereum.FilterQuery{
-		BlockHash: blockHash,
+		FromBlock: big.NewInt(blockNum),
-		FromBlock: blockNumBigInt,
+		ToBlock:   big.NewInt(blockNum),
-		ToBlock:   blockNumBigInt,
 		Addresses: []ethCommon.Address{
 			c.address,
 		},
-		Topics: [][]ethCommon.Hash{},
+		BlockHash: nil,
+		Topics:    [][]ethCommon.Hash{},
 	}
 	logs, err := c.client.client.FilterLogs(context.Background(), query)
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(err)
 	}
-	if len(logs) == 0 {
+	if len(logs) > 0 {
-		return nil, nil
+		blockHash = &logs[0].BlockHash
 	}
-
 	for _, vLog := range logs {
-		if blockHash != nil && vLog.BlockHash != *blockHash {
+		if vLog.BlockHash != *blockHash {
 			log.Errorw("Block hash mismatch", "expected", blockHash.String(), "got", vLog.BlockHash.String())
-			return nil, tracerr.Wrap(ErrBlockHashMismatchEvent)
+			return nil, nil, tracerr.Wrap(ErrBlockHashMismatchEvent)
 		}
 		switch vLog.Topics[0] {
 		case logHermezL1UserTxEvent:
@@ -776,11 +767,11 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			var L1UserTx RollupEventL1UserTx
 			err := c.contractAbi.UnpackIntoInterface(&L1UserTxAux, "L1UserTxEvent", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			L1Tx, err := common.L1UserTxFromBytes(L1UserTxAux.L1UserTx)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			toForgeL1TxsNum := new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
 			L1Tx.ToForgeL1TxsNum = &toForgeL1TxsNum
@@ -792,7 +783,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			var addToken RollupEventAddToken
 			err := c.contractAbi.UnpackIntoInterface(&addToken, "AddToken", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			addToken.TokenAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			rollupEvents.AddToken = append(rollupEvents.AddToken, addToken)
@@ -800,7 +791,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			var forgeBatch RollupEventForgeBatch
 			err := c.contractAbi.UnpackIntoInterface(&forgeBatch, "ForgeBatch", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			forgeBatch.BatchNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
 			forgeBatch.EthTxHash = vLog.TxHash
@@ -812,7 +803,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			}
 			err := c.contractAbi.UnpackIntoInterface(&updateForgeL1L2BatchTimeout, "UpdateForgeL1L2BatchTimeout", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			rollupEvents.UpdateForgeL1L2BatchTimeout = append(rollupEvents.UpdateForgeL1L2BatchTimeout,
 				RollupEventUpdateForgeL1L2BatchTimeout{
@@ -822,7 +813,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			var updateFeeAddToken RollupEventUpdateFeeAddToken
 			err := c.contractAbi.UnpackIntoInterface(&updateFeeAddToken, "UpdateFeeAddToken", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			rollupEvents.UpdateFeeAddToken = append(rollupEvents.UpdateFeeAddToken, updateFeeAddToken)
 		case logHermezWithdrawEvent:
@@ -840,7 +831,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			var updateBucketWithdraw RollupEventUpdateBucketWithdraw
 			err := c.contractAbi.UnpackIntoInterface(&updateBucketWithdrawAux, "UpdateBucketWithdraw", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			updateBucketWithdraw.Withdrawals = updateBucketWithdrawAux.Withdrawals
 			updateBucketWithdraw.NumBucket = int(new(big.Int).SetBytes(vLog.Topics[1][:]).Int64())
@@ -851,7 +842,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			var withdrawalDelay RollupEventUpdateWithdrawalDelay
 			err := c.contractAbi.UnpackIntoInterface(&withdrawalDelay, "UpdateWithdrawalDelay", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			rollupEvents.UpdateWithdrawalDelay = append(rollupEvents.UpdateWithdrawalDelay, withdrawalDelay)
 		case logHermezUpdateBucketsParameters:
@@ -859,7 +850,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			var bucketsParameters RollupEventUpdateBucketsParameters
 			err := c.contractAbi.UnpackIntoInterface(&bucketsParametersAux, "UpdateBucketsParameters", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			for i, bucket := range bucketsParametersAux.ArrayBuckets {
 				bucketsParameters.ArrayBuckets[i].CeilUSD = bucket[0]
@@ -872,7 +863,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 			var tokensExchange RollupEventUpdateTokenExchange
 			err := c.contractAbi.UnpackIntoInterface(&tokensExchange, "UpdateTokenExchange", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			rollupEvents.UpdateTokenExchange = append(rollupEvents.UpdateTokenExchange, tokensExchange)
 		case logHermezSafeMode:
@@ -894,7 +885,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 				bucketsParameters)
 		}
 	}
-	return &rollupEvents, nil
+	return &rollupEvents, blockHash, nil
 }
 
 // RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the
@@ -902,7 +893,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64,
 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))
+		return nil, nil, tracerr.Wrap(err)
 	}
 	txData := tx.Data()
 
@@ -939,9 +930,9 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 		FeeIdxCoordinator:     []common.Idx{},
 	}
 	nLevels := c.consts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels
-	lenL1L2TxsBytes := int((nLevels/8)*2 + common.Float40BytesLength + 1)
+	lenL1L2TxsBytes := int((nLevels/8)*2 + 2 + 1)
 	numBytesL1TxUser := int(l1UserTxsLen) * lenL1L2TxsBytes
-	numTxsL1Coord := len(aux.EncodedL1CoordinatorTx) / common.RollupConstL1CoordinatorTotalBytes
+	numTxsL1Coord := len(aux.EncodedL1CoordinatorTx) / common.L1CoordinatorTxBytesLen
 	numBytesL1TxCoord := numTxsL1Coord * lenL1L2TxsBytes
 	numBeginL2Tx := numBytesL1TxCoord + numBytesL1TxUser
 	l1UserTxsData := []byte{}
@@ -968,7 +959,7 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 		rollupForgeBatchArgs.L2TxsData = append(rollupForgeBatchArgs.L2TxsData, *l2Tx)
 	}
 	for i := 0; i < numTxsL1Coord; i++ {
-		bytesL1Coordinator := aux.EncodedL1CoordinatorTx[i*common.RollupConstL1CoordinatorTotalBytes : (i+1)*common.RollupConstL1CoordinatorTotalBytes]
+		bytesL1Coordinator := aux.EncodedL1CoordinatorTx[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
 		var signature []byte
 		v := bytesL1Coordinator[0]
 		s := bytesL1Coordinator[1:33]

eth/rollup_test.go

@@ -91,7 +91,7 @@ func TestRollupAddToken(t *testing.T) {
 	require.NoError(t, err)
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 
 	assert.Equal(t, tokenHEZAddressConst, rollupEvents.AddToken[0].TokenAddress)
@@ -131,9 +131,9 @@ func TestRollupForgeBatch(t *testing.T) {
 	args.FeeIdxCoordinator = []common.Idx{} // When encoded, 64 times the 0 idx means that no idx to collect fees is specified.
 	l1CoordinatorBytes, err := hex.DecodeString("1c660323607bb113e586183609964a333d07ebe4bef3be82ec13af453bae9590bd7711cdb6abf42f176eadfbe5506fbef5e092e5543733f91b0061d9a7747fa10694a915a6470fa230de387b51e6f4db0b09787867778687b55197ad6d6a86eac000000001")
 	require.NoError(t, err)
-	numTxsL1 := len(l1CoordinatorBytes) / common.RollupConstL1CoordinatorTotalBytes
+	numTxsL1 := len(l1CoordinatorBytes) / common.L1CoordinatorTxBytesLen
 	for i := 0; i < numTxsL1; i++ {
-		bytesL1Coordinator := l1CoordinatorBytes[i*common.RollupConstL1CoordinatorTotalBytes : (i+1)*common.RollupConstL1CoordinatorTotalBytes]
+		bytesL1Coordinator := l1CoordinatorBytes[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
 		var signature []byte
 		v := bytesL1Coordinator[0]
 		s := bytesL1Coordinator[1:33]
@@ -174,7 +174,7 @@ func TestRollupForgeBatch(t *testing.T) {
 
 	currentBlockNum, err = rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 
 	assert.Equal(t, int64(1), rollupEvents.ForgeBatch[0].BatchNum)
@@ -203,7 +203,7 @@ func TestRollupUpdateForgeL1L2BatchTimeout(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 
 	assert.Equal(t, newForgeL1L2BatchTimeout, rollupEvents.UpdateForgeL1L2BatchTimeout[0].NewForgeL1L2BatchTimeout)
@@ -216,7 +216,7 @@ func TestRollupUpdateFeeAddToken(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 
 	assert.Equal(t, newFeeAddToken, rollupEvents.UpdateFeeAddToken[0].NewFeeAddToken)
@@ -235,7 +235,7 @@ func TestRollupUpdateBucketsParameters(t *testing.T) {
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
 	blockStampBucket = currentBlockNum
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, bucketsParameters, rollupEvents.UpdateBucketsParameters[0].ArrayBuckets)
 }
@@ -246,7 +246,7 @@ func TestRollupUpdateWithdrawalDelay(t *testing.T) {
 	require.NoError(t, err)
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, newWithdrawalDelay, int64(rollupEvents.UpdateWithdrawalDelay[0].NewWithdrawalDelay))
 }
@@ -263,7 +263,7 @@ func TestRollupUpdateTokenExchange(t *testing.T) {
 	require.NoError(t, err)
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, addressArray, rollupEvents.UpdateTokenExchange[0].AddressArray)
 	assert.Equal(t, valueArray, rollupEvents.UpdateTokenExchange[0].ValueArray)
@@ -292,7 +292,7 @@ func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
@@ -324,7 +324,7 @@ func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
@@ -356,7 +356,7 @@ func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
@@ -388,7 +388,7 @@ func TestRollupL1UserTxETHDeposit(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -418,7 +418,7 @@ func TestRollupL1UserTxERC20Deposit(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -447,7 +447,7 @@ func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -478,7 +478,7 @@ func TestRollupL1UserTxETHDepositTransfer(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -508,7 +508,7 @@ func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -538,7 +538,7 @@ func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -569,7 +569,7 @@ func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -599,7 +599,7 @@ func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -629,7 +629,7 @@ func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -659,7 +659,7 @@ func TestRollupL1UserTxETHForceTransfer(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -688,7 +688,7 @@ func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -717,7 +717,7 @@ func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -747,7 +747,7 @@ func TestRollupL1UserTxETHForceExit(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -776,7 +776,7 @@ func TestRollupL1UserTxERC20ForceExit(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -807,7 +807,7 @@ func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
 	assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount)
@@ -822,7 +822,7 @@ func TestRollupForgeBatch2(t *testing.T) {
 	require.NoError(t, err)
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 
 	assert.Equal(t, int64(2), rollupEvents.ForgeBatch[0].BatchNum)
@@ -876,7 +876,7 @@ func TestRollupForgeBatch2(t *testing.T) {
 
 	currentBlockNum, err = rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err = rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err = rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 
 	assert.Equal(t, int64(3), rollupEvents.ForgeBatch[0].BatchNum)
@@ -928,7 +928,7 @@ func TestRollupWithdrawMerkleProof(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 
 	assert.Equal(t, uint64(fromIdx), rollupEvents.Withdraw[0].Idx)
@@ -951,7 +951,7 @@ func TestRollupSafeMode(t *testing.T) {
 
 	currentBlockNum, err := rollupClient.client.EthLastBlock()
 	require.NoError(t, err)
-	rollupEvents, err := rollupClient.RollupEventsByBlock(currentBlockNum, nil)
+	rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
 	require.NoError(t, err)
 	auxEvent := new(RollupEventSafeMode)
 	assert.Equal(t, auxEvent, &rollupEvents.SafeMode[0])

eth/wdelayer.go

@@ -134,7 +134,7 @@ type WDelayerInterface interface {
 	WDelayerWithdrawal(owner, token ethCommon.Address) (*types.Transaction, error)
 	WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address, amount *big.Int) (*types.Transaction, error)
 
-	WDelayerEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*WDelayerEvents, error)
+	WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents, *ethCommon.Hash, error)
 	WDelayerConstants() (*common.WDelayerConstants, error)
 	WDelayerEventInit() (*WDelayerEventInitialize, int64, error)
 }
@@ -424,47 +424,40 @@ func (c *WDelayerClient) WDelayerEventInit() (*WDelayerEventInitialize, int64, e
 }
 
 // WDelayerEventsByBlock returns the events in a block that happened in the
-// WDelayer Smart Contract.
+// WDelayer Smart Contract and the blockHash where the eents happened.  If
-// To query by blockNum, set blockNum >= 0 and blockHash == nil.
+// there are no events in that block, blockHash is nil.
-// To query by blockHash set blockHash != nil, and blockNum will be ignored.
+func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents, *ethCommon.Hash, error) {
-// If there are no events in that block the result is nil.
-func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64,
-	blockHash *ethCommon.Hash) (*WDelayerEvents, error) {
 	var wdelayerEvents WDelayerEvents
+	var blockHash *ethCommon.Hash
 
-	var blockNumBigInt *big.Int
-	if blockHash == nil {
-		blockNumBigInt = big.NewInt(blockNum)
-	}
 	query := ethereum.FilterQuery{
-		BlockHash: blockHash,
+		FromBlock: big.NewInt(blockNum),
-		FromBlock: blockNumBigInt,
+		ToBlock:   big.NewInt(blockNum),
-		ToBlock:   blockNumBigInt,
 		Addresses: []ethCommon.Address{
 			c.address,
 		},
-		Topics: [][]ethCommon.Hash{},
+		BlockHash: nil,
+		Topics:    [][]ethCommon.Hash{},
 	}
 
 	logs, err := c.client.client.FilterLogs(context.Background(), query)
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(err)
 	}
-	if len(logs) == 0 {
+	if len(logs) > 0 {
-		return nil, nil
+		blockHash = &logs[0].BlockHash
 	}
-
 	for _, vLog := range logs {
-		if blockHash != nil && vLog.BlockHash != *blockHash {
+		if vLog.BlockHash != *blockHash {
 			log.Errorw("Block hash mismatch", "expected", blockHash.String(), "got", vLog.BlockHash.String())
-			return nil, tracerr.Wrap(ErrBlockHashMismatchEvent)
+			return nil, nil, tracerr.Wrap(ErrBlockHashMismatchEvent)
 		}
 		switch vLog.Topics[0] {
 		case logWDelayerDeposit:
 			var deposit WDelayerEventDeposit
 			err := c.contractAbi.UnpackIntoInterface(&deposit, "Deposit", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			deposit.Owner = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			deposit.Token = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
@@ -475,7 +468,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64,
 			var withdraw WDelayerEventWithdraw
 			err := c.contractAbi.UnpackIntoInterface(&withdraw, "Withdraw", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			withdraw.Token = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			withdraw.Owner = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
@@ -489,7 +482,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64,
 			var withdrawalDelay WDelayerEventNewWithdrawalDelay
 			err := c.contractAbi.UnpackIntoInterface(&withdrawalDelay, "NewWithdrawalDelay", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			wdelayerEvents.NewWithdrawalDelay = append(wdelayerEvents.NewWithdrawalDelay, withdrawalDelay)
 
@@ -497,7 +490,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64,
 			var escapeHatchWithdrawal WDelayerEventEscapeHatchWithdrawal
 			err := c.contractAbi.UnpackIntoInterface(&escapeHatchWithdrawal, "EscapeHatchWithdrawal", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			escapeHatchWithdrawal.Who = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			escapeHatchWithdrawal.To = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
@@ -508,7 +501,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64,
 			var emergencyCouncil WDelayerEventNewEmergencyCouncil
 			err := c.contractAbi.UnpackIntoInterface(&emergencyCouncil, "NewEmergencyCouncil", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			wdelayerEvents.NewEmergencyCouncil = append(wdelayerEvents.NewEmergencyCouncil, emergencyCouncil)
 
@@ -516,10 +509,10 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64,
 			var governanceAddress WDelayerEventNewHermezGovernanceAddress
 			err := c.contractAbi.UnpackIntoInterface(&governanceAddress, "NewHermezGovernanceAddress", vLog.Data)
 			if err != nil {
-				return nil, tracerr.Wrap(err)
+				return nil, nil, tracerr.Wrap(err)
 			}
 			wdelayerEvents.NewHermezGovernanceAddress = append(wdelayerEvents.NewHermezGovernanceAddress, governanceAddress)
 		}
 	}
-	return &wdelayerEvents, nil
+	return &wdelayerEvents, blockHash, nil
 }

eth/wdelayer_test.go

@@ -52,7 +52,7 @@ func TestWDelayerSetHermezGovernanceAddress(t *testing.T) {
 	assert.Equal(t, &auxAddressConst, auxAddress)
 	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
+	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezGovernanceAddress[0].NewHermezGovernanceAddress)
 	_, err = wdelayerClientAux.WDelayerTransferGovernance(governanceAddressConst)
@@ -81,7 +81,7 @@ func TestWDelayerSetEmergencyCouncil(t *testing.T) {
 	assert.Equal(t, &auxAddressConst, auxAddress)
 	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
+	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.NewEmergencyCouncil[0].NewEmergencyCouncil)
 	_, err = wdelayerClientAux.WDelayerTransferEmergencyCouncil(emergencyCouncilAddressConst)
@@ -110,7 +110,7 @@ func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
 	assert.Equal(t, newWithdrawalDelay, withdrawalDelay)
 	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
+	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, uint64(newWithdrawalDelay), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay)
 }
@@ -124,7 +124,7 @@ func TestWDelayerDeposit(t *testing.T) {
 	require.Nil(t, err)
 	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
+	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
@@ -150,7 +150,7 @@ func TestWDelayerWithdrawal(t *testing.T) {
 	require.Nil(t, err)
 	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
+	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, amount, wdelayerEvents.Withdraw[0].Amount)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.Withdraw[0].Owner)
@@ -166,7 +166,7 @@ func TestWDelayerSecondDeposit(t *testing.T) {
 	require.Nil(t, err)
 	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
+	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
@@ -181,7 +181,7 @@ func TestWDelayerEnableEmergencyMode(t *testing.T) {
 	assert.Equal(t, true, emergencyMode)
 	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
+	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	auxEvent := new(WDelayerEventEmergencyModeEnabled)
 	assert.Equal(t, auxEvent, &wdelayerEvents.EmergencyModeEnabled[0])
@@ -210,7 +210,7 @@ func TestWDelayerEscapeHatchWithdrawal(t *testing.T) {
 	require.Nil(t, err)
 	currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
 	require.Nil(t, err)
-	wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
+	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
 	assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token)
 	assert.Equal(t, governanceAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].To)

go.mod

@@ -17,11 +17,11 @@ require (
 	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/stretchr/testify v1.6.1
@@ -29,6 +29,5 @@ require (
 	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
 )

go.sum

@@ -24,8 +24,6 @@ github.com/DataDog/zstd v1.3.6-0.20190409195224-796139022798/go.mod h1:1jcaCB/uf
 github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY=
 github.com/Joker/jade v1.0.1-0.20190614124447-d475f43051e7/go.mod h1:6E6s8o2AE4KhCrqr6GRJjdC/gNfTdxkIXvuGZZda2VM=
 github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
-github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc=
-github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/OneOfOne/xxhash v1.2.5/go.mod h1:eZbhyaAYD41SGSSsnmcpxVoRiQ/MPUTjUdIIOT9Um7Q=
 github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0=
@@ -68,7 +66,6 @@ github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZw
 github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
 github.com/btcsuite/btcd v0.0.0-20171128150713-2e60448ffcc6/go.mod h1:Dmm/EzmjnCiweXmzRIAiUWCInVmPgjkzgv5k4tVyXiQ=
@@ -87,8 +84,6 @@ github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QH
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
 github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s=
-github.com/cespare/cp v1.1.1 h1:nCb6ZLdB7NRaqsm91JtQTAme2SKJzXVsdPIPkyJr1MU=
-github.com/cespare/cp v1.1.1/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s=
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.0.1-0.20190104013014-3767db7a7e18/go.mod h1:HD5P3vAIAh+Y2GAxg0PrPN1P8WkepXGpjbUPDHJqqKM=
@@ -174,8 +169,6 @@ github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5Kwzbycv
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fjl/memsize v0.0.0-20180418122429-ca190fb6ffbc h1:jtW8jbpkO4YirRSyepBOH8E+2HEw6/hKkBvFPwhUN8c=
 github.com/fjl/memsize v0.0.0-20180418122429-ca190fb6ffbc/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
-github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c=
-github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/flosch/pongo2 v0.0.0-20190707114632-bbf5a6c351f4/go.mod h1:T9YF2M40nIgbVgp3rreNmTged+9HrbNTIQf1PsaIiTA=
 github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4=
 github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
@@ -422,6 +415,9 @@ github.com/markbates/oncer v1.0.0 h1:E83IaVAHygyndzPimgUYJjbshhDTALZyXxvk9FOlQRY
 github.com/markbates/oncer v1.0.0/go.mod h1:Z59JA581E9GP6w96jai+TGqafHPW+cPfRxz2aSZ0mcI=
 github.com/markbates/safe v1.0.1 h1:yjZkbvRM6IzKj9tlu/zMJLS0n/V351OZWRnF3QfaUxI=
 github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0=
+github.com/marusama/semaphore v0.0.0-20190110074507-6952cef993b2 h1:sq+a5mb8zHbmHhrIH06oqIMGsanjpbxNgxEgZVfgpvQ=
+github.com/marusama/semaphore/v2 v2.4.1 h1:Y29DhhFMvreVgoqF9EtaSJAF9t2E7Sk7i5VW81sqB8I=
+github.com/marusama/semaphore/v2 v2.4.1/go.mod h1:z9nMiNUekt/LTpTUQdpp+4sJeYqUGpwMHfW0Z8V8fnQ=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-colorable v0.1.0/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU=
@@ -445,7 +441,6 @@ github.com/mattn/go-sqlite3 v1.12.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsO
 github.com/mattn/go-sqlite3 v2.0.3+incompatible h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U=
 github.com/mattn/go-sqlite3 v2.0.3+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
-github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mediocregopher/mediocre-go-lib v0.0.0-20181029021733-cb65787f37ed/go.mod h1:dSsfyI2zABAdhcbvkXqgxOxrCsbYeHCPgrZkku60dSg=
 github.com/mediocregopher/radix/v3 v3.3.0/go.mod h1:EmfVyvspXz1uZEyPBMyGK+kjWiKQGvsUt6O3Pj+LDCQ=
@@ -546,27 +541,23 @@ github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod
 github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=
-github.com/prometheus/client_golang v1.3.0 h1:miYCvYqFXtl/J9FIy8eNpBfYthAEFg+Ys0XyUVEcDsc=
 github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.1.0 h1:ElTg5tNp4DqfV7UQjDqv2+RJlNzsDtvNAWccbItceIE=
 github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
-github.com/prometheus/common v0.7.0 h1:L+1lyG48J1zAQXA3RBX/nG/B3gjlHq0zTt2tlbJLyCY=
 github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
-github.com/prometheus/procfs v0.0.8 h1:+fpWZdT24pJBiqJdAwYBjPSk+5YmQzYNPYzQsdzLkt8=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/tsdb v0.6.2-0.20190402121629-4f204dcbc150/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/prometheus/tsdb v0.7.1 h1:YZcsG11NqnK4czYLrWd9mpEuAJIHVQLwdrleYfszMAA=
@@ -608,8 +599,6 @@ github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeV
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/sirupsen/logrus v1.5.0 h1:1N5EYkVAPEywqZRJd7cwnRtCb6xJx7NH3T3WUTF980Q=
-github.com/sirupsen/logrus v1.5.0/go.mod h1:+F7Ogzej0PZc/94MaYx/nvG9jOFMD2osvC3s+Squfpo=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
@@ -628,8 +617,6 @@ github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DM
 github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
 github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4 h1:Gb2Tyox57NRNuZ2d3rmvB3pcmbu7O1RS3m8WRx7ilrg=
 github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q=
-github.com/status-im/keycard-go v0.0.0-20190424133014-d95853db0f48 h1:ju5UTwk5Odtm4trrY+4Ca4RMj5OyXbmVeDAVad2T0Jw=
-github.com/status-im/keycard-go v0.0.0-20190424133014-d95853db0f48/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q=
 github.com/steakknife/bloomfilter v0.0.0-20180922174646-6819c0d2a570 h1:gIlAHnH1vJb5vwEjIp5kBj/eu99p/bl0Ay2goiPe5xE=
 github.com/steakknife/bloomfilter v0.0.0-20180922174646-6819c0d2a570/go.mod h1:8OR4w3TdeIHIh1g6EMY5p0gVNOovcWC+1vpc7naMuAw=
 github.com/steakknife/hamming v0.0.0-20180906055917-c99c65617cd3 h1:njlZPzLwU639dk2kqnCPPv+wNjq7Xb6EfUxe/oX0/NM=

log/log.go

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

node/node.go

@@ -2,9 +2,7 @@ package node
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"net"
 	"net/http"
 	"sync"
 	"time"
@@ -63,47 +61,27 @@ type Node struct {
 	sync *synchronizer.Synchronizer
 
 	// General
-	cfg          *config.Node
+	cfg     *config.Node
-	mode         Mode
+	mode    Mode
-	sqlConnRead  *sqlx.DB
+	sqlConn *sqlx.DB
-	sqlConnWrite *sqlx.DB
+	ctx     context.Context
-	ctx          context.Context
+	wg      sync.WaitGroup
-	wg           sync.WaitGroup
+	cancel  context.CancelFunc
-	cancel       context.CancelFunc
 }
 
 // NewNode creates a Node
 func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	meddler.Debug = cfg.Debug.MeddlerLogs
 	// Stablish DB connection
-	dbWrite, err := dbUtils.InitSQLDB(
+	db, err := dbUtils.InitSQLDB(
-		cfg.PostgreSQL.PortWrite,
+		cfg.PostgreSQL.Port,
-		cfg.PostgreSQL.HostWrite,
+		cfg.PostgreSQL.Host,
-		cfg.PostgreSQL.UserWrite,
+		cfg.PostgreSQL.User,
-		cfg.PostgreSQL.PasswordWrite,
+		cfg.PostgreSQL.Password,
-		cfg.PostgreSQL.NameWrite,
+		cfg.PostgreSQL.Name,
 	)
 	if err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("dbUtils.InitSQLDB: %w", err))
+		return nil, tracerr.Wrap(err)
-	}
-	var dbRead *sqlx.DB
-	if cfg.PostgreSQL.HostRead == "" {
-		dbRead = dbWrite
-	} else if cfg.PostgreSQL.HostRead == cfg.PostgreSQL.HostWrite {
-		return nil, tracerr.Wrap(fmt.Errorf(
-			"PostgreSQL.HostRead and PostgreSQL.HostWrite must be different",
-		))
-	} else {
-		dbRead, err = dbUtils.InitSQLDB(
-			cfg.PostgreSQL.PortRead,
-			cfg.PostgreSQL.HostRead,
-			cfg.PostgreSQL.UserRead,
-			cfg.PostgreSQL.PasswordRead,
-			cfg.PostgreSQL.NameRead,
-		)
-		if err != nil {
-			return nil, tracerr.Wrap(fmt.Errorf("dbUtils.InitSQLDB: %w", err))
-		}
 	}
 	var apiConnCon *dbUtils.APIConnectionController
 	if cfg.API.Explorer || mode == ModeCoordinator {
@@ -113,7 +91,7 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 		)
 	}
 
-	historyDB := historydb.NewHistoryDB(dbRead, dbWrite, apiConnCon)
+	historyDB := historydb.NewHistoryDB(db, apiConnCon)
 
 	ethClient, err := ethclient.Dial(cfg.Web3.URL)
 	if err != nil {
@@ -124,8 +102,8 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	var keyStore *ethKeystore.KeyStore
 	if mode == ModeCoordinator {
 		ethCfg = eth.EthereumConfig{
-			CallGasLimit: 0, // cfg.Coordinator.EthClient.CallGasLimit,
+			CallGasLimit: cfg.Coordinator.EthClient.CallGasLimit,
-			GasPriceDiv:  0, // cfg.Coordinator.EthClient.GasPriceDiv,
+			GasPriceDiv:  cfg.Coordinator.EthClient.GasPriceDiv,
 		}
 
 		scryptN := ethKeystore.StandardScryptN
@@ -193,12 +171,8 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 		return nil, tracerr.Wrap(fmt.Errorf("cfg.StateDB.Keep = %v < %v, which is unsafe",
 			cfg.StateDB.Keep, safeStateDBKeep))
 	}
-	stateDB, err := statedb.NewStateDB(statedb.Config{
+	stateDB, err := statedb.NewStateDB(cfg.StateDB.Path, cfg.StateDB.Keep,
-		Path:    cfg.StateDB.Path,
+		statedb.TypeSynchronizer, 32)
-		Keep:    cfg.StateDB.Keep,
-		Type:    statedb.TypeSynchronizer,
-		NLevels: statedb.MaxNLevels,
-	})
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -222,10 +196,9 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	var l2DB *l2db.L2DB
 	if mode == ModeCoordinator {
 		l2DB = l2db.NewL2DB(
-			dbRead, dbWrite,
+			db,
 			cfg.Coordinator.L2DB.SafetyPeriod,
 			cfg.Coordinator.L2DB.MaxTxs,
-			cfg.Coordinator.L2DB.MinFeeUSD,
 			cfg.Coordinator.L2DB.TTL.Duration,
 			apiConnCon,
 		)
@@ -267,6 +240,9 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
+		if err != nil {
+			return nil, tracerr.Wrap(err)
+		}
 		serverProofs := make([]prover.Client, len(cfg.Coordinator.ServerProofs))
 		for i, serverProofCfg := range cfg.Coordinator.ServerProofs {
 			serverProofs[i] = prover.NewProofServerClient(serverProofCfg.URL,
@@ -280,37 +256,14 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 			MaxFeeTx: common.RollupConstMaxFeeIdxCoordinator,
 			MaxL1Tx:  common.RollupConstMaxL1Tx,
 		}
-		var verifierIdx int
+		verifierIdx, err := scConsts.Rollup.FindVerifierIdx(
-		if cfg.Coordinator.Debug.RollupVerifierIndex == nil {
+			cfg.Coordinator.Circuit.MaxTx,
-			verifierIdx, err = scConsts.Rollup.FindVerifierIdx(
+			cfg.Coordinator.Circuit.NLevels,
-				cfg.Coordinator.Circuit.MaxTx,
+		)
-				cfg.Coordinator.Circuit.NLevels,
+		if err != nil {
-			)
+			return nil, tracerr.Wrap(err)
-			if err != nil {
-				return nil, tracerr.Wrap(err)
-			}
-			log.Infow("Found verifier that matches circuit config", "verifierIdx", verifierIdx)
-		} else {
-			verifierIdx = *cfg.Coordinator.Debug.RollupVerifierIndex
-			log.Infow("Using debug verifier index from config", "verifierIdx", verifierIdx)
-			if verifierIdx >= len(scConsts.Rollup.Verifiers) {
-				return nil, tracerr.Wrap(
-					fmt.Errorf("verifierIdx (%v) >= "+
-						"len(scConsts.Rollup.Verifiers) (%v)",
-						verifierIdx, len(scConsts.Rollup.Verifiers)))
-			}
-			verifier := scConsts.Rollup.Verifiers[verifierIdx]
-			if verifier.MaxTx != cfg.Coordinator.Circuit.MaxTx ||
-				verifier.NLevels != cfg.Coordinator.Circuit.NLevels {
-				return nil, tracerr.Wrap(
-					fmt.Errorf("Circuit config and verifier params don't match.  "+
-						"circuit.MaxTx = %v, circuit.NLevels = %v, "+
-						"verifier.MaxTx = %v, verifier.NLevels = %v",
-						cfg.Coordinator.Circuit.MaxTx, cfg.Coordinator.Circuit.NLevels,
-						verifier.MaxTx, verifier.NLevels,
-					))
-			}
 		}
+		log.Infow("Found verifier that matches circuit config", "verifierIdx", verifierIdx)
 
 		coord, err = coordinator.NewCoordinator(
 			coordinator.Config{
@@ -318,16 +271,9 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 				ConfirmBlocks:          cfg.Coordinator.ConfirmBlocks,
 				L1BatchTimeoutPerc:     cfg.Coordinator.L1BatchTimeoutPerc,
 				ForgeRetryInterval:     cfg.Coordinator.ForgeRetryInterval.Duration,
-				ForgeDelay:             cfg.Coordinator.ForgeDelay.Duration,
-				ForgeNoTxsDelay:        cfg.Coordinator.ForgeNoTxsDelay.Duration,
 				SyncRetryInterval:      cfg.Coordinator.SyncRetryInterval.Duration,
-				PurgeByExtDelInterval:  cfg.Coordinator.PurgeByExtDelInterval.Duration,
 				EthClientAttempts:      cfg.Coordinator.EthClient.Attempts,
 				EthClientAttemptsDelay: cfg.Coordinator.EthClient.AttemptsDelay.Duration,
-				EthNoReuseNonce:        cfg.Coordinator.EthClient.NoReuseNonce,
-				EthTxResendTimeout:     cfg.Coordinator.EthClient.TxResendTimeout.Duration,
-				MaxGasPrice:            cfg.Coordinator.EthClient.MaxGasPrice,
-				GasPriceIncPerc:        cfg.Coordinator.EthClient.GasPriceIncPerc,
 				TxManagerCheckInterval: cfg.Coordinator.EthClient.CheckLoopInterval.Duration,
 				DebugBatchPath:         cfg.Coordinator.Debug.BatchPath,
 				Purger: coordinator.PurgerCfg{
@@ -336,7 +282,6 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 					PurgeBlockDelay:      cfg.Coordinator.L2DB.PurgeBlockDelay,
 					InvalidateBlockDelay: cfg.Coordinator.L2DB.InvalidateBlockDelay,
 				},
-				ForgeBatchGasCost: cfg.Coordinator.EthClient.ForgeBatchGasCost,
 				VerifierIdx:       uint8(verifierIdx),
 				TxProcessorConfig: txProcessorCfg,
 			},
@@ -413,8 +358,7 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 		sync:         sync,
 		cfg:          cfg,
 		mode:         mode,
-		sqlConnRead:  dbRead,
+		sqlConn:      db,
-		sqlConnWrite: dbWrite,
 		ctx:          ctx,
 		cancel:       cancel,
 	}, nil
@@ -450,6 +394,7 @@ func NewNodeAPI(
 		coordinatorEndpoints, explorerEndpoints,
 		engine,
 		hdb,
+		sdb,
 		l2db,
 		config,
 	)
@@ -467,20 +412,16 @@ func NewNodeAPI(
 // cancelation.
 func (a *NodeAPI) Run(ctx context.Context) error {
 	server := &http.Server{
+		Addr:    a.addr,
 		Handler: a.engine,
 		// TODO: Figure out best parameters for production
 		ReadTimeout:    30 * time.Second, //nolint:gomnd
 		WriteTimeout:   30 * time.Second, //nolint:gomnd
 		MaxHeaderBytes: 1 << 20,          //nolint:gomnd
 	}
-	listener, err := net.Listen("tcp", a.addr)
-	if err != nil {
-		return tracerr.Wrap(err)
-	}
-	log.Infof("NodeAPI is ready at %v", a.addr)
 	go func() {
-		if err := server.Serve(listener); err != nil &&
+		log.Infof("NodeAPI is ready at %v", a.addr)
-			tracerr.Unwrap(err) != http.ErrServerClosed {
+		if err := server.ListenAndServe(); err != nil && tracerr.Unwrap(err) != http.ErrServerClosed {
 			log.Fatalf("Listen: %s\n", err)
 		}
 	}()
@@ -519,15 +460,11 @@ func (n *Node) handleNewBlock(ctx context.Context, stats *synchronizer.Stats, va
 		if stats.Synced() {
 			if err := n.nodeAPI.api.UpdateNetworkInfo(
 				stats.Eth.LastBlock, stats.Sync.LastBlock,
-				common.BatchNum(stats.Eth.LastBatchNum),
+				common.BatchNum(stats.Eth.LastBatch),
 				stats.Sync.Auction.CurrentSlot.SlotNum,
 			); err != nil {
 				log.Errorw("API.UpdateNetworkInfo", "err", err)
 			}
-		} else {
-			n.nodeAPI.api.UpdateNetworkInfoBlock(
-				stats.Eth.LastBlock, stats.Sync.LastBlock,
-			)
 		}
 	}
 }
@@ -609,13 +546,7 @@ func (n *Node) StartSynchronizer() {
 					if n.ctx.Err() != nil {
 						continue
 					}
-					if errors.Is(err, eth.ErrBlockHashMismatchEvent) {
+					log.Errorw("Synchronizer.Sync", "err", err)
-						log.Warnw("Synchronizer.Sync", "err", err)
-					} else if errors.Is(err, synchronizer.ErrUnknownBlock) {
-						log.Warnw("Synchronizer.Sync", "err", err)
-					} else {
-						log.Errorw("Synchronizer.Sync", "err", err)
-					}
 				}
 			}
 		}
@@ -676,10 +607,6 @@ func (n *Node) StartNodeAPI() {
 
 	n.wg.Add(1)
 	go func() {
-		// Do an initial update on startup
-		if err := n.nodeAPI.api.UpdateMetrics(); err != nil {
-			log.Errorw("API.UpdateMetrics", "err", err)
-		}
 		for {
 			select {
 			case <-n.ctx.Done():
@@ -696,10 +623,6 @@ func (n *Node) StartNodeAPI() {
 
 	n.wg.Add(1)
 	go func() {
-		// Do an initial update on startup
-		if err := n.nodeAPI.api.UpdateRecommendedFee(); err != nil {
-			log.Errorw("API.UpdateRecommendedFee", "err", err)
-		}
 		for {
 			select {
 			case <-n.ctx.Done():

priceupdater/priceupdater_test.go

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

synchronizer/metrics.go

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

synchronizer/synchronizer.go

@@ -18,19 +18,6 @@ import (
 	"github.com/hermeznetwork/tracerr"
 )
 
-const (
-	// errStrUnknownBlock is the string returned by geth when querying an
-	// unknown block
-	errStrUnknownBlock = "unknown block"
-)
-
-var (
-	// ErrUnknownBlock is the error returned by the Synchronizer when a
-	// block is queried by hash but the ethereum node doesn't find it due
-	// to it being discarded from a reorg.
-	ErrUnknownBlock = fmt.Errorf("unknown block")
-)
-
 // Stats of the syncrhonizer
 type Stats struct {
 	Eth struct {
@@ -38,12 +25,12 @@ type Stats struct {
 		Updated       time.Time
 		FirstBlockNum int64
 		LastBlock     common.Block
-		LastBatchNum  int64
+		LastBatch     int64
 	}
 	Sync struct {
 		Updated   time.Time
 		LastBlock common.Block
-		LastBatch common.Batch
+		LastBatch int64
 		// LastL1BatchBlock is the last ethereum block in which an
 		// l1Batch was forged
 		LastL1BatchBlock  int64
@@ -90,13 +77,13 @@ func (s *StatsHolder) UpdateCurrentNextSlot(current *common.Slot, next *common.S
 }
 
 // UpdateSync updates the synchronizer stats
-func (s *StatsHolder) UpdateSync(lastBlock *common.Block, lastBatch *common.Batch,
+func (s *StatsHolder) UpdateSync(lastBlock *common.Block, lastBatch *common.BatchNum,
 	lastL1BatchBlock *int64, lastForgeL1TxsNum *int64) {
 	now := time.Now()
 	s.rw.Lock()
 	s.Sync.LastBlock = *lastBlock
 	if lastBatch != nil {
-		s.Sync.LastBatch = *lastBatch
+		s.Sync.LastBatch = int64(*lastBatch)
 	}
 	if lastL1BatchBlock != nil {
 		s.Sync.LastL1BatchBlock = *lastL1BatchBlock
@@ -118,16 +105,16 @@ func (s *StatsHolder) UpdateEth(ethClient eth.ClientInterface) error {
 
 	lastBlock, err := ethClient.EthBlockByNumber(context.TODO(), -1)
 	if err != nil {
-		return tracerr.Wrap(fmt.Errorf("EthBlockByNumber: %w", err))
+		return tracerr.Wrap(err)
 	}
-	lastBatchNum, err := ethClient.RollupLastForgedBatch()
+	lastBatch, err := ethClient.RollupLastForgedBatch()
 	if err != nil {
-		return tracerr.Wrap(fmt.Errorf("RollupLastForgedBatch: %w", err))
+		return tracerr.Wrap(err)
 	}
 	s.rw.Lock()
 	s.Eth.Updated = now
 	s.Eth.LastBlock = *lastBlock
-	s.Eth.LastBatchNum = lastBatchNum
+	s.Eth.LastBatch = lastBatch
 	s.rw.Unlock()
 	return nil
 }
@@ -152,10 +139,6 @@ func (s *StatsHolder) CopyStats() *Stats {
 		sCopy.Sync.Auction.NextSlot.DefaultSlotBid =
 			common.CopyBigInt(s.Sync.Auction.NextSlot.DefaultSlotBid)
 	}
-	if s.Sync.LastBatch.StateRoot != nil {
-		sCopy.Sync.LastBatch.StateRoot =
-			common.CopyBigInt(s.Sync.LastBatch.StateRoot)
-	}
 	s.rw.RUnlock()
 	return &sCopy
 }
@@ -169,9 +152,9 @@ func (s *StatsHolder) blocksPerc() float64 {
 		float64(s.Eth.LastBlock.Num-(s.Eth.FirstBlockNum-1))
 }
 
-func (s *StatsHolder) batchesPerc(batchNum common.BatchNum) float64 {
+func (s *StatsHolder) batchesPerc(batchNum int64) float64 {
 	return float64(batchNum) * 100.0 /
-		float64(s.Eth.LastBatchNum)
+		float64(s.Eth.LastBatch)
 }
 
 // StartBlockNums sets the first block used to start tracking the smart
@@ -212,16 +195,15 @@ type Config struct {
 
 // Synchronizer implements the Synchronizer type
 type Synchronizer struct {
-	ethClient        eth.ClientInterface
+	ethClient     eth.ClientInterface
-	consts           SCConsts
+	consts        SCConsts
-	historyDB        *historydb.HistoryDB
+	historyDB     *historydb.HistoryDB
-	stateDB          *statedb.StateDB
+	stateDB       *statedb.StateDB
-	cfg              Config
+	cfg           Config
-	initVars         SCVariables
+	initVars      SCVariables
-	startBlockNum    int64
+	startBlockNum int64
-	vars             SCVariables
+	vars          SCVariables
-	stats            *StatsHolder
+	stats         *StatsHolder
-	resetStateFailed bool
 }
 
 // NewSynchronizer creates a new Synchronizer
@@ -346,25 +328,23 @@ func (s *Synchronizer) setSlotCoordinator(slot *common.Slot) error {
 	return nil
 }
 
-// updateCurrentSlot updates the slot with information of the current slot.
+// firstBatchBlockNum is the blockNum of first batch in that block, if any
-// The information abouth which coordinator is allowed to forge is only updated
+func (s *Synchronizer) getCurrentSlot(reset bool, firstBatchBlockNum *int64) (*common.Slot, error) {
-// when we are Synced.
+	slot := common.Slot{
-// hasBatch is true when the last synced block contained at least one batch.
+		SlotNum:          s.stats.Sync.Auction.CurrentSlot.SlotNum,
-func (s *Synchronizer) updateCurrentSlot(slot *common.Slot, reset bool, hasBatch bool) error {
+		ForgerCommitment: s.stats.Sync.Auction.CurrentSlot.ForgerCommitment,
+	}
 	// We want the next block because the current one is already mined
 	blockNum := s.stats.Sync.LastBlock.Num + 1
 	slotNum := s.consts.Auction.SlotNum(blockNum)
-	firstBatchBlockNum := s.stats.Sync.LastBlock.Num
 	if reset {
-		// Using this query only to know if there
 		dbFirstBatchBlockNum, err := s.historyDB.GetFirstBatchBlockNumBySlot(slotNum)
 		if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
-			return tracerr.Wrap(fmt.Errorf("historyDB.GetFirstBatchBySlot: %w", err))
+			return nil, tracerr.Wrap(fmt.Errorf("historyDB.GetFirstBatchBySlot: %w", err))
 		} else if tracerr.Unwrap(err) == sql.ErrNoRows {
-			hasBatch = false
+			firstBatchBlockNum = nil
 		} else {
-			hasBatch = true
+			firstBatchBlockNum = &dbFirstBatchBlockNum
-			firstBatchBlockNum = dbFirstBatchBlockNum
 		}
 		slot.ForgerCommitment = false
 	} else if slotNum > slot.SlotNum {
@@ -375,11 +355,11 @@ func (s *Synchronizer) updateCurrentSlot(slot *common.Slot, reset bool, hasBatch
 	slot.StartBlock, slot.EndBlock = s.consts.Auction.SlotBlocks(slot.SlotNum)
 	// If Synced, update the current coordinator
 	if s.stats.Synced() && blockNum >= s.consts.Auction.GenesisBlockNum {
-		if err := s.setSlotCoordinator(slot); err != nil {
+		if err := s.setSlotCoordinator(&slot); err != nil {
-			return tracerr.Wrap(err)
+			return nil, tracerr.Wrap(err)
 		}
-		if hasBatch &&
+		if firstBatchBlockNum != nil &&
-			s.consts.Auction.RelativeBlock(firstBatchBlockNum) <
+			s.consts.Auction.RelativeBlock(*firstBatchBlockNum) <
 				int64(s.vars.Auction.SlotDeadline) {
 			slot.ForgerCommitment = true
 		}
@@ -388,61 +368,57 @@ func (s *Synchronizer) updateCurrentSlot(slot *common.Slot, reset bool, hasBatch
 		// BEGIN SANITY CHECK
 		canForge, err := s.ethClient.AuctionCanForge(slot.Forger, blockNum)
 		if err != nil {
-			return tracerr.Wrap(fmt.Errorf("AuctionCanForge: %w", err))
+			return nil, tracerr.Wrap(err)
 		}
 		if !canForge {
-			return tracerr.Wrap(fmt.Errorf("Synchronized value of forger address for closed slot "+
+			return nil, tracerr.Wrap(fmt.Errorf("Synchronized value of forger address for closed slot "+
 				"differs from smart contract: %+v", slot))
 		}
 		// END SANITY CHECK
 	}
-	return nil
+	return &slot, nil
 }
 
-// updateNextSlot updates the slot with information of the next slot.
+func (s *Synchronizer) getNextSlot() (*common.Slot, error) {
-// The information abouth which coordinator is allowed to forge is only updated
-// when we are Synced.
-func (s *Synchronizer) updateNextSlot(slot *common.Slot) error {
 	// We want the next block because the current one is already mined
 	blockNum := s.stats.Sync.LastBlock.Num + 1
 	slotNum := s.consts.Auction.SlotNum(blockNum) + 1
-	slot.SlotNum = slotNum
+	slot := common.Slot{
-	slot.ForgerCommitment = false
+		SlotNum:          slotNum,
+		ForgerCommitment: false,
+	}
 	slot.StartBlock, slot.EndBlock = s.consts.Auction.SlotBlocks(slot.SlotNum)
 	// If Synced, update the current coordinator
 	if s.stats.Synced() && blockNum >= s.consts.Auction.GenesisBlockNum {
-		if err := s.setSlotCoordinator(slot); err != nil {
+		if err := s.setSlotCoordinator(&slot); err != nil {
-			return tracerr.Wrap(err)
+			return nil, tracerr.Wrap(err)
 		}
 
 		// TODO: Remove this SANITY CHECK once this code is tested enough
 		// BEGIN SANITY CHECK
 		canForge, err := s.ethClient.AuctionCanForge(slot.Forger, slot.StartBlock)
 		if err != nil {
-			return tracerr.Wrap(fmt.Errorf("AuctionCanForge: %w", err))
+			return nil, tracerr.Wrap(err)
 		}
 		if !canForge {
-			return tracerr.Wrap(fmt.Errorf("Synchronized value of forger address for closed slot "+
+			return nil, tracerr.Wrap(fmt.Errorf("Synchronized value of forger address for closed slot "+
 				"differs from smart contract: %+v", slot))
 		}
 		// END SANITY CHECK
 	}
-	return nil
+	return &slot, nil
 }
 
-// updateCurrentNextSlotIfSync updates the current and next slot.  Information
+func (s *Synchronizer) updateCurrentNextSlotIfSync(reset bool, firstBatchBlockNum *int64) error {
-// about forger address that is allowed to forge is only updated if we are
+	current, err := s.getCurrentSlot(reset, firstBatchBlockNum)
-// Synced.
+	if err != nil {
-func (s *Synchronizer) updateCurrentNextSlotIfSync(reset bool, hasBatch bool) error {
-	current := s.stats.Sync.Auction.CurrentSlot
-	next := s.stats.Sync.Auction.NextSlot
-	if err := s.updateCurrentSlot(&current, reset, hasBatch); err != nil {
 		return tracerr.Wrap(err)
 	}
-	if err := s.updateNextSlot(&next); err != nil {
+	next, err := s.getNextSlot()
+	if err != nil {
 		return tracerr.Wrap(err)
 	}
-	s.stats.UpdateCurrentNextSlot(&current, &next)
+	s.stats.UpdateCurrentNextSlot(current, next)
 	return nil
 }
 
@@ -469,10 +445,8 @@ func (s *Synchronizer) init() error {
 		lastBlock = lastSavedBlock
 	}
 	if err := s.resetState(lastBlock); err != nil {
-		s.resetStateFailed = true
 		return tracerr.Wrap(err)
 	}
-	s.resetStateFailed = false
 
 	log.Infow("Sync init block",
 		"syncLastBlock", s.stats.Sync.LastBlock,
@@ -481,44 +455,23 @@ func (s *Synchronizer) init() error {
 		"ethLastBlock", s.stats.Eth.LastBlock,
 	)
 	log.Infow("Sync init batch",
-		"syncLastBatch", s.stats.Sync.LastBatch.BatchNum,
+		"syncLastBatch", s.stats.Sync.LastBatch,
-		"syncBatchesPerc", s.stats.batchesPerc(s.stats.Sync.LastBatch.BatchNum),
+		"syncBatchesPerc", s.stats.batchesPerc(s.stats.Sync.LastBatch),
-		"ethLastBatch", s.stats.Eth.LastBatchNum,
+		"ethLastBatch", s.stats.Eth.LastBatch,
 	)
 	return nil
 }
 
-func (s *Synchronizer) resetIntermediateState() error {
-	lastBlock, err := s.historyDB.GetLastBlock()
-	if tracerr.Unwrap(err) == sql.ErrNoRows {
-		lastBlock = &common.Block{}
-	} else if err != nil {
-		return tracerr.Wrap(fmt.Errorf("historyDB.GetLastBlock: %w", err))
-	}
-	if err := s.resetState(lastBlock); err != nil {
-		s.resetStateFailed = true
-		return tracerr.Wrap(fmt.Errorf("resetState at block %v: %w", lastBlock.Num, err))
-	}
-	s.resetStateFailed = false
-	return nil
-}
-
 // Sync2 attems to synchronize an ethereum block starting from lastSavedBlock.
 // If lastSavedBlock is nil, the lastSavedBlock value is obtained from de DB.
 // If a block is synched, it will be returned and also stored in the DB.  If a
 // reorg is detected, the number of discarded blocks will be returned and no
 // synchronization will be made.
 // TODO: Be smart about locking: only lock during the read/write operations
-func (s *Synchronizer) Sync2(ctx context.Context,
+func (s *Synchronizer) Sync2(ctx context.Context, lastSavedBlock *common.Block) (*common.BlockData, *int64, error) {
-	lastSavedBlock *common.Block) (blockData *common.BlockData, discarded *int64, err error) {
-	if s.resetStateFailed {
-		if err := s.resetIntermediateState(); err != nil {
-			return nil, nil, tracerr.Wrap(err)
-		}
-	}
-
 	var nextBlockNum int64 // next block number to sync
 	if lastSavedBlock == nil {
+		var err error
 		// Get lastSavedBlock from History DB
 		lastSavedBlock, err = s.historyDB.GetLastBlock()
 		if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
@@ -544,7 +497,7 @@ func (s *Synchronizer) Sync2(ctx context.Context,
 	if tracerr.Unwrap(err) == ethereum.NotFound {
 		return nil, nil, nil
 	} else if err != nil {
-		return nil, nil, tracerr.Wrap(fmt.Errorf("EthBlockByNumber: %w", err))
+		return nil, nil, tracerr.Wrap(err)
 	}
 	log.Debugf("ethBlock: num: %v, parent: %v, hash: %v",
 		ethBlock.Num, ethBlock.ParentHash.String(), ethBlock.Hash.String())
@@ -574,20 +527,6 @@ func (s *Synchronizer) Sync2(ctx context.Context,
 		}
 	}
 
-	defer func() {
-		// If there was an error during sync, reset to the last block
-		// in the historyDB because the historyDB is written last in
-		// the Sync method and is the source of consistency.  This
-		// allows reseting the stateDB in the case a batch was
-		// processed but the historyDB block was not committed due to an
-		// error.
-		if err != nil {
-			if err2 := s.resetIntermediateState(); err2 != nil {
-				log.Errorw("sync revert", "err", err2)
-			}
-		}
-	}()
-
 	// Get data from the rollup contract
 	rollupData, err := s.rollupSync(ethBlock)
 	if err != nil {
@@ -625,14 +564,14 @@ func (s *Synchronizer) Sync2(ctx context.Context,
 	}
 
 	// Group all the block data into the structs to save into HistoryDB
-	blockData = &common.BlockData{
+	blockData := common.BlockData{
 		Block:    *ethBlock,
 		Rollup:   *rollupData,
 		Auction:  *auctionData,
 		WDelayer: *wDelayerData,
 	}
 
-	err = s.historyDB.AddBlockSCData(blockData)
+	err = s.historyDB.AddBlockSCData(&blockData)
 	if err != nil {
 		return nil, nil, tracerr.Wrap(err)
 	}
@@ -650,35 +589,31 @@ func (s *Synchronizer) Sync2(ctx context.Context,
 			}
 		}
 		s.stats.UpdateSync(ethBlock,
-			&rollupData.Batches[batchesLen-1].Batch,
+			&rollupData.Batches[batchesLen-1].Batch.BatchNum,
 			lastL1BatchBlock, lastForgeL1TxsNum)
 	}
-	hasBatch := false
+	var firstBatchBlockNum *int64
 	if len(rollupData.Batches) > 0 {
-		hasBatch = true
+		firstBatchBlockNum = &rollupData.Batches[0].Batch.EthBlockNum
 	}
-	if err := s.updateCurrentNextSlotIfSync(false, hasBatch); err != nil {
+	if err := s.updateCurrentNextSlotIfSync(false, firstBatchBlockNum); err != nil {
 		return nil, nil, tracerr.Wrap(err)
 	}
 
-	for _, batchData := range rollupData.Batches {
-		metricSyncedLastBatchNum.Set(float64(batchData.Batch.BatchNum))
-		metricEthLastBatchNum.Set(float64(s.stats.Eth.LastBatchNum))
-		log.Debugw("Synced batch",
-			"syncLastBatch", batchData.Batch.BatchNum,
-			"syncBatchesPerc", s.stats.batchesPerc(batchData.Batch.BatchNum),
-			"ethLastBatch", s.stats.Eth.LastBatchNum,
-		)
-	}
-	metricSyncedLastBlockNum.Set(float64(s.stats.Sync.LastBlock.Num))
-	metricEthLastBlockNum.Set(float64(s.stats.Eth.LastBlock.Num))
 	log.Debugw("Synced block",
 		"syncLastBlockNum", s.stats.Sync.LastBlock.Num,
 		"syncBlocksPerc", s.stats.blocksPerc(),
 		"ethLastBlockNum", s.stats.Eth.LastBlock.Num,
 	)
+	for _, batchData := range rollupData.Batches {
+		log.Debugw("Synced batch",
+			"syncLastBatch", batchData.Batch.BatchNum,
+			"syncBatchesPerc", s.stats.batchesPerc(int64(batchData.Batch.BatchNum)),
+			"ethLastBatch", s.stats.Eth.LastBatch,
+		)
+	}
 
-	return blockData, nil, nil
+	return &blockData, nil, nil
 }
 
 // reorg manages a reorg, updating History and State DB as needed.  Keeps
@@ -710,15 +645,14 @@ func (s *Synchronizer) reorg(uncleBlock *common.Block) (int64, error) {
 	log.Debugw("Discarding blocks", "total", total, "from", uncleBlock.Num, "to", block.Num+1)
 
 	// Set History DB and State DB to the correct state
-	if err := s.historyDB.Reorg(block.Num); err != nil {
+	err := s.historyDB.Reorg(block.Num)
+	if err != nil {
 		return 0, tracerr.Wrap(err)
 	}
 
 	if err := s.resetState(block); err != nil {
-		s.resetStateFailed = true
 		return 0, tracerr.Wrap(err)
 	}
-	s.resetStateFailed = false
 
 	return block.Num, nil
 }
@@ -727,15 +661,15 @@ func getInitialVariables(ethClient eth.ClientInterface,
 	consts *SCConsts) (*SCVariables, *StartBlockNums, error) {
 	rollupInit, rollupInitBlock, err := ethClient.RollupEventInit()
 	if err != nil {
-		return nil, nil, tracerr.Wrap(fmt.Errorf("RollupEventInit: %w", err))
+		return nil, nil, tracerr.Wrap(err)
 	}
 	auctionInit, auctionInitBlock, err := ethClient.AuctionEventInit()
 	if err != nil {
-		return nil, nil, tracerr.Wrap(fmt.Errorf("AuctionEventInit: %w", err))
+		return nil, nil, tracerr.Wrap(err)
 	}
 	wDelayerInit, wDelayerInitBlock, err := ethClient.WDelayerEventInit()
 	if err != nil {
-		return nil, nil, tracerr.Wrap(fmt.Errorf("WDelayerEventInit: %w", err))
+		return nil, nil, tracerr.Wrap(err)
 	}
 	rollupVars := rollupInit.RollupVariables()
 	auctionVars := auctionInit.AuctionVariables(consts.Auction.InitialMinimalBidding)
@@ -780,17 +714,12 @@ func (s *Synchronizer) resetState(block *common.Block) error {
 		s.vars.WDelayer = *wDelayer
 	}
 
-	batch, err := s.historyDB.GetLastBatch()
+	batchNum, err := s.historyDB.GetLastBatchNum()
 	if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
 		return tracerr.Wrap(fmt.Errorf("historyDB.GetLastBatchNum: %w", err))
 	}
 	if tracerr.Unwrap(err) == sql.ErrNoRows {
-		batch = &common.Batch{}
+		batchNum = 0
-	}
-
-	err = s.stateDB.Reset(batch.BatchNum)
-	if err != nil {
-		return tracerr.Wrap(fmt.Errorf("stateDB.Reset: %w", err))
 	}
 
 	lastL1BatchBlockNum, err := s.historyDB.GetLastL1BatchBlockNum()
@@ -810,9 +739,14 @@ func (s *Synchronizer) resetState(block *common.Block) error {
 		lastForgeL1TxsNum = &n
 	}
 
-	s.stats.UpdateSync(block, batch, &lastL1BatchBlockNum, lastForgeL1TxsNum)
+	err = s.stateDB.Reset(batchNum)
+	if err != nil {
+		return tracerr.Wrap(fmt.Errorf("stateDB.Reset: %w", err))
+	}
 
-	if err := s.updateCurrentNextSlotIfSync(true, false); err != nil {
+	s.stats.UpdateSync(block, &batchNum, &lastL1BatchBlockNum, lastForgeL1TxsNum)
+
+	if err := s.updateCurrentNextSlotIfSync(true, nil); err != nil {
 		return tracerr.Wrap(err)
 	}
 	return nil
@@ -827,16 +761,19 @@ func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, e
 
 	// Get rollup events in the block, and make sure the block hash matches
 	// the expected one.
-	rollupEvents, err := s.ethClient.RollupEventsByBlock(blockNum, &ethBlock.Hash)
+	rollupEvents, blockHash, err := s.ethClient.RollupEventsByBlock(blockNum)
-	if err != nil && err.Error() == errStrUnknownBlock {
+	if err != nil {
-		return nil, tracerr.Wrap(ErrUnknownBlock)
+		return nil, tracerr.Wrap(err)
-	} else if err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("RollupEventsByBlock: %w", err))
 	}
 	// No events in this block
-	if rollupEvents == nil {
+	if blockHash == nil {
 		return &rollupData, nil
 	}
+	if *blockHash != ethBlock.Hash {
+		log.Errorw("Block hash mismatch in Rollup events", "expected", ethBlock.Hash.String(),
+			"got", blockHash.String())
+		return nil, tracerr.Wrap(eth.ErrBlockHashMismatchEvent)
+	}
 
 	var nextForgeL1TxsNum int64 // forgeL1TxsNum for the next L1Batch
 	nextForgeL1TxsNumPtr, err := s.historyDB.GetLastL1TxsNum()
@@ -864,7 +801,7 @@ func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, e
 		forgeBatchArgs, sender, err := s.ethClient.RollupForgeBatchArgs(evtForgeBatch.EthTxHash,
 			evtForgeBatch.L1UserTxsLen)
 		if err != nil {
-			return nil, tracerr.Wrap(fmt.Errorf("RollupForgeBatchArgs: %w", err))
+			return nil, tracerr.Wrap(err)
 		}
 
 		batchNum := common.BatchNum(evtForgeBatch.BatchNum)
@@ -947,16 +884,6 @@ func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, e
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
-		if s.stateDB.CurrentBatch() != batchNum {
-			return nil, tracerr.Wrap(fmt.Errorf("stateDB.BatchNum (%v) != "+
-				"evtForgeBatch.BatchNum = (%v)",
-				s.stateDB.CurrentBatch(), batchNum))
-		}
-		if s.stateDB.MT.Root().BigInt().Cmp(forgeBatchArgs.NewStRoot) != 0 {
-			return nil, tracerr.Wrap(fmt.Errorf("stateDB.MTRoot (%v) != "+
-				"forgeBatchArgs.NewStRoot (%v)",
-				s.stateDB.MT.Root().BigInt(), forgeBatchArgs.NewStRoot))
-		}
 
 		// Transform processed PoolL2 txs to L2 and store in BatchData
 		l2Txs, err := common.PoolL2TxsToL2Txs(poolL2Txs) // NOTE: This is a big uggly, find a better way
@@ -997,19 +924,6 @@ func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, e
 		}
 		batchData.CreatedAccounts = processTxsOut.CreatedAccounts
 
-		batchData.UpdatedAccounts = make([]common.AccountUpdate, 0,
-			len(processTxsOut.UpdatedAccounts))
-		for _, acc := range processTxsOut.UpdatedAccounts {
-			batchData.UpdatedAccounts = append(batchData.UpdatedAccounts,
-				common.AccountUpdate{
-					EthBlockNum: blockNum,
-					BatchNum:    batchNum,
-					Idx:         acc.Idx,
-					Nonce:       acc.Nonce,
-					Balance:     acc.Balance,
-				})
-		}
-
 		slotNum := int64(0)
 		if ethBlock.Num >= s.consts.Auction.GenesisBlockNum {
 			slotNum = (ethBlock.Num - s.consts.Auction.GenesisBlockNum) /
@@ -1152,16 +1066,19 @@ func (s *Synchronizer) auctionSync(ethBlock *common.Block) (*common.AuctionData,
 	var auctionData = common.NewAuctionData()
 
 	// Get auction events in the block
-	auctionEvents, err := s.ethClient.AuctionEventsByBlock(blockNum, &ethBlock.Hash)
+	auctionEvents, blockHash, err := s.ethClient.AuctionEventsByBlock(blockNum)
-	if err != nil && err.Error() == errStrUnknownBlock {
+	if err != nil {
-		return nil, tracerr.Wrap(ErrUnknownBlock)
+		return nil, tracerr.Wrap(err)
-	} else if err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("AuctionEventsByBlock: %w", err))
 	}
 	// No events in this block
-	if auctionEvents == nil {
+	if blockHash == nil {
 		return &auctionData, nil
 	}
+	if *blockHash != ethBlock.Hash {
+		log.Errorw("Block hash mismatch in Auction events", "expected", ethBlock.Hash.String(),
+			"got", blockHash.String())
+		return nil, tracerr.Wrap(eth.ErrBlockHashMismatchEvent)
+	}
 
 	// Get bids
 	for _, evt := range auctionEvents.NewBid {
@@ -1251,16 +1168,19 @@ func (s *Synchronizer) wdelayerSync(ethBlock *common.Block) (*common.WDelayerDat
 	wDelayerData := common.NewWDelayerData()
 
 	// Get wDelayer events in the block
-	wDelayerEvents, err := s.ethClient.WDelayerEventsByBlock(blockNum, &ethBlock.Hash)
+	wDelayerEvents, blockHash, err := s.ethClient.WDelayerEventsByBlock(blockNum)
-	if err != nil && err.Error() == errStrUnknownBlock {
+	if err != nil {
-		return nil, tracerr.Wrap(ErrUnknownBlock)
+		return nil, tracerr.Wrap(err)
-	} else if err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("WDelayerEventsByBlock: %w", err))
 	}
 	// No events in this block
-	if wDelayerEvents == nil {
+	if blockHash == nil {
 		return &wDelayerData, nil
 	}
+	if *blockHash != ethBlock.Hash {
+		log.Errorw("Block hash mismatch in WDelayer events", "expected", ethBlock.Hash.String(),
+			"got", blockHash.String())
+		return nil, tracerr.Wrap(eth.ErrBlockHashMismatchEvent)
+	}
 
 	for _, evt := range wDelayerEvents.Deposit {
 		wDelayerData.Deposits = append(wDelayerData.Deposits, common.WDelayerTransfer{

synchronizer/synchronizer_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/db/statedb"
 	"github.com/hermeznetwork/hermez-node/eth"
+	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/hermez-node/test"
 	"github.com/hermeznetwork/hermez-node/test/til"
 	"github.com/jinzhu/copier"
@@ -171,8 +172,6 @@ func checkSyncBlock(t *testing.T, s *Synchronizer, blockNum int, block, syncBloc
 			*exit = syncBatch.ExitTree[j]
 		}
 		assert.Equal(t, batch.Batch, syncBatch.Batch)
-		// Ignore updated accounts
-		syncBatch.UpdatedAccounts = nil
 		assert.Equal(t, batch, syncBatch)
 		assert.Equal(t, &batch.Batch, dbBatch) //nolint:gosec
 
@@ -308,28 +307,20 @@ func newTestModules(t *testing.T) (*statedb.StateDB, *historydb.HistoryDB) {
 	require.NoError(t, err)
 	deleteme = append(deleteme, dir)
 
-	stateDB, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128, Type: statedb.TypeSynchronizer, NLevels: 32})
+	stateDB, err := statedb.NewStateDB(dir, 128, statedb.TypeSynchronizer, 32)
 	require.NoError(t, err)
 
 	// Init History DB
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	historyDB := historydb.NewHistoryDB(db, db, nil)
+	historyDB := historydb.NewHistoryDB(db, nil)
 	// Clear DB
 	test.WipeDB(historyDB.DB())
 
 	return stateDB, historyDB
 }
 
-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 TestSyncGeneral(t *testing.T) {
 	//
 	// Setup
@@ -348,6 +339,7 @@ func TestSyncGeneral(t *testing.T) {
 	s, err := NewSynchronizer(client, historyDB, stateDB, Config{
 		StatsRefreshPeriod: 0 * time.Second,
 	})
+	log.Error(err)
 	require.NoError(t, err)
 
 	ctx := context.Background()
@@ -442,22 +434,12 @@ func TestSyncGeneral(t *testing.T) {
 	require.Equal(t, 5, len(blocks[i].Rollup.L1UserTxs))
 	require.Equal(t, 2, len(blocks[i].Rollup.Batches))
 	require.Equal(t, 2, len(blocks[i].Rollup.Batches[0].L1CoordinatorTxs))
-	// Set StateRoots for batches manually (til doesn't set it)
-	blocks[i].Rollup.Batches[0].Batch.StateRoot =
-		newBigInt("18906357591508007884273218035694076596537737437965299189312069102730480717391")
-	blocks[i].Rollup.Batches[1].Batch.StateRoot =
-		newBigInt("9513185123401321669660637227182204000277156839501731093239187625486561933297")
 	// blocks 1 (blockNum=3)
 	i = 1
 	require.Equal(t, 3, int(blocks[i].Block.Num))
 	require.Equal(t, 5, len(blocks[i].Rollup.L1UserTxs))
 	require.Equal(t, 2, len(blocks[i].Rollup.Batches))
 	require.Equal(t, 3, len(blocks[i].Rollup.Batches[0].L2Txs))
-	// Set StateRoots for batches manually (til doesn't set it)
-	blocks[i].Rollup.Batches[0].Batch.StateRoot =
-		newBigInt("13060270878200012606074130020925677466793317216609491464427188889005039616594")
-	blocks[i].Rollup.Batches[1].Batch.StateRoot =
-		newBigInt("21427104994652624302859637783375978708867165042357535792408500519060088086054")
 
 	// Generate extra required data
 	ethAddTokens(blocks, client)
@@ -632,12 +614,6 @@ func TestSyncGeneral(t *testing.T) {
 	blocks, err = tc.GenerateBlocks(set2)
 	require.NoError(t, err)
 
-	// Set StateRoots for batches manually (til doesn't set it)
-	blocks[0].Rollup.Batches[0].Batch.StateRoot =
-		newBigInt("11218510534825843475100588932060366395781087435899915642332104464234485046683")
-	blocks[0].Rollup.Batches[1].Batch.StateRoot =
-		newBigInt("20283020730369146334077598087403837297563965802277806438205710455191646998983")
-
 	for i := 0; i < 4; i++ {
 		client.CtlRollback()
 	}

test/debugapi/debugapi.go

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

test/debugapi/debugapi_test.go

@@ -44,7 +44,7 @@ func TestDebugAPI(t *testing.T) {
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.Nil(t, err)
 
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128, Type: statedb.TypeSynchronizer, NLevels: 32})
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeSynchronizer, 32)
 	require.Nil(t, err)
 	err = sdb.MakeCheckpoint() // Make a checkpoint to increment the batchNum
 	require.Nil(t, err)

test/ethclient.go

@@ -797,11 +797,11 @@ func (c *Client) RollupL1UserTxERC20ETH(
 	cpy := c.nextBlock().copy()
 	defer func() { c.revertIfErr(err, cpy) }()
 
-	_, err = common.NewFloat40(amount)
+	_, err = common.NewFloat16(amount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	_, err = common.NewFloat40(depositAmount)
+	_, err = common.NewFloat16(depositAmount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -1116,20 +1116,15 @@ func (c *Client) RollupConstants() (*common.RollupConstants, error) {
 }
 
 // RollupEventsByBlock returns the events in a block that happened in the Rollup Smart Contract
-func (c *Client) RollupEventsByBlock(blockNum int64,
+func (c *Client) RollupEventsByBlock(blockNum int64) (*eth.RollupEvents, *ethCommon.Hash, error) {
-	blockHash *ethCommon.Hash) (*eth.RollupEvents, error) {
 	c.rw.RLock()
 	defer c.rw.RUnlock()
 
 	block, ok := c.blocks[blockNum]
 	if !ok {
-		return nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum))
+		return nil, nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum))
 	}
-	if blockHash != nil && *blockHash != block.Eth.Hash {
+	return &block.Rollup.Events, &block.Eth.Hash, nil
-		return nil, tracerr.Wrap(fmt.Errorf("Hash mismatch, requested %v got %v",
-			blockHash, block.Eth.Hash))
-	}
-	return &block.Rollup.Events, nil
 }
 
 // RollupEventInit returns the initialize event with its corresponding block number
@@ -1578,20 +1573,15 @@ func (c *Client) AuctionConstants() (*common.AuctionConstants, error) {
 }
 
 // AuctionEventsByBlock returns the events in a block that happened in the Auction Smart Contract
-func (c *Client) AuctionEventsByBlock(blockNum int64,
+func (c *Client) AuctionEventsByBlock(blockNum int64) (*eth.AuctionEvents, *ethCommon.Hash, error) {
-	blockHash *ethCommon.Hash) (*eth.AuctionEvents, error) {
 	c.rw.RLock()
 	defer c.rw.RUnlock()
 
 	block, ok := c.blocks[blockNum]
 	if !ok {
-		return nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum))
+		return nil, nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum))
 	}
-	if blockHash != nil && *blockHash != block.Eth.Hash {
+	return &block.Auction.Events, &block.Eth.Hash, nil
-		return nil, tracerr.Wrap(fmt.Errorf("Hash mismatch, requested %v got %v",
-			blockHash, block.Eth.Hash))
-	}
-	return &block.Auction.Events, nil
 }
 
 // AuctionEventInit returns the initialize event with its corresponding block number
@@ -1799,20 +1789,15 @@ func (c *Client) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address, amou
 }
 
 // WDelayerEventsByBlock returns the events in a block that happened in the WDelayer Contract
-func (c *Client) WDelayerEventsByBlock(blockNum int64,
+func (c *Client) WDelayerEventsByBlock(blockNum int64) (*eth.WDelayerEvents, *ethCommon.Hash, error) {
-	blockHash *ethCommon.Hash) (*eth.WDelayerEvents, error) {
 	c.rw.RLock()
 	defer c.rw.RUnlock()
 
 	block, ok := c.blocks[blockNum]
 	if !ok {
-		return nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum))
+		return nil, nil, tracerr.Wrap(fmt.Errorf("Block %v doesn't exist", blockNum))
 	}
-	if blockHash != nil && *blockHash != block.Eth.Hash {
+	return &block.WDelayer.Events, &block.Eth.Hash, nil
-		return nil, tracerr.Wrap(fmt.Errorf("Hash mismatch, requested %v got %v",
-			blockHash, block.Eth.Hash))
-	}
-	return &block.WDelayer.Events, nil
 }
 
 // WDelayerConstants returns the Constants of the WDelayer Contract

test/ethclient_test.go

@@ -130,7 +130,7 @@ func TestClientAuction(t *testing.T) {
 	blockNum, err := c.EthLastBlock()
 	require.Nil(t, err)
 
-	auctionEvents, err := c.AuctionEventsByBlock(blockNum, nil)
+	auctionEvents, _, err := c.AuctionEventsByBlock(blockNum)
 	require.Nil(t, err)
 	assert.Equal(t, 2, len(auctionEvents.NewBid))
 }
@@ -171,7 +171,7 @@ func TestClientRollup(t *testing.T) {
 
 	blockNum, err := c.EthLastBlock()
 	require.Nil(t, err)
-	rollupEvents, err := c.RollupEventsByBlock(blockNum, nil)
+	rollupEvents, _, err := c.RollupEventsByBlock(blockNum)
 	require.Nil(t, err)
 	assert.Equal(t, N, len(rollupEvents.L1UserTx))
 	assert.Equal(t, 1, len(rollupEvents.AddToken))
@@ -192,7 +192,7 @@ func TestClientRollup(t *testing.T) {
 
 	blockNumA, err := c.EthLastBlock()
 	require.Nil(t, err)
-	rollupEvents, err = c.RollupEventsByBlock(blockNumA, nil)
+	rollupEvents, hashA, err := c.RollupEventsByBlock(blockNumA)
 	require.Nil(t, err)
 	assert.Equal(t, 0, len(rollupEvents.L1UserTx))
 	assert.Equal(t, 0, len(rollupEvents.AddToken))
@@ -205,14 +205,14 @@ func TestClientRollup(t *testing.T) {
 
 	blockNumB, err := c.EthLastBlock()
 	require.Nil(t, err)
-	rollupEventsB, err := c.RollupEventsByBlock(blockNumA, nil)
+	rollupEvents, hashB, err := c.RollupEventsByBlock(blockNumA)
 	require.Nil(t, err)
-	assert.Equal(t, 0, len(rollupEventsB.L1UserTx))
+	assert.Equal(t, 0, len(rollupEvents.L1UserTx))
-	assert.Equal(t, 0, len(rollupEventsB.AddToken))
+	assert.Equal(t, 0, len(rollupEvents.AddToken))
-	assert.Equal(t, 0, len(rollupEventsB.ForgeBatch))
+	assert.Equal(t, 0, len(rollupEvents.ForgeBatch))
 
 	assert.Equal(t, blockNumA, blockNumB)
-	assert.NotEqual(t, rollupEvents, rollupEventsB)
+	assert.NotEqual(t, hashA, hashB)
 
 	// Forge again
 	rollupForgeBatchArgs0 := &eth.RollupForgeBatchArgs{
@@ -232,7 +232,7 @@ func TestClientRollup(t *testing.T) {
 
 	blockNum, err = c.EthLastBlock()
 	require.Nil(t, err)
-	rollupEvents, err = c.RollupEventsByBlock(blockNum, nil)
+	rollupEvents, _, err = c.RollupEventsByBlock(blockNum)
 	require.Nil(t, err)
 
 	rollupForgeBatchArgs1, sender, err := c.RollupForgeBatchArgs(rollupEvents.ForgeBatch[0].EthTxHash,

test/proofserver/proofserver.go

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

test/txsets/txhelpers.go

@@ -142,12 +142,10 @@ func GenerateTxsZKInputs0(t *testing.T, chainID uint16) (users []til.User, coord
 	// same values than in the js test
 	users = GenerateJsUsers(t)
 
-	depositAmount, err := common.Float40(10400).BigInt()
-	require.Nil(t, err)
 	l1UserTxs = []common.L1Tx{
 		{
 			FromIdx:       0,
-			DepositAmount: depositAmount,
+			DepositAmount: big.NewInt(16000000),
 			Amount:        big.NewInt(0),
 			TokenID:       1,
 			FromBJJ:       users[0].BJJ.Public().Compress(),

test/zkproof/flows_test.go

@@ -38,7 +38,7 @@ func addTokens(t *testing.T, tc *til.Context, db *sqlx.DB) {
 		})
 	}
 
-	hdb := historydb.NewHistoryDB(db, db, nil)
+	hdb := historydb.NewHistoryDB(db, nil)
 	assert.NoError(t, hdb.AddBlock(&common.Block{
 		Num: 1,
 	}))
@@ -75,13 +75,12 @@ func initTxSelector(t *testing.T, chainID uint16, hermezContractAddr ethCommon.A
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpSyncDB")
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
-	syncStateDB, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	syncStateDB, err := statedb.NewStateDB(dir, 128, statedb.TypeSynchronizer, 0)
-		Type: statedb.TypeSynchronizer, NLevels: 0})
 	require.NoError(t, err)
 
 	txselDir, err := ioutil.TempDir("", "tmpTxSelDB")
@@ -311,7 +310,7 @@ func TestZKInputsExitWithFee0(t *testing.T) {
 	assert.Equal(t, "8737171572459172806192626402462788826264011087579491137542380589998149683116", bb.LocalStateDB().MT.Root().BigInt().String())
 	h, err := zki.HashGlobalData()
 	require.NoError(t, err)
-	assert.Equal(t, "18608843755023673022528019960628191162333429206359207449879743919826610006009", h.String())
+	assert.Equal(t, "9971598169768987067017223790214537222850903267980994716992761290793474746117", h.String())
 	sendProofAndCheckResp(t, zki)
 
 	// batch3
@@ -334,7 +333,7 @@ func TestZKInputsExitWithFee0(t *testing.T) {
 	assert.Equal(t, "18306761925365215381387147754881756804475668085493847010988306480531520370130", bb.LocalStateDB().MT.Root().BigInt().String())
 	h, err = zki.HashGlobalData()
 	require.NoError(t, err)
-	assert.Equal(t, "6651837443119278772088559395433504719862425648816904171510845286897104469889", h.String())
+	assert.Equal(t, "7992262236065691439683036344554725221924027193771770363772735722054938818364", h.String())
 	assert.Equal(t, common.EthAddrToBigInt(tc.Users["Coord"].Addr), zki.EthAddr3[0])
 	assert.Equal(t, "0", zki.EthAddr3[1].String())
 	sendProofAndCheckResp(t, zki)

test/zkproof/zkproof_test.go

@@ -31,7 +31,7 @@ func TestMain(m *testing.M) {
 	os.Exit(exitVal)
 }
 
-const MaxTx = 352
+const MaxTx = 376
 const NLevels = 32
 const MaxL1Tx = 256
 const MaxFeeTx = 64
@@ -50,7 +50,7 @@ func initStateDB(t *testing.T, typ statedb.TypeStateDB) *statedb.StateDB {
 	require.NoError(t, err)
 	defer assert.Nil(t, os.RemoveAll(dir))
 
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128, Type: typ, NLevels: NLevels})
+	sdb, err := statedb.NewStateDB(dir, 128, typ, NLevels)
 	require.NoError(t, err)
 	return sdb
 }
@@ -61,7 +61,6 @@ func sendProofAndCheckResp(t *testing.T, zki *common.ZKInputs) {
 		return
 	}
 
-	log.Infof("sending proof to %s", proofServerURL)
 	// Store zkinputs json for debugging purposes
 	zkInputsJSON, err := json.Marshal(zki)
 	require.NoError(t, err)

txprocessor/txprocessor.go

@@ -27,21 +27,16 @@ type TxProcessor struct {
 	// AccumulatedFees contains the accumulated fees for each token (Coord
 	// Idx) in the processed batch
 	AccumulatedFees map[common.Idx]*big.Int
-	// updatedAccounts stores the last version of the account when it has
-	// been created/updated by any of the processed transactions.
-	updatedAccounts map[common.Idx]*common.Account
 	config          Config
 }
 
 // Config contains the TxProcessor configuration parameters
 type Config struct {
-	NLevels uint32
+	NLevels  uint32
-	// MaxFeeTx is the maximum number of coordinator accounts that can receive fees
 	MaxFeeTx uint32
 	MaxTx    uint32
 	MaxL1Tx  uint32
-	// ChainID of the blockchain
+	ChainID  uint16
-	ChainID uint16
 }
 
 type processedExit struct {
@@ -58,9 +53,6 @@ type ProcessTxOutput struct {
 	CreatedAccounts    []common.Account
 	CoordinatorIdxsMap map[common.TokenID]common.Idx
 	CollectedFees      map[common.TokenID]*big.Int
-	// UpdatedAccounts returns the current state of each account
-	// created/updated by any of the processed transactions.
-	UpdatedAccounts map[common.Idx]*common.Account
 }
 
 func newErrorNotEnoughBalance(tx common.Tx) error {
@@ -133,13 +125,9 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 		return nil, tracerr.Wrap(fmt.Errorf("L1UserTx + L1CoordinatorTx (%d) can not be bigger than MaxL1Tx (%d)", len(l1usertxs)+len(l1coordinatortxs), tp.config.MaxTx))
 	}
 
-	if tp.s.Type() == statedb.TypeSynchronizer {
-		tp.updatedAccounts = make(map[common.Idx]*common.Account)
-	}
-
 	exits := make([]processedExit, nTx)
 
-	if tp.s.Type() == statedb.TypeBatchBuilder {
+	if tp.s.Typ == statedb.TypeBatchBuilder {
 		tp.zki = common.NewZKInputs(tp.config.ChainID, tp.config.MaxTx, tp.config.MaxL1Tx,
 			tp.config.MaxFeeTx, tp.config.NLevels, (tp.s.CurrentBatch() + 1).BigInt())
 		tp.zki.OldLastIdx = tp.s.CurrentIdx().BigInt()
@@ -149,7 +137,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 
 	// TBD if ExitTree is only in memory or stored in disk, for the moment
 	// is only needed in memory
-	if tp.s.Type() == statedb.TypeSynchronizer || tp.s.Type() == statedb.TypeBatchBuilder {
+	if tp.s.Typ == statedb.TypeSynchronizer || tp.s.Typ == statedb.TypeBatchBuilder {
 		tmpDir, err := ioutil.TempDir("", "hermez-statedb-exittree")
 		if err != nil {
 			return nil, tracerr.Wrap(err)
@@ -178,7 +166,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
-		if tp.s.Type() == statedb.TypeSynchronizer {
+		if tp.s.Typ == statedb.TypeSynchronizer {
 			if createdAccount != nil {
 				createdAccounts = append(createdAccounts, *createdAccount)
 				l1usertxs[i].EffectiveFromIdx = createdAccount.Idx
@@ -207,8 +195,8 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 				tp.zki.ISExitRoot[tp.i] = exitTree.Root().BigInt()
 			}
 		}
-		if tp.s.Type() == statedb.TypeSynchronizer || tp.s.Type() == statedb.TypeBatchBuilder {
+		if tp.s.Typ == statedb.TypeSynchronizer || tp.s.Typ == statedb.TypeBatchBuilder {
-			if exitIdx != nil && exitTree != nil && exitAccount != nil {
+			if exitIdx != nil && exitTree != nil {
 				exits[tp.i] = processedExit{
 					exit:    true,
 					newExit: newExit,
@@ -229,7 +217,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 		if exitIdx != nil {
 			log.Error("Unexpected Exit in L1CoordinatorTx")
 		}
-		if tp.s.Type() == statedb.TypeSynchronizer {
+		if tp.s.Typ == statedb.TypeSynchronizer {
 			if createdAccount != nil {
 				createdAccounts = append(createdAccounts, *createdAccount)
 				l1coordinatortxs[i].EffectiveFromIdx = createdAccount.Idx
@@ -288,7 +276,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 	// collectedFees will contain the amount of fee collected for each
 	// TokenID
 	var collectedFees map[common.TokenID]*big.Int
-	if tp.s.Type() == statedb.TypeSynchronizer || tp.s.Type() == statedb.TypeBatchBuilder {
+	if tp.s.Typ == statedb.TypeSynchronizer || tp.s.Typ == statedb.TypeBatchBuilder {
 		collectedFees = make(map[common.TokenID]*big.Int)
 		for tokenID := range coordIdxsMap {
 			collectedFees[tokenID] = big.NewInt(0)
@@ -329,7 +317,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 				}
 			}
 		}
-		if tp.s.Type() == statedb.TypeSynchronizer || tp.s.Type() == statedb.TypeBatchBuilder {
+		if tp.s.Typ == statedb.TypeSynchronizer || tp.s.Typ == statedb.TypeBatchBuilder {
 			if exitIdx != nil && exitTree != nil {
 				exits[tp.i] = processedExit{
 					exit:    true,
@@ -392,7 +380,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 			tp.zki.EthAddr3[iFee] = common.EthAddrToBigInt(accCoord.EthAddr)
 		}
 		accCoord.Balance = new(big.Int).Add(accCoord.Balance, accumulatedFee)
-		pFee, err := tp.updateAccount(idx, accCoord)
+		pFee, err := tp.s.UpdateAccount(idx, accCoord)
 		if err != nil {
 			log.Error(err)
 			return nil, tracerr.Wrap(err)
@@ -413,43 +401,43 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 		}
 	}
 
-	if tp.s.Type() == statedb.TypeTxSelector {
+	if tp.s.Typ == statedb.TypeTxSelector {
 		return nil, nil
 	}
 
-	if tp.s.Type() == statedb.TypeSynchronizer {
+	// once all txs processed (exitTree root frozen), for each Exit,
-		// once all txs processed (exitTree root frozen), for each Exit,
+	// generate common.ExitInfo data
-		// generate common.ExitInfo data
+	var exitInfos []common.ExitInfo
-		var exitInfos []common.ExitInfo
+	exitInfosByIdx := make(map[common.Idx]*common.ExitInfo)
-		exitInfosByIdx := make(map[common.Idx]*common.ExitInfo)
+	for i := 0; i < nTx; i++ {
-		for i := 0; i < nTx; i++ {
+		if !exits[i].exit {
-			if !exits[i].exit {
+			continue
-				continue
+		}
-			}
+		exitIdx := exits[i].idx
-			exitIdx := exits[i].idx
+		exitAccount := exits[i].acc
-			exitAccount := exits[i].acc
 
-			// 0. generate MerkleProof
+		// 0. generate MerkleProof
-			p, err := exitTree.GenerateSCVerifierProof(exitIdx.BigInt(), nil)
+		p, err := exitTree.GenerateSCVerifierProof(exitIdx.BigInt(), nil)
-			if err != nil {
+		if err != nil {
-				return nil, tracerr.Wrap(err)
+			return nil, tracerr.Wrap(err)
-			}
-
-			// 1. generate common.ExitInfo
-			ei := common.ExitInfo{
-				AccountIdx:  exitIdx,
-				MerkleProof: p,
-				Balance:     exitAccount.Balance,
-			}
-			if prevExit, ok := exitInfosByIdx[exitIdx]; !ok {
-				exitInfos = append(exitInfos, ei)
-				exitInfosByIdx[exitIdx] = &exitInfos[len(exitInfos)-1]
-			} else {
-				*prevExit = ei
-			}
 		}
 
-		// retun exitInfos, createdAccounts and collectedFees, so Synchronizer will
+		// 1. generate common.ExitInfo
+		ei := common.ExitInfo{
+			AccountIdx:  exitIdx,
+			MerkleProof: p,
+			Balance:     exitAccount.Balance,
+		}
+		if prevExit, ok := exitInfosByIdx[exitIdx]; !ok {
+			exitInfos = append(exitInfos, ei)
+			exitInfosByIdx[exitIdx] = &exitInfos[len(exitInfos)-1]
+		} else {
+			*prevExit = ei
+		}
+	}
+
+	if tp.s.Typ == statedb.TypeSynchronizer {
+		// return exitInfos, createdAccounts and collectedFees, so Synchronizer will
 		// be able to store it into HistoryDB for the concrete BatchNum
 		return &ProcessTxOutput{
 			ZKInputs:           nil,
@@ -457,7 +445,6 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 			CreatedAccounts:    createdAccounts,
 			CoordinatorIdxsMap: coordIdxsMap,
 			CollectedFees:      collectedFees,
-			UpdatedAccounts:    tp.updatedAccounts,
 		}, nil
 	}
 
@@ -514,11 +501,11 @@ func (tp *TxProcessor) ProcessL1Tx(exitTree *merkletree.MerkleTree, tx *common.L
 		tp.zki.OnChain[tp.i] = big.NewInt(1)
 
 		// L1Txs
-		depositAmountF40, err := common.NewFloat40(tx.DepositAmount)
+		depositAmountF16, err := common.NewFloat16(tx.DepositAmount)
 		if err != nil {
 			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
-		tp.zki.DepositAmountF[tp.i] = big.NewInt(int64(depositAmountF40))
+		tp.zki.DepositAmountF[tp.i] = big.NewInt(int64(depositAmountF16))
 		tp.zki.FromEthAddr[tp.i] = common.EthAddrToBigInt(tx.FromEthAddr)
 		if tx.FromBJJ != common.EmptyBJJComp {
 			tp.zki.FromBJJCompressed[tp.i] = BJJCompressedTo256BigInts(tx.FromBJJ)
@@ -528,20 +515,6 @@ func (tp *TxProcessor) ProcessL1Tx(exitTree *merkletree.MerkleTree, tx *common.L
 		if tp.i < len(tp.zki.ISOnChain) { // len(tp.zki.ISOnChain) == nTx
 			tp.zki.ISOnChain[tp.i] = big.NewInt(1)
 		}
-
-		if tx.Type == common.TxTypeForceTransfer ||
-			tx.Type == common.TxTypeDepositTransfer ||
-			tx.Type == common.TxTypeCreateAccountDepositTransfer ||
-			tx.Type == common.TxTypeForceExit {
-			// in the cases where at L1Tx there is usage of the
-			// Amount parameter, add it at the ZKInputs.AmountF
-			// slot
-			amountF40, err := common.NewFloat40(tx.Amount)
-			if err != nil {
-				return nil, nil, false, nil, tracerr.Wrap(err)
-			}
-			tp.zki.AmountF[tp.i] = big.NewInt(int64(amountF40))
-		}
 	}
 
 	switch tx.Type {
@@ -605,7 +578,7 @@ func (tp *TxProcessor) ProcessL1Tx(exitTree *merkletree.MerkleTree, tx *common.L
 
 		// execute exit flow
 		// coordIdxsMap is 'nil', as at L1Txs there is no L2 fees
-		exitAccount, newExit, err := tp.applyExit(nil, nil, exitTree, tx.Tx(), tx.Amount)
+		exitAccount, newExit, err := tp.applyExit(nil, nil, exitTree, tx.Tx())
 		if err != nil {
 			log.Error(err)
 			return nil, nil, false, nil, tracerr.Wrap(err)
@@ -615,7 +588,7 @@ func (tp *TxProcessor) ProcessL1Tx(exitTree *merkletree.MerkleTree, tx *common.L
 	}
 
 	var createdAccount *common.Account
-	if tp.s.Type() == statedb.TypeSynchronizer &&
+	if tp.s.Typ == statedb.TypeSynchronizer &&
 		(tx.Type == common.TxTypeCreateAccountDeposit ||
 			tx.Type == common.TxTypeCreateAccountDepositTransfer) {
 		var err error
@@ -639,8 +612,8 @@ func (tp *TxProcessor) ProcessL2Tx(coordIdxsMap map[common.TokenID]common.Idx,
 	var err error
 	// if tx.ToIdx==0, get toIdx by ToEthAddr or ToBJJ
 	if tx.ToIdx == common.Idx(0) && tx.AuxToIdx == common.Idx(0) {
-		if tp.s.Type() == statedb.TypeSynchronizer {
+		if tp.s.Typ == statedb.TypeSynchronizer {
-			// thisTypeould never be reached
+			// this should never be reached
 			log.Error("WARNING: In StateDB with Synchronizer mode L2.ToIdx can't be 0")
 			return nil, nil, false, tracerr.Wrap(fmt.Errorf("In StateDB with Synchronizer mode L2.ToIdx can't be 0"))
 		}
@@ -684,11 +657,6 @@ func (tp *TxProcessor) ProcessL2Tx(coordIdxsMap map[common.TokenID]common.Idx,
 		tp.zki.ToEthAddr[tp.i] = common.EthAddrToBigInt(tx.ToEthAddr)
 
 		tp.zki.OnChain[tp.i] = big.NewInt(0)
-		amountF40, err := common.NewFloat40(tx.Amount)
-		if err != nil {
-			return nil, nil, false, tracerr.Wrap(err)
-		}
-		tp.zki.AmountF[tp.i] = big.NewInt(int64(amountF40))
 		tp.zki.NewAccount[tp.i] = big.NewInt(0)
 
 		// L2Txs
@@ -708,8 +676,8 @@ func (tp *TxProcessor) ProcessL2Tx(coordIdxsMap map[common.TokenID]common.Idx,
 	}
 
 	// if StateDB type==TypeSynchronizer, will need to add Nonce
-	if tp.s.Type() == statedb.TypeSynchronizer {
+	if tp.s.Typ == statedb.TypeSynchronizer {
-		// as tType==TypeSynchronizer, always tx.ToIdx!=0
+		// as type==TypeSynchronizer, always tx.ToIdx!=0
 		acc, err := tp.s.GetAccount(tx.FromIdx)
 		if err != nil {
 			log.Errorw("GetAccount", "fromIdx", tx.FromIdx, "err", err)
@@ -730,7 +698,7 @@ func (tp *TxProcessor) ProcessL2Tx(coordIdxsMap map[common.TokenID]common.Idx,
 		}
 	case common.TxTypeExit:
 		// execute exit flow
-		exitAccount, newExit, err := tp.applyExit(coordIdxsMap, collectedFees, exitTree, tx.Tx(), tx.Amount)
+		exitAccount, newExit, err := tp.applyExit(coordIdxsMap, collectedFees, exitTree, tx.Tx())
 		if err != nil {
 			log.Error(err)
 			return nil, nil, false, tracerr.Wrap(err)
@@ -752,7 +720,7 @@ func (tp *TxProcessor) applyCreateAccount(tx *common.L1Tx) error {
 		EthAddr: tx.FromEthAddr,
 	}
 
-	p, err := tp.createAccount(common.Idx(tp.s.CurrentIdx()+1), account)
+	p, err := tp.s.CreateAccount(common.Idx(tp.s.CurrentIdx()+1), account)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -787,28 +755,6 @@ func (tp *TxProcessor) applyCreateAccount(tx *common.L1Tx) error {
 	return tp.s.SetCurrentIdx(tp.s.CurrentIdx() + 1)
 }
 
-// createAccount is a wrapper over the StateDB.CreateAccount method that also
-// stores the created account in the updatedAccounts map in case the StateDB is
-// of TypeSynchronizer
-func (tp *TxProcessor) createAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
-	if tp.s.Type() == statedb.TypeSynchronizer {
-		account.Idx = idx
-		tp.updatedAccounts[idx] = account
-	}
-	return tp.s.CreateAccount(idx, account)
-}
-
-// updateAccount is a wrapper over the StateDB.UpdateAccount method that also
-// stores the updated account in the updatedAccounts map in case the StateDB is
-// of TypeSynchronizer
-func (tp *TxProcessor) updateAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
-	if tp.s.Type() == statedb.TypeSynchronizer {
-		account.Idx = idx
-		tp.updatedAccounts[idx] = account
-	}
-	return tp.s.UpdateAccount(idx, account)
-}
-
 // applyDeposit updates the balance in the account of the depositer, if
 // andTransfer parameter is set to true, the method will also apply the
 // Transfer of the L1Tx/DepositTransfer
@@ -839,7 +785,7 @@ func (tp *TxProcessor) applyDeposit(tx *common.L1Tx, transfer bool) error {
 	}
 
 	// update sender account in localStateDB
-	p, err := tp.updateAccount(tx.FromIdx, accSender)
+	p, err := tp.s.UpdateAccount(tx.FromIdx, accSender)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -876,7 +822,7 @@ func (tp *TxProcessor) applyDeposit(tx *common.L1Tx, transfer bool) error {
 		accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.EffectiveAmount)
 
 		// update receiver account in localStateDB
-		p, err := tp.updateAccount(tx.ToIdx, accReceiver)
+		p, err := tp.s.UpdateAccount(tx.ToIdx, accReceiver)
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
@@ -943,8 +889,8 @@ func (tp *TxProcessor) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 			accumulated := tp.AccumulatedFees[accCoord.Idx]
 			accumulated.Add(accumulated, fee)
 
-			if tp.s.Type() == statedb.TypeSynchronizer ||
+			if tp.s.Typ == statedb.TypeSynchronizer ||
-				tp.s.Type() == statedb.TypeBatchBuilder {
+				tp.s.Typ == statedb.TypeBatchBuilder {
 				collected := collectedFees[accCoord.TokenID]
 				collected.Add(collected, fee)
 			}
@@ -959,7 +905,7 @@ func (tp *TxProcessor) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 	}
 
 	// update sender account in localStateDB
-	pSender, err := tp.updateAccount(tx.FromIdx, accSender)
+	pSender, err := tp.s.UpdateAccount(tx.FromIdx, accSender)
 	if err != nil {
 		log.Error(err)
 		return tracerr.Wrap(err)
@@ -998,7 +944,7 @@ func (tp *TxProcessor) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 	accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.Amount)
 
 	// update receiver account in localStateDB
-	pReceiver, err := tp.updateAccount(auxToIdx, accReceiver)
+	pReceiver, err := tp.s.UpdateAccount(auxToIdx, accReceiver)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1041,7 +987,7 @@ func (tp *TxProcessor) applyCreateAccountDepositTransfer(tx *common.L1Tx) error
 	}
 
 	// create Account of the Sender
-	p, err := tp.createAccount(common.Idx(tp.s.CurrentIdx()+1), accSender)
+	p, err := tp.s.CreateAccount(common.Idx(tp.s.CurrentIdx()+1), accSender)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1089,7 +1035,7 @@ func (tp *TxProcessor) applyCreateAccountDepositTransfer(tx *common.L1Tx) error
 	accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.EffectiveAmount)
 
 	// update receiver account in localStateDB
-	p, err = tp.updateAccount(tx.ToIdx, accReceiver)
+	p, err = tp.s.UpdateAccount(tx.ToIdx, accReceiver)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1104,7 +1050,7 @@ func (tp *TxProcessor) applyCreateAccountDepositTransfer(tx *common.L1Tx) error
 // new Leaf in the ExitTree.
 func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 	collectedFees map[common.TokenID]*big.Int, exitTree *merkletree.MerkleTree,
-	tx common.Tx, originalAmount *big.Int) (*common.Account, bool, error) {
+	tx common.Tx) (*common.Account, bool, error) {
 	// 0. subtract tx.Amount from current Account in StateMT
 	// add the tx.Amount into the Account (tx.FromIdx) in the ExitMT
 	acc, err := tp.s.GetAccount(tx.FromIdx)
@@ -1148,8 +1094,8 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 			accumulated := tp.AccumulatedFees[accCoord.Idx]
 			accumulated.Add(accumulated, fee)
 
-			if tp.s.Type() == statedb.TypeSynchronizer ||
+			if tp.s.Typ == statedb.TypeSynchronizer ||
-				tp.s.Type() == statedb.TypeBatchBuilder {
+				tp.s.Typ == statedb.TypeBatchBuilder {
 				collected := collectedFees[accCoord.TokenID]
 				collected.Add(collected, fee)
 			}
@@ -1163,7 +1109,7 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 		}
 	}
 
-	p, err := tp.updateAccount(tx.FromIdx, acc)
+	p, err := tp.s.UpdateAccount(tx.FromIdx, acc)
 	if err != nil {
 		return nil, false, tracerr.Wrap(err)
 	}
@@ -1174,21 +1120,6 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 	if exitTree == nil {
 		return nil, false, nil
 	}
-
-	// Do not add the Exit when Amount=0, not EffectiveAmount=0. In
-	// txprocessor.applyExit function, the tx.Amount is in reality the
-	// EffectiveAmount, that's why is used here the originalAmount
-	// parameter, which contains the real value of the tx.Amount (not
-	// tx.EffectiveAmount).  This is a particularity of the approach of the
-	// circuit, the idea will be in the future to update the circuit and
-	// when Amount>0 but EffectiveAmount=0, to not add the Exit in the
-	// Exits MerkleTree, but for the moment the Go code is adapted to the
-	// circuit.
-	if originalAmount.Cmp(big.NewInt(0)) == 0 { // Amount == 0
-		// if the Exit Amount==0, the Exit is not added to the ExitTree
-		return nil, false, nil
-	}
-
 	exitAccount, err := statedb.GetAccountInTreeDB(exitTree.DB(), tx.FromIdx)
 	if tracerr.Unwrap(err) == db.ErrNotFound {
 		// 1a. if idx does not exist in exitTree:
@@ -1197,8 +1128,6 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 		exitAccount := &common.Account{
 			TokenID: acc.TokenID,
 			Nonce:   common.Nonce(0),
-			// as is a common.Tx, the Amount is already an
-			// EffectiveAmount
 			Balance: tx.Amount,
 			BJJ:     acc.BJJ,
 			EthAddr: acc.EthAddr,
@@ -1212,8 +1141,6 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 				tp.zki.Sign2[tp.i] = big.NewInt(1)
 			}
 			tp.zki.Ay2[tp.i] = accBJJY
-			// as is a common.Tx, the Amount is already an
-			// EffectiveAmount
 			tp.zki.Balance2[tp.i] = tx.Amount
 			tp.zki.EthAddr2[tp.i] = common.EthAddrToBigInt(acc.EthAddr)
 			// as Leaf didn't exist in the ExitTree, set NewExit[i]=1

txprocessor/txprocessor_test.go

@@ -1,10 +1,11 @@
 package txprocessor
 
 import (
+	"encoding/binary"
+	"encoding/hex"
 	"io/ioutil"
 	"math/big"
 	"os"
-	"sort"
 	"testing"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
@@ -35,8 +36,7 @@ func TestComputeEffectiveAmounts(t *testing.T) {
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeSynchronizer, 32)
-		Type: statedb.TypeSynchronizer, NLevels: 32})
 	assert.NoError(t, err)
 
 	set := `
@@ -212,8 +212,7 @@ func TestProcessTxsBalances(t *testing.T) {
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeSynchronizer, 32)
-		Type: statedb.TypeSynchronizer, NLevels: 32})
 	assert.NoError(t, err)
 
 	chainID := uint16(0)
@@ -359,8 +358,7 @@ func TestProcessTxsSynchronizer(t *testing.T) {
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeSynchronizer, 32)
-		Type: statedb.TypeSynchronizer, NLevels: 32})
 	assert.NoError(t, err)
 
 	chainID := uint16(0)
@@ -491,8 +489,7 @@ func TestProcessTxsBatchBuilder(t *testing.T) {
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeBatchBuilder, 32)
-		Type: statedb.TypeBatchBuilder, NLevels: 32})
 	assert.NoError(t, err)
 
 	chainID := uint16(0)
@@ -583,8 +580,7 @@ func TestProcessTxsRootTestVectors(t *testing.T) {
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeBatchBuilder, 32)
-		Type: statedb.TypeBatchBuilder, NLevels: 32})
 	assert.NoError(t, err)
 
 	// same values than in the js test
@@ -635,22 +631,22 @@ func TestCreateAccountDepositMaxValue(t *testing.T) {
 	defer assert.NoError(t, os.RemoveAll(dir))
 
 	nLevels := 16
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeBatchBuilder, nLevels)
-		Type: statedb.TypeBatchBuilder, NLevels: nLevels})
 	assert.NoError(t, err)
 
 	users := txsets.GenerateJsUsers(t)
 
-	daMaxF40 := common.Float40(0xFFFFFFFFFF)
+	daMaxHex, err := hex.DecodeString("FFFF")
-	daMaxBI, err := daMaxF40.BigInt()
 	require.NoError(t, err)
-	assert.Equal(t, "343597383670000000000000000000000000000000", daMaxBI.String())
+	daMaxF16 := common.Float16(binary.BigEndian.Uint16(daMaxHex))
+	daMaxBI := daMaxF16.BigInt()
+	assert.Equal(t, "10235000000000000000000000000000000", daMaxBI.String())
 
-	daMax1F40 := common.Float40(0xFFFFFFFFFE)
+	daMax1Hex, err := hex.DecodeString("FFFE")
 	require.NoError(t, err)
-	daMax1BI, err := daMax1F40.BigInt()
+	daMax1F16 := common.Float16(binary.BigEndian.Uint16(daMax1Hex))
-	require.NoError(t, err)
+	daMax1BI := daMax1F16.BigInt()
-	assert.Equal(t, "343597383660000000000000000000000000000000", daMax1BI.String())
+	assert.Equal(t, "10225000000000000000000000000000000", daMax1BI.String())
 
 	l1Txs := []common.L1Tx{
 		{
@@ -704,8 +700,7 @@ func initTestMultipleCoordIdxForTokenID(t *testing.T) (*TxProcessor, *til.Contex
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeBatchBuilder, 32)
-		Type: statedb.TypeBatchBuilder, NLevels: 32})
 	assert.NoError(t, err)
 
 	chainID := uint16(1)
@@ -803,8 +798,7 @@ func TestTwoExits(t *testing.T) {
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
 
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	sdb, err := statedb.NewStateDB(dir, 128, statedb.TypeSynchronizer, 32)
-		Type: statedb.TypeSynchronizer, NLevels: 32})
 	assert.NoError(t, err)
 
 	chainID := uint16(1)
@@ -871,8 +865,7 @@ func TestTwoExits(t *testing.T) {
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir2))
 
-	sdb2, err := statedb.NewStateDB(statedb.Config{Path: dir2, Keep: 128,
+	sdb2, err := statedb.NewStateDB(dir2, 128, statedb.TypeSynchronizer, 32)
-		Type: statedb.TypeSynchronizer, NLevels: 32})
 	assert.NoError(t, err)
 
 	tc = til.NewContext(chainID, common.RollupConstMaxL1UserTx)
@@ -912,198 +905,3 @@ func TestTwoExits(t *testing.T) {
 
 	assert.Equal(t, ptOuts[3].ExitInfos[0].MerkleProof, ptOuts2[3].ExitInfos[0].MerkleProof)
 }
-
-func TestExitOf0Amount(t *testing.T) {
-	// Test to check that when doing an Exit with amount 0 the Exit Root
-	// does not change (as there is no new Exit Leaf created)
-
-	dir, err := ioutil.TempDir("", "tmpdb")
-	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir))
-
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
-		Type: statedb.TypeBatchBuilder, NLevels: 32})
-	assert.NoError(t, err)
-
-	chainID := uint16(1)
-
-	tc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
-
-	set := `
-		Type: Blockchain
-
-		CreateAccountDeposit(0) A: 100
-		CreateAccountDeposit(0) B: 100
-
-		> batchL1 // batch1: freeze L1User{2}
-		> batchL1 // batch2: forge L1User{2}
-
-		ForceExit(0) A: 10
-		ForceExit(0) B: 0
-
-		> batchL1 // batch3: freeze L1User{2}
-		> batchL1 // batch4: forge L1User{2}
-
-		ForceExit(0) A: 10
-
-		> batchL1 // batch5: freeze L1User{1}
-		> batchL1 // batch6: forge L1User{1}
-
-		ForceExit(0) A: 0
-		> batchL1 // batch7: freeze L1User{1}
-		> batchL1 // batch8: forge L1User{1}
-		> block
-	`
-	blocks, err := tc.GenerateBlocks(set)
-	require.NoError(t, err)
-	err = tc.FillBlocksExtra(blocks, &til.ConfigExtra{})
-	require.NoError(t, err)
-	err = tc.FillBlocksForgedL1UserTxs(blocks)
-	require.NoError(t, err)
-
-	// Sanity check
-	require.Equal(t, 2, len(blocks[0].Rollup.Batches[1].L1UserTxs))
-	require.Equal(t, 2, len(blocks[0].Rollup.Batches[3].L1UserTxs))
-	require.Equal(t, big.NewInt(10), blocks[0].Rollup.Batches[3].L1UserTxs[0].Amount)
-	require.Equal(t, big.NewInt(0), blocks[0].Rollup.Batches[3].L1UserTxs[1].Amount)
-
-	config := Config{
-		NLevels:  32,
-		MaxFeeTx: 64,
-		MaxTx:    512,
-		MaxL1Tx:  16,
-		ChainID:  chainID,
-	}
-	tp := NewTxProcessor(sdb, config)
-
-	// For this test are only processed the batches with transactions:
-	// - Batch2, equivalent to Batches[1]
-	// - Batch4, equivalent to Batches[3]
-	// - Batch6, equivalent to Batches[5]
-	// - Batch8, equivalent to Batches[7]
-
-	// process Batch2:
-	_, err = tp.ProcessTxs(nil, blocks[0].Rollup.Batches[1].L1UserTxs, nil, nil)
-	require.NoError(t, err)
-	// process Batch4:
-	ptOut, err := tp.ProcessTxs(nil, blocks[0].Rollup.Batches[3].L1UserTxs, nil, nil)
-	require.NoError(t, err)
-	assert.Equal(t, "14329759303391468223438874789317921522067594445474390443816827472846339238908", ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String())
-	exitRootBatch4 := ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String()
-
-	// process Batch6:
-	ptOut, err = tp.ProcessTxs(nil, blocks[0].Rollup.Batches[5].L1UserTxs, nil, nil)
-	require.NoError(t, err)
-	assert.Equal(t, "14329759303391468223438874789317921522067594445474390443816827472846339238908", ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String())
-	// Expect that the ExitRoot for the Batch6 will be equal than for the
-	// Batch4, as the Batch4 & Batch6 have the same tx with Exit Amount=10,
-	// and Batch4 has a 2nd tx with Exit Amount=0.
-	assert.Equal(t, exitRootBatch4, ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String())
-
-	// For the Batch8, as there is only 1 exit with Amount=0, the ExitRoot
-	// should be 0.
-	// process Batch8:
-	ptOut, err = tp.ProcessTxs(nil, blocks[0].Rollup.Batches[7].L1UserTxs, nil, nil)
-	require.NoError(t, err)
-	assert.Equal(t, "0", ptOut.ZKInputs.Metadata.NewExitRootRaw.BigInt().String())
-}
-
-func TestUpdatedAccounts(t *testing.T) {
-	dir, err := ioutil.TempDir("", "tmpdb")
-	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir))
-
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
-		Type: statedb.TypeSynchronizer, NLevels: 32})
-	assert.NoError(t, err)
-
-	set := `
-		Type: Blockchain
-		AddToken(1)
-		CreateAccountCoordinator(0) Coord // 256
-		CreateAccountCoordinator(1) Coord // 257
-		> batch // 1
-		CreateAccountDeposit(0) A: 50 // 258
-		CreateAccountDeposit(0) B: 60 // 259
-		CreateAccountDeposit(1) A: 70 // 260
-		CreateAccountDeposit(1) B: 80 // 261
-		> batchL1 // 2
-		> batchL1 // 3
-		Transfer(0) A-B: 5 (126)
-		> batch // 4
-		Exit(1) B: 5 (126)
-		> batch // 5
-		> block
-	`
-
-	chainID := uint16(0)
-	tc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
-	blocks, err := tc.GenerateBlocks(set)
-	require.NoError(t, err)
-	tilCfgExtra := til.ConfigExtra{
-		BootCoordAddr: ethCommon.HexToAddress("0xE39fEc6224708f0772D2A74fd3f9055A90E0A9f2"),
-		CoordUser:     "Coord",
-	}
-	err = tc.FillBlocksExtra(blocks, &tilCfgExtra)
-	require.NoError(t, err)
-	tc.FillBlocksL1UserTxsBatchNum(blocks)
-	err = tc.FillBlocksForgedL1UserTxs(blocks)
-	require.NoError(t, err)
-
-	require.Equal(t, 5, len(blocks[0].Rollup.Batches))
-
-	config := Config{
-		NLevels:  32,
-		MaxFeeTx: 64,
-		MaxTx:    512,
-		MaxL1Tx:  16,
-		ChainID:  chainID,
-	}
-	tp := NewTxProcessor(sdb, config)
-
-	sortedKeys := func(m map[common.Idx]*common.Account) []int {
-		keys := make([]int, 0)
-		for k := range m {
-			keys = append(keys, int(k))
-		}
-		sort.Ints(keys)
-		return keys
-	}
-
-	for _, batch := range blocks[0].Rollup.Batches {
-		l2Txs := common.L2TxsToPoolL2Txs(batch.L2Txs)
-		ptOut, err := tp.ProcessTxs(batch.Batch.FeeIdxsCoordinator, batch.L1UserTxs,
-			batch.L1CoordinatorTxs, l2Txs)
-		require.NoError(t, err)
-		switch batch.Batch.BatchNum {
-		case 1:
-			assert.Equal(t, 2, len(ptOut.UpdatedAccounts))
-			assert.Equal(t, []int{256, 257}, sortedKeys(ptOut.UpdatedAccounts))
-		case 2:
-			assert.Equal(t, 0, len(ptOut.UpdatedAccounts))
-			assert.Equal(t, []int{}, sortedKeys(ptOut.UpdatedAccounts))
-		case 3:
-			assert.Equal(t, 4, len(ptOut.UpdatedAccounts))
-			assert.Equal(t, []int{258, 259, 260, 261}, sortedKeys(ptOut.UpdatedAccounts))
-		case 4:
-			assert.Equal(t, 2+1, len(ptOut.UpdatedAccounts))
-			assert.Equal(t, []int{256, 258, 259}, sortedKeys(ptOut.UpdatedAccounts))
-		case 5:
-			assert.Equal(t, 1+1, len(ptOut.UpdatedAccounts))
-			assert.Equal(t, []int{257, 261}, sortedKeys(ptOut.UpdatedAccounts))
-		}
-		for idx, updAcc := range ptOut.UpdatedAccounts {
-			acc, err := sdb.GetAccount(idx)
-			require.NoError(t, err)
-			// If acc.Balance is 0, set it to 0 with big.NewInt so
-			// that the comparison succeeds.  Without this, the
-			// comparison will not succeed because acc.Balance is
-			// set from a slice, and thus the internal big.Int
-			// buffer is not nil (big.Int.abs)
-			if acc.Balance.BitLen() == 0 {
-				acc.Balance = big.NewInt(0)
-			}
-			assert.Equal(t, acc, updAcc)
-		}
-	}
-}

txselector/metrics.go

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

txselector/txselector.go

@@ -3,13 +3,13 @@ package txselector
 // current: very simple version of TxSelector
 
 import (
+	"bytes"
 	"fmt"
 	"math/big"
 	"sort"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/hermeznetwork/hermez-node/common"
-	"github.com/hermeznetwork/hermez-node/db/kvdb"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
 	"github.com/hermeznetwork/hermez-node/db/statedb"
 	"github.com/hermeznetwork/hermez-node/log"
@@ -18,6 +18,19 @@ import (
 	"github.com/iden3/go-iden3-crypto/babyjub"
 )
 
+// txs implements the interface Sort for an array of Tx
+type txs []common.PoolL2Tx
+
+func (t txs) Len() int {
+	return len(t)
+}
+func (t txs) Swap(i, j int) {
+	t[i], t[j] = t[j], t[i]
+}
+func (t txs) Less(i, j int) bool {
+	return t[i].AbsoluteFee > t[j].AbsoluteFee
+}
+
 // CoordAccount contains the data of the Coordinator account, that will be used
 // to create new transactions of CreateAccountDeposit type to add new TokenID
 // accounts for the Coordinator to receive the fees.
@@ -49,14 +62,8 @@ type TxSelector struct {
 // NewTxSelector returns a *TxSelector
 func NewTxSelector(coordAccount *CoordAccount, dbpath string,
 	synchronizerStateDB *statedb.StateDB, l2 *l2db.L2DB) (*TxSelector, error) {
-	localAccountsDB, err := statedb.NewLocalStateDB(
+	localAccountsDB, err := statedb.NewLocalStateDB(dbpath, 128,
-		statedb.Config{
+		synchronizerStateDB, statedb.TypeTxSelector, 0) // without merkletree
-			Path:    dbpath,
-			Keep:    kvdb.DefaultKeep,
-			Type:    statedb.TypeTxSelector,
-			NLevels: 0,
-		},
-		synchronizerStateDB) // without merkletree
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
@@ -75,8 +82,12 @@ func (txsel *TxSelector) LocalAccountsDB() *statedb.LocalStateDB {
 
 // Reset tells the TxSelector to get it's internal AccountsDB
 // from the required `batchNum`
-func (txsel *TxSelector) Reset(batchNum common.BatchNum, fromSynchronizer bool) error {
+func (txsel *TxSelector) Reset(batchNum common.BatchNum) error {
-	return tracerr.Wrap(txsel.localAccountsDB.Reset(batchNum, fromSynchronizer))
+	err := txsel.localAccountsDB.Reset(batchNum, true)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	return nil
 }
 
 func (txsel *TxSelector) getCoordIdx(tokenID common.TokenID) (common.Idx, error) {
@@ -133,11 +144,9 @@ func (txsel *TxSelector) coordAccountForTokenID(l1CoordinatorTxs []common.L1Tx,
 // included in the next batch.
 func (txsel *TxSelector) GetL2TxSelection(selectionConfig *SelectionConfig) ([]common.Idx,
 	[][]byte, []common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
-	metricGetL2TxSelection.Inc()
+	coordIdxs, accCreationAuths, _, l1CoordinatorTxs, l2Txs, discardedL2Txs, err :=
-	coordIdxs, accCreationAuths, _, l1CoordinatorTxs, l2Txs,
+		txsel.GetL1L2TxSelection(selectionConfig, []common.L1Tx{})
-		discardedL2Txs, err := txsel.getL1L2TxSelection(selectionConfig, []common.L1Tx{})
+	return coordIdxs, accCreationAuths, l1CoordinatorTxs, l2Txs, discardedL2Txs, tracerr.Wrap(err)
-	return coordIdxs, accCreationAuths, l1CoordinatorTxs, l2Txs,
-		discardedL2Txs, tracerr.Wrap(err)
 }
 
 // GetL1L2TxSelection returns the selection of L1 + L2 txs.
@@ -149,16 +158,6 @@ func (txsel *TxSelector) GetL2TxSelection(selectionConfig *SelectionConfig) ([]c
 // creation exists. The L1UserTxs, L1CoordinatorTxs, PoolL2Txs that will be
 // included in the next batch.
 func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
-	l1UserTxs []common.L1Tx) ([]common.Idx, [][]byte, []common.L1Tx,
-	[]common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
-	metricGetL1L2TxSelection.Inc()
-	coordIdxs, accCreationAuths, l1UserTxs, l1CoordinatorTxs, l2Txs,
-		discardedL2Txs, err := txsel.getL1L2TxSelection(selectionConfig, l1UserTxs)
-	return coordIdxs, accCreationAuths, l1UserTxs, l1CoordinatorTxs, l2Txs,
-		discardedL2Txs, tracerr.Wrap(err)
-}
-
-func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 	l1UserTxs []common.L1Tx) ([]common.Idx, [][]byte, []common.L1Tx,
 	[]common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
 	// WIP.0: the TxSelector is not optimized and will need a redesign. The
@@ -189,16 +188,14 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 	}
 
 	// discardedL2Txs contains an array of the L2Txs that have not been selected in this Batch
+	var discardedL2Txs []common.PoolL2Tx
 
 	var l1CoordinatorTxs []common.L1Tx
 	positionL1 := len(l1UserTxs)
 	var accAuths [][]byte
 
 	// sort l2TxsRaw (cropping at MaxTx at this point)
-	l2Txs0, discardedL2Txs := txsel.getL2Profitable(l2TxsRaw, selectionConfig.TxProcessorConfig.MaxTx)
+	l2Txs0 := txsel.getL2Profitable(l2TxsRaw, selectionConfig.TxProcessorConfig.MaxTx)
-	for i := range discardedL2Txs {
-		discardedL2Txs[i].Info = "Tx not selected due to low absolute fee"
-	}
 
 	noncesMap := make(map[common.Idx]common.Nonce)
 	var l2Txs []common.PoolL2Tx
@@ -232,8 +229,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 			if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1UserTxs)-len(l1UserTxs) {
 				// discard L2Tx, and update Info parameter of
 				// the tx, and add it to the discardedTxs array
-				l2Txs0[i].Info = "Tx not selected because the L2Tx depends on a " +
+				l2Txs0[i].Info = "Tx not selected due the L2Tx depends on a L1CoordinatorTx and there is not enough space for L1Coordinator"
-					"L1CoordinatorTx and there is not enough space for L1Coordinator"
 				discardedL2Txs = append(discardedL2Txs, l2Txs0[i])
 				continue
 			}
@@ -258,9 +254,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 			// not valid Amount with current Balance. Discard L2Tx,
 			// and update Info parameter of the tx, and add it to
 			// the discardedTxs array
-			l2Txs[i].Info = fmt.Sprintf("Tx not selected due to not enough Balance at the sender. "+
+			l2Txs[i].Info = fmt.Sprintf("Tx not selected due not enough Balance at the sender. Current sender account Balance: %s, Amount+Fee: %s", balance.String(), feeAndAmount.String())
-				"Current sender account Balance: %s, Amount+Fee: %s",
-				balance.String(), feeAndAmount.String())
 			discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 			continue
 		}
@@ -272,8 +266,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 			// not valid Nonce at tx. Discard L2Tx, and update Info
 			// parameter of the tx, and add it to the discardedTxs
 			// array
-			l2Txs[i].Info = fmt.Sprintf("Tx not selected due to not current Nonce. "+
+			l2Txs[i].Info = fmt.Sprintf("Tx not selected due not current Nonce. Tx.Nonce: %d, Account.Nonce: %d", l2Txs[i].Nonce, nonce)
-				"Tx.Nonce: %d, Account.Nonce: %d", l2Txs[i].Nonce, nonce)
 			discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 			continue
 		}
@@ -291,30 +284,17 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 				txsel.processTxToEthAddrBJJ(validTxs, selectionConfig,
 					len(l1UserTxs), l1CoordinatorTxs, positionL1, l2Txs[i])
 			if err != nil {
-				log.Debugw("txsel.processTxToEthAddrBJJ", "err", err)
+				log.Debug(err)
 				// Discard L2Tx, and update Info parameter of
 				// the tx, and add it to the discardedTxs array
-				l2Txs[i].Info = fmt.Sprintf("Tx not selected (in processTxToEthAddrBJJ) due to %s",
+				l2Txs[i].Info = fmt.Sprintf("Tx not selected (in processTxToEthAddrBJJ) due %s", err.Error())
-					err.Error())
 				discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 				continue
 			}
-			if l1CoordinatorTx != nil {
+			if accAuth != nil && l1CoordinatorTx != nil {
-				// If ToEthAddr == 0xff.. this means that we
+				accAuths = append(accAuths, accAuth.Signature)
-				// are handling a TransferToBJJ, which doesn't
+				l1CoordinatorTxs = append(l1CoordinatorTxs, *l1CoordinatorTx)
-				// require an authorization because it doesn't
+				positionL1++
-				// contain a valid ethereum address.
-				// Otherwise only create the account if we have
-				// the corresponding authorization
-				if validL2Tx.ToEthAddr == common.FFAddr {
-					accAuths = append(accAuths, common.EmptyEthSignature)
-					l1CoordinatorTxs = append(l1CoordinatorTxs, *l1CoordinatorTx)
-					positionL1++
-				} else if accAuth != nil {
-					accAuths = append(accAuths, accAuth.Signature)
-					l1CoordinatorTxs = append(l1CoordinatorTxs, *l1CoordinatorTx)
-					positionL1++
-				}
 			}
 			if validL2Tx != nil {
 				validTxs = append(validTxs, *validL2Tx)
@@ -327,8 +307,8 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 					"ToIdx", l2Txs[i].ToIdx)
 				// Discard L2Tx, and update Info parameter of
 				// the tx, and add it to the discardedTxs array
-				l2Txs[i].Info = fmt.Sprintf("Tx not selected due to tx.ToIdx not found in StateDB. "+
+				l2Txs[i].Info = fmt.Sprintf("Tx not selected due tx.ToIdx not found in StateDB. ToIdx: %d",
-					"ToIdx: %d", l2Txs[i].ToIdx)
+					l2Txs[i].ToIdx)
 				discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 				continue
 			}
@@ -340,9 +320,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 					// Discard L2Tx, and update Info
 					// parameter of the tx, and add it to
 					// the discardedTxs array
-					l2Txs[i].Info = fmt.Sprintf("Tx not selected because ToEthAddr "+
+					l2Txs[i].Info = fmt.Sprintf("Tx not selected due ToEthAddr does not correspond to the Account.EthAddr. tx.ToIdx: %d, tx.ToEthAddr: %s, account.EthAddr: %s",
-						"does not correspond to the Account.EthAddr. "+
-						"tx.ToIdx: %d, tx.ToEthAddr: %s, account.EthAddr: %s",
 						l2Txs[i].ToIdx, l2Txs[i].ToEthAddr, receiverAcc.EthAddr)
 					discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 					continue
@@ -356,9 +334,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 					// Discard L2Tx, and update Info
 					// parameter of the tx, and add it to
 					// the discardedTxs array
-					l2Txs[i].Info = fmt.Sprintf("Tx not selected because tx.ToBJJ "+
+					l2Txs[i].Info = fmt.Sprintf("Tx not selected due tx.ToBJJ does not correspond to the Account.BJJ. tx.ToIdx: %d, tx.ToEthAddr: %s, tx.ToBJJ: %s, account.BJJ: %s",
-						"does not correspond to the Account.BJJ. "+
-						"tx.ToIdx: %d, tx.ToEthAddr: %s, tx.ToBJJ: %s, account.BJJ: %s",
 						l2Txs[i].ToIdx, l2Txs[i].ToEthAddr, l2Txs[i].ToBJJ, receiverAcc.BJJ)
 					discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 					continue
@@ -432,7 +408,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 			log.Error(err)
 			// Discard L2Tx, and update Info parameter of the tx,
 			// and add it to the discardedTxs array
-			selectedL2Txs[i].Info = fmt.Sprintf("Tx not selected (in ProcessL2Tx) due to %s", err.Error())
+			selectedL2Txs[i].Info = fmt.Sprintf("Tx not selected (in ProcessL2Tx) due %s", err.Error())
 			discardedL2Txs = append(discardedL2Txs, selectedL2Txs[i])
 			continue
 		}
@@ -464,11 +440,6 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig *SelectionConfig,
 		return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
 	}
 
-	metricSelectedL1CoordinatorTxs.Set(float64(len(l1CoordinatorTxs)))
-	metricSelectedL1UserTxs.Set(float64(len(l1UserTxs)))
-	metricSelectedL2Txs.Set(float64(len(finalL2Txs)))
-	metricDiscardedL2Txs.Set(float64(len(discardedL2Txs)))
-
 	return coordIdxs, accAuths, l1UserTxs, l1CoordinatorTxs, finalL2Txs, discardedL2Txs, nil
 }
 
@@ -493,7 +464,8 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 
 	var l1CoordinatorTx *common.L1Tx
 	var accAuth *common.AccountCreationAuth
-	if l2Tx.ToEthAddr != common.EmptyAddr && l2Tx.ToEthAddr != common.FFAddr {
+	if !bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.EmptyAddr.Bytes()) &&
+		!bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.FFAddr.Bytes()) {
 		// case: ToEthAddr != 0x00 neither 0xff
 		if l2Tx.ToBJJ != common.EmptyBJJComp {
 			// case: ToBJJ!=0:
@@ -549,7 +521,8 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 			DepositAmount: big.NewInt(0),
 			Type:          common.TxTypeCreateAccountDeposit,
 		}
-	} else if l2Tx.ToEthAddr == common.FFAddr && l2Tx.ToBJJ != common.EmptyBJJComp {
+	} else if bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.FFAddr.Bytes()) &&
+		l2Tx.ToBJJ != common.EmptyBJJComp {
 		// if idx exist for EthAddr&BJJ use it
 		_, err := txsel.localAccountsDB.GetIdxByEthAddrBJJ(l2Tx.ToEthAddr, l2Tx.ToBJJ,
 			l2Tx.TokenID)
@@ -575,8 +548,7 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 	}
 	if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1UserTxs)-nL1UserTxs {
 		// L2Tx discarded
-		return nil, nil, nil, tracerr.Wrap(fmt.Errorf("L2Tx discarded due to no available slots " +
+		return nil, nil, nil, tracerr.Wrap(fmt.Errorf("L2Tx discarded due not slots for L1CoordinatorTx to create a new account for receiver of L2Tx"))
-			"for L1CoordinatorTx to create a new account for receiver of L2Tx"))
 	}
 
 	return &l2Tx, l1CoordinatorTx, accAuth, nil
@@ -585,7 +557,7 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 func checkAlreadyPendingToCreate(l1CoordinatorTxs []common.L1Tx, tokenID common.TokenID,
 	addr ethCommon.Address, bjj babyjub.PublicKeyComp) bool {
 	for i := 0; i < len(l1CoordinatorTxs); i++ {
-		if l1CoordinatorTxs[i].FromEthAddr == addr &&
+		if bytes.Equal(l1CoordinatorTxs[i].FromEthAddr.Bytes(), addr.Bytes()) &&
 			l1CoordinatorTxs[i].TokenID == tokenID &&
 			l1CoordinatorTxs[i].FromBJJ == bjj {
 			return true
@@ -595,33 +567,21 @@ func checkAlreadyPendingToCreate(l1CoordinatorTxs []common.L1Tx, tokenID common.
 }
 
 // getL2Profitable returns the profitable selection of L2Txssorted by Nonce
-func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) ([]common.PoolL2Tx,
+func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) []common.PoolL2Tx {
-	[]common.PoolL2Tx) {
+	sort.Sort(txs(l2Txs))
-	// First sort by nonce so that txs from the same account are sorted so
+	if len(l2Txs) < int(max) {
-	// that they could be applied in succession.
+		return l2Txs
-	sort.Slice(l2Txs, func(i, j int) bool {
-		return l2Txs[i].Nonce < l2Txs[j].Nonce
-	})
-	// Sort by absolute fee with SliceStable, so that txs with same
-	// AbsoluteFee are not rearranged and nonce order is kept in such case
-	sort.SliceStable(l2Txs, func(i, j int) bool {
-		return l2Txs[i].AbsoluteFee > l2Txs[j].AbsoluteFee
-	})
-
-	discardedL2Txs := []common.PoolL2Tx{}
-	if len(l2Txs) > int(max) {
-		discardedL2Txs = l2Txs[max:]
-		l2Txs = l2Txs[:max]
 	}
+	l2Txs = l2Txs[:max]
 
 	// sort l2Txs by Nonce. This can be done in many different ways, what
 	// is needed is to output the l2Txs where the Nonce of l2Txs for each
 	// Account is sorted, but the l2Txs can not be grouped by sender Account
 	// neither by Fee. This is because later on the Nonces will need to be
 	// sequential for the zkproof generation.
-	sort.Slice(l2Txs, func(i, j int) bool {
+	sort.SliceStable(l2Txs, func(i, j int) bool {
 		return l2Txs[i].Nonce < l2Txs[j].Nonce
 	})
 
-	return l2Txs, discardedL2Txs
+	return l2Txs
 }

txselector/txselector_test.go

@@ -29,13 +29,12 @@ func initTest(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
 	defer assert.NoError(t, os.RemoveAll(dir))
-	syncStateDB, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+	syncStateDB, err := statedb.NewStateDB(dir, 128, statedb.TypeTxSelector, 0)
-		Type: statedb.TypeTxSelector, NLevels: 0})
 	require.NoError(t, err)
 
 	txselDir, err := ioutil.TempDir("", "tmpTxSelDB")
@@ -48,7 +47,7 @@ func initTest(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address
 		BJJ:                 coordUser.BJJ.Public().Compress(),
 		AccountCreationAuth: nil,
 	}
-	// fmt.Printf("%v\n", coordAccount)
+	fmt.Printf("%v", coordAccount)
 	auth := common.AccountCreationAuth{
 		EthAddr: coordUser.Addr,
 		BJJ:     coordUser.BJJ.Public().Compress(),
@@ -106,7 +105,7 @@ func addTokens(t *testing.T, tc *til.Context, db *sqlx.DB) {
 		})
 	}
 
-	hdb := historydb.NewHistoryDB(db, db, nil)
+	hdb := historydb.NewHistoryDB(db, nil)
 	assert.NoError(t, hdb.AddBlock(&common.Block{
 		Num: 1,
 	}))
@@ -424,9 +423,9 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
 	require.NoError(t, err)
 
-	expectedTxID0 := "0x028847b86613c0b70be18c8622119ed045b42e4e47d7938fa90bb3d1dc14928965" // 1st TransferToEthAddr
+	expectedTxID0 := "0x0248bae02b5c8c3847d312bfac3a33ae790616e888f2f711f22aeaff007cde92c2" // 1st TransferToEthAddr
-	expectedTxID1 := "0x0200b18773dcf56f770d65870fb02041cb59a088fd35b7c3f3df69f8a250b99a42" // 1st Exit
+	expectedTxID1 := "0x0249af018311a393c337ab9174ca2466cba489e49942b4ca4e5c530903671c4aef" // 1st Exit
-	expectedTxID2 := "0x029720ff506153f970f120ac638cd7ee759eeff2c2012e7634a78e4fdc05c04a90" // 2nd TransferToEthAddr
+	expectedTxID2 := "0x0228b93a261a0cdc62f35588c03bd179d31a0807c28afffdb6a7aaf0c4f017e4cf" // 2nd TransferToEthAddr
 
 	// batch2
 	// prepare the PoolL2Txs
@@ -497,215 +496,3 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
 	require.NoError(t, err)
 }
-
-func TestTransferToBjj(t *testing.T) {
-	set := `
-		Type: Blockchain
-		AddToken(1)
-
-		CreateAccountDeposit(0) Coord: 0
-		CreateAccountDeposit(0) A: 1000
-		CreateAccountDeposit(0) B: 1000
-		CreateAccountDeposit(1) B: 1000
-
-		> batchL1 // freeze L1User{1}
-		> batchL1 // forge L1User{1}
-		> block
-	`
-
-	chainID := uint16(0)
-	tc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
-	blocks, err := tc.GenerateBlocks(set)
-	assert.NoError(t, err)
-
-	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	txsel := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
-
-	// restart nonces of TilContext, as will be set by generating directly
-	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
-	tc.RestartNonces()
-
-	addTokens(t, tc, txsel.l2db.DB())
-
-	tpc := txprocessor.Config{
-		NLevels:  16,
-		MaxFeeTx: 10,
-		MaxTx:    20,
-		MaxL1Tx:  10,
-		ChainID:  chainID,
-	}
-	selectionConfig := &SelectionConfig{
-		MaxL1UserTxs:      5,
-		TxProcessorConfig: tpc,
-	}
-	// batch1 to freeze L1UserTxs that will create some accounts with
-	// positive balance
-	l1UserTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-
-	// Transfer is ToBJJ to a BJJ-only account that doesn't exist
-	// and the coordinator will create it via L1CoordTx.
-
-	batchPoolL2 := `
-	Type: PoolL2
-	PoolTransferToBJJ(0) A-B: 50 (126)
-	`
-	poolL2Txs, err := tc.GeneratePoolL2Txs(batchPoolL2)
-	require.NoError(t, err)
-
-	// add the PoolL2Txs to the l2DB
-	addL2Txs(t, txsel, poolL2Txs)
-
-	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[1].Batch.ForgeL1TxsNum])
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err := txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-	assert.Equal(t, 4, len(oL1UserTxs))
-	// We expect the coordinator to add an L1CoordTx to create an account for the recipient of the l2tx
-	require.Equal(t, 1, len(oL1CoordTxs))
-	assert.Equal(t, poolL2Txs[0].ToEthAddr, oL1CoordTxs[0].FromEthAddr)
-	assert.Equal(t, poolL2Txs[0].ToBJJ, oL1CoordTxs[0].FromBJJ)
-	// fmt.Printf("DBG l1CoordTx[0]: %+v\n", oL1CoordTxs[0])
-	assert.Equal(t, 1, len(oL2Txs))
-	assert.Equal(t, 0, len(discardedL2Txs))
-	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
-	require.NoError(t, err)
-
-	// Now the BJJ-only account for B is already created, so the transfer
-	// happens without an L1CoordTx that creates the user account.
-
-	batchPoolL2 = `
-	Type: PoolL2
-	PoolTransferToBJJ(0) A-B: 50 (126)
-	`
-
-	poolL2Txs, err = tc.GeneratePoolL2Txs(batchPoolL2)
-	require.NoError(t, err)
-	addL2Txs(t, txsel, poolL2Txs)
-
-	l1UserTxs = []common.L1Tx{}
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err = txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(oL1UserTxs))
-	// Since the BJJ-only account B already exists, the coordinator doesn't add any L1CoordTxs
-	assert.Equal(t, 0, len(oL1CoordTxs))
-	assert.Equal(t, 1, len(oL2Txs))
-	assert.Equal(t, 0, len(discardedL2Txs))
-	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
-	require.NoError(t, err)
-
-	// The transfer now is ToBJJ to a BJJ-only account that doesn't exist
-	// and the coordinator will create it via L1CoordTx.   Since it's a
-	// transfer of a token for which the coordinator doesn't have a fee
-	// account, another L1CoordTx will be created for the coordinator to
-	// receive the fees.
-
-	batchPoolL2 = `
-	Type: PoolL2
-	PoolTransferToBJJ(1) B-A: 50 (126)
-	`
-
-	poolL2Txs, err = tc.GeneratePoolL2Txs(batchPoolL2)
-	require.NoError(t, err)
-	addL2Txs(t, txsel, poolL2Txs)
-
-	l1UserTxs = []common.L1Tx{}
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err = txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(oL1UserTxs))
-	// We expect the coordinator to add an L1CoordTx to create an account
-	// to receive the fees by the coordinator and another one for the
-	// recipient of the l2tx
-	assert.Equal(t, 2, len(oL1CoordTxs))
-	// [0] Coordinator account cration for token 1
-	assert.Equal(t, tc.Users["Coord"].Addr, oL1CoordTxs[0].FromEthAddr)
-	// [1] User A BJJ-only account creation for token 1
-	assert.Equal(t, poolL2Txs[0].ToEthAddr, oL1CoordTxs[1].FromEthAddr)
-	assert.Equal(t, poolL2Txs[0].ToBJJ, oL1CoordTxs[1].FromBJJ)
-	assert.Equal(t, common.TokenID(1), oL1CoordTxs[1].TokenID)
-
-	assert.Equal(t, 1, len(oL2Txs))
-	assert.Equal(t, 0, len(discardedL2Txs))
-	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
-	require.NoError(t, err)
-}
-
-func TestTransferManyFromSameAccount(t *testing.T) {
-	set := `
-		Type: Blockchain
-
-		CreateAccountDeposit(0) Coord: 0
-		CreateAccountDeposit(0) A: 1000
-		CreateAccountDeposit(0) B: 1000
-
-		> batchL1 // freeze L1User{1}
-		> batchL1 // forge L1User{1}
-		> block
-	`
-
-	chainID := uint16(0)
-	tc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
-	blocks, err := tc.GenerateBlocks(set)
-	assert.NoError(t, err)
-
-	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	txsel := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
-
-	// restart nonces of TilContext, as will be set by generating directly
-	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
-	tc.RestartNonces()
-
-	tpc := txprocessor.Config{
-		NLevels:  16,
-		MaxFeeTx: 10,
-		MaxTx:    10,
-		MaxL1Tx:  10,
-		ChainID:  chainID,
-	}
-	selectionConfig := &SelectionConfig{
-		MaxL1UserTxs:      5,
-		TxProcessorConfig: tpc,
-	}
-	// batch1 to freeze L1UserTxs
-	l1UserTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-
-	// 8 transfers from the same account
-
-	batchPoolL2 := `
-	Type: PoolL2
-	PoolTransfer(0) A-B: 10 (126) // 1
-	PoolTransfer(0) A-B: 10 (126) // 2
-	PoolTransfer(0) A-B: 10 (126) // 3
-	PoolTransfer(0) A-B: 10 (126) // 4
-	PoolTransfer(0) A-B: 10 (126) // 5
-	PoolTransfer(0) A-B: 10 (126) // 6
-	PoolTransfer(0) A-B: 10 (126) // 7
-	PoolTransfer(0) A-B: 10 (126) // 8
-	PoolTransfer(0) A-B: 10 (126) // 9
-	PoolTransfer(0) A-B: 10 (126) // 10
-	PoolTransfer(0) A-B: 10 (126) // 11
-	`
-	poolL2Txs, err := tc.GeneratePoolL2Txs(batchPoolL2)
-	require.NoError(t, err)
-	require.Equal(t, 11, len(poolL2Txs))
-
-	// reorder poolL2Txs so that nonces are not sorted
-	poolL2Txs[0], poolL2Txs[7] = poolL2Txs[7], poolL2Txs[0]
-	poolL2Txs[1], poolL2Txs[10] = poolL2Txs[10], poolL2Txs[1]
-
-	// add the PoolL2Txs to the l2DB
-	addL2Txs(t, txsel, poolL2Txs)
-	// batch 2 to crate some accounts with positive balance, and do 8 L2Tx transfers from account A
-	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[1].Batch.ForgeL1TxsNum])
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err := txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-	assert.Equal(t, 3, len(oL1UserTxs))
-	require.Equal(t, 0, len(oL1CoordTxs))
-	assert.Equal(t, 7, len(oL2Txs))
-	assert.Equal(t, 1, len(discardedL2Txs))
-
-	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
-	require.NoError(t, err)
-}