Extend L1Tx TxID tests for js checks

fix possible runtime error

README.md

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

api/account.go

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

api/accountcreationauths.go

@@ -26,7 +26,7 @@ func (a *API) postAccountCreationAuth(c *gin.Context) {
 		return
 	}
 	// Insert to DB
-	if err := a.l2.AddAccountCreationAuth(commonAuth); err != nil {
+	if err := a.l2.AddAccountCreationAuthAPI(commonAuth); err != nil {
 		retSQLErr(err, c)
 		return
 	}

api/api.go

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

api/api_test.go

@@ -11,6 +11,7 @@ import (
 	"net/http"
 	"os"
 	"strconv"
+	"sync"
 	"testing"
 	"time"
 
@@ -21,12 +22,12 @@ 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"
 	"github.com/hermeznetwork/hermez-node/test/txsets"
 	"github.com/hermeznetwork/tracerr"
+	"github.com/stretchr/testify/require"
 )
 
 // Pendinger is an interface that allows getting last returned item ID and PendingItems to be used for building fromItem
@@ -199,7 +200,8 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
-	hdb := historydb.NewHistoryDB(database)
+	apiConnCon := db.NewAPICnnectionController(1, time.Second)
+	hdb := historydb.NewHistoryDB(database, apiConnCon)
 	if err != nil {
 		panic(err)
 	}
@@ -213,12 +215,8 @@ func TestMain(m *testing.M) {
 			panic(err)
 		}
 	}()
-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128, Type: statedb.TypeTxSelector, NLevels: 0})
-	if err != nil {
-		panic(err)
-	}
 	// L2DB
-	l2DB := l2db.NewL2DB(database, 10, 1000, 24*time.Hour)
+	l2DB := l2db.NewL2DB(database, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB()) // this will clean HistoryDB and L2DB
 	// Config (smart contract constants)
 	chainID := uint16(0)
@@ -236,7 +234,6 @@ func TestMain(m *testing.M) {
 		true,
 		apiGin,
 		hdb,
-		sdb,
 		l2DB,
 		&_config,
 	)
@@ -347,19 +344,6 @@ func TestMain(m *testing.M) {
 		}
 	}
 
-	// lastBlockNum2 := blocksData[len(blocksData)-1].Block.EthBlockNum
-
-	// Add accounts to StateDB
-	for i := 0; i < len(commonAccounts); i++ {
-		if _, err := api.s.CreateAccount(commonAccounts[i].Idx, &commonAccounts[i]); err != nil {
-			panic(err)
-		}
-	}
-	// Make a checkpoint to make the accounts available in Last
-	if err := api.s.MakeCheckpoint(); err != nil {
-		panic(err)
-	}
-
 	// Generate Coordinators and add them to HistoryDB
 	const nCoords = 10
 	commonCoords := test.GenCoordinators(nCoords, commonBlocks)
