Add filter to include unforged history txs in api

api/api.go

@@ -7,7 +7,6 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
-	"github.com/hermeznetwork/hermez-node/metric"
 	"github.com/hermeznetwork/tracerr"
 )
 
@@ -51,12 +50,6 @@ func NewAPI(
 		hermezAddress: consts.HermezAddress,
 	}
 
-	middleware, err := metric.PrometheusMiddleware()
-	if err != nil {
-		return nil, err
-	}
-	server.Use(middleware)
-
 	v1 := server.Group("/v1")
 
 	// Add coordinator endpoints

api/api_test.go

@@ -161,6 +161,8 @@ var SetBlockchain = `
 	> block
 	> batch
 	> block
+	ForceTransfer(0) D-B: 77777700000000000
+	> block
 `
 
 type testCommon struct {
@@ -362,6 +364,12 @@ func TestMain(m *testing.M) {
 			commonL1Txs = append(commonL1Txs, batch.L1CoordinatorTxs...)
 		}
 	}
+	// Add unforged L1 tx
+	unforgedTx := blocksData[len(blocksData)-1].Rollup.L1UserTxs[0]
+	if unforgedTx.BatchNum != nil {
+		panic("Unforged tx batch num should be nil")
+	}
+	commonL1Txs = append(commonL1Txs, unforgedTx)
 
 	// Generate Coordinators and add them to HistoryDB
 	const nCoords = 10

api/batch.go

