Extend L1Tx TxID tests for js checks

fix possible runtime error

api/account.go

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

api/api.go

@@ -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

@@ -22,7 +22,6 @@ import (
 	"github.com/hermeznetwork/hermez-node/db"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
-	"github.com/hermeznetwork/hermez-node/db/statedb"
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/hermez-node/test"
 	"github.com/hermeznetwork/hermez-node/test/til"
@@ -216,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, apiConnCon)
+	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)
@@ -239,7 +234,6 @@ func TestMain(m *testing.M) {
 		true,
 		apiGin,
 		hdb,
-		sdb,
 		l2DB,
 		&_config,
 	)
@@ -350,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)
@@ -529,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,
@@ -585,7 +594,7 @@ func TestTimeout(t *testing.T) {
 	hdbTO := historydb.NewHistoryDB(databaseTO, apiConnConTO)
 	require.NoError(t, err)
 	// L2DB
-	l2DBTO := l2db.NewL2DB(databaseTO, 10, 1000, 24*time.Hour, apiConnConTO)
+	l2DBTO := l2db.NewL2DB(databaseTO, 10, 1000, 0.0, 24*time.Hour, apiConnConTO)
 
 	// API
 	apiGinTO := gin.Default()
@@ -612,7 +621,6 @@ func TestTimeout(t *testing.T) {
 		true,
 		apiGinTO,
 		hdbTO,
-		nil,
 		l2DBTO,
 		&_config,
 	)

api/txspool.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"errors"
+	"fmt"
 	"math/big"
 	"net/http"
 
@@ -170,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/cfg.buidler.toml

@@ -32,7 +32,6 @@ URL = "http://localhost:8545"
 [Synchronizer]
 SyncLoopInterval = "1s"
 StatsRefreshPeriod = "1s"
-StoreAccountUpdates = true
 
 [SmartContracts]
 Rollup   = "0x8EEaea23686c319133a7cC110b840d1591d9AeE0"
@@ -67,6 +66,7 @@ BJJ = "0x1b176232f78ba0d388ecc5f4896eca2d3b3d4f272092469f559247297f5c0c13"
 [Coordinator.L2DB]
 SafetyPeriod = 10
 MaxTxs       = 512
+MinFeeUSD    = 0.0
 TTL          = "24h"
 PurgeBatchDelay = 10
 InvalidateBatchDelay = 20

cli/node/main.go

@@ -173,6 +173,7 @@ func cmdDiscard(c *cli.Context) error {
 		db,
 		cfg.Coordinator.L2DB.SafetyPeriod,
 		cfg.Coordinator.L2DB.MaxTxs,
+		cfg.Coordinator.L2DB.MinFeeUSD,
 		cfg.Coordinator.L2DB.TTL.Duration,
 		nil,
 	)

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) {

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,

common/utils.go

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

config/config.go

@@ -105,6 +105,10 @@ type Coordinator struct {
 		// reached, inserts to the pool will be denied until some of
 		// the pending txs are forged.
 		MaxTxs uint32 `validate:"required"`
+		// MinFeeUSD is the minimum fee in USD that a tx must pay in
+		// order to be accepted into the pool.  Txs with lower than
+		// minimum fee will be rejected at the API level.
+		MinFeeUSD float64
 		// TTL is the Time To Live for L2Txs in the pool.  Once MaxTxs
 		// L2Txs is reached, L2Txs older than TTL will be deleted.
 		TTL Duration `validate:"required"`
@@ -236,11 +240,6 @@ type Node struct {
 		// `Eth.LastBatch`).  This value only affects the reported % of
 		// synchronization of blocks and batches, nothing else.
 		StatsRefreshPeriod Duration `validate:"required"`
-		// StoreAccountUpdates when set to true makes the synchronizer
-		// store every account update in the account_update SQL table.
-		// This allows querying nonces and balances from the HistoryDB
-		// via SQL.
-		StoreAccountUpdates bool
 	} `validate:"required"`
 	SmartContracts struct {
 		// Rollup is the address of the Hermez.sol smart contract

coordinator/coordinator_test.go

@@ -105,7 +105,7 @@ func newTestModules(t *testing.T) modules {
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	test.WipeDB(db)
-	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, 10, 100, 0.0, 24*time.Hour, nil)
 	historyDB := historydb.NewHistoryDB(db, nil)
 
 	txSelDBPath, err = ioutil.TempDir("", "tmpTxSelDB")

coordinator/purger_test.go

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

coordinator/txmanager.go

@@ -231,7 +231,7 @@ func (t *TxManager) sendRollupForgeBatch(ctx context.Context, batchInfo *BatchIn
 				"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)

db/historydb/apiqueries.go

@@ -835,8 +835,16 @@ func (hdb *HistoryDB) GetAccountAPI(idx common.Idx) (*AccountAPI, error) {
 	err = meddler.QueryRow(hdb.db, account, `SELECT account.item_id, hez_idx(account.idx, 
 		token.symbol) as idx, account.batch_num, account.bjj, account.eth_addr,
 		token.token_id, token.item_id AS token_item_id, token.eth_block_num AS token_block,
-	token.eth_addr as token_eth_addr, token.name, token.symbol, token.decimals, token.usd, token.usd_update 
-	FROM account INNER JOIN token ON account.token_id = token.token_id WHERE idx = $1;`, idx)
+		token.eth_addr as token_eth_addr, token.name, token.symbol, token.decimals, token.usd,
+		token.usd_update, account_update.nonce, account_update.balance 
+		FROM account inner JOIN (
+			SELECT idx, nonce, balance 
+			FROM account_update
+			WHERE idx = $1
+			ORDER BY item_id DESC LIMIT 1
+		) AS account_update ON account_update.idx = account.idx 
+		INNER JOIN token ON account.token_id = token.token_id
+		WHERE account.idx = $1;`, idx)
 
 	if err != nil {
 		return nil, tracerr.Wrap(err)
@@ -864,8 +872,13 @@ func (hdb *HistoryDB) GetAccountsAPI(
 	queryStr := `SELECT account.item_id, hez_idx(account.idx, token.symbol) as idx, account.batch_num, 
 	account.bjj, account.eth_addr, token.token_id, token.item_id AS token_item_id, token.eth_block_num AS token_block,
 	token.eth_addr as token_eth_addr, token.name, token.symbol, token.decimals, token.usd, token.usd_update, 
-	COUNT(*) OVER() AS total_items
-	FROM account INNER JOIN token ON account.token_id = token.token_id `
+	account_update.nonce, account_update.balance, COUNT(*) OVER() AS total_items
+	FROM account inner JOIN (
+		SELECT DISTINCT idx,
+		first_value(nonce) over(partition by idx ORDER BY item_id DESC) as nonce,
+		first_value(balance) over(partition by idx ORDER BY item_id DESC) as balance
+		FROM account_update
+	) AS account_update ON account_update.idx = account.idx INNER JOIN token ON account.token_id = token.token_id `
 	// Apply filters
 	nextIsAnd := false
 	// ethAddr filter
@@ -1024,3 +1037,18 @@ func (hdb *HistoryDB) GetAvgTxFeeAPI() (float64, error) {
 
 	return avgTransactionFee, nil
 }
+
+// GetCommonAccountAPI returns the account associated to an account idx
+func (hdb *HistoryDB) GetCommonAccountAPI(idx common.Idx) (*common.Account, error) {
+	cancel, err := hdb.apiConnCon.Acquire()
+	defer cancel()
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	defer hdb.apiConnCon.Release()
+	account := &common.Account{}
+	err = meddler.QueryRow(
+		hdb.db, account, `SELECT * FROM account WHERE idx = $1;`, idx,
+	)
+	return account, tracerr.Wrap(err)
+}

db/historydb/historydb.go

@@ -447,7 +447,8 @@ func (hdb *HistoryDB) addTokens(d meddler.DB, tokens []common.Token) error {
 	))
 }
 
-// UpdateTokenValue updates the USD value of a token
+// UpdateTokenValue updates the USD value of a token.  Value is the price in
+// USD of a normalized token (1 token = 10^decimals units)
 func (hdb *HistoryDB) UpdateTokenValue(tokenSymbol string, value float64) error {
 	// Sanitize symbol
 	tokenSymbol = strings.ToValidUTF8(tokenSymbol, " ")

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
-	Balance          *apitypes.BigIntStr `meddler:"-"` // max of 192 bits used
+	Nonce            common.Nonce        `meddler:"nonce"`   // max of 40 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

@@ -1,12 +1,18 @@
 package l2db
 
 import (
+	"fmt"
+
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/russross/meddler"
 )
 
+var (
+	errPoolFull = fmt.Errorf("the pool is at full capacity. More transactions are not accepted currently")
+)
+
 // AddAccountCreationAuthAPI inserts an account creation authorization into the DB
 func (l2db *L2DB) AddAccountCreationAuthAPI(auth *common.AccountCreationAuth) error {
 	cancel, err := l2db.apiConnCon.Acquire()
@@ -42,20 +48,54 @@ func (l2db *L2DB) AddTxAPI(tx *PoolL2TxWrite) error {
 		return tracerr.Wrap(err)
 	}
 	defer l2db.apiConnCon.Release()
-	row := l2db.db.QueryRow(
-		"SELECT COUNT(*) FROM tx_pool WHERE state = $1;",
-		common.PoolL2TxStatePending,
-	)
-	var totalTxs uint32
-	if err := row.Scan(&totalTxs); err != nil {
+
+	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 totalTxs >= l2db.maxTxs {
-		return tracerr.New(
-			"The pool is at full capacity. More transactions are not accepted currently",
-		)
+	if feeUSD < l2db.minFeeUSD {
+		return tracerr.Wrap(fmt.Errorf("tx.feeUSD (%v) < minFeeUSD (%v)",
+			feeUSD, l2db.minFeeUSD))
 	}
-	return tracerr.Wrap(meddler.Insert(l2db.db, "tx_pool", tx))
+
+	// Prepare insert SQL query argument parameters
+	namesPart, err := meddler.Default.ColumnsQuoted(tx, false)
+	if err != nil {
+		return err
+	}
+	valuesPart, err := meddler.Default.PlaceholdersString(tx, false)
+	if err != nil {
+		return err
+	}
+	values, err := meddler.Default.Values(tx, false)
+	if err != nil {
+		return err
+	}
+
+	q := fmt.Sprintf(
+		`INSERT INTO tx_pool (%s)
+		SELECT %s
+		WHERE (SELECT COUNT(*) FROM tx_pool WHERE state = $%v) < $%v;`,
+		namesPart, valuesPart,
+		len(values)+1, len(values)+2) //nolint:gomnd
+	values = append(values, common.PoolL2TxStatePending, l2db.maxTxs)
+	res, err := l2db.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

db/l2db/l2db.go

@@ -25,6 +25,7 @@ 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
 }
 
@@ -35,6 +36,7 @@ func NewL2DB(
 	db *sqlx.DB,
 	safetyPeriod common.BatchNum,
 	maxTxs uint32,
+	minFeeUSD float64,
 	TTL time.Duration,
 	apiConnCon *db.APIConnectionController,
 ) *L2DB {
@@ -43,6 +45,7 @@ func NewL2DB(
 		safetyPeriod: safetyPeriod,
 		ttl:          TTL,
 		maxTxs:       maxTxs,
+		minFeeUSD:    minFeeUSD,
 		apiConnCon:   apiConnCon,
 	}
 }
@@ -104,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,
-// but in production txs will only be inserted through the API
-func (l2db *L2DB) AddTxTest(tx *common.PoolL2Tx) error {
+// NewPoolL2TxWriteFromPoolL2Tx creates a new PoolL2TxWrite from a PoolL2Tx
+func NewPoolL2TxWriteFromPoolL2Tx(tx *common.PoolL2Tx) *PoolL2TxWrite {
 	// transform tx from *common.PoolL2Tx to PoolL2TxWrite
 	insertTx := &PoolL2TxWrite{
 		TxID:      tx.TxID,
@@ -148,6 +150,13 @@ 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))
 }
@@ -158,7 +167,8 @@ 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

db/l2db/l2db_test.go

@@ -2,8 +2,7 @@ package l2db
 
 import (
 	"database/sql"
-	"math"
-	"math/big"
+	"fmt"
 	"os"
 	"testing"
 	"time"
@@ -21,12 +20,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+var decimals = uint64(3)
+var tokenValue = 1.0 // The price update gives a value of 1.0 USD to the token
 var l2DB *L2DB
 var l2DBWithACC *L2DB
 var historyDB *historydb.HistoryDB
 var tc *til.Context
 var tokens map[common.TokenID]historydb.TokenWithUSD
-var tokensValue map[common.TokenID]float64
+
 var accs map[common.Idx]common.Account
 
 func TestMain(m *testing.M) {
@@ -36,9 +37,9 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
-	l2DB = NewL2DB(db, 10, 1000, 24*time.Hour, nil)
+	l2DB = NewL2DB(db, 10, 1000, 0.0, 24*time.Hour, nil)
 	apiConnCon := dbUtils.NewAPICnnectionController(1, time.Second)
-	l2DBWithACC = NewL2DB(db, 10, 1000, 24*time.Hour, apiConnCon)
+	l2DBWithACC = NewL2DB(db, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB())
 	historyDB = historydb.NewHistoryDB(db, nil)
 	// Run tests
@@ -59,10 +60,10 @@ func prepareHistoryDB(historyDB *historydb.HistoryDB) error {
 
 			AddToken(1)
 			AddToken(2)
-			CreateAccountDeposit(1) A: 2000
-			CreateAccountDeposit(2) A: 2000
-			CreateAccountDeposit(1) B: 1000
-			CreateAccountDeposit(2) B: 1000
+			CreateAccountDeposit(1) A: 20000
+			CreateAccountDeposit(2) A: 20000
+			CreateAccountDeposit(1) B: 10000
+			CreateAccountDeposit(2) B: 10000
 			> batchL1 
 			> batchL1
 			> block
@@ -83,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 != nil {
+		if err := historyDB.AddBlockSCData(&blocks[i]); err != nil {
 			return tracerr.Wrap(err)
 		}
 		for _, batch := range blocks[i].Rollup.Batches {
@@ -107,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 (tokens have no symbol)
-		tokenSymbol := ""
-		err := historyDB.UpdateTokenValue(tokenSymbol, value)
+			// Set value to the tokens
+			err := historyDB.UpdateTokenValue(readToken.Symbol, *readToken.USD)
 			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(2) A-B: 3 (1)
-			PoolTransfer(1) B-A: 5 (2)
-			PoolTransfer(2) B-A: 10 (3)
-			PoolTransfer(1) A-B: 7 (2)
-			PoolTransfer(2) A-B: 2 (1)
-			PoolTransfer(1) B-A: 8 (2)
-			PoolTransfer(2) B-A: 1 (1)
-			PoolTransfer(1) A-B: 3 (1)
-			PoolTransferToEthAddr(2) B-A: 5 (2)
-			PoolTransferToBJJ(2) B-A: 5 (2)
+			PoolTransfer(1) A-B: 6000 (126)
+			PoolTransfer(2) A-B: 3000 (126)
+			PoolTransfer(1) B-A: 5000 (126)
+			PoolTransfer(2) B-A: 10000 (126)
+			PoolTransfer(1) A-B: 7000 (126)
+			PoolTransfer(2) A-B: 2000 (126)
+			PoolTransfer(1) B-A: 8000 (126)
+			PoolTransfer(2) B-A: 1000 (126)
+			PoolTransfer(1) A-B: 3000 (126)
+			PoolTransferToEthAddr(2) B-A: 5000 (126)
+			PoolTransferToBJJ(2) B-A: 5000 (126)
 
-			PoolExit(1) A: 5 (2)
-			PoolExit(2) B: 3 (1)
+			PoolExit(1) A: 5000 (126)
+			PoolExit(2) B: 3000 (126)
 		`
 	poolL2Txs, err := tc.GeneratePoolL2Txs(setPool)
 	if err != nil {
@@ -154,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)
@@ -186,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)
 	}
 }
@@ -204,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)
-		amountF, _ := f.Float64()
-		expected.AbsoluteFee = *token.USD * amountF * expected.Fee.Percentage()
+		amountUSD := common.TokensToUSD(expected.Amount, token.Decimals, *token.USD)
+		expected.AbsoluteFee = amountUSD * expected.Fee.Percentage()
 		test.AssertUSD(t, &expected.AbsoluteFee, &actual.AbsoluteFee)
 	}
 	assert.Equal(t, expected, actual)
@@ -231,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) {
@@ -254,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)
 		}
@@ -268,11 +333,11 @@ func TestStartForging(t *testing.T) {
 	}
 	// Start forging txs
 	err = l2DB.StartForging(startForgingTxIDs, fakeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range startForgingTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, common.PoolL2TxStateForging, fetchedTx.State)
 		assert.Equal(t, &fakeBatchNum, fetchedTx.BatchNum)
 	}
@@ -286,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)
 		}
@@ -300,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
@@ -312,12 +377,12 @@ func TestDoneForging(t *testing.T) {
 	}
 	// Done forging txs
 	err = l2DB.DoneForging(doneForgingTxIDs, fakeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range doneForgingTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, common.PoolL2TxStateForged, fetchedTx.State)
 		assert.Equal(t, &fakeBatchNum, fetchedTx.BatchNum)
 	}
@@ -331,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)
@@ -345,11 +410,11 @@ func TestInvalidate(t *testing.T) {
 	}
 	// Invalidate txs
 	err = l2DB.InvalidateTxs(invalidTxIDs, fakeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range invalidTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, common.PoolL2TxStateInvalid, fetchedTx.State)
 		assert.Equal(t, &fakeBatchNum, fetchedTx.BatchNum)
 	}
@@ -363,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)
@@ -380,13 +445,13 @@ func TestInvalidateOldNonces(t *testing.T) {
 			invalidTxIDs = append(invalidTxIDs, poolL2Txs[i].TxID)
 		}
 		err := l2DB.AddTxTest(&poolL2Txs[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 	// sanity check
 	require.Greater(t, len(invalidTxIDs), 0)
 
 	err = l2DB.InvalidateOldNonces(updateAccounts, fakeBatchNum)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Fetch txs and check that they've been updated correctly
 	for _, id := range invalidTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
@@ -408,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{}
@@ -419,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)
@@ -431,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
@@ -456,22 +521,22 @@ func TestReorg(t *testing.T) {
 
 	// Invalidate txs BEFORE reorgBatch --> nonReorg
 	err = l2DB.InvalidateTxs(invalidTxIDs, lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Done forging txs in reorgBatch --> Reorg
 	err = l2DB.DoneForging(doneForgingTxIDs, reorgBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = l2DB.Reorg(lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	for _, id := range reorgedTxIDs {
 		tx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, tx.BatchNum)
 		assert.Equal(t, common.PoolL2TxStatePending, tx.State)
 	}
 	for _, id := range nonReorgedTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, lastValidBatch, *fetchedTx.BatchNum)
 	}
 }
@@ -488,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{}
@@ -499,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)
@@ -511,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
@@ -533,22 +598,22 @@ func TestReorg2(t *testing.T) {
 	}
 	// Done forging txs BEFORE reorgBatch --> nonReorg
 	err = l2DB.DoneForging(doneForgingTxIDs, lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Invalidate txs in reorgBatch --> Reorg
 	err = l2DB.InvalidateTxs(invalidTxIDs, reorgBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = l2DB.Reorg(lastValidBatch)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	for _, id := range reorgedTxIDs {
 		tx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Nil(t, tx.BatchNum)
 		assert.Equal(t, common.PoolL2TxStatePending, tx.State)
 	}
 	for _, id := range nonReorgedTxIDs {
 		fetchedTx, err := l2DBWithACC.GetTxAPI(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, lastValidBatch, *fetchedTx.BatchNum)
 	}
 }
@@ -564,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...)
 	}
 
@@ -591,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 {
@@ -599,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 {
@@ -618,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)
@@ -631,7 +696,7 @@ func TestPurge(t *testing.T) {
 	}
 	for _, id := range keepedIDs {
 		_, err := l2DB.GetTx(id)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 }
 
@@ -645,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)
@@ -666,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)
@@ -709,7 +774,7 @@ func TestPurgeByExternalDelete(t *testing.T) {
 		log.Error("Error prepare historyDB", err)
 	}
 	txs, err := generatePoolL2Txs()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// We will work with 8 txs
 	require.GreaterOrEqual(t, len(txs), 8)

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
 );
 
@@ -662,35 +662,35 @@ CREATE TABLE account_creation_auth (
 );
 
 -- +migrate Down
--- drop triggers
-DROP TRIGGER trigger_token_usd_update ON token;
-DROP TRIGGER trigger_set_tx ON tx;
-DROP TRIGGER trigger_forge_l1_txs ON batch;
-DROP TRIGGER trigger_set_pool_tx ON tx_pool;
--- drop functions
-DROP FUNCTION hez_idx;
-DROP FUNCTION set_token_usd_update;
-DROP FUNCTION fee_percentage;
-DROP FUNCTION set_tx;
-DROP FUNCTION forge_l1_user_txs;
-DROP FUNCTION set_pool_tx;
--- drop tables
-DROP TABLE account_creation_auth;
-DROP TABLE tx_pool;
-DROP TABLE auction_vars;
-DROP TABLE rollup_vars;
-DROP TABLE escape_hatch_withdrawal;
-DROP TABLE bucket_update;
-DROP TABLE token_exchange;
-DROP TABLE wdelayer_vars;
-DROP TABLE tx;
-DROP TABLE exit_tree;
-DROP TABLE account_update;
-DROP TABLE account;
-DROP TABLE token;
-DROP TABLE bid;
-DROP TABLE batch;
-DROP TABLE coordinator;
-DROP TABLE block;
--- drop sequences
-DROP SEQUENCE tx_item_id;
+-- triggers
+DROP TRIGGER IF EXISTS trigger_token_usd_update ON token;
+DROP TRIGGER IF EXISTS trigger_set_tx ON tx;
+DROP TRIGGER IF EXISTS trigger_forge_l1_txs ON batch;
+DROP TRIGGER IF EXISTS trigger_set_pool_tx ON tx_pool;
+-- functions
+DROP FUNCTION IF EXISTS hez_idx;
+DROP FUNCTION IF EXISTS set_token_usd_update;
+DROP FUNCTION IF EXISTS fee_percentage;
+DROP FUNCTION IF EXISTS set_tx;
+DROP FUNCTION IF EXISTS forge_l1_user_txs;
+DROP FUNCTION IF EXISTS set_pool_tx;
+-- drop tables IF EXISTS
+DROP TABLE IF EXISTS account_creation_auth;
+DROP TABLE IF EXISTS tx_pool;
+DROP TABLE IF EXISTS auction_vars;
+DROP TABLE IF EXISTS rollup_vars;
+DROP TABLE IF EXISTS escape_hatch_withdrawal;
+DROP TABLE IF EXISTS bucket_update;
+DROP TABLE IF EXISTS token_exchange;
+DROP TABLE IF EXISTS wdelayer_vars;
+DROP TABLE IF EXISTS tx;
+DROP TABLE IF EXISTS exit_tree;
+DROP TABLE IF EXISTS account_update;
+DROP TABLE IF EXISTS account;
+DROP TABLE IF EXISTS token;
+DROP TABLE IF EXISTS bid;
+DROP TABLE IF EXISTS batch;
+DROP TABLE IF EXISTS coordinator;
+DROP TABLE IF EXISTS block;
+-- sequences
+DROP SEQUENCE IF EXISTS tx_item_id;

node/node.go

@@ -184,7 +184,6 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 
 	sync, err := synchronizer.NewSynchronizer(client, historyDB, stateDB, synchronizer.Config{
 		StatsRefreshPeriod: cfg.Synchronizer.StatsRefreshPeriod.Duration,
-		StoreAccountUpdates: cfg.Synchronizer.StoreAccountUpdates,
 		ChainID:            chainIDU16,
 	})
 	if err != nil {
@@ -205,6 +204,7 @@ 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,
 		)
@@ -246,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,
@@ -430,7 +427,6 @@ func NewNodeAPI(
 		coordinatorEndpoints, explorerEndpoints,
 		engine,
 		hdb,
-		sdb,
 		l2db,
 		config,
 	)

synchronizer/synchronizer.go

@@ -207,7 +207,6 @@ type SCConsts struct {
 // Config is the Synchronizer configuration
 type Config struct {
 	StatsRefreshPeriod time.Duration
-	StoreAccountUpdates bool
 	ChainID            uint16
 }
 
@@ -994,7 +993,6 @@ func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, e
 		}
 		batchData.CreatedAccounts = processTxsOut.CreatedAccounts
 
-		if s.cfg.StoreAccountUpdates {
 		batchData.UpdatedAccounts = make([]common.AccountUpdate, 0,
 			len(processTxsOut.UpdatedAccounts))
 		for _, acc := range processTxsOut.UpdatedAccounts {
@@ -1007,7 +1005,6 @@ func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, e
 					Balance:     acc.Balance,
 				})
 		}
-		}
 
 		slotNum := int64(0)
 		if ethBlock.Num >= s.consts.Auction.GenesisBlockNum {

synchronizer/synchronizer_test.go

@@ -347,7 +347,6 @@ func TestSyncGeneral(t *testing.T) {
 	// Create Synchronizer
 	s, err := NewSynchronizer(client, historyDB, stateDB, Config{
 		StatsRefreshPeriod: 0 * time.Second,
-		StoreAccountUpdates: true,
 	})
 	require.NoError(t, err)
 
@@ -739,7 +738,6 @@ func TestSyncForgerCommitment(t *testing.T) {
 	// Create Synchronizer
 	s, err := NewSynchronizer(client, historyDB, stateDB, Config{
 		StatsRefreshPeriod: 0 * time.Second,
-		StoreAccountUpdates: true,
 	})
 	require.NoError(t, err)
 
@@ -840,7 +838,6 @@ func TestSyncForgerCommitment(t *testing.T) {
 
 		s2, err := NewSynchronizer(client, historyDB, stateDB, Config{
 			StatsRefreshPeriod: 0 * time.Second,
-			StoreAccountUpdates: true,
 		})
 		require.NoError(t, err)
 		stats = s2.Stats()

test/zkproof/flows_test.go

@@ -75,7 +75,7 @@ func initTxSelector(t *testing.T, chainID uint16, hermezContractAddr ethCommon.A
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, 10, 100, 0.0, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpSyncDB")
 	require.NoError(t, err)

txselector/txselector_test.go

@@ -29,7 +29,7 @@ func initTest(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, 10, 100, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, 10, 100, 0.0, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)