@@ -526,13 +510,41 @@ func TestMain(m *testing.M) {
 	testTxs := genTestTxs(commonL1Txs, commonL2Txs, commonAccounts, testTokens, commonBlocks)
 	testBatches, testFullBatches := genTestBatches(commonBlocks, commonBatches, testTxs)
 	poolTxsToSend, poolTxsToReceive := genTestPoolTxs(commonPoolTxs, testTokens, commonAccounts)
+	// Add balance and nonce to historyDB
+	accounts := genTestAccounts(commonAccounts, testTokens)
+	accUpdates := []common.AccountUpdate{}
+	for i := 0; i < len(accounts); i++ {
+		balance := new(big.Int)
+		balance.SetString(string(*accounts[i].Balance), 10)
+		idx, err := stringToIdx(string(accounts[i].Idx), "foo")
+		if err != nil {
+			panic(err)
+		}
+		accUpdates = append(accUpdates, common.AccountUpdate{
+			EthBlockNum: 0,
+			BatchNum:    1,
+			Idx:         *idx,
+			Nonce:       0,
+			Balance:     balance,
+		})
+		accUpdates = append(accUpdates, common.AccountUpdate{
+			EthBlockNum: 0,
+			BatchNum:    1,
+			Idx:         *idx,
+			Nonce:       accounts[i].Nonce,
+			Balance:     balance,
+		})
+	}
+	if err := api.h.AddAccountUpdates(accUpdates); err != nil {
+		panic(err)
+	}
 	tc = testCommon{
 		blocks:           commonBlocks,
 		tokens:           testTokens,
 		batches:          testBatches,
 		fullBatches:      testFullBatches,
 		coordinators:     testCoords,
-		accounts:         genTestAccounts(commonAccounts, testTokens),
+		accounts:         accounts,
 		txs:              testTxs,
 		exits:            testExits,
 		poolTxsToSend:    poolTxsToSend,
@@ -574,6 +586,81 @@ func TestMain(m *testing.M) {
 	os.Exit(result)
 }
 
+func TestTimeout(t *testing.T) {
+	pass := os.Getenv("POSTGRES_PASS")
+	databaseTO, err := db.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
+	require.NoError(t, err)
+	apiConnConTO := db.NewAPICnnectionController(1, 100*time.Millisecond)
+	hdbTO := historydb.NewHistoryDB(databaseTO, apiConnConTO)
+	require.NoError(t, err)
+	// L2DB
+	l2DBTO := l2db.NewL2DB(databaseTO, 10, 1000, 0.0, 24*time.Hour, apiConnConTO)
+
+	// API
+	apiGinTO := gin.Default()
+	finishWait := make(chan interface{})
+	startWait := make(chan interface{})
+	apiGinTO.GET("/wait", func(c *gin.Context) {
+		cancel, err := apiConnConTO.Acquire()
+		defer cancel()
+		require.NoError(t, err)
+		defer apiConnConTO.Release()
+		startWait <- nil
+		<-finishWait
+	})
+	// Start server
+	serverTO := &http.Server{Addr: ":4444", Handler: apiGinTO}
+	go func() {
+		if err := serverTO.ListenAndServe(); err != nil && tracerr.Unwrap(err) != http.ErrServerClosed {
+			require.NoError(t, err)
+		}
+	}()
+	_config := getConfigTest(0)
+	_, err = NewAPI(
+		true,
+		true,
+		apiGinTO,
+		hdbTO,
+		l2DBTO,
+		&_config,
+	)
+	require.NoError(t, err)
+
+	client := &http.Client{}
+	httpReq, err := http.NewRequest("GET", "http://localhost:4444/tokens", nil)
+	require.NoError(t, err)
+	httpReqWait, err := http.NewRequest("GET", "http://localhost:4444/wait", nil)
+	require.NoError(t, err)
+	// Request that will get timed out
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		// Request that will make the API busy
+		_, err = client.Do(httpReqWait)
+		require.NoError(t, err)
+		wg.Done()
+	}()
+	<-startWait
+	resp, err := client.Do(httpReq)
+	require.NoError(t, err)
+	require.Equal(t, http.StatusServiceUnavailable, resp.StatusCode)
+	defer resp.Body.Close() //nolint
+	body, err := ioutil.ReadAll(resp.Body)
+	require.NoError(t, err)
+	// Unmarshal body into return struct
+	msg := &errorMsg{}
+	err = json.Unmarshal(body, msg)
+	require.NoError(t, err)
+	// Check that the error was the expected down
+	require.Equal(t, errSQLTimeout, msg.Message)
+	finishWait <- nil
+
+	// Stop server
+	wg.Wait()
+	require.NoError(t, serverTO.Shutdown(context.Background()))
+	require.NoError(t, databaseTO.Close())
+}
+
 func doGoodReqPaginated(
 	path, order string,
 	iterStruct Pendinger,

api/batch.go

@@ -108,7 +108,7 @@ func (a *API) getFullBatch(c *gin.Context) {
 	}
 	// Fetch txs forged in the batch from historyDB
 	maxTxsPerBatch := uint(2048) //nolint:gomnd
-	txs, _, err := a.h.GetHistoryTxs(
+	txs, _, err := a.h.GetTxsAPI(
 		nil, nil, nil, nil, batchNum, nil, nil, &maxTxsPerBatch, historydb.OrderAsc,
 	)
 	if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {

api/handlers.go

@@ -10,6 +10,7 @@ import (
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/lib/pq"
+	"github.com/russross/meddler"
 )
 
 const (
@@ -30,6 +31,12 @@ const (
 
 	// Error for duplicated key
 	errDuplicatedKey = "Item already exists"
+
+	// Error for timeout due to SQL connection
+	errSQLTimeout = "The node is under heavy preasure, please try again later"
+
+	// Error message returned when context reaches timeout
+	errCtxTimeout = "context deadline exceeded"
 )
 
 var (
@@ -39,21 +46,34 @@ var (
 
 func retSQLErr(err error, c *gin.Context) {
 	log.Warnw("HTTP API SQL request error", "err", err)
-	if sqlErr, ok := tracerr.Unwrap(err).(*pq.Error); ok {
+	errMsg := tracerr.Unwrap(err).Error()
+	retDupKey := func(errCode pq.ErrorCode) {
 		// https://www.postgresql.org/docs/current/errcodes-appendix.html
-		if sqlErr.Code == "23505" {
+		if errCode == "23505" {
 			c.JSON(http.StatusInternalServerError, errorMsg{
 				Message: errDuplicatedKey,
 			})
+		} else {
+			c.JSON(http.StatusInternalServerError, errorMsg{
+				Message: errMsg,
+			})
 		}
 	}
-	if tracerr.Unwrap(err) == sql.ErrNoRows {
+	if errMsg == errCtxTimeout {
+		c.JSON(http.StatusServiceUnavailable, errorMsg{
+			Message: errSQLTimeout,
+		})
+	} else if sqlErr, ok := tracerr.Unwrap(err).(*pq.Error); ok {
+		retDupKey(sqlErr.Code)
+	} else if sqlErr, ok := meddler.DriverErr(tracerr.Unwrap(err)); ok {
+		retDupKey(sqlErr.(*pq.Error).Code)
+	} else if tracerr.Unwrap(err) == sql.ErrNoRows {
 		c.JSON(http.StatusNotFound, errorMsg{
-			Message: err.Error(),
+			Message: errMsg,
 		})
 	} else {
 		c.JSON(http.StatusInternalServerError, errorMsg{
-			Message: err.Error(),
+			Message: errMsg,
 		})
 	}
 }

api/slots.go

@@ -97,12 +97,12 @@ func (a *API) getSlot(c *gin.Context) {
 		retBadReq(err, c)
 		return
 	}
-	currentBlock, err := a.h.GetLastBlock()
+	currentBlock, err := a.h.GetLastBlockAPI()
 	if err != nil {
 		retBadReq(err, c)
 		return
 	}
-	auctionVars, err := a.h.GetAuctionVars()
+	auctionVars, err := a.h.GetAuctionVarsAPI()
 	if err != nil {
 		retBadReq(err, c)
 		return
@@ -200,12 +200,12 @@ func (a *API) getSlots(c *gin.Context) {
 		return
 	}
 
-	currentBlock, err := a.h.GetLastBlock()
+	currentBlock, err := a.h.GetLastBlockAPI()
 	if err != nil {
 		retBadReq(err, c)
 		return
 	}
-	auctionVars, err := a.h.GetAuctionVars()
+	auctionVars, err := a.h.GetAuctionVarsAPI()
 	if err != nil {
 		retBadReq(err, c)
 		return
@@ -220,13 +220,13 @@ func (a *API) getSlots(c *gin.Context) {
 			retBadReq(errors.New("It is necessary to add maxSlotNum filter"), c)
 			return
 		} else if *finishedAuction {
-			currentBlock, err := a.h.GetLastBlock()
+			currentBlock, err := a.h.GetLastBlockAPI()
 			if err != nil {
 				retBadReq(err, c)
 				return
 			}
 			currentSlot := a.getCurrentSlot(currentBlock.Num)
-			auctionVars, err := a.h.GetAuctionVars()
+			auctionVars, err := a.h.GetAuctionVarsAPI()
 			if err != nil {
 				retBadReq(err, c)
 				return

api/state.go

@@ -141,7 +141,7 @@ func (a *API) UpdateNetworkInfo(
 	a.status.Network.NextForgers = nextForgers
 
 	// Update buckets withdrawals
-	bucketsUpdate, err := a.h.GetBucketUpdates()
+	bucketsUpdate, err := a.h.GetBucketUpdatesAPI()
 	if tracerr.Unwrap(err) == sql.ErrNoRows {
 		bucketsUpdate = nil
 	} else if err != nil {
@@ -201,7 +201,7 @@ func (a *API) getNextForgers(lastBlock common.Block, currentSlot, lastClosedSlot
 		}}
 	} else {
 		// Get all the relevant updates from the DB
-		minBidInfo, err = a.h.GetAuctionVarsUntilSetSlotNum(lastClosedSlot, int(lastClosedSlot-currentSlot)+1)
+		minBidInfo, err = a.h.GetAuctionVarsUntilSetSlotNumAPI(lastClosedSlot, int(lastClosedSlot-currentSlot)+1)
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
@@ -279,7 +279,7 @@ func (a *API) UpdateMetrics() error {
 	}
 	batchNum := a.status.Network.LastBatch.BatchNum
 	a.status.RUnlock()
-	metrics, err := a.h.GetMetrics(batchNum)
+	metrics, err := a.h.GetMetricsAPI(batchNum)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -293,7 +293,7 @@ func (a *API) UpdateMetrics() error {
 
 // UpdateRecommendedFee update Status.RecommendedFee information
 func (a *API) UpdateRecommendedFee() error {
-	feeExistingAccount, err := a.h.GetAvgTxFee()
+	feeExistingAccount, err := a.h.GetAvgTxFeeAPI()
 	if err != nil {
 		return tracerr.Wrap(err)
 	}

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 + [2 bytes] depositAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx).
+              description: Number of bytes that a L1 user transaction has ([20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6 bytes] fromIdx + [5 bytes] depositAmountFloat40 + [5 bytes] amountFloat40 + [4 bytes] tokenId + [6 bytes] toIdx).
               example: 72
             maxL1UserTx:
               type: integer

api/token.go

@@ -22,7 +22,7 @@ func (a *API) getToken(c *gin.Context) {
 	}
 	tokenID := common.TokenID(*tokenIDUint)
 	// Fetch token from historyDB
-	token, err := a.h.GetToken(tokenID)
+	token, err := a.h.GetTokenAPI(tokenID)
 	if err != nil {
 		retSQLErr(err, c)
 		return
@@ -45,7 +45,7 @@ func (a *API) getTokens(c *gin.Context) {
 		return
 	}
 	// Fetch exits from historyDB
-	tokens, pendingItems, err := a.h.GetTokens(
+	tokens, pendingItems, err := a.h.GetTokensAPI(
 		tokenIDs, symbols, name, fromItem, limit, order,
 	)
 	if err != nil {

api/txshistory.go

@@ -34,7 +34,7 @@ func (a *API) getHistoryTxs(c *gin.Context) {
 	}
 
 	// Fetch txs from historyDB
-	txs, pendingItems, err := a.h.GetHistoryTxs(
+	txs, pendingItems, err := a.h.GetTxsAPI(
 		addr, bjj, tokenID, idx, batchNum, txType, fromItem, limit, order,
 	)
 	if err != nil {
@@ -61,7 +61,7 @@ func (a *API) getHistoryTx(c *gin.Context) {
 		return
 	}
 	// Fetch tx from historyDB
-	tx, err := a.h.GetHistoryTx(txID)
+	tx, err := a.h.GetTxAPI(txID)
 	if err != nil {
 		retSQLErr(err, c)
 		return

api/txspool.go

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

api/txspool_test.go

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

batchbuilder/batchbuilder.go

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

cli/node/.gitignore

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

cli/node/README.md

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

@@ -3,6 +3,8 @@ Address = "localhost:8086"
 Explorer = true
 UpdateMetricsInterval = "10s"
 UpdateRecommendedFeeInterval = "10s"
+MaxSQLConnections = 100
+SQLConnectionTimeout = "2s"
 
 [PriceUpdater]
 Interval = "10s"
@@ -51,6 +53,9 @@ SendBatchBlocksMarginCheck = 1
 ProofServerPollInterval = "1s"
 ForgeRetryInterval = "500ms"
 SyncRetryInterval = "1s"
+ForgeDelay = "10s"
+ForgeNoTxsDelay = "0s"
+PurgeByExtDelInterval = "1m"
 
 [Coordinator.FeeAccount]
 Address = "0x56232B1c5B10038125Bc7345664B4AFD745bcF8E"
@@ -61,6 +66,7 @@ BJJ = "0x1b176232f78ba0d388ecc5f4896eca2d3b3d4f272092469f559247297f5c0c13"
 [Coordinator.L2DB]
 SafetyPeriod = 10
 MaxTxs       = 512
+MinFeeUSD    = 0.0
 TTL          = "24h"
 PurgeBatchDelay = 10
 InvalidateBatchDelay = 20
@@ -81,16 +87,13 @@ MaxTx = 512
 NLevels = 32
 
 [Coordinator.EthClient]
-ReceiptTimeout      = "60s"
-ReceiptLoopInterval = "500ms"
 CheckLoopInterval = "500ms"
 Attempts = 4
 AttemptsDelay = "500ms"
 TxResendTimeout = "2m"
 NoReuseNonce = false
-CallGasLimit = 300000
-GasPriceDiv = 100
 MaxGasPrice = "5000000000"
+GasPriceIncPerc = 10
 
 [Coordinator.EthClient.Keystore]
 Path = "/tmp/iden3-test/hermez/ethkeystore"

cli/node/main.go

@@ -11,6 +11,8 @@ 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"
@@ -23,6 +25,7 @@ const (
 	flagMode  = "mode"
 	flagSK    = "privatekey"
 	flagYes   = "yes"
+	flagBlock = "block"
 	modeSync  = "sync"
 	modeCoord = "coord"
 )
@@ -139,6 +142,48 @@ 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)
+
+	db, err := dbUtils.InitSQLDB(
+		cfg.PostgreSQL.Port,
+		cfg.PostgreSQL.Host,
+		cfg.PostgreSQL.User,
+		cfg.PostgreSQL.Password,
+		cfg.PostgreSQL.Name,
+	)
+	if err != nil {
+		return tracerr.Wrap(fmt.Errorf("dbUtils.InitSQLDB: %w", err))
+	}
+	historyDB := historydb.NewHistoryDB(db, 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(
+		db,
+		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
@@ -239,6 +284,18 @@ 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,3 +263,13 @@ type IdxNonce struct {
 	Idx   Idx   `db:"idx"`
 	Nonce Nonce `db:"nonce"`
 }
+
+// AccountUpdate represents an account balance and/or nonce update after a
+// processed batch
+type AccountUpdate struct {
+	EthBlockNum int64    `meddler:"eth_block_num"`
+	BatchNum    BatchNum `meddler:"batch_num"`
+	Idx         Idx      `meddler:"idx"`
+	Nonce       Nonce    `meddler:"nonce"`
+	Balance     *big.Int `meddler:"balance,bigint"`
+}

common/accountcreationauths.go

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

@@ -77,6 +77,7 @@ type BatchData struct {
 	L1CoordinatorTxs []L1Tx
 	L2Txs            []L2Tx
 	CreatedAccounts  []Account
+	UpdatedAccounts  []AccountUpdate
 	ExitTree         []ExitInfo
 	Batch            Batch
 }
@@ -93,23 +94,3 @@ func NewBatchData() *BatchData {
 		Batch:            Batch{},
 	}
 }
-
-// BatchSync is a subset of Batch that contains fileds needed for the
-// synchronizer and coordinator
-// type BatchSync struct {
-// 	BatchNum    BatchNum          `meddler:"batch_num"`
-// 	EthBlockNum int64             `meddler:"eth_block_num"` // Ethereum block in which the batch is forged
-// 	ForgerAddr  ethCommon.Address `meddler:"forger_addr"`
-// 	StateRoot   *big.Int          `meddler:"state_root,bigint"`
-// 	SlotNum     int64             `meddler:"slot_num"` // Slot in which the batch is forged
-// }
-//
-// func NewBatchSync() *BatchSync {
-// 	return &BatchSync{
-// 		BatchNum:    0,
-// 		EthBlockNum: 0,
-// 		ForgerAddr:  ethCommon.Address,
-// 		StateRoot:   big.NewInt(0),
-// 		SlotNum:     0,
-// 	}
-// }

common/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 +
-	// [2 bytes] depositAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx
+	// [5 bytes] depositAmountFloat40 + [5 bytes] amountFloat40 + [4 bytes] tokenId + [6 bytes] toIdx
-	RollupConstL1UserTotalBytes = 72
+	RollupConstL1UserTotalBytes = 78
 	// RollupConstMaxL1UserTx Maximum L1-user transactions allowed to be queued in a batch
 	RollupConstMaxL1UserTx = 128
 	// RollupConstMaxL1Tx Maximum L1 transactions allowed to be queued in a batch

common/float16.go

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

common/float16_test.go

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

common/float40.go

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

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

common/l1tx_test.go

@@ -15,7 +15,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestNewL1UserTx(t *testing.T) {
+func TestNewL1UserTxID(t *testing.T) {
 	toForge := int64(123456)
 	l1Tx := &L1Tx{
 		ToForgeL1TxsNum: &toForge,
@@ -30,6 +30,38 @@ func TestNewL1UserTx(t *testing.T) {
 	l1Tx, err := NewL1Tx(l1Tx)
 	assert.NoError(t, err)
 	assert.Equal(t, "0x00a6cbae3b8661fb75b0919ca6605a02cfb04d9c6dd16870fa0fcdf01befa32768", l1Tx.TxID.String())
+
+	maxInt64 := 0xFFFF_FFFF_FFFF_FFFF >> 1
+
+	toForge = int64(maxInt64)
+	l1Tx = &L1Tx{
+		ToForgeL1TxsNum: &toForge,
+		Position:        maxInt64,
+		UserOrigin:      true,
+	}
+	l1Tx, err = NewL1Tx(l1Tx)
+	assert.NoError(t, err)
+	assert.Equal(t, "0x001ff31eb325f324652bfe6b607a19e04789e082ee3b779eefe4a466062ea331d9", l1Tx.TxID.String())
+
+	toForge = int64(maxInt64 - 1)
+	l1Tx = &L1Tx{
+		ToForgeL1TxsNum: &toForge,
+		Position:        maxInt64 - 1,
+		UserOrigin:      true,
+	}
+	l1Tx, err = NewL1Tx(l1Tx)
+	assert.NoError(t, err)
+	assert.Equal(t, "0x0003434eca58d35fd85795e3a6cce67c8801deb805ea1f7429cc270aa9f35ea403", l1Tx.TxID.String())
+
+	toForge = int64(0)
+	l1Tx = &L1Tx{
+		ToForgeL1TxsNum: &toForge,
+		Position:        0,
+		UserOrigin:      true,
+	}
+	l1Tx, err = NewL1Tx(l1Tx)
+	assert.NoError(t, err)
+	assert.Equal(t, "0x006bd2dd6bd408cbee33429358bf24fdc64612fbf8b1b4db604518f40ffd34b607", l1Tx.TxID.String())
 }
 
 func TestNewL1CoordinatorTx(t *testing.T) {
@@ -50,64 +82,110 @@ 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: 2,
+		FromIdx: (1 << 48) - 1,
-		ToIdx:   3,
+		ToIdx:   (1 << 48) - 1,
-		Amount:  big.NewInt(4),
+		Amount:  amount,
-		TokenID: 5,
+		TokenID: (1 << 32) - 1,
 	}
-	chainID := uint16(0)
+	txCompressedData, err := tx.TxCompressedData(uint16((1 << 16) - 1))
-	txCompressedData, err := tx.TxCompressedData(chainID)
 	assert.NoError(t, err)
+	expectedStr := "ffffffffffffffffffffffffffffffffffffc60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
 
-	// test vector value generated from javascript implementation
+	tx = L1Tx{
-	expectedStr := "7307597389635308713748674793997299267459594577423"
+		FromIdx: 0,
-	assert.Equal(t, expectedStr, txCompressedData.String())
+		ToIdx:   0,
-	assert.Equal(t, "0500040000000000030000000000020000c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
+		Amount:  big.NewInt(0),
+		TokenID: 0,
+	}
+	txCompressedData, err = tx.TxCompressedData(uint16(0))
+	assert.NoError(t, err)
+	expectedStr = "c60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
+
+	amount, ok = new(big.Int).SetString("63000000000000000", 10)
+	require.True(t, ok)
+	tx = L1Tx{
+		FromIdx: 324,
+		ToIdx:   256,
+		Amount:  amount,
+		TokenID: 123,
+	}
+	txCompressedData, err = tx.TxCompressedData(uint16(1))
+	assert.NoError(t, err)
+	expectedStr = "7b0000000001000000000001440001c60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
+
+	tx = L1Tx{
+		FromIdx: 1,
+		ToIdx:   2,
+		TokenID: 3,
+	}
+	txCompressedData, err = tx.TxCompressedData(uint16(0))
+	assert.NoError(t, err)
+	expectedStr = "030000000000020000000000010000c60be60f"
+	assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
 }
 
 func TestBytesDataAvailability(t *testing.T) {
+	// test vectors values generated from javascript implementation
+	amount, ok := new(big.Int).SetString("343597383670000000000000000000000000000000", 10)
+	require.True(t, ok)
 	tx := L1Tx{
-		FromIdx: 2,
+		ToIdx:           (1 << 16) - 1,
-		ToIdx:   3,
+		FromIdx:         (1 << 16) - 1,
-		Amount:  big.NewInt(4),
+		EffectiveAmount: amount,
-		TokenID: 5,
 	}
-	txCompressedData, err := tx.BytesDataAvailability(32)
+	txCompressedData, err := tx.BytesDataAvailability(16)
 	assert.NoError(t, err)
-	assert.Equal(t, "0000000200000003000000", hex.EncodeToString(txCompressedData))
+	assert.Equal(t, "ffffffffffffffffff00", hex.EncodeToString(txCompressedData))
-
+	l1tx, err := L1TxFromDataAvailability(txCompressedData, 16)
-	tx = L1Tx{
-		FromIdx:         2,
-		ToIdx:           3,
-		EffectiveAmount: big.NewInt(4),
-		TokenID:         5,
-	}
-	txCompressedData, err = tx.BytesDataAvailability(32)
-	assert.NoError(t, err)
-	assert.Equal(t, "0000000200000003000400", hex.EncodeToString(txCompressedData))
-}
-
-func TestL1TxFromDataAvailability(t *testing.T) {
-	tx := L1Tx{
-		FromIdx: 2,
-		ToIdx:   3,
-		Amount:  big.NewInt(4),
-	}
-	txCompressedData, err := tx.BytesDataAvailability(32)
-	assert.NoError(t, err)
-	l1tx, err := L1TxFromDataAvailability(txCompressedData, 32)
 	require.NoError(t, err)
 	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
 	assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
+	assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
 
 	tx = L1Tx{
-		FromIdx:         2,
+		ToIdx:           (1 << 32) - 1,
-		ToIdx:           3,
+		FromIdx:         (1 << 32) - 1,
-		EffectiveAmount: big.NewInt(4),
+		EffectiveAmount: amount,
 	}
 	txCompressedData, err = tx.BytesDataAvailability(32)
 	assert.NoError(t, err)
+	assert.Equal(t, "ffffffffffffffffffffffffff00", hex.EncodeToString(txCompressedData))
+	l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
+	require.NoError(t, err)
+	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
+	assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
+	assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
+
+	tx = L1Tx{
+		ToIdx:           0,
+		FromIdx:         0,
+		EffectiveAmount: big.NewInt(0),
+	}
+	txCompressedData, err = tx.BytesDataAvailability(32)
+	assert.NoError(t, err)
+	assert.Equal(t, "0000000000000000000000000000", hex.EncodeToString(txCompressedData))
+	l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
+	require.NoError(t, err)
+	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
+	assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
+	assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
+
+	tx = L1Tx{
+		ToIdx:           635,
+		FromIdx:         296,
+		EffectiveAmount: big.NewInt(1000000000000000000),
+	}
+	txCompressedData, err = tx.BytesDataAvailability(32)
+	assert.NoError(t, err)
+	assert.Equal(t, "000001280000027b42540be40000", hex.EncodeToString(txCompressedData))
 	l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
 	require.NoError(t, err)
 	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
@@ -172,12 +250,10 @@ func TestL1TxByteParsersCompatibility(t *testing.T) {
 		UserOrigin:    true,
 	}
 
-	expected, err := utils.HexDecode("85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a000001c638db8be880f00020039c0000053cb88d")
-	require.NoError(t, err)
-
 	encodedData, err := l1Tx.BytesUser()
 	require.NoError(t, err)
-	assert.Equal(t, expected, encodedData)
+	expected := "85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a000001c638db52540be400459682f0000020039c0000053cb88d"
+	assert.Equal(t, expected, hex.EncodeToString(encodedData))
 }
 
 func TestL1CoordinatorTxByteParsers(t *testing.T) {

common/l2tx.go

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

common/l2tx_test.go

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

common/pooll2tx.go

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

common/pooll2tx_test.go

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

common/utils.go

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

common/zk.go

@@ -102,6 +102,8 @@ type ZKInputs struct {
 	ToBJJAy []*big.Int `json:"toBjjAy"` // big.Int, len: [maxTx]
 	// ToEthAddr
 	ToEthAddr []*big.Int `json:"toEthAddr"` // ethCommon.Address, len: [maxTx]
+	// AmountF encoded as float40
+	AmountF []*big.Int `json:"amountF"` // uint40 len: [maxTx]
 
 	// OnChain determines if is L1 (1/true) or L2 (0/false)
 	OnChain []*big.Int `json:"onChain"` // bool, len: [maxTx]
@@ -112,8 +114,8 @@ type ZKInputs struct {
 	// NewAccount boolean (0/1) flag set 'true' when L1 tx creates a new
 	// account (fromIdx==0)
 	NewAccount []*big.Int `json:"newAccount"` // bool, len: [maxTx]
-	// DepositAmountF encoded as float16
+	// DepositAmountF encoded as float40
-	DepositAmountF []*big.Int `json:"loadAmountF"` // uint16, len: [maxTx]
+	DepositAmountF []*big.Int `json:"loadAmountF"` // uint40, len: [maxTx]
 	// FromEthAddr
 	FromEthAddr []*big.Int `json:"fromEthAddr"` // ethCommon.Address, len: [maxTx]
 	// FromBJJCompressed boolean encoded where each value is a *big.Int
@@ -326,6 +328,7 @@ func NewZKInputs(chainID uint16, maxTx, maxL1Tx, maxFeeIdxs, nLevels uint32, cur
 	zki.AuxToIdx = newSlice(maxTx)
 	zki.ToBJJAy = newSlice(maxTx)
 	zki.ToEthAddr = newSlice(maxTx)
+	zki.AmountF = newSlice(maxTx)
 	zki.OnChain = newSlice(maxTx)
 	zki.NewAccount = newSlice(maxTx)
 
@@ -476,8 +479,8 @@ func (z ZKInputs) ToHashGlobalData() ([]byte, error) {
 	copy(newExitRoot, z.Metadata.NewExitRootRaw.Bytes())
 	b = append(b, newExitRoot...)
 
-	// [MAX_L1_TX * (2 * MAX_NLEVELS + 480) bits] L1TxsData
+	// [MAX_L1_TX * (2 * MAX_NLEVELS + 528) bits] L1TxsData
-	l1TxDataLen := (2*z.Metadata.MaxLevels + 480)
+	l1TxDataLen := (2*z.Metadata.MaxLevels + 528)
 	l1TxsDataLen := (z.Metadata.MaxL1Tx * l1TxDataLen)
 	l1TxsData := make([]byte, l1TxsDataLen/8) //nolint:gomnd
 	for i := 0; i < len(z.Metadata.L1TxsData); i++ {
@@ -494,9 +497,9 @@ func (z ZKInputs) ToHashGlobalData() ([]byte, error) {
 	}
 	b = append(b, l1TxsDataAvailability...)
 
-	// [MAX_TX*(2*NLevels + 24) bits] L2TxsData
+	// [MAX_TX*(2*NLevels + 48) bits] L2TxsData
 	var l2TxsData []byte
-	l2TxDataLen := 2*z.Metadata.NLevels + 24 //nolint:gomnd
+	l2TxDataLen := 2*z.Metadata.NLevels + 48 //nolint:gomnd
 	l2TxsDataLen := (z.Metadata.MaxTx * l2TxDataLen)
 	expectedL2TxsDataLen := l2TxsDataLen / 8 //nolint:gomnd
 	for i := 0; i < len(z.Metadata.L2TxsData); i++ {

config/config.go

@@ -79,27 +79,58 @@ type Coordinator struct {
 	// ForgeRetryInterval is the waiting interval between calls forge a
 	// batch after an error
 	ForgeRetryInterval Duration `validate:"required"`
+	// ForgeDelay is the delay after which a batch is forged if the slot is
+	// already committed.  If set to 0s, the coordinator will continuously
+	// forge at the maximum rate.
+	ForgeDelay Duration `validate:"-"`
+	// ForgeNoTxsDelay is the delay after which a batch is forged even if
+	// there are no txs to forge if the slot is already committed.  If set
+	// to 0s, the coordinator will continuously forge even if the batches
+	// are empty.
+	ForgeNoTxsDelay Duration `validate:"-"`
 	// SyncRetryInterval is the waiting interval between calls to the main
 	// handler of a synced block after an error
 	SyncRetryInterval Duration `validate:"required"`
+	// PurgeByExtDelInterval is the waiting interval between calls
+	// to the PurgeByExternalDelete function of the l2db which deletes
+	// pending txs externally marked by the column `external_delete`
+	PurgeByExtDelInterval Duration `validate:"required"`
 	// L2DB is the DB that holds the pool of L2Txs
 	L2DB struct {
 		// SafetyPeriod is the number of batches after which
 		// non-pending L2Txs are deleted from the pool
 		SafetyPeriod common.BatchNum `validate:"required"`
-		// MaxTxs is the number of L2Txs that once reached triggers
+		// MaxTxs is the maximum number of pending L2Txs that can be
-		// deletion of old L2Txs
+		// stored in the pool.  Once this number of pending L2Txs is
+		// reached, inserts to the pool will be denied until some of
+		// the pending txs are forged.
 		MaxTxs uint32 `validate:"required"`
+		// MinFeeUSD is the minimum fee in USD that a tx must pay in
+		// order to be accepted into the pool.  Txs with lower than
+		// minimum fee will be rejected at the API level.
+		MinFeeUSD float64
 		// TTL is the Time To Live for L2Txs in the pool.  Once MaxTxs
 		// L2Txs is reached, L2Txs older than TTL will be deleted.
 		TTL Duration `validate:"required"`
-		// PurgeBatchDelay is the delay between batches to purge outdated transactions
+		// PurgeBatchDelay is the delay between batches to purge
+		// outdated transactions.  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 invalid transactions
+		// InvalidateBatchDelay is the delay between batches to mark
+		// invalid transactions due to nonce lower than the account
+		// nonce.
 		InvalidateBatchDelay int64 `validate:"required"`
-		// PurgeBlockDelay is the delay between blocks to purge outdated transactions
+		// PurgeBlockDelay is the delay between blocks to purge
+		// outdated transactions.  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 invalid transactions
+		// InvalidateBlockDelay is the delay between blocks to mark
+		// invalid transactions due to nonce lower than the account
+		// nonce.
 		InvalidateBlockDelay int64 `validate:"required"`
 	} `validate:"required"`
 	TxSelector struct {
@@ -119,15 +150,13 @@ type Coordinator struct {
 		NLevels int64 `validate:"required"`
 	} `validate:"required"`
 	EthClient struct {
-		// CallGasLimit is the default gas limit set for ethereum
-		// calls, except for methods  where a particular gas limit is
-		// harcoded because it's known to be a big value
-		CallGasLimit uint64 `validate:"required"`
 		// MaxGasPrice is the maximum gas price allowed for ethereum
 		// transactions
 		MaxGasPrice *big.Int `validate:"required"`
-		// GasPriceDiv is the gas price division
+		// GasPriceIncPerc is the percentage increase of gas price set
-		GasPriceDiv uint64 `validate:"required"`
+		// in an ethereum transaction from the suggested gas price by
+		// the ehtereum node
+		GasPriceIncPerc int64
 		// CheckLoopInterval is the waiting interval between receipt
 		// checks of ethereum transactions in the TxManager
 		CheckLoopInterval Duration `validate:"required"`
@@ -236,9 +265,14 @@ type Node struct {
 		// UpdateMetricsInterval is the interval between updates of the
 		// API metrics
 		UpdateMetricsInterval Duration
-		// UpdateMetricsInterval is the interval between updates of the
+		// UpdateRecommendedFeeInterval is the interval between updates of the
 		// recommended fees
 		UpdateRecommendedFeeInterval Duration
+		// Maximum concurrent connections allowed between API and SQL
+		MaxSQLConnections int `validate:"required"`
+		// SQLConnectionTimeout is the maximum amount of time that an API request
+		// can wait to stablish a SQL connection
+		SQLConnectionTimeout Duration
 	} `validate:"required"`
 	Debug struct {
 		// APIAddress is the address where the debugAPI will listen if

coordinator/batch.go

@@ -91,7 +91,8 @@ type BatchInfo struct {
 	CoordIdxs             []common.Idx
 	ForgeBatchArgs        *eth.RollupForgeBatchArgs
 	// FeesInfo
-	EthTx *types.Transaction
+	EthTx    *types.Transaction
+	EthTxErr error
 	// SendTimestamp  the time of batch sent to ethereum
 	SendTimestamp time.Time
 	Receipt       *types.Receipt

coordinator/coordinator.go

@@ -23,7 +23,9 @@ 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 (
@@ -71,9 +73,22 @@ type Config struct {
 	// ForgeRetryInterval is the waiting interval between calls forge a
 	// batch after an error
 	ForgeRetryInterval time.Duration
+	// ForgeDelay is the delay after which a batch is forged if the slot is
+	// already committed.  If set to 0s, the coordinator will continuously
+	// forge at the maximum rate.
+	ForgeDelay time.Duration
+	// ForgeNoTxsDelay is the delay after which a batch is forged even if
+	// there are no txs to forge if the slot is already committed.  If set
+	// to 0s, the coordinator will continuously forge even if the batches
+	// are empty.
+	ForgeNoTxsDelay time.Duration
 	// SyncRetryInterval is the waiting interval between calls to the main
 	// handler of a synced block after an error
 	SyncRetryInterval time.Duration
+	// PurgeByExtDelInterval is the waiting interval between calls
+	// to the PurgeByExternalDelete function of the l2db which deletes
+	// pending txs externally marked by the column `external_delete`
+	PurgeByExtDelInterval time.Duration
 	// EthClientAttemptsDelay is delay between attempts do do an eth client
 	// RPC call
 	EthClientAttemptsDelay time.Duration
@@ -87,6 +102,10 @@ type Config struct {
 	// MaxGasPrice is the maximum gas price allowed for ethereum
 	// transactions
 	MaxGasPrice *big.Int
+	// GasPriceIncPerc is the percentage increase of gas price set in an
+	// ethereum transaction from the suggested gas price by the ehtereum
+	// node
+	GasPriceIncPerc int64
 	// TxManagerCheckInterval is the waiting interval between receipt
 	// checks of ethereum transactions in the TxManager
 	TxManagerCheckInterval time.Duration
@@ -138,6 +157,15 @@ type Coordinator struct {
 	wg     sync.WaitGroup
 	cancel context.CancelFunc
 
+	// mutexL2DBUpdateDelete protects updates to the L2DB so that
+	// these two processes always happen exclusively:
+	// - Pipeline taking pending txs, running through the TxProcessor and
+	//   marking selected txs as forging
+	// - Coordinator deleting pending txs that have been marked with
+	//   `external_delete`.
+	// Without this mutex, the coordinator could delete a pending txs that
+	// has just been selected by the TxProcessor in the pipeline.
+	mutexL2DBUpdateDelete sync.Mutex
 	pipeline              *Pipeline
 	lastNonFailedBatchNum common.BatchNum
 
@@ -233,7 +261,8 @@ func (c *Coordinator) BatchBuilder() *batchbuilder.BatchBuilder {
 func (c *Coordinator) newPipeline(ctx context.Context) (*Pipeline, error) {
 	c.pipelineNum++
 	return NewPipeline(ctx, c.cfg, c.pipelineNum, c.historyDB, c.l2DB, c.txSelector,
-		c.batchBuilder, c.purger, c, c.txManager, c.provers, &c.consts)
+		c.batchBuilder, &c.mutexL2DBUpdateDelete, c.purger, c, c.txManager,
+		c.provers, &c.consts)
 }
 
 // MsgSyncBlock indicates an update to the Synchronizer stats
@@ -254,7 +283,7 @@ type MsgSyncReorg struct {
 // MsgStopPipeline indicates a signal to reset the pipeline
 type MsgStopPipeline struct {
 	Reason string
-	// FailedBatchNum indicates the first batchNum that faile in the
+	// FailedBatchNum indicates the first batchNum that failed in the
 	// pipeline.  If FailedBatchNum is 0, it should be ignored.
 	FailedBatchNum common.BatchNum
 }
@@ -338,25 +367,31 @@ func (c *Coordinator) syncStats(ctx context.Context, stats *synchronizer.Stats)
 	if c.pipeline == nil {
 		relativeBlock := c.consts.Auction.RelativeBlock(nextBlock)
 		if canForge && relativeBlock < c.cfg.StartSlotBlocksDelay {
-			log.Debugw("Coordinator: delaying pipeline start due to "+
+			log.Debugf("Coordinator: delaying pipeline start due to "+
 				"relativeBlock (%v) < cfg.StartSlotBlocksDelay (%v)",
 				relativeBlock, c.cfg.StartSlotBlocksDelay)
 		} else if canForge {
 			log.Infow("Coordinator: forging state begin", "block",
 				stats.Eth.LastBlock.Num+1, "batch", stats.Sync.LastBatch.BatchNum)
-			batchNum := stats.Sync.LastBatch.BatchNum
+			fromBatch := fromBatch{
-			if c.lastNonFailedBatchNum > batchNum {
+				BatchNum:   stats.Sync.LastBatch.BatchNum,
-				batchNum = c.lastNonFailedBatchNum
+				ForgerAddr: stats.Sync.LastBatch.ForgerAddr,
+				StateRoot:  stats.Sync.LastBatch.StateRoot,
+			}
+			if c.lastNonFailedBatchNum > fromBatch.BatchNum {
+				fromBatch.BatchNum = c.lastNonFailedBatchNum
+				fromBatch.ForgerAddr = c.cfg.ForgerAddress
+				fromBatch.StateRoot = big.NewInt(0)
 			}
 			var err error
 			if c.pipeline, err = c.newPipeline(ctx); err != nil {
 				return tracerr.Wrap(err)
 			}
-			if err := c.pipeline.Start(batchNum, stats, &c.vars); err != nil {
+			c.pipelineFromBatch = fromBatch
+			if err := c.pipeline.Start(fromBatch.BatchNum, stats, &c.vars); err != nil {
 				c.pipeline = nil
 				return tracerr.Wrap(err)
 			}
-			// c.pipelineBatchNum = batchNum
 		}
 	} else {
 		if !canForge {
@@ -366,18 +401,6 @@ func (c *Coordinator) syncStats(ctx context.Context, stats *synchronizer.Stats)
 		}
 	}
 	if c.pipeline == nil {
-		// Mark invalid in Pool due to forged L2Txs
-		// for _, batch := range batches {
-		// 	if err := c.l2DB.InvalidateOldNonces(
-		// 		idxsNonceFromL2Txs(batch.L2Txs), batch.Batch.BatchNum); err != nil {
-		// 		return err
-		// 	}
-		// }
-		// if c.purger.CanInvalidate(stats.Sync.LastBlock.Num, int64(stats.Sync.LastBatch.BatchNum)) {
-		// 	if err := c.txSelector.Reset(stats.Sync.LastBatch.BatchNum); err != nil {
-		// 		return tracerr.Wrap(err)
-		// 	}
-		// }
 		if _, err := c.purger.InvalidateMaybe(c.l2DB, c.txSelector.LocalAccountsDB(),
 			stats.Sync.LastBlock.Num, int64(stats.Sync.LastBatch.BatchNum)); err != nil {
 			return tracerr.Wrap(err)
@@ -411,7 +434,8 @@ func (c *Coordinator) handleReorg(ctx context.Context, msg *MsgSyncReorg) error
 		c.pipeline.SetSyncStatsVars(ctx, &msg.Stats, &msg.Vars)
 	}
 	if c.stats.Sync.LastBatch.ForgerAddr != c.cfg.ForgerAddress &&
-		c.stats.Sync.LastBatch.StateRoot.Cmp(c.pipelineFromBatch.StateRoot) != 0 {
+		(c.stats.Sync.LastBatch.StateRoot == nil || c.pipelineFromBatch.StateRoot == nil ||
+			c.stats.Sync.LastBatch.StateRoot.Cmp(c.pipelineFromBatch.StateRoot) != 0) {
 		// There's been a reorg and the batch state root from which the
 		// pipeline was started has changed (probably because it was in
 		// a block that was discarded), and it was sent by a different
@@ -438,13 +462,13 @@ func (c *Coordinator) handleStopPipeline(ctx context.Context, reason string, fai
 	if failedBatchNum != 0 {
 		batchNum = failedBatchNum - 1
 	}
-	if err := c.l2DB.Reorg(batchNum); err != nil {
-		return tracerr.Wrap(err)
-	}
 	if c.pipeline != nil {
 		c.pipeline.Stop(c.ctx)
 		c.pipeline = nil
 	}
+	if err := c.l2DB.Reorg(batchNum); err != nil {
+		return tracerr.Wrap(err)
+	}
 	c.lastNonFailedBatchNum = batchNum
 	return nil
 }
@@ -484,7 +508,7 @@ func (c *Coordinator) Start() {
 
 	c.wg.Add(1)
 	go func() {
-		waitDuration := longWaitDuration
+		waitCh := time.After(longWaitDuration)
 		for {
 			select {
 			case <-c.ctx.Done():
@@ -496,23 +520,42 @@ func (c *Coordinator) Start() {
 					continue
 				} else if err != nil {
 					log.Errorw("Coordinator.handleMsg", "err", err)
-					waitDuration = c.cfg.SyncRetryInterval
+					waitCh = time.After(c.cfg.SyncRetryInterval)
 					continue
 				}
-				waitDuration = longWaitDuration
+				waitCh = time.After(longWaitDuration)
-			case <-time.After(waitDuration):
+			case <-waitCh:
 				if !c.stats.Synced() {
-					waitDuration = longWaitDuration
+					waitCh = time.After(longWaitDuration)
 					continue
 				}
 				if err := c.syncStats(c.ctx, &c.stats); c.ctx.Err() != nil {
+					waitCh = time.After(longWaitDuration)
 					continue
 				} else if err != nil {
 					log.Errorw("Coordinator.syncStats", "err", err)
-					waitDuration = c.cfg.SyncRetryInterval
+					waitCh = time.After(c.cfg.SyncRetryInterval)
 					continue
 				}
-				waitDuration = longWaitDuration
+				waitCh = time.After(longWaitDuration)
+			}
+		}
+	}()
+
+	c.wg.Add(1)
+	go func() {
+		for {
+			select {
+			case <-c.ctx.Done():
+				log.Info("Coordinator L2DB.PurgeByExternalDelete loop done")
+				c.wg.Done()
+				return
+			case <-time.After(c.cfg.PurgeByExtDelInterval):
+				c.mutexL2DBUpdateDelete.Lock()
+				if err := c.l2DB.PurgeByExternalDelete(); err != nil {
+					log.Errorw("L2DB.PurgeByExternalDelete", "err", err)
+				}
+				c.mutexL2DBUpdateDelete.Unlock()
 			}
 		}
 	}()

coordinator/coordinator_test.go

@@ -2,7 +2,6 @@ package coordinator
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"math/big"
@@ -12,7 +11,6 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
 	"github.com/hermeznetwork/hermez-node/batchbuilder"
 	"github.com/hermeznetwork/hermez-node/common"
 	dbUtils "github.com/hermeznetwork/hermez-node/db"
@@ -107,8 +105,8 @@ func newTestModules(t *testing.T) modules {
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	test.WipeDB(db)
-	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour)
+	l2DB := l2db.NewL2DB(db, 10, 100, 0.0, 24*time.Hour, nil)
-	historyDB := historydb.NewHistoryDB(db)
+	historyDB := historydb.NewHistoryDB(db, nil)
 
 	txSelDBPath, err = ioutil.TempDir("", "tmpTxSelDB")
 	require.NoError(t, err)
@@ -568,8 +566,3 @@ func TestCoordinatorStress(t *testing.T) {
 // TODO: Test forgeBatch
 // TODO: Test waitServerProof
 // TODO: Test handleReorg
-
-func TestFoo(t *testing.T) {
-	a := tracerr.Wrap(fmt.Errorf("AAA: %w", core.ErrNonceTooLow))
-	fmt.Println(errors.Is(a, core.ErrNonceTooLow))
-}

coordinator/pipeline.go

@@ -29,6 +29,7 @@ type state struct {
 	batchNum                     common.BatchNum
 	lastScheduledL1BatchBlockNum int64
 	lastForgeL1TxsNum            int64
+	lastSlotForged               int64
 }
 
 // Pipeline manages the forging of batches with parallel server proofs
@@ -38,23 +39,22 @@ type Pipeline struct {
 	consts synchronizer.SCConsts
 
 	// state
-	state state
+	state         state
-	// batchNum                     common.BatchNum
-	// lastScheduledL1BatchBlockNum int64
-	// lastForgeL1TxsNum            int64
 	started       bool
 	rw            sync.RWMutex
 	errAtBatchNum common.BatchNum
+	lastForgeTime time.Time
 
-	proversPool  *ProversPool
+	proversPool           *ProversPool
-	provers      []prover.Client
+	provers               []prover.Client
-	coord        *Coordinator
+	coord                 *Coordinator
-	txManager    *TxManager
+	txManager             *TxManager
-	historyDB    *historydb.HistoryDB
+	historyDB             *historydb.HistoryDB
-	l2DB         *l2db.L2DB
+	l2DB                  *l2db.L2DB
-	txSelector   *txselector.TxSelector
+	txSelector            *txselector.TxSelector
-	batchBuilder *batchbuilder.BatchBuilder
+	batchBuilder          *batchbuilder.BatchBuilder
-	purger       *Purger
+	mutexL2DBUpdateDelete *sync.Mutex
+	purger                *Purger
 
 	stats       synchronizer.Stats
 	vars        synchronizer.SCVariables
@@ -85,6 +85,7 @@ func NewPipeline(ctx context.Context,
 	l2DB *l2db.L2DB,
 	txSelector *txselector.TxSelector,
 	batchBuilder *batchbuilder.BatchBuilder,
+	mutexL2DBUpdateDelete *sync.Mutex,
 	purger *Purger,
 	coord *Coordinator,
 	txManager *TxManager,
@@ -105,19 +106,20 @@ func NewPipeline(ctx context.Context,
 		return nil, tracerr.Wrap(fmt.Errorf("no provers in the pool"))
 	}
 	return &Pipeline{
-		num:          num,
+		num:                   num,
-		cfg:          cfg,
+		cfg:                   cfg,
-		historyDB:    historyDB,
+		historyDB:             historyDB,
-		l2DB:         l2DB,
+		l2DB:                  l2DB,
-		txSelector:   txSelector,
+		txSelector:            txSelector,
-		batchBuilder: batchBuilder,
+		batchBuilder:          batchBuilder,
-		provers:      provers,
+		provers:               provers,
-		proversPool:  proversPool,
+		proversPool:           proversPool,
-		purger:       purger,
+		mutexL2DBUpdateDelete: mutexL2DBUpdateDelete,
-		coord:        coord,
+		purger:                purger,
-		txManager:    txManager,
+		coord:                 coord,
-		consts:       *scConsts,
+		txManager:             txManager,
-		statsVarsCh:  make(chan statsVars, queueLen),
+		consts:                *scConsts,
+		statsVarsCh:           make(chan statsVars, queueLen),
 	}, nil
 }
 
@@ -136,6 +138,7 @@ func (p *Pipeline) reset(batchNum common.BatchNum,
 		batchNum:                     batchNum,
 		lastForgeL1TxsNum:            stats.Sync.LastForgeL1TxsNum,
 		lastScheduledL1BatchBlockNum: 0,
+		lastSlotForged:               -1,
 	}
 	p.stats = *stats
 	p.vars = *vars
@@ -199,7 +202,9 @@ func (p *Pipeline) syncSCVars(vars synchronizer.SCVariablesPtr) {
 // and then waits for an available proof server and sends the zkInputs to it so
 // that the proof computation begins.
 func (p *Pipeline) handleForgeBatch(ctx context.Context, batchNum common.BatchNum) (*BatchInfo, error) {
+	p.mutexL2DBUpdateDelete.Lock()
 	batchInfo, err := p.forgeBatch(batchNum)
+	p.mutexL2DBUpdateDelete.Unlock()
 	if ctx.Err() != nil {
 		return nil, ctx.Err()
 	} else if err != nil {
@@ -207,6 +212,9 @@ func (p *Pipeline) handleForgeBatch(ctx context.Context, batchNum common.BatchNu
 			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)
 		}
@@ -250,7 +258,7 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 
 	p.wg.Add(1)
 	go func() {
-		waitDuration := zeroDuration
+		waitCh := time.After(zeroDuration)
 		for {
 			select {
 			case <-p.ctx.Done():
@@ -260,37 +268,42 @@ func (p *Pipeline) Start(batchNum common.BatchNum,
 			case statsVars := <-p.statsVarsCh:
 				p.stats = statsVars.Stats
 				p.syncSCVars(statsVars.Vars)
-			case <-time.After(waitDuration):
+			case <-waitCh:
 				// Once errAtBatchNum != 0, we stop forging
 				// batches because there's been an error and we
 				// wait for the pipeline to be stopped.
 				if p.getErrAtBatchNum() != 0 {
-					waitDuration = p.cfg.ForgeRetryInterval
+					waitCh = time.After(p.cfg.ForgeRetryInterval)
 					continue
 				}
 				batchNum = p.state.batchNum + 1
 				batchInfo, err := p.handleForgeBatch(p.ctx, batchNum)
 				if p.ctx.Err() != nil {
+					waitCh = time.After(p.cfg.ForgeRetryInterval)
 					continue
-				} else if tracerr.Unwrap(err) == errLastL1BatchNotSynced {
+				} else if tracerr.Unwrap(err) == errLastL1BatchNotSynced ||
-					waitDuration = p.cfg.ForgeRetryInterval
+					tracerr.Unwrap(err) == errForgeNoTxsBeforeDelay ||
+					tracerr.Unwrap(err) == errForgeBeforeDelay {
+					waitCh = time.After(p.cfg.ForgeRetryInterval)
 					continue
 				} else if err != nil {
 					p.setErrAtBatchNum(batchNum)
-					waitDuration = p.cfg.ForgeRetryInterval
 					p.coord.SendMsg(p.ctx, MsgStopPipeline{
 						Reason: fmt.Sprintf(
 							"Pipeline.handleForgBatch: %v", err),
 						FailedBatchNum: batchNum,
 					})
+					waitCh = time.After(p.cfg.ForgeRetryInterval)
 					continue
 				}
+				p.lastForgeTime = time.Now()
 
 				p.state.batchNum = batchNum
 				select {
 				case batchChSentServerProof <- batchInfo:
 				case <-p.ctx.Done():
 				}
+				waitCh = time.After(zeroDuration)
 			}
 		}
 	}()
@@ -376,8 +389,9 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo, e
 		return nil, tracerr.Wrap(err)
 	}
 	// Structure to accumulate data and metadata of the batch
+	now := time.Now()
 	batchInfo = &BatchInfo{PipelineNum: p.num, BatchNum: batchNum}
-	batchInfo.Debug.StartTimestamp = time.Now()
+	batchInfo.Debug.StartTimestamp = now
 	batchInfo.Debug.StartBlockNum = p.stats.Eth.LastBlock.Num + 1
 
 	selectionCfg := &txselector.SelectionConfig{
@@ -391,10 +405,17 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo, e
 	var auths [][]byte
 	var coordIdxs []common.Idx
 
-	// TODO: If there are no txs and we are behind the timeout, skip
+	// Check if the slot is not yet fulfilled
-	// forging a batch and return a particular error that can be handleded
+	slotCommitted := false
-	// in the loop where handleForgeBatch is called to retry after an
+	if p.stats.Sync.Auction.CurrentSlot.ForgerCommitment ||
-	// interval
+		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) {
@@ -412,9 +433,6 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo, e
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
-
-		p.state.lastScheduledL1BatchBlockNum = p.stats.Eth.LastBlock.Num + 1
-		p.state.lastForgeL1TxsNum++
 	} else {
 		// 2b: only L2 txs
 		coordIdxs, auths, l1CoordTxs, poolL2Txs, discardedL2Txs, err =
@@ -425,6 +443,43 @@ 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
@@ -469,6 +524,8 @@ 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
 }
 

coordinator/pipeline_test.go

@@ -25,6 +25,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func newBigInt(s string) *big.Int {
+	v, ok := new(big.Int).SetString(s, 10)
+	if !ok {
+		panic(fmt.Errorf("Can't set big.Int from %s", s))
+	}
+	return v
+}
+
 func TestPipelineShouldL1L2Batch(t *testing.T) {
 	ethClientSetup := test.NewClientSetupExample()
 	ethClientSetup.ChainID = big.NewInt(int64(chainID))
@@ -128,6 +136,11 @@ func preloadSync(t *testing.T, ethClient *test.Client, sync *synchronizer.Synchr
 	blocks, err := tc.GenerateBlocksFromInstructions(set)
 	require.NoError(t, err)
 	require.NotNil(t, blocks)
+	// Set StateRoots for batches manually (til doesn't set it)
+	blocks[0].Rollup.Batches[0].Batch.StateRoot =
+		newBigInt("0")
+	blocks[0].Rollup.Batches[1].Batch.StateRoot =
+		newBigInt("10941365282189107056349764238909072001483688090878331371699519307087372995595")
 
 	ethAddTokens(blocks, ethClient)
 	err = ethClient.CtlAddBlocks(blocks)

coordinator/purger.go

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

coordinator/purger_test.go

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

coordinator/txmanager.go

@@ -2,9 +2,9 @@ package coordinator
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"math/big"
+	"strings"
 	"time"
 
 	"github.com/ethereum/go-ethereum"
@@ -49,8 +49,6 @@ type TxManager struct {
 	// accNextNonce is the nonce that we should use to send the next tx.
 	// In some cases this will be a reused nonce of an already pending tx.
 	accNextNonce uint64
-	// accPendingNonce is the pending nonce of the account due to pending txs
-	// accPendingNonce uint64
 
 	lastSentL1BatchBlockNum int64
 }
@@ -70,14 +68,6 @@ func NewTxManager(ctx context.Context, cfg *Config, ethClient eth.ClientInterfac
 	if err != nil {
 		return nil, err
 	}
-	// accPendingNonce, err := ethClient.EthPendingNonceAt(ctx, *address)
-	// if err != nil {
-	// 	return nil, err
-	// }
-	// if accNonce != accPendingNonce {
-	// 	return nil, tracerr.Wrap(fmt.Errorf("currentNonce (%v) != accPendingNonce (%v)",
-	// 		accNonce, accPendingNonce))
-	// }
 	log.Infow("TxManager started", "nonce", accNonce)
 	return &TxManager{
 		cfg:               *cfg,
@@ -99,7 +89,6 @@ func NewTxManager(ctx context.Context, cfg *Config, ethClient eth.ClientInterfac
 		queue:          NewQueue(),
 		accNonce:       accNonce,
 		accNextNonce:   accNonce,
-		// accPendingNonce: accPendingNonce,
 	}, nil
 }
 
@@ -139,11 +128,14 @@ func (t *TxManager) NewAuth(ctx context.Context) (*bind.TransactOpts, error) {
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	inc := new(big.Int).Set(gasPrice)
+	if t.cfg.GasPriceIncPerc != 0 {
-	// TODO: Replace this by a value of percentage
+		inc := new(big.Int).Set(gasPrice)
-	const gasPriceDiv = 100
+		inc.Mul(inc, new(big.Int).SetInt64(t.cfg.GasPriceIncPerc))
-	inc.Div(inc, new(big.Int).SetUint64(gasPriceDiv))
+		// nolint reason: to calculate percentages we use 100
-	gasPrice.Add(gasPrice, inc)
+		inc.Div(inc, new(big.Int).SetUint64(100)) //nolint:gomnd
+		gasPrice.Add(gasPrice, inc)
+	}
+
 	// log.Debugw("TxManager: transaction metadata", "gasPrice", gasPrice)
 
 	auth, err := bind.NewKeyStoreTransactorWithChainID(t.ethClient.EthKeyStore(), t.account, t.chainID)
@@ -152,6 +144,13 @@ func (t *TxManager) NewAuth(ctx context.Context) (*bind.TransactOpts, error) {
 	}
 	auth.Value = big.NewInt(0) // in wei
 	// TODO: Calculate GasLimit based on the contents of the ForgeBatchArgs
+	// This requires a function that estimates the gas usage of the
+	// forgeBatch call based on the contents of the ForgeBatch args:
+	// - length of l2txs
+	// - length of l1Usertxs
+	// - length of l1CoordTxs with authorization signature
+	// - length of l1CoordTxs without authoriation signature
+	// - etc.
 	auth.GasLimit = 1000000
 	auth.GasPrice = gasPrice
 	auth.Nonce = nil
@@ -184,7 +183,7 @@ func (t *TxManager) shouldSendRollupForgeBatch(batchInfo *BatchInfo) error {
 func addPerc(v *big.Int, p int64) *big.Int {
 	r := new(big.Int).Set(v)
 	r.Mul(r, big.NewInt(p))
-	// nolint reason: to calculate percetnages we divide by 100
+	// nolint reason: to calculate percentages we divide by 100
 	r.Div(r, big.NewInt(100)) //nolit:gomnd
 	return r.Add(v, r)
 }
@@ -207,32 +206,35 @@ func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchIn
 		}
 		// RollupForgeBatch() calls ethclient.SendTransaction()
 		ethTx, err = t.ethClient.RollupForgeBatch(batchInfo.ForgeBatchArgs, auth)
-		if errors.Is(err, core.ErrNonceTooLow) {
+		// We check the errors via strings because we match the
+		// definition of the error from geth, with the string returned
+		// via RPC obtained by the client.
+		if err == nil {
+			break
+		} else if strings.Contains(err.Error(), core.ErrNonceTooLow.Error()) {
 			log.Warnw("TxManager ethClient.RollupForgeBatch incrementing nonce",
 				"err", err, "nonce", auth.Nonce, "batchNum", batchInfo.BatchNum)
 			auth.Nonce.Add(auth.Nonce, big.NewInt(1))
 			attempt--
-		} else if errors.Is(err, core.ErrNonceTooHigh) {
+		} else if strings.Contains(err.Error(), core.ErrNonceTooHigh.Error()) {
 			log.Warnw("TxManager ethClient.RollupForgeBatch decrementing nonce",
 				"err", err, "nonce", auth.Nonce, "batchNum", batchInfo.BatchNum)
 			auth.Nonce.Sub(auth.Nonce, big.NewInt(1))
 			attempt--
-		} else if errors.Is(err, core.ErrUnderpriced) {
+		} else if strings.Contains(err.Error(), core.ErrReplaceUnderpriced.Error()) {
 			log.Warnw("TxManager ethClient.RollupForgeBatch incrementing gasPrice",
 				"err", err, "gasPrice", auth.GasPrice, "batchNum", batchInfo.BatchNum)
 			auth.GasPrice = addPerc(auth.GasPrice, 10)
 			attempt--
-		} else if errors.Is(err, core.ErrReplaceUnderpriced) {
+		} else if strings.Contains(err.Error(), core.ErrUnderpriced.Error()) {
 			log.Warnw("TxManager ethClient.RollupForgeBatch incrementing gasPrice",
 				"err", err, "gasPrice", auth.GasPrice, "batchNum", batchInfo.BatchNum)
 			auth.GasPrice = addPerc(auth.GasPrice, 10)
 			attempt--
-		} else if err != nil {
+		} else {
 			log.Errorw("TxManager ethClient.RollupForgeBatch",
 				"attempt", attempt, "err", err, "block", t.stats.Eth.LastBlock.Num+1,
 				"batchNum", batchInfo.BatchNum)
-		} else {
-			break
 		}
 		select {
 		case <-ctx.Done():
@@ -261,7 +263,6 @@ func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchIn
 		batchInfo.Debug.StartTimestamp).Seconds()
 	t.cfg.debugBatchStore(batchInfo)
 
-	// t.lastPendingBatch = batchInfo.BatchNum
 	if !resend {
 		if batchInfo.L1Batch {
 			t.lastSentL1BatchBlockNum = t.stats.Eth.LastBlock.Num + 1
@@ -314,14 +315,15 @@ func (t *TxManager) handleReceipt(ctx context.Context, batchInfo *BatchInfo) (*i
 		}
 		if receipt.Status == types.ReceiptStatusFailed {
 			batchInfo.Debug.Status = StatusFailed
-			t.cfg.debugBatchStore(batchInfo)
 			_, err := t.ethClient.EthCall(ctx, batchInfo.EthTx, receipt.BlockNumber)
 			log.Warnw("TxManager receipt status is failed", "tx", receipt.TxHash,
 				"batch", batchInfo.BatchNum, "block", receipt.BlockNumber.Int64(),
 				"err", err)
+			batchInfo.EthTxErr = err
 			if batchInfo.BatchNum <= t.lastSuccessBatch {
 				t.lastSuccessBatch = batchInfo.BatchNum - 1
 			}
+			t.cfg.debugBatchStore(batchInfo)
 			return nil, tracerr.Wrap(fmt.Errorf(
 				"ethereum transaction receipt status is failed: %w", err))
 		} else if receipt.Status == types.ReceiptStatusSuccessful {
@@ -417,7 +419,7 @@ func (q *Queue) Push(batchInfo *BatchInfo) {
 
 // Run the TxManager
 func (t *TxManager) Run(ctx context.Context) {
-	waitDuration := longWaitDuration
+	waitCh := time.After(longWaitDuration)
 
 	var statsVars statsVars
 	select {
@@ -472,11 +474,11 @@ func (t *TxManager) Run(ctx context.Context) {
 				continue
 			}
 			t.queue.Push(batchInfo)
-			waitDuration = t.cfg.TxManagerCheckInterval
+			waitCh = time.After(t.cfg.TxManagerCheckInterval)
-		case <-time.After(waitDuration):
+		case <-waitCh:
 			queuePosition, batchInfo := t.queue.Next()
 			if batchInfo == nil {
-				waitDuration = longWaitDuration
+				waitCh = time.After(longWaitDuration)
 				continue
 			}
 			if err := t.checkEthTransactionReceipt(ctx, batchInfo); ctx.Err() != nil {
@@ -539,7 +541,6 @@ func (t *TxManager) Run(ctx context.Context) {
 
 func (t *TxManager) removeBadBatchInfos(ctx context.Context) error {
 	next := 0
-	// batchNum := 0
 	for {
 		batchInfo := t.queue.At(next)
 		if batchInfo == nil {
@@ -572,7 +573,6 @@ func (t *TxManager) removeBadBatchInfos(ctx context.Context) error {
 		// from the queue
 		if confirm == nil {
 			if batchInfo.PipelineNum < t.minPipelineNum {
-				// batchNum++
 				t.queue.Remove(next)
 				continue
 			}

db/historydb/historydb_test.go

@@ -22,6 +22,7 @@ import (
 )
 
 var historyDB *HistoryDB
+var historyDBWithACC *HistoryDB
 
 // In order to run the test you need to run a Posgres DB with
 // a database named "history" that is accessible by
@@ -38,10 +39,12 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
-	historyDB = NewHistoryDB(db)
+	historyDB = NewHistoryDB(db, nil)
 	if err != nil {
 		panic(err)
 	}
+	apiConnCon := dbUtils.NewAPICnnectionController(1, time.Second)
+	historyDBWithACC = NewHistoryDB(db, apiConnCon)
 	// Run tests
 	result := m.Run()
 	// Close DB
@@ -85,7 +88,7 @@ func TestBlocks(t *testing.T) {
 		blocks...,
 	)
 	// Get all blocks from DB
-	fetchedBlocks, err := historyDB.GetBlocks(fromBlock, toBlock)
+	fetchedBlocks, err := historyDB.getBlocks(fromBlock, toBlock)
 	assert.Equal(t, len(blocks), len(fetchedBlocks))
 	// Compare generated vs getted blocks
 	assert.NoError(t, err)
@@ -255,9 +258,8 @@ func TestTokens(t *testing.T) {
 	err := historyDB.AddTokens(tokens)
 	assert.NoError(t, err)
 	tokens = append([]common.Token{ethToken}, tokens...)
-	limit := uint(10)
 	// Fetch tokens
-	fetchedTokens, _, err := historyDB.GetTokens(nil, nil, "", nil, &limit, OrderAsc)
+	fetchedTokens, err := historyDB.GetTokensTest()
 	assert.NoError(t, err)
 	// Compare fetched tokens vs generated tokens
 	// All the tokens should have USDUpdate setted by the DB trigger
@@ -277,7 +279,7 @@ func TestTokens(t *testing.T) {
 		assert.NoError(t, historyDB.UpdateTokenValue(token.Symbol, value))
 	}
 	// Fetch tokens
-	fetchedTokens, _, err = historyDB.GetTokens(nil, nil, "", nil, &limit, OrderAsc)
+	fetchedTokens, err = historyDB.GetTokensTest()
 	assert.NoError(t, err)
 	// Compare fetched tokens vs generated tokens
 	// All the tokens should have USDUpdate setted by the DB trigger
@@ -312,9 +314,8 @@ func TestTokensUTF8(t *testing.T) {
 	assert.NoError(t, err)
 	// Work with nonUTFTokens as tokens one gets updated and non UTF-8 characters are lost
 	nonUTFTokens = append([]common.Token{ethToken}, nonUTFTokens...)
-	limit := uint(10)
 	// Fetch tokens
-	fetchedTokens, _, err := historyDB.GetTokens(nil, nil, "", nil, &limit, OrderAsc)
+	fetchedTokens, err := historyDB.GetTokensTest()
 	assert.NoError(t, err)
 	// Compare fetched tokens vs generated tokens
 	// All the tokens should have USDUpdate setted by the DB trigger
@@ -334,7 +335,7 @@ func TestTokensUTF8(t *testing.T) {
 		assert.NoError(t, historyDB.UpdateTokenValue(token.Symbol, value))
 	}
 	// Fetch tokens
-	fetchedTokens, _, err = historyDB.GetTokens(nil, nil, "", nil, &limit, OrderAsc)
+	fetchedTokens, err = historyDB.GetTokensTest()
 	assert.NoError(t, err)
 	// Compare fetched tokens vs generated tokens
 	// All the tokens should have USDUpdate setted by the DB trigger
@@ -376,6 +377,22 @@ func TestAccounts(t *testing.T) {
 		accs[i].Balance = nil
 		assert.Equal(t, accs[i], acc)
 	}
+	// Test AccountBalances
+	accUpdates := make([]common.AccountUpdate, len(accs))
+	for i, acc := range accs {
+		accUpdates[i] = common.AccountUpdate{
+			EthBlockNum: batches[acc.BatchNum-1].EthBlockNum,
+			BatchNum:    acc.BatchNum,
+			Idx:         acc.Idx,
+			Nonce:       common.Nonce(i),
+			Balance:     big.NewInt(int64(i)),
+		}
+	}
+	err = historyDB.AddAccountUpdates(accUpdates)
+	require.NoError(t, err)
+	fetchedAccBalances, err := historyDB.GetAllAccountUpdates()
+	require.NoError(t, err)
+	assert.Equal(t, accUpdates, fetchedAccBalances)
 }
 
 func TestTxs(t *testing.T) {
@@ -620,10 +637,10 @@ func TestTxs(t *testing.T) {
 	assert.Equal(t, common.TxTypeExit, dbL2Txs[3].Type)
 
 	// Tx ID
-	assert.Equal(t, "0x02d709307533c4e3c03f20751fc4d72bc18b225d14f9616525540a64342c7c350d", dbL2Txs[0].TxID.String())
+	assert.Equal(t, "0x024e555248100b69a8aabf6d31719b9fe8a60dcc6c3407904a93c8d2d9ade18ee5", dbL2Txs[0].TxID.String())
-	assert.Equal(t, "0x02e88bc5503f282cca045847668511290e642410a459bb67b1fafcd1b6097c149c", dbL2Txs[1].TxID.String())
+	assert.Equal(t, "0x021ae87ca34d50ff35d98dfc0d7c95f2bf2e4ffeebb82ea71f43a8b0dfa5d36d89", dbL2Txs[1].TxID.String())
-	assert.Equal(t, "0x027911262b43315c0b24942a02fe228274b6e4d57a476bfcdd7a324b3091362c7d", dbL2Txs[2].TxID.String())
+	assert.Equal(t, "0x024abce7f3f2382dc520ed557593f11dea1ee197e55b60402e664facc27aa19774", dbL2Txs[2].TxID.String())
-	assert.Equal(t, "0x02f572b63f2a5c302e1b9337ea6944bfbac3d199e4ddd262b5a53759c72ec10ee6", dbL2Txs[3].TxID.String())
+	assert.Equal(t, "0x02f921ad9e7a6e59606570fe12a7dde0e36014197de0363b9b45e5097d6f2b1dd0", dbL2Txs[3].TxID.String())
 
 	// Tx From and To IDx
 	assert.Equal(t, dbL2Txs[0].ToIdx, dbL2Txs[2].FromIdx)
@@ -1097,9 +1114,8 @@ func TestAddEscapeHatchWithdrawals(t *testing.T) {
 	assert.Equal(t, escapeHatchWithdrawals, dbEscapeHatchWithdrawals)
 }
 
-func TestGetMetrics(t *testing.T) {
+func TestGetMetricsAPI(t *testing.T) {
 	test.WipeDB(historyDB.DB())
-
 	set := `
 		Type: Blockchain
 
@@ -1156,7 +1172,7 @@ func TestGetMetrics(t *testing.T) {
 		assert.NoError(t, err)
 	}
 
-	res, err := historyDB.GetMetrics(common.BatchNum(numBatches))
+	res, err := historyDBWithACC.GetMetricsAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
 	assert.Equal(t, float64(numTx)/float64(numBatches-1), res.TransactionsPerBatch)
@@ -1175,7 +1191,7 @@ func TestGetMetrics(t *testing.T) {
 	assert.Equal(t, float64(0), res.AvgTransactionFee)
 }
 
-func TestGetMetricsMoreThan24Hours(t *testing.T) {
+func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {
 	test.WipeDB(historyDB.DB())
 
 	testUsersLen := 3
@@ -1195,7 +1211,8 @@ func TestGetMetricsMoreThan24Hours(t *testing.T) {
 	set = append(set, til.Instruction{Typ: til.TypeNewBlock})
 
 	// Transfers
-	for x := 0; x < 6000; x++ {
+	const numBlocks int = 30
+	for x := 0; x < numBlocks; x++ {
 		set = append(set, til.Instruction{
 			Typ:           common.TxTypeTransfer,
 			TokenID:       common.TokenID(0),
@@ -1219,51 +1236,46 @@ func TestGetMetricsMoreThan24Hours(t *testing.T) {
 	err = tc.FillBlocksExtra(blocks, &tilCfgExtra)
 	require.NoError(t, err)
 
-	const numBatches int = 6002
+	const numBatches int = 2 + numBlocks
-	const numTx int = 6003
+	const blockNum = 4 + numBlocks
-	const blockNum = 6005 - 1
 
 	// Sanity check
 	require.Equal(t, blockNum, len(blocks))
 
 	// Adding one batch per block
 	// batch frequency can be chosen
-	const frequency int = 15
+	const blockTime time.Duration = 3600 * time.Second
+	now := time.Now()
+	require.NoError(t, err)
 
 	for i := range blocks {
-		blocks[i].Block.Timestamp = time.Now().Add(-time.Second * time.Duration(frequency*(len(blocks)-i)))
+		blocks[i].Block.Timestamp = now.Add(-time.Duration(len(blocks)-1-i) * blockTime)
 		err = historyDB.AddBlockSCData(&blocks[i])
 		assert.NoError(t, err)
 	}
 
-	res, err := historyDB.GetMetrics(common.BatchNum(numBatches))
+	res, err := historyDBWithACC.GetMetricsAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
-	assert.Equal(t, math.Trunc((float64(numTx)/float64(numBatches-1))/0.001)*0.001, math.Trunc(res.TransactionsPerBatch/0.001)*0.001)
+	assert.InEpsilon(t, 1.0, res.TransactionsPerBatch, 0.1)
 
-	// Frequency is not exactly the desired one, some decimals may appear
+	assert.InEpsilon(t, res.BatchFrequency, float64(blockTime/time.Second), 0.1)
-	assert.GreaterOrEqual(t, res.BatchFrequency, float64(frequency))
+	assert.InEpsilon(t, 1.0/float64(blockTime/time.Second), res.TransactionsPerSecond, 0.1)
-	assert.Less(t, res.BatchFrequency, float64(frequency+1))
-	// Truncate frecuency into an int to do an exact check
-	assert.Equal(t, frequency, int(res.BatchFrequency))
-	// This may also be different in some decimals
-	// Truncate it to the third decimal to compare
-	assert.Equal(t, math.Trunc((float64(numTx)/float64(frequency*blockNum-frequency))/0.001)*0.001, math.Trunc(res.TransactionsPerSecond/0.001)*0.001)
 	assert.Equal(t, int64(3), res.TotalAccounts)
 	assert.Equal(t, int64(3), res.TotalBJJs)
 	// Til does not set fees
 	assert.Equal(t, float64(0), res.AvgTransactionFee)
 }
 
-func TestGetMetricsEmpty(t *testing.T) {
+func TestGetMetricsAPIEmpty(t *testing.T) {
 	test.WipeDB(historyDB.DB())
-	_, err := historyDB.GetMetrics(0)
+	_, err := historyDBWithACC.GetMetricsAPI(0)
 	assert.NoError(t, err)
 }
 
 func TestGetAvgTxFeeEmpty(t *testing.T) {
 	test.WipeDB(historyDB.DB())
-	_, err := historyDB.GetAvgTxFee()
+	_, err := historyDBWithACC.GetAvgTxFeeAPI()
 	assert.NoError(t, err)
 }
 

db/historydb/views.go

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

db/l2db/apiqueries.go

@@ -0,0 +1,125 @@
+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()
+	defer cancel()
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	defer l2db.apiConnCon.Release()
+	return l2db.AddAccountCreationAuth(auth)
+}
+
+// GetAccountCreationAuthAPI returns an account creation authorization from the DB
+func (l2db *L2DB) GetAccountCreationAuthAPI(addr ethCommon.Address) (*AccountCreationAuthAPI, error) {
+	cancel, err := l2db.apiConnCon.Acquire()
+	defer cancel()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	defer l2db.apiConnCon.Release()
+	auth := new(AccountCreationAuthAPI)
+	return auth, tracerr.Wrap(meddler.QueryRow(
+		l2db.db, auth,
+		"SELECT * FROM account_creation_auth WHERE eth_addr = $1;",
+		addr,
+	))
+}
+
+// AddTxAPI inserts a tx to the pool
+func (l2db *L2DB) AddTxAPI(tx *PoolL2TxWrite) error {
+	cancel, err := l2db.apiConnCon.Acquire()
+	defer cancel()
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	defer l2db.apiConnCon.Release()
+
+	row := l2db.db.QueryRow(`SELECT
+		($1::NUMERIC * token.usd * fee_percentage($2::NUMERIC)) /
+			(10.0 ^ token.decimals::NUMERIC)
+		FROM token WHERE token.token_id = $3;`,
+		tx.AmountFloat, tx.Fee, tx.TokenID)
+	var feeUSD float64
+	if err := row.Scan(&feeUSD); err != nil {
+		return tracerr.Wrap(err)
+	}
+	if feeUSD < l2db.minFeeUSD {
+		return tracerr.Wrap(fmt.Errorf("tx.feeUSD (%v) < minFeeUSD (%v)",
+			feeUSD, l2db.minFeeUSD))
+	}
+
+	// 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.db.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
+const selectPoolTxAPI = `SELECT  tx_pool.tx_id, hez_idx(tx_pool.from_idx, token.symbol) AS from_idx, tx_pool.effective_from_eth_addr, 
+tx_pool.effective_from_bjj, hez_idx(tx_pool.to_idx, token.symbol) AS to_idx, tx_pool.effective_to_eth_addr, 
+tx_pool.effective_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, tx_pool.batch_num, hez_idx(tx_pool.rq_from_idx, token.symbol) AS rq_from_idx, 
+hez_idx(tx_pool.rq_to_idx, token.symbol) AS 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, 
+token.item_id AS token_item_id, token.eth_block_num, token.eth_addr, token.name, token.symbol, token.decimals, token.usd, token.usd_update 
+FROM tx_pool INNER JOIN token ON tx_pool.token_id = token.token_id `
+
+// GetTxAPI return the specified Tx in PoolTxAPI format
+func (l2db *L2DB) GetTxAPI(txID common.TxID) (*PoolTxAPI, error) {
+	cancel, err := l2db.apiConnCon.Acquire()
+	defer cancel()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	defer l2db.apiConnCon.Release()
+	tx := new(PoolTxAPI)
+	return tx, tracerr.Wrap(meddler.QueryRow(
+		l2db.db, tx,
+		selectPoolTxAPI+"WHERE tx_id = $1;",
+		txID,
+	))
+}

db/l2db/l2db.go

@@ -25,17 +25,28 @@ type L2DB struct {
 	safetyPeriod common.BatchNum
 	ttl          time.Duration
 	maxTxs       uint32 // limit of txs that are accepted in the pool
+	minFeeUSD    float64
+	apiConnCon   *db.APIConnectionController
 }
 
 // NewL2DB creates a L2DB.
 // To create it, it's needed db connection, safety period expressed in batches,
 // maxTxs that the DB should have and TTL (time to live) for pending txs.
-func NewL2DB(db *sqlx.DB, safetyPeriod common.BatchNum, maxTxs uint32, TTL time.Duration) *L2DB {
+func NewL2DB(
+	db *sqlx.DB,
+	safetyPeriod common.BatchNum,
+	maxTxs uint32,
+	minFeeUSD float64,
+	TTL time.Duration,
+	apiConnCon *db.APIConnectionController,
+) *L2DB {
 	return &L2DB{
 		db:           db,
 		safetyPeriod: safetyPeriod,
 		ttl:          TTL,
 		maxTxs:       maxTxs,
+		minFeeUSD:    minFeeUSD,
+		apiConnCon:   apiConnCon,
 	}
 }
 
@@ -47,7 +58,6 @@ func (l2db *L2DB) DB() *sqlx.DB {
 
 // AddAccountCreationAuth inserts an account creation authorization into the DB
 func (l2db *L2DB) AddAccountCreationAuth(auth *common.AccountCreationAuth) error {
-	// return meddler.Insert(l2db.db, "account_creation_auth", auth)
 	_, err := l2db.db.Exec(
 		`INSERT INTO account_creation_auth (eth_addr, bjj, signature)
 		VALUES ($1, $2, $3);`,
@@ -66,34 +76,6 @@ func (l2db *L2DB) GetAccountCreationAuth(addr ethCommon.Address) (*common.Accoun
 	))
 }
 
-// GetAccountCreationAuthAPI returns an account creation authorization from the DB
-func (l2db *L2DB) GetAccountCreationAuthAPI(addr ethCommon.Address) (*AccountCreationAuthAPI, error) {
-	auth := new(AccountCreationAuthAPI)
-	return auth, tracerr.Wrap(meddler.QueryRow(
-		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 {
@@ -125,9 +107,8 @@ func (l2db *L2DB) UpdateTxsInfo(txs []common.PoolL2Tx) error {
 	return nil
 }
 
-// AddTxTest inserts a tx into the L2DB. This is useful for test purposes,
+// NewPoolL2TxWriteFromPoolL2Tx creates a new PoolL2TxWrite from a PoolL2Tx
-// but in production txs will only be inserted through the API
+func NewPoolL2TxWriteFromPoolL2Tx(tx *common.PoolL2Tx) *PoolL2TxWrite {
-func (l2db *L2DB) AddTxTest(tx *common.PoolL2Tx) error {
 	// transform tx from *common.PoolL2Tx to PoolL2TxWrite
 	insertTx := &PoolL2TxWrite{
 		TxID:      tx.TxID,
@@ -169,27 +150,25 @@ func (l2db *L2DB) AddTxTest(tx *common.PoolL2Tx) error {
 	f := new(big.Float).SetInt(tx.Amount)
 	amountF, _ := f.Float64()
 	insertTx.AmountFloat = amountF
+	return insertTx
+}
+
+// AddTxTest inserts a tx into the L2DB. This is useful for test purposes,
+// but in production txs will only be inserted through the API
+func (l2db *L2DB) AddTxTest(tx *common.PoolL2Tx) error {
+	insertTx := NewPoolL2TxWriteFromPoolL2Tx(tx)
 	// insert tx
 	return tracerr.Wrap(meddler.Insert(l2db.db, "tx_pool", insertTx))
 }
 
-// selectPoolTxAPI select part of queries to get PoolL2TxRead
-const selectPoolTxAPI = `SELECT  tx_pool.tx_id, hez_idx(tx_pool.from_idx, token.symbol) AS from_idx, tx_pool.effective_from_eth_addr, 
-tx_pool.effective_from_bjj, hez_idx(tx_pool.to_idx, token.symbol) AS to_idx, tx_pool.effective_to_eth_addr, 
-tx_pool.effective_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, tx_pool.batch_num, hez_idx(tx_pool.rq_from_idx, token.symbol) AS rq_from_idx, 
-hez_idx(tx_pool.rq_to_idx, token.symbol) AS 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, 
-token.item_id AS token_item_id, token.eth_block_num, token.eth_addr, token.name, token.symbol, token.decimals, token.usd, token.usd_update 
-FROM tx_pool INNER JOIN token ON tx_pool.token_id = token.token_id `
-
 // selectPoolTxCommon select part of queries to get common.PoolL2Tx
 const selectPoolTxCommon = `SELECT  tx_pool.tx_id, from_idx, to_idx, tx_pool.to_eth_addr, 
 tx_pool.to_bjj, tx_pool.token_id, tx_pool.amount, tx_pool.fee, tx_pool.nonce, 
 tx_pool.state, tx_pool.info, tx_pool.signature, tx_pool.timestamp, rq_from_idx, 
 rq_to_idx, tx_pool.rq_to_eth_addr, tx_pool.rq_to_bjj, tx_pool.rq_token_id, tx_pool.rq_amount, 
 tx_pool.rq_fee, tx_pool.rq_nonce, tx_pool.tx_type, 
-fee_percentage(tx_pool.fee::NUMERIC) * token.usd * tx_pool.amount_f AS fee_usd, token.usd_update  
+(fee_percentage(tx_pool.fee::NUMERIC) * token.usd * tx_pool.amount_f) /
+	(10.0 ^ token.decimals::NUMERIC) AS fee_usd, token.usd_update
 FROM tx_pool INNER JOIN token ON tx_pool.token_id = token.token_id `
 
 // GetTx  return the specified Tx in common.PoolL2Tx format
@@ -202,16 +181,6 @@ func (l2db *L2DB) GetTx(txID common.TxID) (*common.PoolL2Tx, error) {
 	))
 }
 
-// GetTxAPI return the specified Tx in PoolTxAPI format
-func (l2db *L2DB) GetTxAPI(txID common.TxID) (*PoolTxAPI, error) {
-	tx := new(PoolTxAPI)
-	return tx, tracerr.Wrap(meddler.QueryRow(
-		l2db.db, tx,
-		selectPoolTxAPI+"WHERE tx_id = $1;",
-		txID,
-	))
-}
-
 // GetPendingTxs return all the pending txs of the L2DB, that have a non NULL AbsoluteFee
 func (l2db *L2DB) GetPendingTxs() ([]common.PoolL2Tx, error) {
 	var txs []*common.PoolL2Tx
@@ -346,9 +315,10 @@ func (l2db *L2DB) InvalidateOldNonces(updatedAccounts []common.IdxNonce, batchNu
 // The state of the affected txs can change form Forged -> Pending or from Invalid -> Pending
 func (l2db *L2DB) Reorg(lastValidBatch common.BatchNum) error {
 	_, err := l2db.db.Exec(
-		`UPDATE tx_pool SET batch_num = NULL, state = $1 
+		`UPDATE tx_pool SET batch_num = NULL, state = $1
-		WHERE (state = $2 OR state = $3) AND batch_num > $4`,
+		WHERE (state = $2 OR state = $3 OR state = $4) AND batch_num > $5`,
 		common.PoolL2TxStatePending,
+		common.PoolL2TxStateForging,
 		common.PoolL2TxStateForged,
 		common.PoolL2TxStateInvalid,
 		lastValidBatch,
@@ -376,3 +346,14 @@ func (l2db *L2DB) Purge(currentBatchNum common.BatchNum) (err error) {
 	)
 	return tracerr.Wrap(err)
 }
+
+// PurgeByExternalDelete deletes all pending transactions marked with true in
+// the `external_delete` column.  An external process can set this column to
+// true to instruct the coordinator to delete the tx when possible.
+func (l2db *L2DB) PurgeByExternalDelete() error {
+	_, err := l2db.db.Exec(
+		`DELETE from tx_pool WHERE (external_delete = true AND state = $1);`,
+		common.PoolL2TxStatePending,
+	)
+	return tracerr.Wrap(err)
+}

db/l2db/l2db_test.go

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

db/l2db/views.go

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

db/migrations/0001.sql

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

db/utils.go

@@ -1,11 +1,13 @@
 package db
 
 import (
+	"context"
 	"database/sql"
 	"fmt"
 	"math/big"
 	"reflect"
 	"strings"
+	"time"
 
 	"github.com/gobuffalo/packr/v2"
 	"github.com/hermeznetwork/hermez-node/log"
@@ -13,6 +15,7 @@ import (
 	"github.com/jmoiron/sqlx"
 	migrate "github.com/rubenv/sql-migrate"
 	"github.com/russross/meddler"
+	"golang.org/x/sync/semaphore"
 )
 
 var migrations *migrate.PackrMigrationSource
@@ -84,6 +87,32 @@ func InitSQLDB(port int, host, user, password, name string) (*sqlx.DB, error) {
 	return db, nil
 }
 
+// APIConnectionController is used to limit the SQL open connections used by the API
+type APIConnectionController struct {
+	smphr   *semaphore.Weighted
+	timeout time.Duration
+}
+
+// NewAPICnnectionController initialize APIConnectionController
+func NewAPICnnectionController(maxConnections int, timeout time.Duration) *APIConnectionController {
+	return &APIConnectionController{
+		smphr:   semaphore.NewWeighted(int64(maxConnections)),
+		timeout: timeout,
+	}
+}
+
+// Acquire reserves a SQL connection. If the connection is not acquired
+// within the timeout, the function will return an error
+func (acc *APIConnectionController) Acquire() (context.CancelFunc, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), acc.timeout) //nolint:govet
+	return cancel, acc.smphr.Acquire(ctx, 1)
+}
+
+// Release frees a SQL connection
+func (acc *APIConnectionController) Release() {
+	acc.smphr.Release(1)
+}
+
 // initMeddler registers tags to be used to read/write from SQL DBs using meddler
 func initMeddler() {
 	meddler.Register("bigint", BigIntMeddler{})

eth/ethereum.go

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

eth/rollup.go

@@ -316,7 +316,7 @@ func NewRollupClient(client *EthereumClient, address ethCommon.Address, tokenHEZ
 	}
 	consts, err := c.RollupConstants()
 	if err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, tracerr.Wrap(fmt.Errorf("RollupConstants at %v: %w", address, err))
 	}
 	c.consts = consts
 	return c, nil
@@ -327,7 +327,7 @@ func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs, auth *bind.T
 	if auth == nil {
 		auth, err = c.client.NewAuth()
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		auth.GasLimit = 1000000
 	}
@@ -393,7 +393,7 @@ func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs, auth *bind.T
 		l1CoordinatorBytes, l1l2TxData, feeIdxCoordinator, args.VerifierIdx, args.L1Batch,
 		args.ProofA, args.ProofB, args.ProofC)
 	if err != nil {
-		return nil, tracerr.Wrap(fmt.Errorf("Failed Hermez.ForgeBatch: %w", err))
+		return nil, tracerr.Wrap(fmt.Errorf("Hermez.ForgeBatch: %w", err))
 	}
 	return tx, nil
 }
@@ -462,11 +462,11 @@ func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fro
 			}
 			fromIdxBig := big.NewInt(fromIdx)
 			toIdxBig := big.NewInt(toIdx)
-			depositAmountF, err := common.NewFloat16(depositAmount)
+			depositAmountF, err := common.NewFloat40(depositAmount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			amountF, err := common.NewFloat16(amount)
+			amountF, err := common.NewFloat40(amount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
@@ -497,11 +497,11 @@ func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp,
 			}
 			fromIdxBig := big.NewInt(fromIdx)
 			toIdxBig := big.NewInt(toIdx)
-			depositAmountF, err := common.NewFloat16(depositAmount)
+			depositAmountF, err := common.NewFloat40(depositAmount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
-			amountF, err := common.NewFloat16(amount)
+			amountF, err := common.NewFloat40(amount)
 			if err != nil {
 				return nil, tracerr.Wrap(err)
 			}
@@ -939,9 +939,9 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 		FeeIdxCoordinator:     []common.Idx{},
 	}
 	nLevels := c.consts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels
-	lenL1L2TxsBytes := int((nLevels/8)*2 + 2 + 1)
+	lenL1L2TxsBytes := int((nLevels/8)*2 + common.Float40BytesLength + 1)
 	numBytesL1TxUser := int(l1UserTxsLen) * lenL1L2TxsBytes
-	numTxsL1Coord := len(aux.EncodedL1CoordinatorTx) / common.L1CoordinatorTxBytesLen
+	numTxsL1Coord := len(aux.EncodedL1CoordinatorTx) / common.RollupConstL1CoordinatorTotalBytes
 	numBytesL1TxCoord := numTxsL1Coord * lenL1L2TxsBytes
 	numBeginL2Tx := numBytesL1TxCoord + numBytesL1TxUser
 	l1UserTxsData := []byte{}
@@ -968,7 +968,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.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
+		bytesL1Coordinator := aux.EncodedL1CoordinatorTx[i*common.RollupConstL1CoordinatorTotalBytes : (i+1)*common.RollupConstL1CoordinatorTotalBytes]
 		var signature []byte
 		v := bytesL1Coordinator[0]
 		s := bytesL1Coordinator[1:33]

eth/rollup_test.go

@@ -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.L1CoordinatorTxBytesLen
+	numTxsL1 := len(l1CoordinatorBytes) / common.RollupConstL1CoordinatorTotalBytes
 	for i := 0; i < numTxsL1; i++ {
-		bytesL1Coordinator := l1CoordinatorBytes[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
+		bytesL1Coordinator := l1CoordinatorBytes[i*common.RollupConstL1CoordinatorTotalBytes : (i+1)*common.RollupConstL1CoordinatorTotalBytes]
 		var signature []byte
 		v := bytesL1Coordinator[0]
 		s := bytesL1Coordinator[1:33]

go.mod

@@ -6,7 +6,6 @@ require (
 	github.com/BurntSushi/toml v0.3.1
 	github.com/dghubble/sling v1.3.0
 	github.com/ethereum/go-ethereum v1.9.25
-	github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 // indirect
 	github.com/getkin/kin-openapi v0.22.0
 	github.com/gin-contrib/cors v1.3.1
 	github.com/gin-gonic/gin v1.5.0
@@ -24,12 +23,11 @@ require (
 	github.com/mitchellh/mapstructure v1.3.0
 	github.com/rubenv/sql-migrate v0.0.0-20200616145509-8d140a17f351
 	github.com/russross/meddler v1.0.0
-	github.com/sirupsen/logrus v1.5.0 // indirect
-	github.com/status-im/keycard-go v0.0.0-20190424133014-d95853db0f48 // indirect
 	github.com/stretchr/testify v1.6.1
 	github.com/urfave/cli/v2 v2.2.0
 	go.uber.org/zap v1.16.0
 	golang.org/x/crypto v0.0.0-20201217014255-9d1352758620
 	golang.org/x/net v0.0.0-20200822124328-c89045814202
+	golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9
 	gopkg.in/go-playground/validator.v9 v9.29.1
 )

log/log.go

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

node/node.go

@@ -84,8 +84,15 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
+	var apiConnCon *dbUtils.APIConnectionController
+	if cfg.API.Explorer || mode == ModeCoordinator {
+		apiConnCon = dbUtils.NewAPICnnectionController(
+			cfg.API.MaxSQLConnections,
+			cfg.API.SQLConnectionTimeout.Duration,
+		)
+	}
 
-	historyDB := historydb.NewHistoryDB(db)
+	historyDB := historydb.NewHistoryDB(db, apiConnCon)
 
 	ethClient, err := ethclient.Dial(cfg.Web3.URL)
 	if err != nil {
@@ -96,8 +103,8 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	var keyStore *ethKeystore.KeyStore
 	if mode == ModeCoordinator {
 		ethCfg = eth.EthereumConfig{
-			CallGasLimit: cfg.Coordinator.EthClient.CallGasLimit,
+			CallGasLimit: 0, // cfg.Coordinator.EthClient.CallGasLimit,
-			GasPriceDiv:  cfg.Coordinator.EthClient.GasPriceDiv,
+			GasPriceDiv:  0, // cfg.Coordinator.EthClient.GasPriceDiv,
 		}
 
 		scryptN := ethKeystore.StandardScryptN
@@ -197,7 +204,9 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 			db,
 			cfg.Coordinator.L2DB.SafetyPeriod,
 			cfg.Coordinator.L2DB.MaxTxs,
+			cfg.Coordinator.L2DB.MinFeeUSD,
 			cfg.Coordinator.L2DB.TTL.Duration,
+			apiConnCon,
 		)
 
 		// Unlock FeeAccount EthAddr in the keystore to generate the
@@ -237,9 +246,6 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
 		serverProofs := make([]prover.Client, len(cfg.Coordinator.ServerProofs))
 		for i, serverProofCfg := range cfg.Coordinator.ServerProofs {
 			serverProofs[i] = prover.NewProofServerClient(serverProofCfg.URL,
@@ -291,12 +297,16 @@ 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{
@@ -417,7 +427,6 @@ func NewNodeAPI(
 		coordinatorEndpoints, explorerEndpoints,
 		engine,
 		hdb,
-		sdb,
 		l2db,
 		config,
 	)
@@ -575,6 +584,8 @@ func (n *Node) StartSynchronizer() {
 					}
 					if errors.Is(err, eth.ErrBlockHashMismatchEvent) {
 						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)
 					}

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)
+	historyDB := historydb.NewHistoryDB(db, nil)
 	// Clean DB
 	test.WipeDB(historyDB.DB())
 	// Populate DB
@@ -46,8 +46,7 @@ func TestPriceUpdater(t *testing.T) {
 	// Update prices
 	pu.UpdatePrices(context.Background())
 	// Check that prices have been updated
-	limit := uint(10)
+	fetchedTokens, err := historyDB.GetTokensTest()
-	fetchedTokens, _, err := historyDB.GetTokens(nil, nil, "", nil, &limit, historydb.OrderAsc)
 	require.NoError(t, err)
 	// TokenID 0 (ETH) is always on the DB
 	assert.Equal(t, 2, len(fetchedTokens))

synchronizer/synchronizer.go

@@ -18,6 +18,19 @@ 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 {
@@ -105,11 +118,11 @@ func (s *StatsHolder) UpdateEth(ethClient eth.ClientInterface) error {
 
 	lastBlock, err := ethClient.EthBlockByNumber(context.TODO(), -1)
 	if err != nil {
-		return tracerr.Wrap(err)
+		return tracerr.Wrap(fmt.Errorf("EthBlockByNumber: %w", err))
 	}
 	lastBatchNum, err := ethClient.RollupLastForgedBatch()
 	if err != nil {
-		return tracerr.Wrap(err)
+		return tracerr.Wrap(fmt.Errorf("RollupLastForgedBatch: %w", err))
 	}
 	s.rw.Lock()
 	s.Eth.Updated = now
@@ -375,7 +388,7 @@ 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(err)
+			return tracerr.Wrap(fmt.Errorf("AuctionCanForge: %w", err))
 		}
 		if !canForge {
 			return tracerr.Wrap(fmt.Errorf("Synchronized value of forger address for closed slot "+
@@ -406,7 +419,7 @@ func (s *Synchronizer) updateNextSlot(slot *common.Slot) error {
 		// BEGIN SANITY CHECK
 		canForge, err := s.ethClient.AuctionCanForge(slot.Forger, slot.StartBlock)
 		if err != nil {
-			return tracerr.Wrap(err)
+			return tracerr.Wrap(fmt.Errorf("AuctionCanForge: %w", err))
 		}
 		if !canForge {
 			return tracerr.Wrap(fmt.Errorf("Synchronized value of forger address for closed slot "+
@@ -531,7 +544,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(err)
+		return nil, nil, tracerr.Wrap(fmt.Errorf("EthBlockByNumber: %w", err))
 	}
 	log.Debugf("ethBlock: num: %v, parent: %v, hash: %v",
 		ethBlock.Num, ethBlock.ParentHash.String(), ethBlock.Hash.String())
@@ -648,11 +661,6 @@ func (s *Synchronizer) Sync2(ctx context.Context,
 		return nil, nil, tracerr.Wrap(err)
 	}
 
-	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,
@@ -660,6 +668,11 @@ func (s *Synchronizer) Sync2(ctx context.Context,
 			"ethLastBatch", s.stats.Eth.LastBatchNum,
 		)
 	}
+	log.Debugw("Synced block",
+		"syncLastBlockNum", s.stats.Sync.LastBlock.Num,
+		"syncBlocksPerc", s.stats.blocksPerc(),
+		"ethLastBlockNum", s.stats.Eth.LastBlock.Num,
+	)
 
 	return blockData, nil, nil
 }
@@ -710,15 +723,15 @@ func getInitialVariables(ethClient eth.ClientInterface,
 	consts *SCConsts) (*SCVariables, *StartBlockNums, error) {
 	rollupInit, rollupInitBlock, err := ethClient.RollupEventInit()
 	if err != nil {
-		return nil, nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(fmt.Errorf("RollupEventInit: %w", err))
 	}
 	auctionInit, auctionInitBlock, err := ethClient.AuctionEventInit()
 	if err != nil {
-		return nil, nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(fmt.Errorf("AuctionEventInit: %w", err))
 	}
 	wDelayerInit, wDelayerInitBlock, err := ethClient.WDelayerEventInit()
 	if err != nil {
-		return nil, nil, tracerr.Wrap(err)
+		return nil, nil, tracerr.Wrap(fmt.Errorf("WDelayerEventInit: %w", err))
 	}
 	rollupVars := rollupInit.RollupVariables()
 	auctionVars := auctionInit.AuctionVariables(consts.Auction.InitialMinimalBidding)
@@ -811,8 +824,10 @@ 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)
-	if err != nil {
+	if err != nil && err.Error() == errStrUnknownBlock {
-		return nil, tracerr.Wrap(err)
+		return nil, tracerr.Wrap(ErrUnknownBlock)
+	} else if err != nil {
+		return nil, tracerr.Wrap(fmt.Errorf("RollupEventsByBlock: %w", err))
 	}
 	// No events in this block
 	if rollupEvents == nil {
@@ -978,6 +993,19 @@ func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, e
 		}
 		batchData.CreatedAccounts = processTxsOut.CreatedAccounts
 
+		batchData.UpdatedAccounts = make([]common.AccountUpdate, 0,
+			len(processTxsOut.UpdatedAccounts))
+		for _, acc := range processTxsOut.UpdatedAccounts {
+			batchData.UpdatedAccounts = append(batchData.UpdatedAccounts,
+				common.AccountUpdate{
+					EthBlockNum: blockNum,
+					BatchNum:    batchNum,
+					Idx:         acc.Idx,
+					Nonce:       acc.Nonce,
+					Balance:     acc.Balance,
+				})
+		}
+
 		slotNum := int64(0)
 		if ethBlock.Num >= s.consts.Auction.GenesisBlockNum {
 			slotNum = (ethBlock.Num - s.consts.Auction.GenesisBlockNum) /
@@ -1121,8 +1149,10 @@ func (s *Synchronizer) auctionSync(ethBlock *common.Block) (*common.AuctionData,
 
 	// Get auction events in the block
 	auctionEvents, err := s.ethClient.AuctionEventsByBlock(blockNum, &ethBlock.Hash)
-	if err != nil {
+	if err != nil && err.Error() == errStrUnknownBlock {
-		return nil, tracerr.Wrap(err)
+		return nil, tracerr.Wrap(ErrUnknownBlock)
+	} else if err != nil {
+		return nil, tracerr.Wrap(fmt.Errorf("AuctionEventsByBlock: %w", err))
 	}
 	// No events in this block
 	if auctionEvents == nil {
@@ -1218,8 +1248,10 @@ func (s *Synchronizer) wdelayerSync(ethBlock *common.Block) (*common.WDelayerDat
 
 	// Get wDelayer events in the block
 	wDelayerEvents, err := s.ethClient.WDelayerEventsByBlock(blockNum, &ethBlock.Hash)
-	if err != nil {
+	if err != nil && err.Error() == errStrUnknownBlock {
-		return nil, tracerr.Wrap(err)
+		return nil, tracerr.Wrap(ErrUnknownBlock)
+	} else if err != nil {
+		return nil, tracerr.Wrap(fmt.Errorf("WDelayerEventsByBlock: %w", err))
 	}
 	// No events in this block
 	if wDelayerEvents == nil {

synchronizer/synchronizer_test.go

@@ -17,7 +17,6 @@ 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"
@@ -172,6 +171,8 @@ func checkSyncBlock(t *testing.T, s *Synchronizer, blockNum int, block, syncBloc
 			*exit = syncBatch.ExitTree[j]
 		}
 		assert.Equal(t, batch.Batch, syncBatch.Batch)
+		// Ignore updated accounts
+		syncBatch.UpdatedAccounts = nil
 		assert.Equal(t, batch, syncBatch)
 		assert.Equal(t, &batch.Batch, dbBatch) //nolint:gosec
 
@@ -314,13 +315,21 @@ func newTestModules(t *testing.T) (*statedb.StateDB, *historydb.HistoryDB) {
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	historyDB := historydb.NewHistoryDB(db)
+	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
@@ -339,7 +348,6 @@ 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()
@@ -434,12 +442,22 @@ 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)
@@ -614,6 +632,12 @@ 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/ethclient.go

@@ -797,11 +797,11 @@ func (c *Client) RollupL1UserTxERC20ETH(
 	cpy := c.nextBlock().copy()
 	defer func() { c.revertIfErr(err, cpy) }()
 
-	_, err = common.NewFloat16(amount)
+	_, err = common.NewFloat40(amount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	_, err = common.NewFloat16(depositAmount)
+	_, err = common.NewFloat40(depositAmount)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}

test/proofserver/proofserver.go

@@ -145,7 +145,7 @@ const longWaitDuration = 999 * time.Hour
 // const provingDuration = 2 * time.Second
 
 func (s *Mock) runProver(ctx context.Context) {
-	waitDuration := longWaitDuration
+	waitCh := time.After(longWaitDuration)
 	for {
 		select {
 		case <-ctx.Done():
@@ -153,21 +153,21 @@ func (s *Mock) runProver(ctx context.Context) {
 		case msg := <-s.msgCh:
 			switch msg.value {
 			case "cancel":
-				waitDuration = longWaitDuration
+				waitCh = time.After(longWaitDuration)
 				s.Lock()
 				if !s.status.IsReady() {
 					s.status = prover.StatusCodeAborted
 				}
 				s.Unlock()
 			case "prove":
-				waitDuration = s.provingDuration
+				waitCh = time.After(s.provingDuration)
 				s.Lock()
 				s.status = prover.StatusCodeBusy
 				s.Unlock()
 			}
 			msg.ackCh <- true
-		case <-time.After(waitDuration):
+		case <-waitCh:
-			waitDuration = longWaitDuration
+			waitCh = time.After(longWaitDuration)
 			s.Lock()
 			if s.status != prover.StatusCodeBusy {
 				s.Unlock()

test/txsets/txhelpers.go

@@ -142,10 +142,12 @@ 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: big.NewInt(16000000),
+			DepositAmount: depositAmount,
 			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)
+	hdb := historydb.NewHistoryDB(db, nil)
 	assert.NoError(t, hdb.AddBlock(&common.Block{
 		Num: 1,
 	}))
@@ -75,7 +75,7 @@ func initTxSelector(t *testing.T, chainID uint16, hermezContractAddr ethCommon.A
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour)
+	l2DB := l2db.NewL2DB(db, 10, 100, 0.0, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpSyncDB")
 	require.NoError(t, err)
@@ -311,7 +311,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, "9971598169768987067017223790214537222850903267980994716992761290793474746117", h.String())
+	assert.Equal(t, "18608843755023673022528019960628191162333429206359207449879743919826610006009", h.String())
 	sendProofAndCheckResp(t, zki)
 
 	// batch3
@@ -334,7 +334,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, "7992262236065691439683036344554725221924027193771770363772735722054938818364", h.String())
+	assert.Equal(t, "6651837443119278772088559395433504719862425648816904171510845286897104469889", 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 = 376
+const MaxTx = 352
 const NLevels = 32
 const MaxL1Tx = 256
 const MaxFeeTx = 64
@@ -61,6 +61,7 @@ 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,16 +27,21 @@ 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  uint16
+	// ChainID of the blockchain
+	ChainID uint16
 }
 
 type processedExit struct {
@@ -53,6 +58,9 @@ type ProcessTxOutput struct {
 	CreatedAccounts    []common.Account
 	CoordinatorIdxsMap map[common.TokenID]common.Idx
 	CollectedFees      map[common.TokenID]*big.Int
+	// UpdatedAccounts returns the current state of each account
+	// created/updated by any of the processed transactions.
+	UpdatedAccounts map[common.Idx]*common.Account
 }
 
 func newErrorNotEnoughBalance(tx common.Tx) error {
@@ -125,6 +133,10 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 		return nil, tracerr.Wrap(fmt.Errorf("L1UserTx + L1CoordinatorTx (%d) can not be bigger than MaxL1Tx (%d)", len(l1usertxs)+len(l1coordinatortxs), tp.config.MaxTx))
 	}
 
+	if tp.s.Type() == statedb.TypeSynchronizer {
+		tp.updatedAccounts = make(map[common.Idx]*common.Account)
+	}
+
 	exits := make([]processedExit, nTx)
 
 	if tp.s.Type() == statedb.TypeBatchBuilder {
@@ -196,7 +208,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 			}
 		}
 		if tp.s.Type() == statedb.TypeSynchronizer || tp.s.Type() == statedb.TypeBatchBuilder {
-			if exitIdx != nil && exitTree != nil {
+			if exitIdx != nil && exitTree != nil && exitAccount != nil {
 				exits[tp.i] = processedExit{
 					exit:    true,
 					newExit: newExit,
@@ -380,7 +392,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 			tp.zki.EthAddr3[iFee] = common.EthAddrToBigInt(accCoord.EthAddr)
 		}
 		accCoord.Balance = new(big.Int).Add(accCoord.Balance, accumulatedFee)
-		pFee, err := tp.s.UpdateAccount(idx, accCoord)
+		pFee, err := tp.updateAccount(idx, accCoord)
 		if err != nil {
 			log.Error(err)
 			return nil, tracerr.Wrap(err)
@@ -405,39 +417,39 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 		return nil, nil
 	}
 
-	// once all txs processed (exitTree root frozen), for each Exit,
-	// generate common.ExitInfo data
-	var exitInfos []common.ExitInfo
-	exitInfosByIdx := make(map[common.Idx]*common.ExitInfo)
-	for i := 0; i < nTx; i++ {
-		if !exits[i].exit {
-			continue
-		}
-		exitIdx := exits[i].idx
-		exitAccount := exits[i].acc
-
-		// 0. generate MerkleProof
-		p, err := exitTree.GenerateSCVerifierProof(exitIdx.BigInt(), nil)
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-
-		// 1. generate common.ExitInfo
-		ei := common.ExitInfo{
-			AccountIdx:  exitIdx,
-			MerkleProof: p,
-			Balance:     exitAccount.Balance,
-		}
-		if prevExit, ok := exitInfosByIdx[exitIdx]; !ok {
-			exitInfos = append(exitInfos, ei)
-			exitInfosByIdx[exitIdx] = &exitInfos[len(exitInfos)-1]
-		} else {
-			*prevExit = ei
-		}
-	}
-
 	if tp.s.Type() == statedb.TypeSynchronizer {
-		// retuTypeexitInfos, createdAccounts and collectedFees, so Synchronizer will
+		// once all txs processed (exitTree root frozen), for each Exit,
+		// generate common.ExitInfo data
+		var exitInfos []common.ExitInfo
+		exitInfosByIdx := make(map[common.Idx]*common.ExitInfo)
+		for i := 0; i < nTx; i++ {
+			if !exits[i].exit {
+				continue
+			}
+			exitIdx := exits[i].idx
+			exitAccount := exits[i].acc
+
+			// 0. generate MerkleProof
+			p, err := exitTree.GenerateSCVerifierProof(exitIdx.BigInt(), nil)
+			if err != nil {
+				return nil, tracerr.Wrap(err)
+			}
+
+			// 1. generate common.ExitInfo
+			ei := common.ExitInfo{
+				AccountIdx:  exitIdx,
+				MerkleProof: p,
+				Balance:     exitAccount.Balance,
+			}
+			if prevExit, ok := exitInfosByIdx[exitIdx]; !ok {
+				exitInfos = append(exitInfos, ei)
+				exitInfosByIdx[exitIdx] = &exitInfos[len(exitInfos)-1]
+			} else {
+				*prevExit = ei
+			}
+		}
+
+		// retun exitInfos, createdAccounts and collectedFees, so Synchronizer will
 		// be able to store it into HistoryDB for the concrete BatchNum
 		return &ProcessTxOutput{
 			ZKInputs:           nil,
@@ -445,6 +457,7 @@ func (tp *TxProcessor) ProcessTxs(coordIdxs []common.Idx, l1usertxs, l1coordinat
 			CreatedAccounts:    createdAccounts,
 			CoordinatorIdxsMap: coordIdxsMap,
 			CollectedFees:      collectedFees,
+			UpdatedAccounts:    tp.updatedAccounts,
 		}, nil
 	}
 
@@ -501,11 +514,11 @@ func (tp *TxProcessor) ProcessL1Tx(exitTree *merkletree.MerkleTree, tx *common.L
 		tp.zki.OnChain[tp.i] = big.NewInt(1)
 
 		// L1Txs
-		depositAmountF16, err := common.NewFloat16(tx.DepositAmount)
+		depositAmountF40, err := common.NewFloat40(tx.DepositAmount)
 		if err != nil {
 			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
-		tp.zki.DepositAmountF[tp.i] = big.NewInt(int64(depositAmountF16))
+		tp.zki.DepositAmountF[tp.i] = big.NewInt(int64(depositAmountF40))
 		tp.zki.FromEthAddr[tp.i] = common.EthAddrToBigInt(tx.FromEthAddr)
 		if tx.FromBJJ != common.EmptyBJJComp {
 			tp.zki.FromBJJCompressed[tp.i] = BJJCompressedTo256BigInts(tx.FromBJJ)
@@ -515,6 +528,20 @@ 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 {
@@ -657,6 +684,11 @@ 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
@@ -720,7 +752,7 @@ func (tp *TxProcessor) applyCreateAccount(tx *common.L1Tx) error {
 		EthAddr: tx.FromEthAddr,
 	}
 
-	p, err := tp.s.CreateAccount(common.Idx(tp.s.CurrentIdx()+1), account)
+	p, err := tp.createAccount(common.Idx(tp.s.CurrentIdx()+1), account)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -755,6 +787,28 @@ func (tp *TxProcessor) applyCreateAccount(tx *common.L1Tx) error {
 	return tp.s.SetCurrentIdx(tp.s.CurrentIdx() + 1)
 }
 
+// createAccount is a wrapper over the StateDB.CreateAccount method that also
+// stores the created account in the updatedAccounts map in case the StateDB is
+// of TypeSynchronizer
+func (tp *TxProcessor) createAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
+	if tp.s.Type() == statedb.TypeSynchronizer {
+		account.Idx = idx
+		tp.updatedAccounts[idx] = account
+	}
+	return tp.s.CreateAccount(idx, account)
+}
+
+// updateAccount is a wrapper over the StateDB.UpdateAccount method that also
+// stores the updated account in the updatedAccounts map in case the StateDB is
+// of TypeSynchronizer
+func (tp *TxProcessor) updateAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
+	if tp.s.Type() == statedb.TypeSynchronizer {
+		account.Idx = idx
+		tp.updatedAccounts[idx] = account
+	}
+	return tp.s.UpdateAccount(idx, account)
+}
+
 // applyDeposit updates the balance in the account of the depositer, if
 // andTransfer parameter is set to true, the method will also apply the
 // Transfer of the L1Tx/DepositTransfer
@@ -785,7 +839,7 @@ func (tp *TxProcessor) applyDeposit(tx *common.L1Tx, transfer bool) error {
 	}
 
 	// update sender account in localStateDB
-	p, err := tp.s.UpdateAccount(tx.FromIdx, accSender)
+	p, err := tp.updateAccount(tx.FromIdx, accSender)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -822,7 +876,7 @@ func (tp *TxProcessor) applyDeposit(tx *common.L1Tx, transfer bool) error {
 		accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.EffectiveAmount)
 
 		// update receiver account in localStateDB
-		p, err := tp.s.UpdateAccount(tx.ToIdx, accReceiver)
+		p, err := tp.updateAccount(tx.ToIdx, accReceiver)
 		if err != nil {
 			return tracerr.Wrap(err)
 		}
@@ -905,7 +959,7 @@ func (tp *TxProcessor) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 	}
 
 	// update sender account in localStateDB
-	pSender, err := tp.s.UpdateAccount(tx.FromIdx, accSender)
+	pSender, err := tp.updateAccount(tx.FromIdx, accSender)
 	if err != nil {
 		log.Error(err)
 		return tracerr.Wrap(err)
@@ -944,7 +998,7 @@ func (tp *TxProcessor) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 	accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.Amount)
 
 	// update receiver account in localStateDB
-	pReceiver, err := tp.s.UpdateAccount(auxToIdx, accReceiver)
+	pReceiver, err := tp.updateAccount(auxToIdx, accReceiver)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -987,7 +1041,7 @@ func (tp *TxProcessor) applyCreateAccountDepositTransfer(tx *common.L1Tx) error
 	}
 
 	// create Account of the Sender
-	p, err := tp.s.CreateAccount(common.Idx(tp.s.CurrentIdx()+1), accSender)
+	p, err := tp.createAccount(common.Idx(tp.s.CurrentIdx()+1), accSender)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1035,7 +1089,7 @@ func (tp *TxProcessor) applyCreateAccountDepositTransfer(tx *common.L1Tx) error
 	accReceiver.Balance = new(big.Int).Add(accReceiver.Balance, tx.EffectiveAmount)
 
 	// update receiver account in localStateDB
-	p, err = tp.s.UpdateAccount(tx.ToIdx, accReceiver)
+	p, err = tp.updateAccount(tx.ToIdx, accReceiver)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -1109,7 +1163,7 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 		}
 	}
 
-	p, err := tp.s.UpdateAccount(tx.FromIdx, acc)
+	p, err := tp.updateAccount(tx.FromIdx, acc)
 	if err != nil {
 		return nil, false, tracerr.Wrap(err)
 	}
@@ -1120,6 +1174,11 @@ func (tp *TxProcessor) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 	if exitTree == nil {
 		return nil, false, nil
 	}
+	if tx.Amount.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:

txprocessor/txprocessor_test.go

@@ -1,11 +1,10 @@
 package txprocessor
 
 import (
-	"encoding/binary"
-	"encoding/hex"
 	"io/ioutil"
 	"math/big"
 	"os"
+	"sort"
 	"testing"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
@@ -642,17 +641,16 @@ func TestCreateAccountDepositMaxValue(t *testing.T) {
 
 	users := txsets.GenerateJsUsers(t)
 
-	daMaxHex, err := hex.DecodeString("FFFF")
+	daMaxF40 := common.Float40(0xFFFFFFFFFF)
+	daMaxBI, err := daMaxF40.BigInt()
 	require.NoError(t, err)
-	daMaxF16 := common.Float16(binary.BigEndian.Uint16(daMaxHex))
+	assert.Equal(t, "343597383670000000000000000000000000000000", daMaxBI.String())
-	daMaxBI := daMaxF16.BigInt()
-	assert.Equal(t, "10235000000000000000000000000000000", daMaxBI.String())
 
-	daMax1Hex, err := hex.DecodeString("FFFE")
+	daMax1F40 := common.Float40(0xFFFFFFFFFE)
 	require.NoError(t, err)
-	daMax1F16 := common.Float16(binary.BigEndian.Uint16(daMax1Hex))
+	daMax1BI, err := daMax1F40.BigInt()
-	daMax1BI := daMax1F16.BigInt()
+	require.NoError(t, err)
-	assert.Equal(t, "10225000000000000000000000000000000", daMax1BI.String())
+	assert.Equal(t, "343597383660000000000000000000000000000000", daMax1BI.String())
 
 	l1Txs := []common.L1Tx{
 		{
@@ -914,3 +912,198 @@ 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/txselector.go

@@ -3,7 +3,6 @@ package txselector
 // current: very simple version of TxSelector
 
 import (
-	"bytes"
 	"fmt"
 	"math/big"
 	"sort"
@@ -19,19 +18,6 @@ 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.
@@ -191,14 +177,16 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 	}
 
 	// discardedL2Txs contains an array of the L2Txs that have not been selected in this Batch
-	var discardedL2Txs []common.PoolL2Tx
 
 	var l1CoordinatorTxs []common.L1Tx
 	positionL1 := len(l1UserTxs)
 	var accAuths [][]byte
 
 	// sort l2TxsRaw (cropping at MaxTx at this point)
-	l2Txs0 := txsel.getL2Profitable(l2TxsRaw, selectionConfig.TxProcessorConfig.MaxTx)
+	l2Txs0, discardedL2Txs := txsel.getL2Profitable(l2TxsRaw, selectionConfig.TxProcessorConfig.MaxTx)
+	for i := range discardedL2Txs {
+		discardedL2Txs[i].Info = "Tx not selected due to low absolute fee"
+	}
 
 	noncesMap := make(map[common.Idx]common.Nonce)
 	var l2Txs []common.PoolL2Tx
@@ -232,7 +220,8 @@ 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 due the L2Tx depends on a L1CoordinatorTx and there is not enough space for L1Coordinator"
+				l2Txs0[i].Info = "Tx not selected because the L2Tx depends on a " +
+					"L1CoordinatorTx and there is not enough space for L1Coordinator"
 				discardedL2Txs = append(discardedL2Txs, l2Txs0[i])
 				continue
 			}
@@ -257,7 +246,9 @@ 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 not enough Balance at the sender. Current sender account Balance: %s, Amount+Fee: %s", balance.String(), feeAndAmount.String())
+			l2Txs[i].Info = fmt.Sprintf("Tx not selected due to not enough Balance at the sender. "+
+				"Current sender account Balance: %s, Amount+Fee: %s",
+				balance.String(), feeAndAmount.String())
 			discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 			continue
 		}
@@ -269,7 +260,8 @@ 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 not current Nonce. Tx.Nonce: %d, Account.Nonce: %d", l2Txs[i].Nonce, nonce)
+			l2Txs[i].Info = fmt.Sprintf("Tx not selected due to not current Nonce. "+
+				"Tx.Nonce: %d, Account.Nonce: %d", l2Txs[i].Nonce, nonce)
 			discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 			continue
 		}
@@ -287,17 +279,30 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 				txsel.processTxToEthAddrBJJ(validTxs, selectionConfig,
 					len(l1UserTxs), l1CoordinatorTxs, positionL1, l2Txs[i])
 			if err != nil {
-				log.Debug(err)
+				log.Debugw("txsel.processTxToEthAddrBJJ", "err", 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 %s", err.Error())
+				l2Txs[i].Info = fmt.Sprintf("Tx not selected (in processTxToEthAddrBJJ) due to %s",
+					err.Error())
 				discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 				continue
 			}
-			if accAuth != nil && l1CoordinatorTx != nil {
+			if l1CoordinatorTx != nil {
-				accAuths = append(accAuths, accAuth.Signature)
+				// If ToEthAddr == 0xff.. this means that we
-				l1CoordinatorTxs = append(l1CoordinatorTxs, *l1CoordinatorTx)
+				// are handling a TransferToBJJ, which doesn't
-				positionL1++
+				// require an authorization because it doesn't
+				// 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)
@@ -310,8 +315,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 tx.ToIdx not found in StateDB. ToIdx: %d",
+				l2Txs[i].Info = fmt.Sprintf("Tx not selected due to tx.ToIdx not found in StateDB. "+
-					l2Txs[i].ToIdx)
+					"ToIdx: %d", l2Txs[i].ToIdx)
 				discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 				continue
 			}
@@ -323,7 +328,9 @@ 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 due ToEthAddr does not correspond to the Account.EthAddr. tx.ToIdx: %d, tx.ToEthAddr: %s, account.EthAddr: %s",
+					l2Txs[i].Info = fmt.Sprintf("Tx not selected because ToEthAddr "+
+						"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
@@ -337,7 +344,9 @@ 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 due tx.ToBJJ does not correspond to the Account.BJJ. tx.ToIdx: %d, tx.ToEthAddr: %s, tx.ToBJJ: %s, account.BJJ: %s",
+					l2Txs[i].Info = fmt.Sprintf("Tx not selected because tx.ToBJJ "+
+						"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
@@ -411,7 +420,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 %s", err.Error())
+			selectedL2Txs[i].Info = fmt.Sprintf("Tx not selected (in ProcessL2Tx) due to %s", err.Error())
 			discardedL2Txs = append(discardedL2Txs, selectedL2Txs[i])
 			continue
 		}
@@ -467,8 +476,7 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 
 	var l1CoordinatorTx *common.L1Tx
 	var accAuth *common.AccountCreationAuth
-	if !bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.EmptyAddr.Bytes()) &&
+	if l2Tx.ToEthAddr != common.EmptyAddr && l2Tx.ToEthAddr != common.FFAddr {
-		!bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.FFAddr.Bytes()) {
 		// case: ToEthAddr != 0x00 neither 0xff
 		if l2Tx.ToBJJ != common.EmptyBJJComp {
 			// case: ToBJJ!=0:
@@ -524,8 +532,7 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 			DepositAmount: big.NewInt(0),
 			Type:          common.TxTypeCreateAccountDeposit,
 		}
-	} else if bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.FFAddr.Bytes()) &&
+	} else if l2Tx.ToEthAddr == common.FFAddr && l2Tx.ToBJJ != common.EmptyBJJComp {
-		l2Tx.ToBJJ != common.EmptyBJJComp {
 		// if idx exist for EthAddr&BJJ use it
 		_, err := txsel.localAccountsDB.GetIdxByEthAddrBJJ(l2Tx.ToEthAddr, l2Tx.ToBJJ,
 			l2Tx.TokenID)
@@ -551,7 +558,8 @@ 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 not slots for L1CoordinatorTx to create a new account for receiver of L2Tx"))
+		return nil, nil, nil, tracerr.Wrap(fmt.Errorf("L2Tx discarded due to no available slots " +
+			"for L1CoordinatorTx to create a new account for receiver of L2Tx"))
 	}
 
 	return &l2Tx, l1CoordinatorTx, accAuth, nil
@@ -560,7 +568,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 bytes.Equal(l1CoordinatorTxs[i].FromEthAddr.Bytes(), addr.Bytes()) &&
+		if l1CoordinatorTxs[i].FromEthAddr == addr &&
 			l1CoordinatorTxs[i].TokenID == tokenID &&
 			l1CoordinatorTxs[i].FromBJJ == bjj {
 			return true
@@ -570,21 +578,33 @@ func checkAlreadyPendingToCreate(l1CoordinatorTxs []common.L1Tx, tokenID common.
 }
 
 // getL2Profitable returns the profitable selection of L2Txssorted by Nonce
-func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) []common.PoolL2Tx {
+func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) ([]common.PoolL2Tx,
-	sort.Sort(txs(l2Txs))
+	[]common.PoolL2Tx) {
-	if len(l2Txs) < int(max) {
+	// First sort by nonce so that txs from the same account are sorted so
-		return l2Txs
+	// that they could be applied in succession.
+	sort.Slice(l2Txs, func(i, j int) bool {
+		return l2Txs[i].Nonce < l2Txs[j].Nonce
+	})
+	// Sort by absolute fee with SliceStable, so that txs with same
+	// AbsoluteFee are not rearranged and nonce order is kept in such case
+	sort.SliceStable(l2Txs, func(i, j int) bool {
+		return l2Txs[i].AbsoluteFee > l2Txs[j].AbsoluteFee
+	})
+
+	discardedL2Txs := []common.PoolL2Tx{}
+	if len(l2Txs) > int(max) {
+		discardedL2Txs = l2Txs[max:]
+		l2Txs = l2Txs[:max]
 	}
-	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.SliceStable(l2Txs, func(i, j int) bool {
+	sort.Slice(l2Txs, func(i, j int) bool {
 		return l2Txs[i].Nonce < l2Txs[j].Nonce
 	})
 
-	return l2Txs
+	return l2Txs, discardedL2Txs
 }

txselector/txselector_test.go

@@ -29,7 +29,7 @@ func initTest(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour)
+	l2DB := l2db.NewL2DB(db, 10, 100, 0.0, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
@@ -48,7 +48,7 @@ func initTest(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address
 		BJJ:                 coordUser.BJJ.Public().Compress(),
 		AccountCreationAuth: nil,
 	}
-	fmt.Printf("%v", coordAccount)
+	// fmt.Printf("%v\n", coordAccount)
 	auth := common.AccountCreationAuth{
 		EthAddr: coordUser.Addr,
 		BJJ:     coordUser.BJJ.Public().Compress(),
@@ -106,7 +106,7 @@ func addTokens(t *testing.T, tc *til.Context, db *sqlx.DB) {
 		})
 	}
 
-	hdb := historydb.NewHistoryDB(db)
+	hdb := historydb.NewHistoryDB(db, nil)
 	assert.NoError(t, hdb.AddBlock(&common.Block{
 		Num: 1,
 	}))
@@ -424,9 +424,9 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
 	require.NoError(t, err)
 
-	expectedTxID0 := "0x0248bae02b5c8c3847d312bfac3a33ae790616e888f2f711f22aeaff007cde92c2" // 1st TransferToEthAddr
+	expectedTxID0 := "0x028847b86613c0b70be18c8622119ed045b42e4e47d7938fa90bb3d1dc14928965" // 1st TransferToEthAddr
-	expectedTxID1 := "0x0249af018311a393c337ab9174ca2466cba489e49942b4ca4e5c530903671c4aef" // 1st Exit
+	expectedTxID1 := "0x0200b18773dcf56f770d65870fb02041cb59a088fd35b7c3f3df69f8a250b99a42" // 1st Exit
-	expectedTxID2 := "0x0228b93a261a0cdc62f35588c03bd179d31a0807c28afffdb6a7aaf0c4f017e4cf" // 2nd TransferToEthAddr
+	expectedTxID2 := "0x029720ff506153f970f120ac638cd7ee759eeff2c2012e7634a78e4fdc05c04a90" // 2nd TransferToEthAddr
 
 	// batch2
 	// prepare the PoolL2Txs
@@ -497,3 +497,215 @@ 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)
+}