@@ -109,7 +109,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.GetTxsAPI(
-		nil, nil, nil, nil, batchNum, nil, nil, &maxTxsPerBatch, historydb.OrderAsc,
+		nil, nil, nil, nil, batchNum, nil, nil, nil, &maxTxsPerBatch, historydb.OrderAsc,
 	)
 	if err != nil && tracerr.Unwrap(err) != sql.ErrNoRows {
 		retSQLErr(err, c)

api/handlers.go

@@ -8,7 +8,6 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/log"
-	"github.com/hermeznetwork/hermez-node/metric"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/lib/pq"
 	"github.com/russross/meddler"
@@ -47,9 +46,7 @@ var (
 
 func retSQLErr(err error, c *gin.Context) {
 	log.Warnw("HTTP API SQL request error", "err", err)
-	unwrapErr := tracerr.Unwrap(err)
-	metric.CollectError(unwrapErr)
-	errMsg := unwrapErr.Error()
+	errMsg := tracerr.Unwrap(err).Error()
 	retDupKey := func(errCode pq.ErrorCode) {
 		// https://www.postgresql.org/docs/current/errcodes-appendix.html
 		if errCode == "23505" {
@@ -83,7 +80,6 @@ func retSQLErr(err error, c *gin.Context) {
 
 func retBadReq(err error, c *gin.Context) {
 	log.Warnw("HTTP API Bad request error", "err", err)
-	metric.CollectError(err)
 	c.JSON(http.StatusBadRequest, errorMsg{
 		Message: err.Error(),
 	})

api/swagger.yml

@@ -529,6 +529,15 @@ paths:
             type: integer
             minimum: 1
             maximum: 2049
+        - name: includePendingL1s
+          in: query
+          required: false
+          description: |
+            If set to true L1 transactions that have been added to the smart contract queue but haven't been forged yet are returned.
+            Warning: the correctness of the order is not guaranteed when using this filter, as the unforged transactions may change their position
+            once they are forged. 
+          schema:
+            type: boolean
       responses:
         '200':
           description: Successful operation.

api/txshistory.go

@@ -26,6 +26,14 @@ func (a *API) getHistoryTxs(c *gin.Context) {
 		retBadReq(err, c)
 		return
 	}
+	// IncludePendingL1s
+	includePendingL1s := new(bool)
+	*includePendingL1s = false
+	includePendingL1s, err = parseQueryBool("includePendingL1s", includePendingL1s, c)
+	if err != nil {
+		retBadReq(err, c)
+		return
+	}
 	// Pagination
 	fromItem, order, limit, err := parsePagination(c)
 	if err != nil {
@@ -35,7 +43,7 @@ func (a *API) getHistoryTxs(c *gin.Context) {
 
 	// Fetch txs from historyDB
 	txs, pendingItems, err := a.h.GetTxsAPI(
-		addr, bjj, tokenID, idx, batchNum, txType, fromItem, limit, order,
+		addr, bjj, tokenID, idx, batchNum, txType, includePendingL1s, fromItem, limit, order,
 	)
 	if err != nil {
 		retSQLErr(err, c)

api/txshistory_test.go

@@ -71,7 +71,7 @@ func (t txsSort) Less(i, j int) bool {
 	}
 	// i is forged
 	if jsf.BatchNum == nil {
-		return false // j is not forged
+		return true // j is not forged
 	}
 	// Both are forged
 	if *isf.BatchNum == *jsf.BatchNum {
@@ -111,7 +111,7 @@ func genTestTxs(
 ) []testTx {
 	txs := []testTx{}
 	// common.L1Tx ==> testTx
-	for _, l1 := range l1s {
+	for i, l1 := range l1s {
 		token := getTokenByID(l1.TokenID, tokens)
 		// l1.FromEthAddr and l1.FromBJJ can't be nil
 		fromEthAddr := string(apitypes.NewHezEthAddr(l1.FromEthAddr))
@@ -137,15 +137,26 @@ func genTestTxs(
 			},
 			Token: token,
 		}
+
 		// set BatchNum for user txs
 		if tx.L1Info.ToForgeL1TxsNum != nil {
-			// WARNING: this is an asumption, and the test input data can brake it easily
+			// WARNING: this works just because the way "common" txs are generated using til
+			// any change on the test set could break this
 			bn := common.BatchNum(*tx.L1Info.ToForgeL1TxsNum + 2)
 			tx.BatchNum = &bn
 		}
 		// If FromIdx is not nil
 		idxStr := idxToHez(l1.EffectiveFromIdx, token.Symbol)
 		tx.FromIdx = &idxStr
+		if i == len(l1s)-1 {
+			// Last tx of the L1 set is supposed to be unforged as per the til set.
+			// Unforged txs have some special propperties
+			tx.L1Info.DepositAmountSuccess = false
+			tx.L1Info.AmountSuccess = false
+			tx.BatchNum = nil
+			idxStrUnforged := idxToHez(l1.FromIdx, token.Symbol)
+			tx.FromIdx = &idxStrUnforged
+		}
 		// If tx has a normal ToIdx (>255), set FromEthAddr and FromBJJ
 		if l1.ToIdx >= common.UserThreshold {
 			// find account
@@ -261,12 +272,26 @@ func TestGetHistoryTxs(t *testing.T) {
 			fetchedTxs = append(fetchedTxs, tmp.(testTx))
 		}
 	}
-	// Get all (no filters)
+	// Get all (no filters, excluding unforged txs)
 	limit := 20
 	path := fmt.Sprintf("%s?limit=%d", endpoint, limit)
 	err := doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
 	assert.NoError(t, err)
+	forgedTxs := []testTx{}
+	for i := 0; i < len(tc.txs); i++ {
+		if tc.txs[i].BatchNum != nil {
+			forgedTxs = append(forgedTxs, tc.txs[i])
+		}
+	}
+	assertTxs(t, forgedTxs, fetchedTxs)
+
+	// Get all, including unforged txs
+	fetchedTxs = []testTx{}
+	path = fmt.Sprintf("%s?limit=%d&includePendingL1s=true", endpoint, limit)
+	err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
+	assert.NoError(t, err)
 	assertTxs(t, tc.txs, fetchedTxs)
+
 	// Get by ethAddr
 	account := tc.accounts[2]
 	fetchedTxs = []testTx{}
@@ -285,7 +310,7 @@ func TestGetHistoryTxs(t *testing.T) {
 			(tx.FromEthAddr != nil && *tx.FromEthAddr == string(account.EthAddr)) ||
 			(tx.ToEthAddr != nil && *tx.ToEthAddr == string(account.EthAddr)) ||
 			(tx.FromBJJ != nil && *tx.FromBJJ == string(account.PublicKey)) ||
-			(tx.ToBJJ != nil && *tx.ToBJJ == string(account.PublicKey)) {
+			(tx.ToBJJ != nil && *tx.ToBJJ == string(account.PublicKey)) && tx.BatchNum != nil {
 			accountTxs = append(accountTxs, tx)
 		}
 	}
@@ -312,7 +337,7 @@ func TestGetHistoryTxs(t *testing.T) {
 	assert.NoError(t, err)
 	tokenIDTxs := []testTx{}
 	for i := 0; i < len(tc.txs); i++ {
-		if tc.txs[i].Token.TokenID == tokenID {
+		if tc.txs[i].BatchNum != nil && tc.txs[i].Token.TokenID == tokenID {
 			tokenIDTxs = append(tokenIDTxs, tc.txs[i])
 		}
 	}
@@ -331,6 +356,9 @@ func TestGetHistoryTxs(t *testing.T) {
 	assert.NoError(t, err)
 	idxTxs := []testTx{}
 	for i := 0; i < len(tc.txs); i++ {
+		if tc.txs[i].BatchNum == nil {
+			continue
+		}
 		var fromIdx *common.Idx
 		if tc.txs[i].FromIdx != nil {
 			fromIdx, err = stringToIdx(*tc.txs[i].FromIdx, "")
@@ -388,7 +416,7 @@ func TestGetHistoryTxs(t *testing.T) {
 		assert.NoError(t, err)
 		txTypeTxs := []testTx{}
 		for i := 0; i < len(tc.txs); i++ {
-			if tc.txs[i].Type == txType {
+			if tc.txs[i].Type == txType && tc.txs[i].BatchNum != nil {
 				txTypeTxs = append(txTypeTxs, tc.txs[i])
 			}
 		}
@@ -420,7 +448,9 @@ func TestGetHistoryTxs(t *testing.T) {
 	assert.NoError(t, err)
 	flipedTxs := []testTx{}
 	for i := 0; i < len(tc.txs); i++ {
-		flipedTxs = append(flipedTxs, tc.txs[len(tc.txs)-1-i])
+		if tc.txs[len(tc.txs)-1-i].BatchNum != nil {
+			flipedTxs = append(flipedTxs, tc.txs[len(tc.txs)-1-i])
+		}
 	}
 	assertTxs(t, flipedTxs, fetchedTxs)
 	// Empty array

cli/node/cfg.buidler.toml

@@ -35,7 +35,7 @@ Symbol = "SUSHI"
 Addr = "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2"
 
 [Debug]
-APIAddress = "0.0.0.0:12345"
+APIAddress = "localhost:12345"
 MeddlerLogs = true
 GinDebugMode = true
 

common/l1tx.go

@@ -22,7 +22,7 @@ type L1Tx struct {
 	// 	- L1UserTx: 0
 	// 	- L1CoordinatorTx: 1
 	TxID TxID `meddler:"id"`
-	// ToForgeL1TxsNum indicates in which L1UserTx queue the tx was forged / will be forged
+	// ToForgeL1TxsNum indicates in which the tx was forged / will be forged
 	ToForgeL1TxsNum *int64 `meddler:"to_forge_l1_txs_num"`
 	Position        int    `meddler:"position"`
 	// UserOrigin is set to true if the tx was originated by a user, false if it was

coordinator/batch.go

@@ -80,7 +80,6 @@ type BatchInfo struct {
 	PipelineNum           int
 	BatchNum              common.BatchNum
 	ServerProof           prover.Client
-	ProofStart            time.Time
 	ZKInputs              *common.ZKInputs
 	Proof                 *prover.Proof
 	PublicInputs          []*big.Int

coordinator/pipeline.go

@@ -5,7 +5,6 @@ import (
 	"database/sql"
 	"fmt"
 	"math/big"
-	"strconv"
 	"sync"
 	"time"
 
@@ -15,7 +14,6 @@ import (
 	"github.com/hermeznetwork/hermez-node/db/l2db"
 	"github.com/hermeznetwork/hermez-node/eth"
 	"github.com/hermeznetwork/hermez-node/log"
-	"github.com/hermeznetwork/hermez-node/metric"
 	"github.com/hermeznetwork/hermez-node/prover"
 	"github.com/hermeznetwork/hermez-node/synchronizer"
 	"github.com/hermeznetwork/hermez-node/txselector"
@@ -248,7 +246,6 @@ func (p *Pipeline) handleForgeBatch(ctx context.Context,
 
 	// 3. Send the ZKInputs to the proof server
 	batchInfo.ServerProof = serverProof
-	batchInfo.ProofStart = time.Now()
 	if err := p.sendServerProof(ctx, batchInfo); ctx.Err() != nil {
 		return nil, ctx.Err()
 	} else if err != nil {
@@ -523,30 +520,15 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo,
 		if err != nil {
 			return nil, nil, tracerr.Wrap(err)
 		}
-		// l1UserFutureTxs are the l1UserTxs that are not being forged
-		// in the next batch, but that are also in the queue for the
-		// future batches
-		l1UserFutureTxs, err := p.historyDB.GetUnforgedL1UserFutureTxs(p.state.lastForgeL1TxsNum + 1)
-		if err != nil {
-			return nil, nil, tracerr.Wrap(err)
-		}
-
 		coordIdxs, auths, l1UserTxs, l1CoordTxs, poolL2Txs, discardedL2Txs, err =
-			p.txSelector.GetL1L2TxSelection(p.cfg.TxProcessorConfig, _l1UserTxs, l1UserFutureTxs)
+			p.txSelector.GetL1L2TxSelection(p.cfg.TxProcessorConfig, _l1UserTxs)
 		if err != nil {
 			return nil, nil, tracerr.Wrap(err)
 		}
 	} else {
-		// get l1UserFutureTxs which are all the l1 pending in all the
-		// queues
-		l1UserFutureTxs, err := p.historyDB.GetUnforgedL1UserFutureTxs(p.state.lastForgeL1TxsNum) //nolint:gomnd
-		if err != nil {
-			return nil, nil, tracerr.Wrap(err)
-		}
-
 		// 2b: only L2 txs
 		coordIdxs, auths, l1CoordTxs, poolL2Txs, discardedL2Txs, err =
-			p.txSelector.GetL2TxSelection(p.cfg.TxProcessorConfig, l1UserFutureTxs)
+			p.txSelector.GetL2TxSelection(p.cfg.TxProcessorConfig)
 		if err != nil {
 			return nil, nil, tracerr.Wrap(err)
 		}
@@ -620,9 +602,6 @@ func (p *Pipeline) forgeBatch(batchNum common.BatchNum) (batchInfo *BatchInfo,
 
 // waitServerProof gets the generated zkProof & sends it to the SmartContract
 func (p *Pipeline) waitServerProof(ctx context.Context, batchInfo *BatchInfo) error {
-	defer metric.MeasureDuration(metric.WaitServerProof, batchInfo.ProofStart,
-		batchInfo.BatchNum.BigInt().String(), strconv.Itoa(batchInfo.PipelineNum))
-
 	proof, pubInputs, err := batchInfo.ServerProof.GetProof(ctx) // blocking call,
 	// until not resolved don't continue. Returns when the proof server has calculated the proof
 	if err != nil {

db/historydb/apiqueries.go

@@ -457,6 +457,7 @@ func (hdb *HistoryDB) GetTxAPI(txID common.TxID) (*TxAPI, error) {
 func (hdb *HistoryDB) GetTxsAPI(
 	ethAddr *ethCommon.Address, bjj *babyjub.PublicKeyComp,
 	tokenID *common.TokenID, idx *common.Idx, batchNum *uint, txType *common.TxType,
+	includePendingL1s *bool,
 	fromItem, limit *uint, order string,
 ) ([]TxAPI, uint64, error) {
 	// Warning: amount_success and deposit_amount_success have true as default for
@@ -554,12 +555,16 @@ func (hdb *HistoryDB) GetTxsAPI(
 		args = append(args, fromItem)
 		nextIsAnd = true
 	}
-	if nextIsAnd {
-		queryStr += "AND "
-	} else {
-		queryStr += "WHERE "
+
+	// Include pending L1 txs? (deafault false)
+	if includePendingL1s == nil || (includePendingL1s != nil && !*includePendingL1s) {
+		if nextIsAnd {
+			queryStr += "AND "
+		} else {
+			queryStr += "WHERE "
+		}
+		queryStr += "tx.batch_num IS NOT NULL "
 	}
-	queryStr += "tx.batch_num IS NOT NULL "
 
 	// pagination
 	queryStr += "ORDER BY tx.item_id "

db/historydb/historydb.go

@@ -751,24 +751,6 @@ func (hdb *HistoryDB) GetUnforgedL1UserTxs(toForgeL1TxsNum int64) ([]common.L1Tx
 	return db.SlicePtrsToSlice(txs).([]common.L1Tx), tracerr.Wrap(err)
 }
 
-// GetUnforgedL1UserFutureTxs gets L1 User Txs to be forged after the L1Batch
-// with toForgeL1TxsNum (in one of the future batches, not in the next one).
-func (hdb *HistoryDB) GetUnforgedL1UserFutureTxs(toForgeL1TxsNum int64) ([]common.L1Tx, error) {
-	var txs []*common.L1Tx
-	err := meddler.QueryAll(
-		hdb.dbRead, &txs, // only L1 user txs can have batch_num set to null
-		`SELECT tx.id, tx.to_forge_l1_txs_num, tx.position, tx.user_origin,
-		tx.from_idx, tx.from_eth_addr, tx.from_bjj, tx.to_idx, tx.token_id,
-		tx.amount, NULL AS effective_amount,
-		tx.deposit_amount, NULL AS effective_deposit_amount,
-		tx.eth_block_num, tx.type, tx.batch_num
-		FROM tx WHERE batch_num IS NULL AND to_forge_l1_txs_num > $1
-		ORDER BY position;`,
-		toForgeL1TxsNum,
-	)
-	return db.SlicePtrsToSlice(txs).([]common.L1Tx), tracerr.Wrap(err)
-}
-
 // GetUnforgedL1UserTxsCount returns the count of unforged L1Txs (either in
 // open or frozen queues that are not yet forged)
 func (hdb *HistoryDB) GetUnforgedL1UserTxsCount() (int, error) {

db/historydb/historydb_test.go

@@ -699,55 +699,34 @@ func TestGetUnforgedL1UserTxs(t *testing.T) {
 		CreateAccountDeposit(1) B: 5
 		CreateAccountDeposit(1) C: 5
 		CreateAccountDeposit(1) D: 5
-		> block
 
-		> batchL1
 		> block
-
-		CreateAccountDeposit(1) E: 5
-		CreateAccountDeposit(1) F: 5
-		> block
-
 	`
 	tc := til.NewContext(uint16(0), 128)
 	blocks, err := tc.GenerateBlocks(set)
 	require.NoError(t, err)
 	// Sanity check
-	require.Equal(t, 3, len(blocks))
+	require.Equal(t, 1, len(blocks))
 	require.Equal(t, 5, len(blocks[0].Rollup.L1UserTxs))
 
+	toForgeL1TxsNum := int64(1)
+
 	for i := range blocks {
 		err = historyDB.AddBlockSCData(&blocks[i])
 		require.NoError(t, err)
 	}
 
-	l1UserTxs, err := historyDB.GetUnforgedL1UserFutureTxs(0)
-	require.NoError(t, err)
-	assert.Equal(t, 7, len(l1UserTxs))
-
-	l1UserTxs, err = historyDB.GetUnforgedL1UserTxs(1)
+	l1UserTxs, err := historyDB.GetUnforgedL1UserTxs(toForgeL1TxsNum)
 	require.NoError(t, err)
 	assert.Equal(t, 5, len(l1UserTxs))
 	assert.Equal(t, blocks[0].Rollup.L1UserTxs, l1UserTxs)
 
-	l1UserTxs, err = historyDB.GetUnforgedL1UserFutureTxs(1)
-	require.NoError(t, err)
-	assert.Equal(t, 2, len(l1UserTxs))
-
 	count, err := historyDB.GetUnforgedL1UserTxsCount()
 	require.NoError(t, err)
-	assert.Equal(t, 7, count)
-
-	l1UserTxs, err = historyDB.GetUnforgedL1UserTxs(2)
-	require.NoError(t, err)
-	assert.Equal(t, 2, len(l1UserTxs))
-
-	l1UserTxs, err = historyDB.GetUnforgedL1UserFutureTxs(2)
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(l1UserTxs))
+	assert.Equal(t, 5, count)
 
 	// No l1UserTxs for this toForgeL1TxsNum
-	l1UserTxs, err = historyDB.GetUnforgedL1UserTxs(3)
+	l1UserTxs, err = historyDB.GetUnforgedL1UserTxs(2)
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(l1UserTxs))
 }

eth/ethereum.go

@@ -245,15 +245,15 @@ func (c *EthereumClient) EthBlockByNumber(ctx context.Context, number int64) (*c
 	if number == -1 {
 		blockNum = nil
 	}
-	header, err := c.client.HeaderByNumber(ctx, blockNum)
+	block, err := c.client.BlockByNumber(ctx, blockNum)
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
 	b := &common.Block{
-		Num:        header.Number.Int64(),
-		Timestamp:  time.Unix(int64(header.Time), 0),
-		ParentHash: header.ParentHash,
-		Hash:       header.Hash(),
+		Num:        block.Number().Int64(),
+		Timestamp:  time.Unix(int64(block.Time()), 0),
+		ParentHash: block.ParentHash(),
+		Hash:       block.Hash(),
 	}
 	return b, nil
 }

metric/metric.go

@@ -1,192 +0,0 @@
-package metric
-
-import (
-	"time"
-
-	"github.com/hermeznetwork/hermez-node/log"
-	"github.com/prometheus/client_golang/prometheus"
-)
-
-type (
-	// Metric represents the metric type
-	Metric string
-)
-
-const (
-	namespaceError      = "error"
-	namespaceSync       = "synchronizer"
-	namespaceTxSelector = "txselector"
-	namespaceAPI        = "api"
-)
-
-var (
-	// Errors errors count metric.
-	Errors = prometheus.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: namespaceError,
-			Name:      "errors",
-			Help:      "",
-		}, []string{"error"})
-
-	// WaitServerProof duration time to get the calculated
-	// proof from the server.
-	WaitServerProof = prometheus.NewHistogramVec(
-		prometheus.HistogramOpts{
-			Namespace: namespaceSync,
-			Name:      "wait_server_proof",
-			Help:      "",
-		}, []string{"batch_number", "pipeline_number"})
-
-	// Reorgs block reorg count
-	Reorgs = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Namespace: namespaceSync,
-			Name:      "reorgs",
-			Help:      "",
-		})
-
-	// LastBlockNum last block synced
-	LastBlockNum = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Namespace: namespaceSync,
-			Name:      "synced_last_block_num",
-			Help:      "",
-		})
-
-	// EthLastBlockNum last eth block synced
-	EthLastBlockNum = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Namespace: namespaceSync,
-			Name:      "eth_last_block_num",
-			Help:      "",
-		})
-
-	// LastBatchNum last batch synced
-	LastBatchNum = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Namespace: namespaceSync,
-			Name:      "synced_last_batch_num",
-			Help:      "",
-		})
-
-	// EthLastBatchNum last eth batch synced
-	EthLastBatchNum = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Namespace: namespaceSync,
-			Name:      "eth_last_batch_num",
-			Help:      "",
-		})
-
-	// GetL2TxSelection L2 tx selection count
-	GetL2TxSelection = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Namespace: namespaceTxSelector,
-			Name:      "get_l2_txselection_total",
-			Help:      "",
-		})
-
-	// GetL1L2TxSelection L1L2 tx selection count
-	GetL1L2TxSelection = prometheus.NewCounter(
-		prometheus.CounterOpts{
-			Namespace: namespaceTxSelector,
-			Name:      "get_l1_l2_txselection_total",
-			Help:      "",
-		})
-
-	// SelectedL1CoordinatorTxs selected L1 coordinator tx count
-	SelectedL1CoordinatorTxs = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Namespace: namespaceTxSelector,
-			Name:      "selected_l1_coordinator_txs",
-			Help:      "",
-		})
-
-	// SelectedL1UserTxs selected L1 user tx count
-	SelectedL1UserTxs = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Namespace: namespaceTxSelector,
-			Name:      "selected_l1_user_txs",
-			Help:      "",
-		})
-
-	// SelectedL2Txs selected L2 tx count
-	SelectedL2Txs = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Namespace: namespaceTxSelector,
-			Name:      "selected_l2_txs",
-			Help:      "",
-		})
-
-	// DiscardedL2Txs discarded L2 tx count
-	DiscardedL2Txs = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Namespace: namespaceTxSelector,
-			Name:      "discarded_l2_txs",
-			Help:      "",
-		})
-)
-
-func init() {
-	if err := registerCollectors(); err != nil {
-		log.Error(err)
-	}
-}
-func registerCollectors() error {
-	if err := registerCollector(Errors); err != nil {
-		return err
-	}
-	if err := registerCollector(WaitServerProof); err != nil {
-		return err
-	}
-	if err := registerCollector(Reorgs); err != nil {
-		return err
-	}
-	if err := registerCollector(LastBlockNum); err != nil {
-		return err
-	}
-	if err := registerCollector(LastBatchNum); err != nil {
-		return err
-	}
-	if err := registerCollector(EthLastBlockNum); err != nil {
-		return err
-	}
-	if err := registerCollector(EthLastBatchNum); err != nil {
-		return err
-	}
-	if err := registerCollector(GetL2TxSelection); err != nil {
-		return err
-	}
-	if err := registerCollector(GetL1L2TxSelection); err != nil {
-		return err
-	}
-	if err := registerCollector(SelectedL1CoordinatorTxs); err != nil {
-		return err
-	}
-	if err := registerCollector(SelectedL1UserTxs); err != nil {
-		return err
-	}
-	return registerCollector(DiscardedL2Txs)
-}
-
-func registerCollector(collector prometheus.Collector) error {
-	err := prometheus.Register(collector)
-	if err != nil {
-		if _, ok := err.(prometheus.AlreadyRegisteredError); !ok {
-			return err
-		}
-	}
-	return nil
-}
-
-// MeasureDuration measure the method execution duration
-// and save it into a histogram metric
-func MeasureDuration(histogram *prometheus.HistogramVec, start time.Time, lvs ...string) {
-	duration := time.Since(start)
-	histogram.WithLabelValues(lvs...).Observe(float64(duration.Milliseconds()))
-}
-
-// CollectError collect the error message and increment
-// the error count
-func CollectError(err error) {
-	Errors.With(map[string]string{"error": err.Error()}).Inc()
-}

metric/request.go

@@ -1,78 +0,0 @@
-package metric
-
-import (
-	"strconv"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/prometheus/client_golang/prometheus"
-)
-
-const (
-	favicon = "/favicon.ico"
-)
-
-// Prometheus contains the metrics gathered by the instance and its path
-type Prometheus struct {
-	reqCnt *prometheus.CounterVec
-	reqDur *prometheus.HistogramVec
-}
-
-// NewPrometheus generates a new set of metrics with a certain subsystem name
-func NewPrometheus() (*Prometheus, error) {
-	reqCnt := prometheus.NewCounterVec(
-		prometheus.CounterOpts{
-			Namespace: namespaceAPI,
-			Name:      "requests_total",
-			Help:      "How many HTTP requests processed, partitioned by status code and HTTP method",
-		},
-		[]string{"code", "method", "path"},
-	)
-	if err := registerCollector(reqCnt); err != nil {
-		return nil, err
-	}
-	reqDur := prometheus.NewHistogramVec(
-		prometheus.HistogramOpts{
-			Namespace: namespaceAPI,
-			Name:      "request_duration_seconds",
-			Help:      "The HTTP request latencies in seconds",
-		},
-		[]string{"code", "method", "path"},
-	)
-	if err := registerCollector(reqDur); err != nil {
-		return nil, err
-	}
-	return &Prometheus{
-		reqCnt: reqCnt,
-		reqDur: reqDur,
-	}, nil
-}
-
-// PrometheusMiddleware creates the prometheus collector and
-// defines status handler function for the middleware
-func PrometheusMiddleware() (gin.HandlerFunc, error) {
-	p, err := NewPrometheus()
-	if err != nil {
-		return nil, err
-	}
-	return p.Middleware(), nil
-}
-
-// Middleware defines status handler function for middleware
-func (p *Prometheus) Middleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		if c.Request.URL.Path == favicon {
-			c.Next()
-			return
-		}
-		start := time.Now()
-		c.Next()
-
-		status := strconv.Itoa(c.Writer.Status())
-		elapsed := float64(time.Since(start)) / float64(time.Second)
-		fullPath := c.FullPath()
-
-		p.reqDur.WithLabelValues(status, c.Request.Method, fullPath).Observe(elapsed)
-		p.reqCnt.WithLabelValues(status, c.Request.Method, fullPath).Inc()
-	}
-}

synchronizer/metrics.go

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

synchronizer/synchronizer.go

@@ -47,7 +47,6 @@ import (
 	"github.com/hermeznetwork/hermez-node/db/statedb"
 	"github.com/hermeznetwork/hermez-node/eth"
 	"github.com/hermeznetwork/hermez-node/log"
-	"github.com/hermeznetwork/hermez-node/metric"
 	"github.com/hermeznetwork/hermez-node/txprocessor"
 	"github.com/hermeznetwork/tracerr"
 )
@@ -582,7 +581,6 @@ func (s *Synchronizer) Sync(ctx context.Context,
 				return nil, nil, tracerr.Wrap(err)
 			}
 			discarded := lastSavedBlock.Num - lastDBBlockNum
-			metric.Reorgs.Inc()
 			return nil, &discarded, nil
 		}
 	}
@@ -675,16 +673,16 @@ func (s *Synchronizer) Sync(ctx context.Context,
 	}
 
 	for _, batchData := range rollupData.Batches {
-		metric.LastBatchNum.Set(float64(batchData.Batch.BatchNum))
-		metric.EthLastBatchNum.Set(float64(s.stats.Eth.LastBatchNum))
+		metricSyncedLastBatchNum.Set(float64(batchData.Batch.BatchNum))
+		metricEthLastBatchNum.Set(float64(s.stats.Eth.LastBatchNum))
 		log.Debugw("Synced batch",
 			"syncLastBatch", batchData.Batch.BatchNum,
 			"syncBatchesPerc", s.stats.batchesPerc(batchData.Batch.BatchNum),
 			"ethLastBatch", s.stats.Eth.LastBatchNum,
 		)
 	}
-	metric.LastBlockNum.Set(float64(s.stats.Sync.LastBlock.Num))
-	metric.EthLastBlockNum.Set(float64(s.stats.Eth.LastBlock.Num))
+	metricSyncedLastBlockNum.Set(float64(s.stats.Sync.LastBlock.Num))
+	metricEthLastBlockNum.Set(float64(s.stats.Eth.LastBlock.Num))
 	log.Debugw("Synced block",
 		"syncLastBlockNum", s.stats.Sync.LastBlock.Num,
 		"syncBlocksPerc", s.stats.blocksPerc(),

test/zkproof/flows_test.go

@@ -156,7 +156,7 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 		}
 		// TxSelector select the transactions for the next Batch
 		coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err :=
-			txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs, nil)
+			txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs)
 		require.NoError(t, err)
 		// BatchBuilder build Batch
 		zki, err := bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
@@ -180,7 +180,7 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 	l1UserTxs := til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[6].Batch.ForgeL1TxsNum])
 	// TxSelector select the transactions for the next Batch
 	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
-		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err := bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
@@ -209,7 +209,7 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[7].Batch.ForgeL1TxsNum])
 	// TxSelector select the transactions for the next Batch
 	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err = bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
@@ -236,7 +236,7 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[1].Rollup.Batches[0].Batch.ForgeL1TxsNum])
 	// TxSelector select the transactions for the next Batch
 	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err = bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
@@ -256,7 +256,7 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[1].Rollup.Batches[1].Batch.ForgeL1TxsNum])
 	// TxSelector select the transactions for the next Batch
 	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err = bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
@@ -319,7 +319,7 @@ func TestZKInputsExitWithFee0(t *testing.T) {
 	// TxSelector select the transactions for the next Batch
 	l1UserTxs := til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[1].Batch.ForgeL1TxsNum])
 	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err :=
-		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(txprocConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err := bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
@@ -342,7 +342,7 @@ func TestZKInputsExitWithFee0(t *testing.T) {
 	require.NoError(t, err)
 	addL2Txs(t, l2DBTxSel, l2Txs) // Add L2s to TxSelector.L2DB
 	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
-		txsel.GetL1L2TxSelection(txprocConfig, nil, nil)
+		txsel.GetL1L2TxSelection(txprocConfig, nil)
 	require.NoError(t, err)
 	assert.Equal(t, 1, len(coordIdxs))
 	assert.Equal(t, 0, len(oL1UserTxs))

txselector/metrics.go

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

txselector/txselector.go

@@ -13,7 +13,6 @@ import (
 	"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/metric"
 	"github.com/hermeznetwork/hermez-node/txprocessor"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-iden3-crypto/babyjub"
@@ -85,7 +84,7 @@ func (txsel *TxSelector) getCoordIdx(tokenID common.TokenID) (common.Idx, error)
 func (txsel *TxSelector) coordAccountForTokenID(l1CoordinatorTxs []common.L1Tx,
 	tokenID common.TokenID, positionL1 int) (*common.L1Tx, int, error) {
 	// check if CoordinatorAccount for TokenID is already pending to create
-	if checkPendingToCreateL1CoordTx(l1CoordinatorTxs, tokenID,
+	if checkAlreadyPendingToCreate(l1CoordinatorTxs, tokenID,
 		txsel.coordAccount.Addr, txsel.coordAccount.BJJ) {
 		return nil, positionL1, nil
 	}
@@ -122,12 +121,11 @@ func (txsel *TxSelector) coordAccountForTokenID(l1CoordinatorTxs []common.L1Tx,
 // but there is a transactions to them and the authorization of account
 // creation exists. The L1UserTxs, L1CoordinatorTxs, PoolL2Txs that will be
 // included in the next batch.
-func (txsel *TxSelector) GetL2TxSelection(selectionConfig txprocessor.Config, l1UserFutureTxs []common.L1Tx) ([]common.Idx,
+func (txsel *TxSelector) GetL2TxSelection(selectionConfig txprocessor.Config) ([]common.Idx,
 	[][]byte, []common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
-	metric.GetL2TxSelection.Inc()
+	metricGetL2TxSelection.Inc()
 	coordIdxs, accCreationAuths, _, l1CoordinatorTxs, l2Txs,
-		discardedL2Txs, err := txsel.getL1L2TxSelection(selectionConfig,
-		[]common.L1Tx{}, l1UserFutureTxs)
+		discardedL2Txs, err := txsel.getL1L2TxSelection(selectionConfig, []common.L1Tx{})
 	return coordIdxs, accCreationAuths, l1CoordinatorTxs, l2Txs,
 		discardedL2Txs, tracerr.Wrap(err)
 }
@@ -141,11 +139,11 @@ func (txsel *TxSelector) GetL2TxSelection(selectionConfig txprocessor.Config, l1
 // creation exists. The L1UserTxs, L1CoordinatorTxs, PoolL2Txs that will be
 // included in the next batch.
 func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig txprocessor.Config,
-	l1UserTxs, l1UserFutureTxs []common.L1Tx) ([]common.Idx, [][]byte, []common.L1Tx,
+	l1UserTxs []common.L1Tx) ([]common.Idx, [][]byte, []common.L1Tx,
 	[]common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
-	metric.GetL1L2TxSelection.Inc()
+	metricGetL1L2TxSelection.Inc()
 	coordIdxs, accCreationAuths, l1UserTxs, l1CoordinatorTxs, l2Txs,
-		discardedL2Txs, err := txsel.getL1L2TxSelection(selectionConfig, l1UserTxs, l1UserFutureTxs)
+		discardedL2Txs, err := txsel.getL1L2TxSelection(selectionConfig, l1UserTxs)
 	return coordIdxs, accCreationAuths, l1UserTxs, l1CoordinatorTxs, l2Txs,
 		discardedL2Txs, tracerr.Wrap(err)
 }
@@ -159,7 +157,7 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig txprocessor.Config,
 // creation exists. The L1UserTxs, L1CoordinatorTxs, PoolL2Txs that will be
 // included in the next batch.
 func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
-	l1UserTxs, l1UserFutureTxs []common.L1Tx) ([]common.Idx, [][]byte, []common.L1Tx,
+	l1UserTxs []common.L1Tx) ([]common.Idx, [][]byte, []common.L1Tx,
 	[]common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
 	// WIP.0: the TxSelector is not optimized and will need a redesign. The
 	// current version is implemented in order to have a functional
@@ -223,11 +221,10 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
 		}
 
-		metric.SelectedL1UserTxs.Set(float64(len(l1UserTxs)))
-		metric.SelectedL1CoordinatorTxs.Set(0)
-		metric.SelectedL2Txs.Set(0)
-		metric.DiscardedL2Txs.Set(float64(len(discardedL2Txs)))
-
+		metricSelectedL1UserTxs.Set(float64(len(l1UserTxs)))
+		metricSelectedL1CoordinatorTxs.Set(0)
+		metricSelectedL2Txs.Set(0)
+		metricDiscardedL2Txs.Set(float64(len(discardedL2Txs)))
 		return nil, nil, l1UserTxs, nil, nil, discardedL2Txs, nil
 	}
 
@@ -236,7 +233,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 	var validTxs, discardedL2Txs []common.PoolL2Tx
 	l2TxsForgable = sortL2Txs(l2TxsForgable)
 	accAuths, l1CoordinatorTxs, validTxs, discardedL2Txs, err =
-		txsel.processL2Txs(tp, selectionConfig, len(l1UserTxs), l1UserFutureTxs,
+		txsel.processL2Txs(tp, selectionConfig, len(l1UserTxs),
 			l2TxsForgable, validTxs, discardedL2Txs)
 	if err != nil {
 		return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
@@ -250,8 +247,8 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 		var l1CoordinatorTxs2 []common.L1Tx
 		accAuths2, l1CoordinatorTxs2, validTxs, discardedL2Txs, err =
 			txsel.processL2Txs(tp, selectionConfig,
-				len(l1UserTxs)+len(l1CoordinatorTxs), l1UserFutureTxs,
-				l2TxsNonForgable, validTxs, discardedL2Txs)
+				len(l1UserTxs)+len(l1CoordinatorTxs), l2TxsNonForgable,
+				validTxs, discardedL2Txs)
 		if err != nil {
 			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
 		}
@@ -323,18 +320,17 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 		return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
 	}
 
-	metric.SelectedL1CoordinatorTxs.Set(float64(len(l1CoordinatorTxs)))
-	metric.SelectedL1UserTxs.Set(float64(len(l1UserTxs)))
-	metric.SelectedL2Txs.Set(float64(len(validTxs)))
-	metric.DiscardedL2Txs.Set(float64(len(discardedL2Txs)))
+	metricSelectedL1UserTxs.Set(float64(len(l1UserTxs)))
+	metricSelectedL1CoordinatorTxs.Set(float64(len(l1CoordinatorTxs)))
+	metricSelectedL2Txs.Set(float64(len(validTxs)))
+	metricDiscardedL2Txs.Set(float64(len(discardedL2Txs)))
 
 	return coordIdxs, accAuths, l1UserTxs, l1CoordinatorTxs, validTxs, discardedL2Txs, nil
 }
 
 func (txsel *TxSelector) processL2Txs(tp *txprocessor.TxProcessor,
-	selectionConfig txprocessor.Config, nL1Txs int, l1UserFutureTxs []common.L1Tx,
-	l2Txs, validTxs, discardedL2Txs []common.PoolL2Tx) ([][]byte, []common.L1Tx,
-	[]common.PoolL2Tx, []common.PoolL2Tx, error) {
+	selectionConfig txprocessor.Config, nL1Txs int, l2Txs, validTxs, discardedL2Txs []common.PoolL2Tx) (
+	[][]byte, []common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
 	var l1CoordinatorTxs []common.L1Tx
 	positionL1 := nL1Txs
 	var accAuths [][]byte
@@ -436,8 +432,7 @@ func (txsel *TxSelector) processL2Txs(tp *txprocessor.TxProcessor,
 		if l2Txs[i].ToIdx == 0 { // ToEthAddr/ToBJJ case
 			validL2Tx, l1CoordinatorTx, accAuth, err :=
 				txsel.processTxToEthAddrBJJ(validTxs, selectionConfig,
-					nL1Txs, l1UserFutureTxs, l1CoordinatorTxs,
-					positionL1, l2Txs[i])
+					nL1Txs, l1CoordinatorTxs, positionL1, l2Txs[i])
 			if err != nil {
 				log.Debugw("txsel.processTxToEthAddrBJJ", "err", err)
 				// Discard L2Tx, and update Info parameter of
@@ -577,35 +572,18 @@ func (txsel *TxSelector) processL2Txs(tp *txprocessor.TxProcessor,
 // l1CoordinatorTxs array, and then the PoolL2Tx is added into the validTxs
 // array.
 func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
-	selectionConfig txprocessor.Config, nL1UserTxs int, l1UserFutureTxs,
-	l1CoordinatorTxs []common.L1Tx, positionL1 int, l2Tx common.PoolL2Tx) (
-	*common.PoolL2Tx, *common.L1Tx, *common.AccountCreationAuth, error) {
+	selectionConfig txprocessor.Config, nL1UserTxs int, l1CoordinatorTxs []common.L1Tx,
+	positionL1 int, l2Tx common.PoolL2Tx) (*common.PoolL2Tx, *common.L1Tx,
+	*common.AccountCreationAuth, error) {
 	// if L2Tx needs a new L1CoordinatorTx of CreateAccount type, and a
 	// previous L2Tx in the current process already created a
 	// L1CoordinatorTx of this type, in the DB there still seem that needs
 	// to create a new L1CoordinatorTx, but as is already created, the tx
 	// is valid
-	if checkPendingToCreateL1CoordTx(l1CoordinatorTxs, l2Tx.TokenID, l2Tx.ToEthAddr, l2Tx.ToBJJ) {
+	if checkAlreadyPendingToCreate(l1CoordinatorTxs, l2Tx.TokenID, l2Tx.ToEthAddr, l2Tx.ToBJJ) {
 		return &l2Tx, nil, nil, nil
 	}
 
-	// check if L2Tx receiver account will be created by a L1UserFutureTxs
-	// (in the next batch, the current frozen queue). In that case, the L2Tx
-	// will be discarded at the current batch, even if there is an
-	// AccountCreationAuth for the account, as there is a L1UserTx in the
-	// frozen queue that will create the receiver Account.  The L2Tx is
-	// discarded to avoid the Coordinator creating a new L1CoordinatorTx to
-	// create the receiver account, which will be also created in the next
-	// batch from the L1UserFutureTx, ending with the user having 2
-	// different accounts for the same TokenID. The double account creation
-	// is supported by the Hermez zkRollup specification, but it was decided
-	// to mitigate it at the TxSelector level for the explained cases.
-	if checkPendingToCreateFutureTxs(l1UserFutureTxs, l2Tx.TokenID, l2Tx.ToEthAddr, l2Tx.ToBJJ) {
-		return nil, nil, nil, fmt.Errorf("L2Tx discarded at the current batch, as the" +
-			" receiver account does not exist yet, and there is a L1UserTx that" +
-			" will create that account in a future batch.")
-	}
-
 	var l1CoordinatorTx *common.L1Tx
 	var accAuth *common.AccountCreationAuth
 	if l2Tx.ToEthAddr != common.EmptyAddr && l2Tx.ToEthAddr != common.FFAddr {
@@ -708,7 +686,7 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 	return &l2Tx, l1CoordinatorTx, accAuth, nil
 }
 
-func checkPendingToCreateL1CoordTx(l1CoordinatorTxs []common.L1Tx, tokenID common.TokenID,
+func checkAlreadyPendingToCreate(l1CoordinatorTxs []common.L1Tx, tokenID common.TokenID,
 	addr ethCommon.Address, bjj babyjub.PublicKeyComp) bool {
 	for i := 0; i < len(l1CoordinatorTxs); i++ {
 		if l1CoordinatorTxs[i].FromEthAddr == addr &&
@@ -720,23 +698,6 @@ func checkPendingToCreateL1CoordTx(l1CoordinatorTxs []common.L1Tx, tokenID commo
 	return false
 }
 
-func checkPendingToCreateFutureTxs(l1UserFutureTxs []common.L1Tx, tokenID common.TokenID,
-	addr ethCommon.Address, bjj babyjub.PublicKeyComp) bool {
-	for i := 0; i < len(l1UserFutureTxs); i++ {
-		if l1UserFutureTxs[i].FromEthAddr == addr &&
-			l1UserFutureTxs[i].TokenID == tokenID &&
-			l1UserFutureTxs[i].FromBJJ == bjj {
-			return true
-		}
-		if l1UserFutureTxs[i].FromEthAddr == addr &&
-			l1UserFutureTxs[i].TokenID == tokenID &&
-			common.EmptyBJJComp == bjj {
-			return true
-		}
-	}
-	return false
-}
-
 // sortL2Txs sorts the PoolL2Txs by AbsoluteFee and then by Nonce
 func sortL2Txs(l2Txs []common.PoolL2Tx) []common.PoolL2Tx {
 	// Sort by absolute fee with SliceStable, so that txs with same

txselector/txselector_test.go

@@ -182,7 +182,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	log.Debug("block:0 batch:1")
 	l1UserTxs := []common.L1Tx{}
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err :=
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
@@ -193,7 +193,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	log.Debug("block:0 batch:2")
 	l1UserTxs = []common.L1Tx{}
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
@@ -204,7 +204,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	log.Debug("block:0 batch:3")
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[2].Batch.ForgeL1TxsNum])
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 2, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
@@ -217,7 +217,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	log.Debug("block:0 batch:4")
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[3].Batch.ForgeL1TxsNum])
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 1, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
@@ -231,7 +231,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	log.Debug("block:0 batch:5")
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[4].Batch.ForgeL1TxsNum])
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
@@ -245,7 +245,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	log.Debug("block:0 batch:6")
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[5].Batch.ForgeL1TxsNum])
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 1, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
@@ -279,7 +279,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	assert.True(t, l2TxsFromDB[1].VerifySignature(chainID, tc.Users["B"].BJJ.Public().Compress()))
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[6].Batch.ForgeL1TxsNum])
 	coordIdxs, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, []common.Idx{261, 263}, coordIdxs)
 	assert.Equal(t, txsel.coordAccount.AccountCreationAuth, accAuths[0])
@@ -328,7 +328,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	assert.True(t, l2TxsFromDB[3].VerifySignature(chainID, tc.Users["A"].BJJ.Public().Compress()))
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[7].Batch.ForgeL1TxsNum])
 	coordIdxs, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, []common.Idx{261, 263}, coordIdxs)
 	assert.Equal(t, 0, len(accAuths))
@@ -372,7 +372,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	assert.True(t, l2TxsFromDB[1].VerifySignature(chainID, tc.Users["B"].BJJ.Public().Compress()))
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[1].Rollup.Batches[0].Batch.ForgeL1TxsNum])
 	coordIdxs, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, []common.Idx{263}, coordIdxs)
 	assert.Equal(t, 0, len(accAuths))
@@ -434,7 +434,7 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	}
 	// batch1
 	l1UserTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	// 1st TransferToEthAddr
 	expectedTxID0 := "0x028847b86613c0b70be18c8622119ed045b42e4e47d7938fa90bb3d1dc14928965"
@@ -456,7 +456,7 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[1].Batch.ForgeL1TxsNum])
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 3, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
@@ -481,7 +481,7 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 
 	l1UserTxs = []common.L1Tx{}
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
@@ -500,7 +500,7 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	// initial PoolExit, which now is valid as B has enough Balance
 	l1UserTxs = []common.L1Tx{}
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
@@ -550,7 +550,7 @@ func TestTransferToBjj(t *testing.T) {
 	// batch1 to freeze L1UserTxs that will create some accounts with
 	// positive balance
 	l1UserTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 
 	// Transfer is ToBJJ to a BJJ-only account that doesn't exist
@@ -568,7 +568,7 @@ func TestTransferToBjj(t *testing.T) {
 
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[1].Batch.ForgeL1TxsNum])
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, 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
@@ -595,7 +595,7 @@ func TestTransferToBjj(t *testing.T) {
 
 	l1UserTxs = []common.L1Tx{}
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, 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
@@ -623,7 +623,7 @@ func TestTransferToBjj(t *testing.T) {
 
 	l1UserTxs = []common.L1Tx{}
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(oL1UserTxs))
 	// We expect the coordinator to add an L1CoordTx to create an account
@@ -678,7 +678,7 @@ func TestTransferManyFromSameAccount(t *testing.T) {
 	}
 	// batch1 to freeze L1UserTxs
 	l1UserTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 
 	// 8 transfers from the same account
@@ -710,7 +710,7 @@ func TestTransferManyFromSameAccount(t *testing.T) {
 	// transfers from account A
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[1].Batch.ForgeL1TxsNum])
 	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 3, len(oL1UserTxs))
 	require.Equal(t, 0, len(oL1CoordTxs))
@@ -760,7 +760,7 @@ func TestPoolL2TxInvalidNonces(t *testing.T) {
 	}
 	// batch1 to freeze L1UserTxs
 	l1UserTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 
 	batchPoolL2 := `
@@ -794,7 +794,7 @@ func TestPoolL2TxInvalidNonces(t *testing.T) {
 
 	// select L1 & L2 txs
 	_, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	require.Equal(t, 3, len(oL1UserTxs))
 	require.Equal(t, 0, len(oL1CoordTxs))
@@ -809,7 +809,7 @@ func TestPoolL2TxInvalidNonces(t *testing.T) {
 	// batch 3
 	l1UserTxs = []common.L1Tx{}
 	_, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 
 	require.Equal(t, 0, len(oL1UserTxs))
@@ -825,7 +825,7 @@ func TestPoolL2TxInvalidNonces(t *testing.T) {
 	// batch 4
 	l1UserTxs = []common.L1Tx{}
 	_, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 
 	require.Equal(t, 0, len(oL1UserTxs))
@@ -873,10 +873,10 @@ func TestProcessL2Selection(t *testing.T) {
 	}
 	// batch1 to freeze L1UserTxs
 	l1UserTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 
-	// 3 transfers from the same account
+	// 8 transfers from the same account
 	batchPoolL2 := `
 	Type: PoolL2
 	PoolTransfer(0) A-B: 10 (126)
@@ -889,10 +889,10 @@ func TestProcessL2Selection(t *testing.T) {
 
 	// add the PoolL2Txs to the l2DB
 	addL2Txs(t, txsel, poolL2Txs)
-	// batch 2 to crate some accounts with positive balance, and do 3 L2Tx transfers from account A
+	// 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(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	assert.Equal(t, 3, len(oL1UserTxs))
 	require.Equal(t, 0, len(oL1CoordTxs))
@@ -968,7 +968,7 @@ func TestValidTxsWithLowFeeAndInvalidTxsWithHighFee(t *testing.T) {
 	}
 	// batch1 to freeze L1UserTxs
 	l1UserTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 
 	// batch 2 to crate the accounts (from L1UserTxs)
@@ -976,7 +976,7 @@ func TestValidTxsWithLowFeeAndInvalidTxsWithHighFee(t *testing.T) {
 
 	// select L1 & L2 txs
 	_, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 	require.Equal(t, 3, len(oL1UserTxs))
 	require.Equal(t, 0, len(oL1CoordTxs))
@@ -1014,7 +1014,7 @@ func TestValidTxsWithLowFeeAndInvalidTxsWithHighFee(t *testing.T) {
 	addL2Txs(t, txsel, poolL2Txs)
 	l1UserTxs = []common.L1Tx{}
 	_, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 
 	require.Equal(t, 0, len(oL1UserTxs))
@@ -1029,7 +1029,7 @@ func TestValidTxsWithLowFeeAndInvalidTxsWithHighFee(t *testing.T) {
 
 	// batch 4. In this Batch, account B has enough balance to send the txs
 	_, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, nil)
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
 	require.NoError(t, err)
 
 	require.Equal(t, 0, len(oL1UserTxs))
@@ -1038,112 +1038,3 @@ func TestValidTxsWithLowFeeAndInvalidTxsWithHighFee(t *testing.T) {
 	require.Equal(t, 3, len(discardedL2Txs))
 	require.Equal(t, 0, len(accAuths))
 }
-
-func TestL1UserFutureTxs(t *testing.T) {
-	set := `
-		Type: Blockchain
-
-		CreateAccountDeposit(0) Coord: 0
-		CreateAccountDeposit(0) A: 100
-
-		> batchL1 // freeze L1User{2}
-		CreateAccountDeposit(0) B: 18
-		> batchL1 // forge L1User{2}, 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,
-	}
-	// batch1 to freeze L1UserTxs
-	l1UserTxs := []common.L1Tx{}
-	l1UserFutureTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs, l1UserFutureTxs)
-	require.NoError(t, err)
-
-	batchPoolL2 := `
-	Type: PoolL2
-	PoolTransferToEthAddr(0) A-B: 10 (126)
-	`
-	poolL2Txs, err := tc.GeneratePoolL2Txs(batchPoolL2)
-	require.NoError(t, err)
-	require.Equal(t, 1, len(poolL2Txs))
-
-	// add AccountCreationAuth for B
-	_ = addAccCreationAuth(t, tc, txsel, chainID, hermezContractAddr, "B")
-	// add the PoolL2Txs to the l2DB
-	addL2Txs(t, txsel, poolL2Txs)
-	// batch 2 to crate some accounts with positive balance, and do 1 L2Tx transfer from account A
-	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[1].Batch.ForgeL1TxsNum])
-	l1UserFutureTxs =
-		til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[2].Batch.ForgeL1TxsNum])
-	require.Equal(t, 2, len(l1UserTxs))
-	require.Equal(t, 1, len(l1UserFutureTxs))
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, l1UserFutureTxs)
-	require.NoError(t, err)
-	assert.Equal(t, 2, len(oL1UserTxs))
-	require.Equal(t, 0, len(oL1CoordTxs))
-	// no L2Tx selected due the L1UserFutureTx, the L2Tx will be processed
-	// at the next batch once the L1UserTx of CreateAccount B is processed,
-	// despite that there is an AccountCreationAuth for Account B.
-	assert.Equal(t, 0, len(oL2Txs))
-	assert.Equal(t, 1, len(discardedL2Txs))
-	assert.Equal(t, "Tx not selected (in processTxToEthAddrBJJ) due to L2Tx"+
-		" discarded at the current batch, as the receiver account does"+
-		" not exist yet, and there is a L1UserTx that will create that"+
-		" account in a future batch.",
-		discardedL2Txs[0].Info)
-
-	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs),
-		txsel.localAccountsDB.CurrentBatch())
-	require.NoError(t, err)
-
-	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[2].Batch.ForgeL1TxsNum])
-	l1UserFutureTxs = []common.L1Tx{}
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, l1UserTxs, l1UserFutureTxs)
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(oL1UserTxs))
-	require.Equal(t, 0, len(oL1CoordTxs))
-	// L2Tx selected as now the L1UserTx of CreateAccount B is processed
-	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)
-
-	// generate a new L2Tx A-B and check that is processed
-	poolL2Txs, err = tc.GeneratePoolL2Txs(batchPoolL2)
-	require.NoError(t, err)
-	require.Equal(t, 1, len(poolL2Txs))
-	// add the PoolL2Txs to the l2DB
-	addL2Txs(t, txsel, poolL2Txs)
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
-		txsel.GetL1L2TxSelection(tpc, nil, nil)
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(oL1UserTxs))
-	require.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)
-}