Merge pull request #287 from hermeznetwork/feature/api-test-til

Add til to API
2026-02-07 11:26:44 +01:00 · 2020-11-17 17:59:03 +01:00
parent 98aa5d791f ce1218e28a
commit 0e7d3e72fd
20 changed files with 737 additions and 593 deletions
--- a/api/account_test.go
+++ b/api/account_test.go
@@ -36,6 +36,8 @@ func (t testAccountsResponse) GetPending() (pendingItems, lastItemID uint64) {

 func (t *testAccountsResponse) Len() int { return len(t.Accounts) }

+func (t testAccountsResponse) New() Pendinger { return &testAccountsResponse{} }
+
 func genTestAccounts(accounts []common.Account, tokens []historydb.TokenWithUSD) []testAccount {
 	tAccounts := []testAccount{}
 	for x, account := range accounts {
@@ -98,7 +100,7 @@ func TestGetAccounts(t *testing.T) {
 	assert.LessOrEqual(t, len(fetchedAccounts), len(tc.accounts))
 	fetchedAccounts = []testAccount{}
 	// Token Ids + bjj
-	path = fmt.Sprintf("%s?tokenIds=%s&BJJ=%s&limit=%d&fromItem=", endpoint, stringIds, tc.accounts[0].PublicKey, limit)
+	path = fmt.Sprintf("%s?tokenIds=%s&BJJ=%s&limit=%d&fromItem=", endpoint, stringIds, tc.accounts[10].PublicKey, limit)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testAccountsResponse{}, appendIter)
 	assert.NoError(t, err)
 	assert.Greater(t, len(fetchedAccounts), 0)
--- a/api/api_test.go
+++ b/api/api_test.go
@@ -10,7 +10,6 @@ import (
 	"math/big"
 	"net/http"
 	"os"
-	"sort"
 	"strconv"
 	"testing"
 	"time"
@@ -25,7 +24,7 @@ import (
 	"github.com/hermeznetwork/hermez-node/db/statedb"
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/hermez-node/test"
-	"github.com/iden3/go-iden3-crypto/babyjub"
+	"github.com/hermeznetwork/hermez-node/test/til"
 )

 // Pendinger is an interface that allows getting last returned item ID and PendingItems to be used for building fromItem
@@ -33,11 +32,132 @@ import (
 type Pendinger interface {
 	GetPending() (pendingItems, lastItemID uint64)
 	Len() int
+	New() Pendinger
 }

 const apiPort = ":4010"
 const apiURL = "http://localhost" + apiPort + "/"

+var SetBlockchain = `
+	Type: Blockchain
+
+	AddToken(1)
+	AddToken(2)
+	AddToken(3)
+	AddToken(4)
+	AddToken(5)
+	AddToken(6)
+	AddToken(7)
+	AddToken(8)
+	> block
+
+	// Coordinator accounts, Idxs: 256, 257
+	CreateAccountCoordinator(0) Coord
+	CreateAccountCoordinator(1) Coord
+
+	// close Block:0, Batch:0
+	> batch
+
+	CreateAccountDeposit(0) A: 111111111
+	CreateAccountDeposit(1) C: 222222222
+	CreateAccountCoordinator(0) C
+
+	// close Block:0, Batch:1
+	> batchL1
+	// Expected balances:
+	//     Coord(0): 0, Coord(1): 0
+	//     C(0): 0
+
+	CreateAccountDeposit(1) A: 333333333
+
+	// close Block:0, Batch:2
+	> batchL1
+
+	// close Block:0, Batch:3
+	> batchL1
+
+	CreateAccountDepositTransfer(0) B-A: 444444444, 1234444444 // to_eth_addr is NULL
+
+	// close Block:0, Batch:4
+	> batchL1
+	CreateAccountDeposit(0) D: 555555555
+
+	// close Block:0, Batch:5
+	> batchL1
+
+	CreateAccountCoordinator(1) B
+
+	Transfer(1) A-B: 111111 (2) // to_eth_addr is NULL
+	Transfer(0) B-C: 222222 (3)
+
+	// close Block:0, Batch:6
+	> batchL1 // forge L1User{1}, forge L1Coord{2}, forge L2{2}
+
+	Deposit(0) C: 666666666
+	DepositTransfer(0) C-D: 777777777, 123777777 // to_eth_addr is NULL
+
+	Transfer(0) A-B: 333333 (111)
+	Transfer(0) C-A: 444444 (222)
+	Transfer(1) B-C: 555555 (123)
+	Exit(0) A: 666666 (44)
+
+	ForceTransfer(0) D-B: 777777 // to_eth_addr is NULL
+	ForceExit(0) B: 888888
+
+	// close Block:0, Batch:7
+	> batchL1
+	> block
+
+	Transfer(0) D-A: 999999 (77)
+	Transfer(0) B-D: 123123 (55)
+
+	// close Block:1, Batch:0
+	> batchL1
+
+	CreateAccountCoordinator(0) F
+
+	CreateAccountCoordinator(0) G
+	CreateAccountCoordinator(0) H
+	CreateAccountCoordinator(0) I
+	CreateAccountCoordinator(0) J
+	CreateAccountCoordinator(0) K
+	CreateAccountCoordinator(0) L
+	CreateAccountCoordinator(0) M
+	CreateAccountCoordinator(0) N
+	CreateAccountCoordinator(0) O
+	CreateAccountCoordinator(0) P
+
+	CreateAccountCoordinator(5) G
+	CreateAccountCoordinator(5) H
+	CreateAccountCoordinator(5) I
+	CreateAccountCoordinator(5) J
+	CreateAccountCoordinator(5) K
+	CreateAccountCoordinator(5) L
+	CreateAccountCoordinator(5) M
+	CreateAccountCoordinator(5) N
+	CreateAccountCoordinator(5) O
+	CreateAccountCoordinator(5) P
+
+	CreateAccountCoordinator(2) G
+	CreateAccountCoordinator(2) H
+	CreateAccountCoordinator(2) I
+	CreateAccountCoordinator(2) J
+	CreateAccountCoordinator(2) K
+	CreateAccountCoordinator(2) L
+	CreateAccountCoordinator(2) M
+	CreateAccountCoordinator(2) N
+	CreateAccountCoordinator(2) O
+	CreateAccountCoordinator(2) P
+
+
+	> batch
+	> block
+	> batch
+	> block
+	> batch
+	> block
+`
+
 type testCommon struct {
 	blocks           []common.Block
 	tokens           []historydb.TokenWithUSD
@@ -45,13 +165,8 @@ type testCommon struct {
 	fullBatches      []testFullBatch
 	coordinators     []historydb.CoordinatorAPI
 	accounts         []testAccount
-	usrAddr          string
-	usrBjj           string
-	accs             []common.Account
-	usrTxs           []testTx
-	allTxs           []testTx
+	txs              []testTx
 	exits            []testExit
-	usrExits         []testExit
 	poolTxsToSend    []testPoolTxSend
 	poolTxsToReceive []testPoolTxReceive
 	auths            []testAuth
@@ -71,16 +186,6 @@ var api *API
 // emulating the task of the synchronizer in order to have data to be returned
 // by the API endpoints that will be tested
 func TestMain(m *testing.M) {
-	/*
-		til update considerations:
-		1. Two instructions sets should be enough (one for L2 another for historydb)
-		2. FillBlocksExtra function must be used, there is a coment on top of the function that explains which data is setted
-		3. Some data will not be generated by til nor FillBlocksExtra, test.GenXXX will still be required to cover this cases
-		4. Most of the historydb inserts should be replaced with nBlocks calls to AddBlockSCData
-		5. When defining til instructions, there is no need to have 100s of entries for each table, but it's interesting to
-		   cover all different cases (for instance all tx types)
-	*/
-
 	// Initializations
 	// Swagger
 	router := swagger.NewRouter().WithSwaggerFromFile("./swagger.yml")
@@ -139,29 +244,63 @@ func TestMain(m *testing.M) {
 		}
 	}()

-	// Fill HistoryDB and StateDB with fake data
-	// Gen blocks and add them to DB
-	const nBlocks = 5
-	// TODO: UPDATE with til
-	blocks := test.GenBlocks(1, nBlocks+1)
-	err = api.h.AddBlocks(blocks)
-	if err != nil {
-		panic(err)
-	}
-	lastBlockNum := blocks[nBlocks-1].EthBlockNum
+	// Reset DB
+	test.WipeDB(api.h.DB())

-	// Gen tokens and add them to DB
-	const nTokens = 10
-	// TODO: UPDATE with til
-	tokens, ethToken := test.GenTokens(nTokens, blocks)
-	err = api.h.AddTokens(tokens)
+	// Genratre blockchain data with til
+	tcc := til.NewContext(common.RollupConstMaxL1UserTx)
+	tilCfgExtra := til.ConfigExtra{
+		BootCoordAddr: ethCommon.HexToAddress("0xE39fEc6224708f0772D2A74fd3f9055A90E0A9f2"),
+		CoordUser:     "Coord",
+	}
+	blocksData, err := tcc.GenerateBlocks(SetBlockchain)
 	if err != nil {
 		panic(err)
 	}
-	tokens = append([]common.Token{ethToken}, tokens...)
-	// Set token value
-	tokensUSD := []historydb.TokenWithUSD{}
-	for i, tkn := range tokens {
+	err = tcc.FillBlocksExtra(blocksData, &tilCfgExtra)
+	if err != nil {
+		panic(err)
+	}
+	AddAditionalInformation(blocksData)
+	// Generate L2 Txs with til
+	commonPoolTxs, err := tcc.GeneratePoolL2Txs(til.SetPoolL2MinimumFlow0)
+	if err != nil {
+		panic(err)
+	}
+
+	// Extract til generated data, and add it to HistoryDB
+	var commonBlocks []common.Block
+	var commonBatches []common.Batch
+	var commonAccounts []common.Account
+	var commonExitTree []common.ExitInfo
+	var commonL1Txs []common.L1Tx
+	var commonL2Txs []common.L2Tx
+	// Add ETH token at the beginning of the array
+	testTokens := []historydb.TokenWithUSD{}
+	ethUSD := float64(500)
+	ethNow := time.Now()
+	testTokens = append(testTokens, historydb.TokenWithUSD{
+		TokenID:     test.EthToken.TokenID,
+		EthBlockNum: test.EthToken.EthBlockNum,
+		EthAddr:     test.EthToken.EthAddr,
+		Name:        test.EthToken.Name,
+		Symbol:      test.EthToken.Symbol,
+		Decimals:    test.EthToken.Decimals,
+		USD:         &ethUSD,
+		USDUpdate:   &ethNow,
+	})
+	err = api.h.UpdateTokenValue(test.EthToken.Symbol, ethUSD)
+	if err != nil {
+		panic(err)
+	}
+	for _, block := range blocksData {
+		// Insert block into HistoryDB
+		if err := api.h.AddBlockSCData(&block); err != nil { //nolint:gosec block is used as read only in the function
+			panic(err)
+		}
+		// Extract data
+		commonBlocks = append(commonBlocks, block.Block)
+		for i, tkn := range block.Rollup.AddedTokens {
 			token := historydb.TokenWithUSD{
 				TokenID:     tkn.TokenID,
 				EthBlockNum: tkn.EthBlockNum,
@@ -170,137 +309,52 @@ func TestMain(m *testing.M) {
 				Symbol:      tkn.Symbol,
 				Decimals:    tkn.Decimals,
 			}
-		// Set value of 50% of the tokens
-		if i%2 != 0 {
-			value := float64(i) * 1.234567
+			value := float64(i + 423)
 			now := time.Now().UTC()
 			token.USD = &value
 			token.USDUpdate = &now
+			// Set value in DB
 			err = api.h.UpdateTokenValue(token.Symbol, value)
 			if err != nil {
 				panic(err)
 			}
+			testTokens = append(testTokens, token)
 		}
-		tokensUSD = append(tokensUSD, token)
-	}
-	// Gen batches and add them to DB
-	const nBatches = 10
-	// TODO: UPDATE with til
-	batches := test.GenBatches(nBatches, blocks)
-	err = api.h.AddBatches(batches)
-	if err != nil {
-		panic(err)
-	}
-	// Gen accounts and add them to HistoryDB and StateDB
-	const totalAccounts = 40
-	const userAccounts = 4
-	usrAddr := ethCommon.BigToAddress(big.NewInt(4896847))
-	privK := babyjub.NewRandPrivKey()
-	usrBjj := privK.Public()
-	// TODO: UPDATE with til
-	accs := test.GenAccounts(totalAccounts, userAccounts, tokens, &usrAddr, usrBjj, batches)
-	err = api.h.AddAccounts(accs)
-	if err != nil {
-		panic(err)
-	}
-	for i := 0; i < len(accs); i++ {
-		if _, err := api.s.CreateAccount(accs[i].Idx, &accs[i]); err != nil {
-			panic(err)
-		}
-	}
-	// helper to vinculate user related resources
-	usrIdxs := []string{}
-	for _, acc := range accs {
-		if acc.EthAddr == usrAddr || acc.PublicKey == usrBjj {
-			for _, token := range tokens {
-				if token.TokenID == acc.TokenID {
-					usrIdxs = append(usrIdxs, idxToHez(acc.Idx, token.Symbol))
-				}
-			}
-		}
-	}
-	// Gen exits and add them to DB
-	const totalExits = 40
-	// TODO: UPDATE with til
-	exits := test.GenExitTree(totalExits, batches, accs, blocks)
-	err = api.h.AddExitTree(exits)
-	if err != nil {
-		panic(err)
-	}
-
-	// L1 and L2 txs need to be sorted in a combined way
-	// Gen L1Txs
-	const totalL1Txs = 40
-	const userL1Txs = 4
-	// TODO: UPDATE with til
-	usrL1Txs, othrL1Txs := test.GenL1Txs(256, totalL1Txs, userL1Txs, &usrAddr, accs, tokens, blocks, batches)
-	// Gen L2Txs
-	const totalL2Txs = 20
-	const userL2Txs = 4
-	// TODO: UPDATE with til
-	usrL2Txs, othrL2Txs := test.GenL2Txs(256+totalL1Txs, totalL2Txs, userL2Txs, &usrAddr, accs, tokens, blocks, batches)
-	// Sort txs
-	sortedTxs := []txSortFielder{}
-	for i := 0; i < len(usrL1Txs); i++ {
-		wL1 := wrappedL1(usrL1Txs[i])
-		sortedTxs = append(sortedTxs, &wL1)
-	}
-	for i := 0; i < len(othrL1Txs); i++ {
-		wL1 := wrappedL1(othrL1Txs[i])
-		sortedTxs = append(sortedTxs, &wL1)
-	}
-	for i := 0; i < len(usrL2Txs); i++ {
-		wL2 := wrappedL2(usrL2Txs[i])
-		sortedTxs = append(sortedTxs, &wL2)
-	}
-	for i := 0; i < len(othrL2Txs); i++ {
-		wL2 := wrappedL2(othrL2Txs[i])
-		sortedTxs = append(sortedTxs, &wL2)
-	}
-	sort.Sort(txsSort(sortedTxs))
-	// Store txs to DB
-	for _, genericTx := range sortedTxs {
-		l1 := genericTx.L1()
-		l2 := genericTx.L2()
-		if l1 != nil {
-			err = api.h.AddL1Txs([]common.L1Tx{*l1})
-			if err != nil {
-				panic(err)
-			}
-		} else if l2 != nil {
-			err = api.h.AddL2Txs([]common.L2Tx{*l2})
-			if err != nil {
-				panic(err)
-			}
-		} else {
-			panic("should be l1 or l2")
+		// Set USD value for tokens in DB
+		commonL1Txs = append(commonL1Txs, block.Rollup.L1UserTxs...)
+		for _, batch := range block.Rollup.Batches {
+			commonL2Txs = append(commonL2Txs, batch.L2Txs...)
+			commonAccounts = append(commonAccounts, batch.CreatedAccounts...)
+			commonBatches = append(commonBatches, batch.Batch)
+			commonExitTree = append(commonExitTree, batch.ExitTree...)
+			commonL1Txs = append(commonL1Txs, batch.L1CoordinatorTxs...)
 		}
 	}

-	// Coordinators
+	// 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)
+		}
+	}
+
+	// Generate Coordinators and add them to HistoryDB
 	const nCoords = 10
-	coords := test.GenCoordinators(nCoords, blocks)
-	err = api.h.AddCoordinators(coords)
-	if err != nil {
-		panic(err)
-	}
-	fromItem := uint(0)
-	limit := uint(99999)
-	coordinators, _, err := api.h.GetCoordinatorsAPI(&fromItem, &limit, historydb.OrderAsc)
-	if err != nil {
+	commonCoords := test.GenCoordinators(nCoords, commonBlocks)
+	if err := api.h.AddCoordinators(commonCoords); err != nil {
 		panic(err)
 	}

-	// Bids
+	// Generate Bids and add them to HistoryDB
 	const nBids = 20
-	bids := test.GenBids(nBids, blocks, coords)
-	err = api.h.AddBids(bids)
-	if err != nil {
+	commonBids := test.GenBids(nBids, commonBlocks, commonCoords)
+	if err = api.h.AddBids(commonBids); err != nil {
 		panic(err)
 	}
-	testBids := genTestBids(blocks, coordinators, bids)

-	// Vars
+	// Generate SC vars and add them to HistoryDB (if needed)
 	var defaultSlotSetBid [6]*big.Int = [6]*big.Int{big.NewInt(10), big.NewInt(10), big.NewInt(10), big.NewInt(10), big.NewInt(10), big.NewInt(10)}
 	auctionVars := common.AuctionVariables{
 		EthBlockNum:        int64(2),
@@ -329,33 +383,33 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}

-	const nSlots = 20
-
-	// Set testCommon
-	usrTxs, allTxs := genTestTxs(sortedTxs, usrIdxs, accs, tokensUSD, blocks)
-	poolTxsToSend, poolTxsToReceive := genTestPoolTx(accs, []babyjub.PrivateKey{privK}, tokensUSD) // NOTE: pool txs are not inserted to the DB here. In the test they will be posted and getted.
-	testBatches, fullBatches := genTestBatches(blocks, batches, allTxs)
-	usrExits, allExits := genTestExits(exits, tokensUSD, accs, usrIdxs)
+	// Generate test data, as expected to be received/sended from/to the API
+	testCoords := genTestCoordinators(commonCoords)
+	testBids := genTestBids(commonBlocks, testCoords, commonBids)
+	testExits := genTestExits(commonExitTree, testTokens, commonAccounts)
+	testTxs := genTestTxs(commonL1Txs, commonL2Txs, commonAccounts, testTokens, commonBlocks)
+	testBatches, testFullBatches := genTestBatches(commonBlocks, commonBatches, testTxs)
+	poolTxsToSend, poolTxsToReceive := genTestPoolTxs(commonPoolTxs, testTokens, commonAccounts)
 	tc = testCommon{
-		blocks:           blocks,
-		tokens:           tokensUSD,
+		blocks:           commonBlocks,
+		tokens:           testTokens,
 		batches:          testBatches,
-		fullBatches:      fullBatches,
-		coordinators:     coordinators,
-		accounts:         genTestAccounts(accs, tokensUSD),
-		usrAddr:          ethAddrToHez(usrAddr),
-		usrBjj:           bjjToString(usrBjj),
-		accs:             accs,
-		usrTxs:           usrTxs,
-		allTxs:           allTxs,
-		exits:            allExits,
-		usrExits:         usrExits,
+		fullBatches:      testFullBatches,
+		coordinators:     testCoords,
+		accounts:         genTestAccounts(commonAccounts, testTokens),
+		txs:              testTxs,
+		exits:            testExits,
 		poolTxsToSend:    poolTxsToSend,
 		poolTxsToReceive: poolTxsToReceive,
 		auths:            genTestAuths(test.GenAuths(5)),
 		router:           router,
 		bids:             testBids,
-		slots:            api.genTestSlots(nSlots, lastBlockNum, testBids, auctionVars),
+		slots: api.genTestSlots(
+			20,
+			commonBlocks[len(commonBlocks)-1].EthBlockNum,
+			testBids,
+			auctionVars,
+		),
 		auctionVars:  auctionVars,
 		rollupVars:   rollupVars,
 		wdelayerVars: wdelayerVars,
@@ -406,7 +460,11 @@ func doGoodReqPaginated(
 			iterPath += strconv.Itoa(int(next))
 		}
 		// Call API to get this iteration items
-		if err := doGoodReq("GET", iterPath+"&order="+order, nil, iterStruct); err != nil {
+		iterStruct = iterStruct.New()
+		if err := doGoodReq(
+			"GET", iterPath+"&order="+order, nil,
+			iterStruct,
+		); err != nil {
 			return err
 		}
 		appendIter(iterStruct)
@@ -482,8 +540,10 @@ func doGoodReq(method, path string, reqBody io.Reader, returnStruct interface{})
 	// Unmarshal body into return struct
 	if err := json.Unmarshal(body, returnStruct); err != nil {
 		log.Error("invalid json: " + string(body))
+		log.Error(err)
 		return err
 	}
+	// log.Info(string(body))
 	// Validate response against swagger spec
 	responseValidationInput := &swagger.ResponseValidationInput{
 		RequestValidationInput: requestValidationInput,
--- a/api/aux_test.go
+++ b/api/aux_test.go
@@ -0,0 +1,45 @@
+package api
+
+import (
+	"math/big"
+	"strconv"
+	"time"
+
+	ethCommon "github.com/ethereum/go-ethereum/common"
+	"github.com/hermeznetwork/hermez-node/common"
+	"github.com/iden3/go-merkletree"
+)
+
+func AddAditionalInformation(blocks []common.BlockData) {
+	for i := range blocks {
+		blocks[i].Block.Timestamp = time.Now().Add(time.Second * 13).UTC()
+		blocks[i].Block.Hash = ethCommon.BigToHash(big.NewInt(blocks[i].Block.EthBlockNum))
+		for j := range blocks[i].Rollup.AddedTokens {
+			blocks[i].Rollup.AddedTokens[j].Name = "NAME" + strconv.Itoa(int(blocks[i].Rollup.AddedTokens[j].TokenID))
+			blocks[i].Rollup.AddedTokens[j].Symbol = strconv.Itoa(int(blocks[i].Rollup.AddedTokens[j].TokenID))
+			blocks[i].Rollup.AddedTokens[j].Decimals = uint64(blocks[i].Rollup.AddedTokens[j].TokenID + 1)
+		}
+		for x := range blocks[i].Rollup.Batches {
+			for q := range blocks[i].Rollup.Batches[x].CreatedAccounts {
+				blocks[i].Rollup.Batches[x].CreatedAccounts[q].Balance =
+					big.NewInt(int64(blocks[i].Rollup.Batches[x].CreatedAccounts[q].Idx * 10000000))
+			}
+			for y := range blocks[i].Rollup.Batches[x].ExitTree {
+				blocks[i].Rollup.Batches[x].ExitTree[y].MerkleProof =
+					&merkletree.CircomVerifierProof{
+						Root: &merkletree.Hash{byte(y), byte(y + 1)},
+						Siblings: []*merkletree.Hash{
+							merkletree.NewHashFromBigInt(big.NewInt(int64(y) * 10)),
+							merkletree.NewHashFromBigInt(big.NewInt(int64(y)*100 + 1)),
+							merkletree.NewHashFromBigInt(big.NewInt(int64(y)*1000 + 2))},
+						OldKey:   &merkletree.Hash{byte(y * 1), byte(y*1 + 1)},
+						OldValue: &merkletree.Hash{byte(y * 2), byte(y*2 + 1)},
+						IsOld0:   y%2 == 0,
+						Key:      &merkletree.Hash{byte(y * 3), byte(y*3 + 1)},
+						Value:    &merkletree.Hash{byte(y * 4), byte(y*4 + 1)},
+						Fnc:      y % 2,
+					}
+			}
+		}
+	}
+}
--- a/api/batch.go
+++ b/api/batch.go
@@ -1,6 +1,7 @@
 package api

 import (
+	"database/sql"
 	"errors"
 	"net/http"

@@ -109,7 +110,7 @@ func (a *API) getFullBatch(c *gin.Context) {
 	txs, _, err := a.h.GetHistoryTxs(
 		nil, nil, nil, nil, batchNum, nil, nil, &maxTxsPerBatch, historydb.OrderAsc,
 	)
-	if err != nil {
+	if err != nil && err != sql.ErrNoRows {
 		retSQLErr(err, c)
 		return
 	}
--- a/api/batch_test.go
+++ b/api/batch_test.go
@@ -43,6 +43,8 @@ func (t testBatchesResponse) Len() int {
 	return len(t.Batches)
 }

+func (t testBatchesResponse) New() Pendinger { return &testBatchesResponse{} }
+
 type testFullBatch struct {
 	Batch testBatch `json:"batch"`
 	Txs   []testTx  `json:"transactions"`
@@ -54,11 +56,11 @@ func genTestBatches(
 	txs []testTx,
 ) ([]testBatch, []testFullBatch) {
 	tBatches := []testBatch{}
-	for _, cBatch := range cBatches {
+	for i := 0; i < len(cBatches); i++ {
 		block := common.Block{}
 		found := false
 		for _, b := range blocks {
-			if b.EthBlockNum == cBatch.EthBlockNum {
+			if b.EthBlockNum == cBatches[i].EthBlockNum {
 				block = b
 				found = true
 				break
@@ -68,22 +70,22 @@ func genTestBatches(
 			panic("block not found")
 		}
 		collectedFees := make(map[common.TokenID]string)
-		for k, v := range cBatch.CollectedFees {
+		for k, v := range cBatches[i].CollectedFees {
 			collectedFees[k] = v.String()
 		}
 		tBatch := testBatch{
-			BatchNum:      cBatch.BatchNum,
-			EthBlockNum:   cBatch.EthBlockNum,
+			BatchNum:      cBatches[i].BatchNum,
+			EthBlockNum:   cBatches[i].EthBlockNum,
 			EthBlockHash:  block.Hash,
 			Timestamp:     block.Timestamp,
-			ForgerAddr:    cBatch.ForgerAddr,
+			ForgerAddr:    cBatches[i].ForgerAddr,
 			CollectedFees: collectedFees,
-			TotalFeesUSD:  cBatch.TotalFeesUSD,
-			StateRoot:     cBatch.StateRoot.String(),
-			NumAccounts:   cBatch.NumAccounts,
-			ExitRoot:      cBatch.ExitRoot.String(),
-			ForgeL1TxsNum: cBatch.ForgeL1TxsNum,
-			SlotNum:       cBatch.SlotNum,
+			TotalFeesUSD:  cBatches[i].TotalFeesUSD,
+			StateRoot:     cBatches[i].StateRoot.String(),
+			NumAccounts:   cBatches[i].NumAccounts,
+			ExitRoot:      cBatches[i].ExitRoot.String(),
+			ForgeL1TxsNum: cBatches[i].ForgeL1TxsNum,
+			SlotNum:       cBatches[i].SlotNum,
 		}
 		tBatches = append(tBatches, tBatch)
 	}
--- a/api/bids_test.go
+++ b/api/bids_test.go
@@ -38,6 +38,8 @@ func (t testBidsResponse) Len() int {
 	return len(t.Bids)
 }

+func (t testBidsResponse) New() Pendinger { return &testBidsResponse{} }
+
 func genTestBids(blocks []common.Block, coordinators []historydb.CoordinatorAPI, bids []common.Bid) []testBid {
 	tBids := []testBid{}
 	for _, bid := range bids {
@@ -112,8 +114,8 @@ func TestGetBids(t *testing.T) {

 	// Mixed filters
 	fetchedBids = []testBid{}
-	bidderAddress = tc.bids[9].Bidder
-	slotNum = tc.bids[4].SlotNum
+	bidderAddress = tc.bids[1].Bidder
+	slotNum = tc.bids[1].SlotNum
 	path = fmt.Sprintf("%s?bidderAddr=%s&slotNum=%d&limit=%d&fromItem=", endpoint, bidderAddress.String(), slotNum, limit)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testBidsResponse{}, appendIter)
 	assert.NoError(t, err)
--- a/api/coordinator_test.go
+++ b/api/coordinator_test.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"testing"

+	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/mitchellh/copystructure"
 	"github.com/stretchr/testify/assert"
@@ -22,10 +23,24 @@ func (t testCoordinatorsResponse) GetPending() (pendingItems, lastItemID uint64)

 func (t *testCoordinatorsResponse) Len() int { return len(t.Coordinators) }

+func (t testCoordinatorsResponse) New() Pendinger { return &testCoordinatorsResponse{} }
+
+func genTestCoordinators(coordinators []common.Coordinator) []historydb.CoordinatorAPI {
+	testCoords := []historydb.CoordinatorAPI{}
+	for i := 0; i < len(coordinators); i++ {
+		testCoords = append(testCoords, historydb.CoordinatorAPI{
+			Bidder:      coordinators[i].Bidder,
+			Forger:      coordinators[i].Forger,
+			EthBlockNum: coordinators[i].EthBlockNum,
+			URL:         coordinators[i].URL,
+		})
+	}
+	return testCoords
+}
+
 func TestGetCoordinators(t *testing.T) {
 	endpoint := apiURL + "coordinators"
 	fetchedCoordinators := []historydb.CoordinatorAPI{}
-
 	appendIter := func(intr interface{}) {
 		for i := 0; i < len(intr.(*testCoordinatorsResponse).Coordinators); i++ {
 			tmp, err := copystructure.Copy(intr.(*testCoordinatorsResponse).Coordinators[i])
@@ -36,45 +51,30 @@ func TestGetCoordinators(t *testing.T) {
 		}
 	}

+	// All
 	limit := 5
-
 	path := fmt.Sprintf("%s?limit=%d&fromItem=", endpoint, limit)
 	err := doGoodReqPaginated(path, historydb.OrderAsc, &testCoordinatorsResponse{}, appendIter)
 	assert.NoError(t, err)
-	for i := 0; i < len(fetchedCoordinators); i++ {
-		assert.Equal(t, tc.coordinators[i].ItemID, fetchedCoordinators[i].ItemID)
-		assert.Equal(t, tc.coordinators[i].Bidder, fetchedCoordinators[i].Bidder)
-		assert.Equal(t, tc.coordinators[i].Forger, fetchedCoordinators[i].Forger)
-		assert.Equal(t, tc.coordinators[i].EthBlockNum, fetchedCoordinators[i].EthBlockNum)
-		assert.Equal(t, tc.coordinators[i].URL, fetchedCoordinators[i].URL)
-	}
+	assertCoordinators(t, tc.coordinators, fetchedCoordinators)

-	// Reverse Order
-	reversedCoordinators := []historydb.CoordinatorAPI{}
-	appendIter = func(intr interface{}) {
-		for i := 0; i < len(intr.(*testCoordinatorsResponse).Coordinators); i++ {
-			tmp, err := copystructure.Copy(intr.(*testCoordinatorsResponse).Coordinators[i])
-			if err != nil {
-				panic(err)
-			}
-			reversedCoordinators = append(reversedCoordinators, tmp.(historydb.CoordinatorAPI))
-		}
-	}
+	// All in reverse order
+	fetchedCoordinators = []historydb.CoordinatorAPI{}
 	err = doGoodReqPaginated(path, historydb.OrderDesc, &testCoordinatorsResponse{}, appendIter)
 	assert.NoError(t, err)
-	for i := 0; i < len(fetchedCoordinators); i++ {
-		assert.Equal(t, reversedCoordinators[i].ItemID, fetchedCoordinators[len(fetchedCoordinators)-1-i].ItemID)
-		assert.Equal(t, reversedCoordinators[i].Bidder, fetchedCoordinators[len(fetchedCoordinators)-1-i].Bidder)
-		assert.Equal(t, reversedCoordinators[i].Forger, fetchedCoordinators[len(fetchedCoordinators)-1-i].Forger)
-		assert.Equal(t, reversedCoordinators[i].EthBlockNum, fetchedCoordinators[len(fetchedCoordinators)-1-i].EthBlockNum)
-		assert.Equal(t, reversedCoordinators[i].URL, fetchedCoordinators[len(fetchedCoordinators)-1-i].URL)
+	reversedCoordinators := []historydb.CoordinatorAPI{}
+	for i := 0; i < len(tc.coordinators); i++ {
+		reversedCoordinators = append(reversedCoordinators, tc.coordinators[len(tc.coordinators)-1-i])
 	}
+	assertCoordinators(t, reversedCoordinators, fetchedCoordinators)

 	// Test GetCoordinator
-	path = fmt.Sprintf("%s/%s", endpoint, fetchedCoordinators[2].Forger.String())
-	coordinator := historydb.CoordinatorAPI{}
-	assert.NoError(t, doGoodReq("GET", path, nil, &coordinator))
-	assert.Equal(t, fetchedCoordinators[2], coordinator)
+	for _, coord := range tc.coordinators {
+		path = fmt.Sprintf("%s/%s", endpoint, coord.Forger.String())
+		fetchedCoordinator := historydb.CoordinatorAPI{}
+		assert.NoError(t, doGoodReq("GET", path, nil, &fetchedCoordinator))
+		assertCoordinator(t, coord, fetchedCoordinator)
+	}

 	// 400
 	path = fmt.Sprintf("%s/0x001", endpoint)
@@ -85,3 +85,15 @@ func TestGetCoordinators(t *testing.T) {
 	err = doBadReq("GET", path, nil, 404)
 	assert.NoError(t, err)
 }
+
+func assertCoordinator(t *testing.T, expected, actual historydb.CoordinatorAPI) {
+	actual.ItemID = 0
+	assert.Equal(t, expected, actual)
+}
+
+func assertCoordinators(t *testing.T, expected, actual []historydb.CoordinatorAPI) {
+	assert.Equal(t, len(expected), len(actual))
+	for i := 0; i < len(expected); i++ {
+		assertCoordinator(t, expected[i], actual[i])
+	}
+}
--- a/api/exits_test.go
+++ b/api/exits_test.go
@@ -45,6 +45,8 @@ func (t testExitsResponse) GetPending() (pendingItems, lastItemID uint64) {
 	return pendingItems, lastItemID
 }

+func (t testExitsResponse) New() Pendinger { return &testExitsResponse{} }
+
 func (t *testExitsResponse) Len() int {
 	return len(t.Exits)
 }
@@ -53,9 +55,8 @@ func genTestExits(
 	commonExits []common.ExitInfo,
 	tokens []historydb.TokenWithUSD,
 	accs []common.Account,
-	usrIdxs []string,
-) (usrExits, allExits []testExit) {
-	allExits = []testExit{}
+) []testExit {
+	allExits := []testExit{}
 	for _, exit := range commonExits {
 		token := getTokenByIdx(exit.AccountIdx, tokens, accs)
 		siblings := []string{}
@@ -82,16 +83,7 @@ func genTestExits(
 			Token:                  token,
 		})
 	}
-	usrExits = []testExit{}
-	for _, exit := range allExits {
-		for _, idx := range usrIdxs {
-			if idx == exit.AccountIdx {
-				usrExits = append(usrExits, exit)
-				break
-			}
-		}
-	}
-	return usrExits, allExits
+	return allExits
 }

 func TestGetExits(t *testing.T) {
@@ -116,23 +108,48 @@ func TestGetExits(t *testing.T) {
 	// Get by ethAddr
 	fetchedExits = []testExit{}
 	limit = 7
+	var account testAccount
+	for _, tx := range tc.txs {
+		found := false
+		if tx.Type == common.TxTypeExit {
+			for i := 0; i < len(tc.accounts); i++ {
+				if tx.FromIdx != nil && string(tc.accounts[i].Idx) == *tx.FromIdx {
+					account = tc.accounts[i]
+					break
+				}
+			}
+		}
+		if found {
+			break
+		}
+	}
 	path = fmt.Sprintf(
 		"%s?hermezEthereumAddress=%s&limit=%d&fromItem=",
-		endpoint, tc.usrAddr, limit,
+		endpoint, account.EthAddr, limit,
 	)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testExitsResponse{}, appendIter)
 	assert.NoError(t, err)
-	assertExitAPIs(t, tc.usrExits, fetchedExits)
+	var accountExits []testExit
+	for i := range tc.exits {
+		for _, acc := range tc.accounts {
+			if string(acc.Idx) == tc.exits[i].AccountIdx {
+				if acc.EthAddr == account.EthAddr {
+					accountExits = append(accountExits, tc.exits[i])
+				}
+			}
+		}
+	}
+	assertExitAPIs(t, accountExits, fetchedExits)
 	// Get by bjj
 	fetchedExits = []testExit{}
 	limit = 6
 	path = fmt.Sprintf(
 		"%s?BJJ=%s&limit=%d&fromItem=",
-		endpoint, tc.usrBjj, limit,
+		endpoint, account.PublicKey, limit,
 	)
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testExitsResponse{}, appendIter)
 	assert.NoError(t, err)
-	assertExitAPIs(t, tc.usrExits, fetchedExits)
+	assertExitAPIs(t, accountExits, fetchedExits)
 	// Get by tokenID
 	fetchedExits = []testExit{}
 	limit = 5
@@ -228,7 +245,7 @@ func TestGetExits(t *testing.T) {
 	// 400
 	path = fmt.Sprintf(
 		"%s?accountIndex=%s&hermezEthereumAddress=%s",
-		endpoint, idx, tc.usrAddr,
+		endpoint, idx, account.EthAddr,
 	)
 	err = doBadReq("GET", path, nil, 400)
 	assert.NoError(t, err)
--- a/api/slots.go
+++ b/api/slots.go
@@ -17,7 +17,7 @@ type SlotAPI struct {
 	FirstBlock  int64             `json:"firstBlock"`
 	LastBlock   int64             `json:"lastBlock"`
 	OpenAuction bool              `json:"openAuction"`
-	WinnerBid   *historydb.BidAPI `json:"winnerBid"`
+	WinnerBid   *historydb.BidAPI `json:"bestBid"`
 	TotalItems  uint64            `json:"-"`
 	FirstItem   uint64            `json:"-"`
 	LastItem    uint64            `json:"-"`
--- a/api/slots_test.go
+++ b/api/slots_test.go
@@ -17,7 +17,7 @@ type testSlot struct {
 	FirstBlock  int64    `json:"firstBlock"`
 	LastBlock   int64    `json:"lastBlock"`
 	OpenAuction bool     `json:"openAuction"`
-	WinnerBid   *testBid `json:"winnerBid"`
+	WinnerBid   *testBid `json:"bestBid"`
 }

 type testSlotsResponse struct {
@@ -35,6 +35,8 @@ func (t testSlotsResponse) Len() int {
 	return len(t.Slots)
 }

+func (t testSlotsResponse) New() Pendinger { return &testSlotsResponse{} }
+
 func (a *API) genTestSlots(nSlots int, lastBlockNum int64, bids []testBid, auctionVars common.AuctionVariables) []testSlot {
 	tSlots := []testSlot{}
 	bestBids := make(map[int64]testBid)
--- a/api/state.go
+++ b/api/state.go
@@ -12,7 +12,8 @@ import (

 // Network define status of the network
 type Network struct {
-	LastBlock   int64              `json:"lastBlock"`
+	LastEthBlock  int64              `json:"lastEthereumBlock"`
+	LastSyncBlock int64              `json:"lastSynchedBlock"`
 	LastBatch     historydb.BatchAPI `json:"lastBatch"`
 	CurrentSlot   int64              `json:"currentSlot"`
 	NextForgers   []NextForger       `json:"nextForgers"`
@@ -65,8 +66,12 @@ func (a *API) SetAuctionVariables(auctionVariables common.AuctionVariables) {
 // Network

 // UpdateNetworkInfo update Status.Network information
-func (a *API) UpdateNetworkInfo(lastBlock common.Block, lastBatchNum common.BatchNum, currentSlot int64) error {
-	a.status.Network.LastBlock = lastBlock.EthBlockNum
+func (a *API) UpdateNetworkInfo(
+	lastEthBlock, lastSyncBlock common.Block,
+	lastBatchNum common.BatchNum, currentSlot int64,
+) error {
+	a.status.Network.LastSyncBlock = lastSyncBlock.EthBlockNum
+	a.status.Network.LastEthBlock = lastEthBlock.EthBlockNum
 	lastBatch, err := a.h.GetBatchAPI(lastBatchNum)
 	if err != nil {
 		return err
@@ -74,7 +79,7 @@ func (a *API) UpdateNetworkInfo(lastBlock common.Block, lastBatchNum common.Batc
 	a.status.Network.LastBatch = *lastBatch
 	a.status.Network.CurrentSlot = currentSlot
 	lastClosedSlot := currentSlot + int64(a.status.Auction.ClosedAuctionSlots)
-	nextForgers, err := a.GetNextForgers(lastBlock, currentSlot, lastClosedSlot)
+	nextForgers, err := a.GetNextForgers(lastSyncBlock, currentSlot, lastClosedSlot)
 	if err != nil {
 		return err
 	}
--- a/api/state_test.go
+++ b/api/state_test.go
@@ -21,7 +21,8 @@ type testStatus struct {
 }

 type testNetwork struct {
-	LastBlock   int64        `json:"lastBlock"`
+	LastEthBlock  int64        `json:"lastEthereumBlock"`
+	LastSyncBlock int64        `json:"lastSynchedBlock"`
 	LastBatch     testBatch    `json:"lastBatch"`
 	CurrentSlot   int64        `json:"currentSlot"`
 	NextForgers   []NextForger `json:"nextForgers"`
@@ -80,16 +81,16 @@ func TestNextForgers(t *testing.T) {

 func TestUpdateNetworkInfo(t *testing.T) {
 	status := &Network{}
-	assert.Equal(t, status.LastBlock, api.status.Network.LastBlock)
+	assert.Equal(t, status.LastSyncBlock, api.status.Network.LastSyncBlock)
 	assert.Equal(t, status.LastBatch.BatchNum, api.status.Network.LastBatch.BatchNum)
 	assert.Equal(t, status.CurrentSlot, api.status.Network.CurrentSlot)
 	assert.Equal(t, status.NextForgers, api.status.Network.NextForgers)
 	lastBlock := tc.blocks[3]
 	lastBatchNum := common.BatchNum(3)
 	currentSlotNum := int64(1)
-	err := api.UpdateNetworkInfo(lastBlock, lastBatchNum, currentSlotNum)
+	err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
 	assert.NoError(t, err)
-	assert.Equal(t, lastBlock.EthBlockNum, api.status.Network.LastBlock)
+	assert.Equal(t, lastBlock.EthBlockNum, api.status.Network.LastSyncBlock)
 	assert.Equal(t, lastBatchNum, api.status.Network.LastBatch.BatchNum)
 	assert.Equal(t, currentSlotNum, api.status.Network.CurrentSlot)
 	assert.Equal(t, int(api.status.Auction.ClosedAuctionSlots)+1, len(api.status.Network.NextForgers))
@@ -101,7 +102,7 @@ func TestUpdateMetrics(t *testing.T) {
 	lastBlock := tc.blocks[3]
 	lastBatchNum := common.BatchNum(3)
 	currentSlotNum := int64(1)
-	err := api.UpdateNetworkInfo(lastBlock, lastBatchNum, currentSlotNum)
+	err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
 	assert.NoError(t, err)

 	err = api.UpdateMetrics()
@@ -124,14 +125,14 @@ func TestUpdateRecommendedFee(t *testing.T) {
 		api.status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
 }

-func TestGetStatus(t *testing.T) {
+func TestGetState(t *testing.T) {
 	lastBlock := tc.blocks[3]
 	lastBatchNum := common.BatchNum(3)
 	currentSlotNum := int64(1)
 	api.SetRollupVariables(tc.rollupVars)
 	api.SetWDelayerVariables(tc.wdelayerVars)
 	api.SetAuctionVariables(tc.auctionVars)
-	err := api.UpdateNetworkInfo(lastBlock, lastBatchNum, currentSlotNum)
+	err := api.UpdateNetworkInfo(lastBlock, lastBlock, lastBatchNum, currentSlotNum)
 	assert.NoError(t, err)
 	err = api.UpdateMetrics()
 	assert.NoError(t, err)
@@ -145,7 +146,8 @@ func TestGetStatus(t *testing.T) {
 	assert.Equal(t, tc.rollupVars, status.Rollup)
 	assert.Equal(t, tc.auctionVars, status.Auction)
 	assert.Equal(t, tc.wdelayerVars, status.WithdrawalDelayer)
-	assert.Equal(t, lastBlock.EthBlockNum, status.Network.LastBlock)
+	assert.Equal(t, lastBlock.EthBlockNum, status.Network.LastEthBlock)
+	assert.Equal(t, lastBlock.EthBlockNum, status.Network.LastSyncBlock)
 	assert.Equal(t, lastBatchNum, status.Network.LastBatch.BatchNum)
 	assert.Equal(t, currentSlotNum, status.Network.CurrentSlot)
 	assert.Equal(t, int(api.status.Auction.ClosedAuctionSlots)+1, len(status.Network.NextForgers))
--- a/api/swagger.yml
+++ b/api/swagger.yml
@@ -1857,6 +1857,7 @@ components:
          description: List of forged transactions in the batch
          items:
            $ref: '#/components/schemas/HistoryTransaction'
+          nullable: true
      additionalProperties: false
      required:
        - batch
@@ -2205,9 +2206,9 @@ components:
        openAuction:
          type: boolean
          description: Whether the auction of the slot is open or not.
-        winnerBid:
+        bestBid:
          type: object
-          description: The winning bid of the auction. If openAuction == true, is the current winner. If the auction is closed because it has already been finalized, the bid is the final winner. If the winnerBid is null, it is because no coordinator has bid for that slot.
+          description: The best bid of the auction. If the bestBid is null, it is because no coordinator has bid for that slot.
          nullable: true
          properties:
            itemId:
@@ -2245,7 +2246,7 @@ components:
        - firstBlock
        - lastBlock
        - openAuction
-        - winnerBid
+        - bestBid
    Slots:
      type: object
      properties:
@@ -2328,10 +2329,15 @@ components:
      type: object
      description: Gobal statistics of the network
      properties:
-        lastBlock:
+        lastEthereumBlock:
          allOf:
            - $ref: '#/components/schemas/EthBlockNum'
-            - description: Last synchronized Etherum block.
+            - description: Current Etherum block. Note that this is the actual last block of Ethereum, not the last synchronized block by the node.
+            - example: 3457437
+        lastSynchedBlock:
+          allOf:
+            - $ref: '#/components/schemas/EthBlockNum'
+            - description: Last synchronized Etherum block. Compare with lastEthereumBlock to check the synchronization status of the node.
            - example: 3457437
        lastBatch:
          $ref: '#/components/schemas/Batch'
@@ -2344,7 +2350,8 @@ components:
          $ref: '#/components/schemas/NextForgers'
      additionalProperties: false
      required: 
-        - lastBlock
+        - lastEthereumBlock
+        - lastSynchedBlock 
        - lastBatch
        - currentSlot
        - nextForgers
--- a/api/token_test.go
+++ b/api/token_test.go
@@ -26,6 +26,8 @@ func (t *testTokensResponse) Len() int {
 	return len(t.Tokens)
 }

+func (t testTokensResponse) New() Pendinger { return &testTokensResponse{} }
+
 func TestGetToken(t *testing.T) {
 	// Get all txs by their ID
 	endpoint := apiURL + "tokens/"
--- a/api/txshistory_test.go
+++ b/api/txshistory_test.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"math"
 	"math/big"
+	"sort"
 	"testing"
 	"time"

@@ -51,43 +52,14 @@ type testTx struct {
 	Token       historydb.TokenWithUSD `json:"token"`
 }

-type testTxsResponse struct {
-	Txs          []testTx `json:"transactions"`
-	PendingItems uint64   `json:"pendingItems"`
-}
-
-func (t testTxsResponse) GetPending() (pendingItems, lastItemID uint64) {
-	pendingItems = t.PendingItems
-	lastItemID = t.Txs[len(t.Txs)-1].ItemID
-	return pendingItems, lastItemID
-}
-
-func (t testTxsResponse) Len() int {
-	return len(t.Txs)
-}
-
-// TxSortFields represents the fields needed to sort L1 and L2 transactions
-type txSortFields struct {
-	BatchNum *common.BatchNum
-	Position int
-}
-
-// TxSortFielder is a interface that allows sorting L1 and L2 transactions in a combined way
-type txSortFielder interface {
-	SortFields() txSortFields
-	L1() *common.L1Tx
-	L2() *common.L2Tx
-}
-
-// TxsSort array of TxSortFielder
-type txsSort []txSortFielder
+type txsSort []testTx

 func (t txsSort) Len() int      { return len(t) }
 func (t txsSort) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
 func (t txsSort) Less(i, j int) bool {
 	// i not forged yet
-	isf := t[i].SortFields()
-	jsf := t[j].SortFields()
+	isf := t[i]
+	jsf := t[j]
 	if isf.BatchNum == nil {
 		if jsf.BatchNum != nil { // j is already forged
 			return false
@@ -108,68 +80,33 @@ func (t txsSort) Less(i, j int) bool {
 	return *isf.BatchNum < *jsf.BatchNum
 }

-type wrappedL1 common.L1Tx
-
-// SortFields implements TxSortFielder
-func (tx *wrappedL1) SortFields() txSortFields {
-	return txSortFields{
-		BatchNum: tx.BatchNum,
-		Position: tx.Position,
-	}
+type testTxsResponse struct {
+	Txs          []testTx `json:"transactions"`
+	PendingItems uint64   `json:"pendingItems"`
 }

-// L1 implements TxSortFielder
-func (tx *wrappedL1) L1() *common.L1Tx {
-	l1tx := common.L1Tx(*tx)
-	return &l1tx
+func (t testTxsResponse) GetPending() (pendingItems, lastItemID uint64) {
+	pendingItems = t.PendingItems
+	lastItemID = t.Txs[len(t.Txs)-1].ItemID
+	return pendingItems, lastItemID
 }

-// L2 implements TxSortFielder
-func (tx *wrappedL1) L2() *common.L2Tx { return nil }
-
-type wrappedL2 common.L2Tx
-
-// SortFields implements TxSortFielder
-func (tx *wrappedL2) SortFields() txSortFields {
-	return txSortFields{
-		BatchNum: &tx.BatchNum,
-		Position: tx.Position,
-	}
+func (t testTxsResponse) Len() int {
+	return len(t.Txs)
 }

-// L1 implements TxSortFielder
-func (tx *wrappedL2) L1() *common.L1Tx { return nil }
-
-// L2 implements TxSortFielder
-func (tx *wrappedL2) L2() *common.L2Tx {
-	l2tx := common.L2Tx(*tx)
-	return &l2tx
-}
+func (t testTxsResponse) New() Pendinger { return &testTxsResponse{} }

 func genTestTxs(
-	genericTxs []txSortFielder,
-	usrIdxs []string,
+	l1s []common.L1Tx,
+	l2s []common.L2Tx,
 	accs []common.Account,
 	tokens []historydb.TokenWithUSD,
 	blocks []common.Block,
-) (usrTxs []testTx, allTxs []testTx) {
-	usrTxs = []testTx{}
-	allTxs = []testTx{}
-	isUsrTx := func(tx testTx) bool {
-		for _, idx := range usrIdxs {
-			if tx.FromIdx != nil && *tx.FromIdx == idx {
-				return true
-			}
-			if tx.ToIdx == idx {
-				return true
-			}
-		}
-		return false
-	}
-	for _, genericTx := range genericTxs {
-		l1 := genericTx.L1()
-		l2 := genericTx.L2()
-		if l1 != nil { // L1Tx to testTx
+) []testTx {
+	txs := []testTx{}
+	// common.L1Tx ==> testTx
+	for _, l1 := range l1s {
 		token := getTokenByID(l1.TokenID, tokens)
 		// l1.FromEthAddr and l1.FromBJJ can't be nil
 		fromEthAddr := string(apitypes.NewHezEthAddr(l1.FromEthAddr))
@@ -193,11 +130,15 @@ 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
+			bn := common.BatchNum(*tx.L1Info.ToForgeL1TxsNum + 2)
+			tx.BatchNum = &bn
+		}
 		// If FromIdx is not nil
-			if l1.FromIdx != 0 {
 		idxStr := idxToHez(l1.FromIdx, token.Symbol)
 		tx.FromIdx = &idxStr
-			}
 		// If tx has a normal ToIdx (>255), set FromEthAddr and FromBJJ
 		if l1.ToIdx >= common.UserThreshold {
 			// find account
@@ -216,44 +157,48 @@ func genTestTxs(
 			af := new(big.Float).SetInt(l1.Amount)
 			amountFloat, _ := af.Float64()
 			usd := *token.USD * amountFloat / math.Pow(10, float64(token.Decimals))
+			if usd != 0 {
 				tx.HistoricUSD = &usd
+			}
 			laf := new(big.Float).SetInt(l1.LoadAmount)
 			loadAmountFloat, _ := laf.Float64()
 			loadUSD := *token.USD * loadAmountFloat / math.Pow(10, float64(token.Decimals))
+			if loadAmountFloat != 0 {
 				tx.L1Info.HistoricLoadAmountUSD = &loadUSD
 			}
-			allTxs = append(allTxs, tx)
-			if isUsrTx(tx) {
-				usrTxs = append(usrTxs, tx)
 		}
-		} else { // L2Tx to testTx
-			token := getTokenByIdx(l2.FromIdx, tokens, accs)
+		txs = append(txs, tx)
+	}
+
+	// common.L2Tx ==> testTx
+	for i := 0; i < len(l2s); i++ {
+		token := getTokenByIdx(l2s[i].FromIdx, tokens, accs)
 		// l1.FromIdx can't be nil
-			fromIdx := idxToHez(l2.FromIdx, token.Symbol)
+		fromIdx := idxToHez(l2s[i].FromIdx, token.Symbol)
 		tx := testTx{
 			IsL1:      "L2",
-				TxID:      l2.TxID,
-				Type:      l2.Type,
-				Position:  l2.Position,
-				ToIdx:     idxToHez(l2.ToIdx, token.Symbol),
+			TxID:      l2s[i].TxID,
+			Type:      l2s[i].Type,
+			Position:  l2s[i].Position,
+			ToIdx:     idxToHez(l2s[i].ToIdx, token.Symbol),
 			FromIdx:   &fromIdx,
-				Amount:    l2.Amount.String(),
-				BatchNum:  &l2.BatchNum,
-				Timestamp: getTimestamp(l2.EthBlockNum, blocks),
+			Amount:    l2s[i].Amount.String(),
+			BatchNum:  &l2s[i].BatchNum,
+			Timestamp: getTimestamp(l2s[i].EthBlockNum, blocks),
 			L2Info: &testL2Info{
-					Nonce: l2.Nonce,
-					Fee:   l2.Fee,
+				Nonce: l2s[i].Nonce,
+				Fee:   l2s[i].Fee,
 			},
 			Token: token,
 		}
 		// If FromIdx is not nil
-			if l2.FromIdx != 0 {
-				idxStr := idxToHez(l2.FromIdx, token.Symbol)
+		if l2s[i].FromIdx != 0 {
+			idxStr := idxToHez(l2s[i].FromIdx, token.Symbol)
 			tx.FromIdx = &idxStr
 		}
 		// Set FromEthAddr and FromBJJ (FromIdx it's always >255)
 		for _, acc := range accs {
-				if l2.ToIdx == acc.Idx {
+			if l2s[i].FromIdx == acc.Idx {
 				fromEthAddr := string(apitypes.NewHezEthAddr(acc.EthAddr))
 				tx.FromEthAddr = &fromEthAddr
 				fromBJJ := string(apitypes.NewHezBJJ(acc.PublicKey))
@@ -262,10 +207,10 @@ func genTestTxs(
 			}
 		}
 		// If tx has a normal ToIdx (>255), set FromEthAddr and FromBJJ
-			if l2.ToIdx >= common.UserThreshold {
+		if l2s[i].ToIdx >= common.UserThreshold {
 			// find account
 			for _, acc := range accs {
-					if l2.ToIdx == acc.Idx {
+				if l2s[i].ToIdx == acc.Idx {
 					toEthAddr := string(apitypes.NewHezEthAddr(acc.EthAddr))
 					tx.ToEthAddr = &toEthAddr
 					toBJJ := string(apitypes.NewHezBJJ(acc.PublicKey))
@@ -276,21 +221,25 @@ func genTestTxs(
 		}
 		// If the token has USD value setted
 		if token.USD != nil {
-				af := new(big.Float).SetInt(l2.Amount)
+			af := new(big.Float).SetInt(l2s[i].Amount)
 			amountFloat, _ := af.Float64()
 			usd := *token.USD * amountFloat / math.Pow(10, float64(token.Decimals))
+			if usd != 0 {
 				tx.HistoricUSD = &usd
-				feeUSD := usd * l2.Fee.Percentage()
-				tx.HistoricUSD = &usd
+				feeUSD := usd * l2s[i].Fee.Percentage()
+				if feeUSD != 0 {
 					tx.L2Info.HistoricFeeUSD = &feeUSD
 				}
-			allTxs = append(allTxs, tx)
-			if isUsrTx(tx) {
-				usrTxs = append(usrTxs, tx)
 			}
 		}
+		txs = append(txs, tx)
 	}
-	return usrTxs, allTxs
+
+	// Sort txs
+	sortedTxs := txsSort(txs)
+	sort.Sort(sortedTxs)
+
+	return []testTx(sortedTxs)
 }

 func TestGetHistoryTxs(t *testing.T) {
@@ -310,32 +259,44 @@ func TestGetHistoryTxs(t *testing.T) {
 	path := fmt.Sprintf("%s?limit=%d&fromItem=", endpoint, limit)
 	err := doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
 	assert.NoError(t, err)
-	assertTxs(t, tc.allTxs, fetchedTxs)
-	// Uncomment once tx generation for tests is fixed
-	// // Get by ethAddr
-	// fetchedTxs = []testTx{}
-	// limit = 7
-	// path = fmt.Sprintf(
-	// 	"%s?hermezEthereumAddress=%s&limit=%d&fromItem=",
-	// 	endpoint, tc.usrAddr, limit,
-	// )
-	// err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
-	// assert.NoError(t, err)
-	// assertTxs(t, tc.usrTxs, fetchedTxs)
-	// // Get by bjj
-	// fetchedTxs = []testTx{}
-	// limit = 6
-	// path = fmt.Sprintf(
-	// 	"%s?BJJ=%s&limit=%d&fromItem=",
-	// 	endpoint, tc.usrBjj, limit,
-	// )
-	// err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
-	// assert.NoError(t, err)
-	// assertTxs(t, tc.usrTxs, fetchedTxs)
+	assertTxs(t, tc.txs, fetchedTxs)
+	// Get by ethAddr
+	account := tc.accounts[2]
+	fetchedTxs = []testTx{}
+	limit = 7
+	path = fmt.Sprintf(
+		"%s?hermezEthereumAddress=%s&limit=%d&fromItem=",
+		endpoint, account.EthAddr, limit,
+	)
+	err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
+	assert.NoError(t, err)
+	accountTxs := []testTx{}
+	for i := 0; i < len(tc.txs); i++ {
+		tx := tc.txs[i]
+		if (tx.FromIdx != nil && *tx.FromIdx == string(account.Idx)) ||
+			tx.ToIdx == string(account.Idx) ||
+			(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)) {
+			accountTxs = append(accountTxs, tx)
+		}
+	}
+	assertTxs(t, accountTxs, fetchedTxs)
+	// Get by bjj
+	fetchedTxs = []testTx{}
+	limit = 6
+	path = fmt.Sprintf(
+		"%s?BJJ=%s&limit=%d&fromItem=",
+		endpoint, account.PublicKey, limit,
+	)
+	err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
+	assert.NoError(t, err)
+	assertTxs(t, accountTxs, fetchedTxs)
 	// Get by tokenID
 	fetchedTxs = []testTx{}
 	limit = 5
-	tokenID := tc.allTxs[0].Token.TokenID
+	tokenID := tc.txs[0].Token.TokenID
 	path = fmt.Sprintf(
 		"%s?tokenId=%d&limit=%d&fromItem=",
 		endpoint, tokenID, limit,
@@ -343,34 +304,46 @@ func TestGetHistoryTxs(t *testing.T) {
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
 	assert.NoError(t, err)
 	tokenIDTxs := []testTx{}
-	for i := 0; i < len(tc.allTxs); i++ {
-		if tc.allTxs[i].Token.TokenID == tokenID {
-			tokenIDTxs = append(tokenIDTxs, tc.allTxs[i])
+	for i := 0; i < len(tc.txs); i++ {
+		if tc.txs[i].Token.TokenID == tokenID {
+			tokenIDTxs = append(tokenIDTxs, tc.txs[i])
 		}
 	}
 	assertTxs(t, tokenIDTxs, fetchedTxs)
-	// // idx
-	// fetchedTxs = []testTx{}
-	// limit = 4
-	idx := tc.allTxs[0].ToIdx
-	// path = fmt.Sprintf(
-	// 	"%s?accountIndex=%s&limit=%d&fromItem=",
-	// 	endpoint, idx, limit,
-	// )
-	// err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
-	// assert.NoError(t, err)
-	// idxTxs := []testTx{}
-	// for i := 0; i < len(tc.allTxs); i++ {
-	// 	if (tc.allTxs[i].FromIdx != nil && (*tc.allTxs[i].FromIdx)[6:] == idx[6:]) ||
-	// 		tc.allTxs[i].ToIdx[6:] == idx[6:] {
-	// 		idxTxs = append(idxTxs, tc.allTxs[i])
-	// 	}
-	// }
-	// assertHistoryTxAPIs(t, idxTxs, fetchedTxs)
+	// idx
+	fetchedTxs = []testTx{}
+	limit = 4
+	idxStr := tc.txs[0].ToIdx
+	idx, err := stringToIdx(idxStr, "")
+	assert.NoError(t, err)
+	path = fmt.Sprintf(
+		"%s?accountIndex=%s&limit=%d&fromItem=",
+		endpoint, idxStr, limit,
+	)
+	err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
+	assert.NoError(t, err)
+	idxTxs := []testTx{}
+	for i := 0; i < len(tc.txs); i++ {
+		var fromIdx *common.Idx
+		if tc.txs[i].FromIdx != nil {
+			fromIdx, err = stringToIdx(*tc.txs[i].FromIdx, "")
+			assert.NoError(t, err)
+			if *fromIdx == *idx {
+				idxTxs = append(idxTxs, tc.txs[i])
+				continue
+			}
+		}
+		toIdx, err := stringToIdx((tc.txs[i].ToIdx), "")
+		assert.NoError(t, err)
+		if *toIdx == *idx {
+			idxTxs = append(idxTxs, tc.txs[i])
+		}
+	}
+	assertTxs(t, idxTxs, fetchedTxs)
 	// batchNum
 	fetchedTxs = []testTx{}
 	limit = 3
-	batchNum := tc.allTxs[0].BatchNum
+	batchNum := tc.txs[0].BatchNum
 	path = fmt.Sprintf(
 		"%s?batchNum=%d&limit=%d&fromItem=",
 		endpoint, *batchNum, limit,
@@ -378,26 +351,24 @@ func TestGetHistoryTxs(t *testing.T) {
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
 	assert.NoError(t, err)
 	batchNumTxs := []testTx{}
-	for i := 0; i < len(tc.allTxs); i++ {
-		if tc.allTxs[i].BatchNum != nil &&
-			*tc.allTxs[i].BatchNum == *batchNum {
-			batchNumTxs = append(batchNumTxs, tc.allTxs[i])
+	for i := 0; i < len(tc.txs); i++ {
+		if tc.txs[i].BatchNum != nil &&
+			*tc.txs[i].BatchNum == *batchNum {
+			batchNumTxs = append(batchNumTxs, tc.txs[i])
 		}
 	}
 	assertTxs(t, batchNumTxs, fetchedTxs)
 	// type
 	txTypes := []common.TxType{
 		// Uncomment once test gen is fixed
-		// common.TxTypeExit,
-		// common.TxTypeTransfer,
-		// common.TxTypeDeposit,
+		common.TxTypeExit,
+		common.TxTypeTransfer,
+		common.TxTypeDeposit,
 		common.TxTypeCreateAccountDeposit,
-		// common.TxTypeCreateAccountDepositTransfer,
-		// common.TxTypeDepositTransfer,
+		common.TxTypeCreateAccountDepositTransfer,
+		common.TxTypeDepositTransfer,
 		common.TxTypeForceTransfer,
-		// common.TxTypeForceExit,
-		// common.TxTypeTransferToEthAddr,
-		// common.TxTypeTransferToBJJ,
+		common.TxTypeForceExit,
 	}
 	for _, txType := range txTypes {
 		fetchedTxs = []testTx{}
@@ -409,9 +380,9 @@ func TestGetHistoryTxs(t *testing.T) {
 		err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
 		assert.NoError(t, err)
 		txTypeTxs := []testTx{}
-		for i := 0; i < len(tc.allTxs); i++ {
-			if tc.allTxs[i].Type == txType {
-				txTypeTxs = append(txTypeTxs, tc.allTxs[i])
+		for i := 0; i < len(tc.txs); i++ {
+			if tc.txs[i].Type == txType {
+				txTypeTxs = append(txTypeTxs, tc.txs[i])
 			}
 		}
 		assertTxs(t, txTypeTxs, fetchedTxs)
@@ -426,10 +397,10 @@ func TestGetHistoryTxs(t *testing.T) {
 	err = doGoodReqPaginated(path, historydb.OrderAsc, &testTxsResponse{}, appendIter)
 	assert.NoError(t, err)
 	mixedTxs := []testTx{}
-	for i := 0; i < len(tc.allTxs); i++ {
-		if tc.allTxs[i].BatchNum != nil {
-			if *tc.allTxs[i].BatchNum == *batchNum && tc.allTxs[i].Token.TokenID == tokenID {
-				mixedTxs = append(mixedTxs, tc.allTxs[i])
+	for i := 0; i < len(tc.txs); i++ {
+		if tc.txs[i].BatchNum != nil {
+			if *tc.txs[i].BatchNum == *batchNum && tc.txs[i].Token.TokenID == tokenID {
+				mixedTxs = append(mixedTxs, tc.txs[i])
 			}
 		}
 	}
@@ -441,14 +412,14 @@ func TestGetHistoryTxs(t *testing.T) {
 	err = doGoodReqPaginated(path, historydb.OrderDesc, &testTxsResponse{}, appendIter)
 	assert.NoError(t, err)
 	flipedTxs := []testTx{}
-	for i := 0; i < len(tc.allTxs); i++ {
-		flipedTxs = append(flipedTxs, tc.allTxs[len(tc.allTxs)-1-i])
+	for i := 0; i < len(tc.txs); i++ {
+		flipedTxs = append(flipedTxs, tc.txs[len(tc.txs)-1-i])
 	}
 	assertTxs(t, flipedTxs, fetchedTxs)
 	// 400
 	path = fmt.Sprintf(
 		"%s?accountIndex=%s&hermezEthereumAddress=%s",
-		endpoint, idx, tc.usrAddr,
+		endpoint, idx, account.EthAddr,
 	)
 	err = doBadReq("GET", path, nil, 400)
 	assert.NoError(t, err)
@@ -468,13 +439,13 @@ func TestGetHistoryTx(t *testing.T) {
 	// Get all txs by their ID
 	endpoint := apiURL + "transactions-history/"
 	fetchedTxs := []testTx{}
-	for _, tx := range tc.allTxs {
+	for _, tx := range tc.txs {
 		fetchedTx := testTx{}
 		err := doGoodReq("GET", endpoint+tx.TxID.String(), nil, &fetchedTx)
 		assert.NoError(t, err)
 		fetchedTxs = append(fetchedTxs, fetchedTx)
 	}
-	assertTxs(t, tc.allTxs, fetchedTxs)
+	assertTxs(t, tc.txs, fetchedTxs)
 	// 400
 	err := doBadReq("GET", endpoint+"0x001", nil, 400)
 	assert.NoError(t, err)
@@ -486,12 +457,15 @@ func TestGetHistoryTx(t *testing.T) {
 func assertTxs(t *testing.T, expected, actual []testTx) {
 	require.Equal(t, len(expected), len(actual))
 	for i := 0; i < len(actual); i++ { //nolint len(actual) won't change within the loop
+		assert.Equal(t, expected[i].BatchNum, actual[i].BatchNum)
+		assert.Equal(t, expected[i].Position, actual[i].Position)
 		actual[i].ItemID = 0
 		actual[i].Token.ItemID = 0
 		assert.Equal(t, expected[i].Timestamp.Unix(), actual[i].Timestamp.Unix())
 		expected[i].Timestamp = actual[i].Timestamp
 		if expected[i].Token.USDUpdate == nil {
 			assert.Equal(t, expected[i].Token.USDUpdate, actual[i].Token.USDUpdate)
+			expected[i].Token.USDUpdate = actual[i].Token.USDUpdate
 		} else {
 			assert.Equal(t, expected[i].Token.USDUpdate.Unix(), actual[i].Token.USDUpdate.Unix())
 			expected[i].Token.USDUpdate = actual[i].Token.USDUpdate
--- a/api/txspool_test.go
+++ b/api/txspool_test.go
@@ -3,7 +3,6 @@ package api
 import (
 	"bytes"
 	"encoding/json"
-	"math/big"
 	"testing"
 	"time"

@@ -66,32 +65,11 @@ type testPoolTxSend struct {
 	RqNonce     *common.Nonce         `json:"requestNonce"`
 }

-func genTestPoolTx(accs []common.Account, privKs []babyjub.PrivateKey, tokens []historydb.TokenWithUSD) (poolTxsToSend []testPoolTxSend, poolTxsToReceive []testPoolTxReceive) {
-	// Generate common.PoolL2Tx
-	// WARNING: this should be replaced once til is ready
-	poolTxs := []common.PoolL2Tx{}
-	amount := new(big.Int)
-	amount, ok := amount.SetString("100000000000000", 10)
-	if !ok {
-		panic("bad amount")
-	}
-	poolTx := common.PoolL2Tx{
-		FromIdx: accs[0].Idx,
-		ToIdx:   accs[1].Idx,
-		Amount:  amount,
-		TokenID: accs[0].TokenID,
-		Nonce:   6,
-	}
-	if _, err := common.NewPoolL2Tx(&poolTx); err != nil {
-		panic(err)
-	}
-	h, err := poolTx.HashToSign()
-	if err != nil {
-		panic(err)
-	}
-	poolTx.Signature = privKs[0].SignPoseidon(h).Compress()
-	poolTxs = append(poolTxs, poolTx)
-	// Transform to API formats
+func genTestPoolTxs(
+	poolTxs []common.PoolL2Tx,
+	tokens []historydb.TokenWithUSD,
+	accs []common.Account,
+) (poolTxsToSend []testPoolTxSend, poolTxsToReceive []testPoolTxReceive) {
 	poolTxsToSend = []testPoolTxSend{}
 	poolTxsToReceive = []testPoolTxReceive{}
 	for _, poolTx := range poolTxs {
@@ -125,7 +103,7 @@ func genTestPoolTx(accs []common.Account, privKs []babyjub.PrivateKey, tokens []
 			RqNonce: &poolTx.RqNonce,
 			Token:   token,
 		}
-		fromAcc := getAccountByIdx(poolTx.ToIdx, accs)
+		fromAcc := getAccountByIdx(poolTx.FromIdx, accs)
 		fromAddr := ethAddrToHez(fromAcc.EthAddr)
 		genReceiveTx.FromEthAddr = &fromAddr
 		fromBjj := bjjToString(fromAcc.PublicKey)
--- a/apitypes/apitypes.go
+++ b/apitypes/apitypes.go
@@ -95,12 +95,12 @@ func (c *CollectedFees) UnmarshalJSON(text []byte) error {
 	if err := json.Unmarshal(text, &bigIntMap); err != nil {
 		return err
 	}
-	bStrMap := make(map[common.TokenID]BigIntStr)
+	*c = CollectedFees(make(map[common.TokenID]BigIntStr))
 	for k, v := range bigIntMap {
 		bStr := NewBigIntStr(v)
-		bStrMap[k] = *bStr
+		(CollectedFees(*c)[k]) = *bStr
 	}
-	*c = CollectedFees(bStrMap)
+	// *c = CollectedFees(bStrMap)
 	return nil
 }

--- a/db/historydb/historydb.go
+++ b/db/historydb/historydb.go
@@ -894,17 +894,13 @@ func (hdb *HistoryDB) GetHistoryTxs(
 	nextIsAnd := false
 	// ethAddr filter
 	if ethAddr != nil {
-		queryStr = `WITH acc AS 
-		(select idx from account where eth_addr = ?) ` + queryStr
-		queryStr += ", acc WHERE (tx.from_idx IN(acc.idx) OR tx.to_idx IN(acc.idx)) "
+		queryStr += "WHERE (tx.from_eth_addr = ? OR tx.to_eth_addr = ?) "
 		nextIsAnd = true
-		args = append(args, ethAddr)
+		args = append(args, ethAddr, ethAddr)
 	} else if bjj != nil { // bjj filter
-		queryStr = `WITH acc AS 
-		(select idx from account where bjj = ?) ` + queryStr
-		queryStr += ", acc WHERE (tx.from_idx IN(acc.idx) OR tx.to_idx IN(acc.idx)) "
+		queryStr += "WHERE (tx.from_bjj = ? OR tx.to_bjj = ?) "
 		nextIsAnd = true
-		args = append(args, bjj)
+		args = append(args, bjj, bjj)
 	}
 	// tokenID filter
 	if tokenID != nil {
@@ -1302,10 +1298,30 @@ func (hdb *HistoryDB) AddBlockSCData(blockData *common.BlockData) (err error) {
 		}
 	}

-	// Add l1 Txs
-	if len(blockData.Rollup.L1UserTxs) > 0 {
-		if err := hdb.addL1Txs(txn, blockData.Rollup.L1UserTxs); err != nil {
-			return err
+	// Prepare user L1 txs to be added.
+	// They must be added before the batch that will forge them (which can be in the same block)
+	// and after the account that will be sent to (also can be in the same block).
+	// Note: insert order is not relevant since item_id will be updated by a DB trigger when
+	// the batch that forges those txs is inserted
+	userL1s := make(map[common.BatchNum][]common.L1Tx)
+	for i := range blockData.Rollup.L1UserTxs {
+		batchThatForgesIsInTheBlock := false
+		for _, batch := range blockData.Rollup.Batches {
+			if batch.Batch.ForgeL1TxsNum != nil &&
+				*batch.Batch.ForgeL1TxsNum == *blockData.Rollup.L1UserTxs[i].ToForgeL1TxsNum {
+				// Tx is forged in this block. It's guaranteed that:
+				// * the first batch of the block won't forge user L1 txs that have been added in this block
+				// * batch nums are sequential therefore it's safe to add the tx at batch.BatchNum -1
+				batchThatForgesIsInTheBlock = true
+				addAtBatchNum := batch.Batch.BatchNum - 1
+				userL1s[addAtBatchNum] = append(userL1s[addAtBatchNum], blockData.Rollup.L1UserTxs[i])
+				break
+			}
+		}
+		if !batchThatForgesIsInTheBlock {
+			// User artificial batchNum 0 to add txs that are not forge in this block
+			// after all the accounts of the block have been added
+			userL1s[0] = append(userL1s[0], blockData.Rollup.L1UserTxs[i])
 		}
 	}

@@ -1318,14 +1334,19 @@ func (hdb *HistoryDB) AddBlockSCData(blockData *common.BlockData) (err error) {
 			return err
 		}

-		// Add unforged l1 Txs
-		if batch.L1Batch {
+		// Add accounts
+		if len(batch.CreatedAccounts) > 0 {
+			if err := hdb.addAccounts(txn, batch.CreatedAccounts); err != nil {
+				return err
+			}
+		}
+
+		// Add forged l1 coordinator Txs
 		if len(batch.L1CoordinatorTxs) > 0 {
 			if err := hdb.addL1Txs(txn, batch.L1CoordinatorTxs); err != nil {
 				return err
 			}
 		}
-		}

 		// Add l2 Txs
 		if len(batch.L2Txs) > 0 {
@@ -1334,9 +1355,9 @@ func (hdb *HistoryDB) AddBlockSCData(blockData *common.BlockData) (err error) {
 			}
 		}

-		// Add accounts
-		if len(batch.CreatedAccounts) > 0 {
-			if err := hdb.addAccounts(txn, batch.CreatedAccounts); err != nil {
+		// Add user L1 txs that will be forged in next batch
+		if userlL1s, ok := userL1s[batch.Batch.BatchNum]; ok {
+			if err := hdb.addL1Txs(txn, userlL1s); err != nil {
 				return err
 			}
 		}
@@ -1348,6 +1369,12 @@ func (hdb *HistoryDB) AddBlockSCData(blockData *common.BlockData) (err error) {
 			}
 		}
 	}
+	// Add user L1 txs that won't be forged in this block
+	if userL1sNotForgedInThisBlock, ok := userL1s[0]; ok {
+		if err := hdb.addL1Txs(txn, userL1sNotForgedInThisBlock); err != nil {
+			return err
+		}
+	}
 	if blockData.Rollup.Vars != nil {
 		if err := hdb.setRollupVars(txn, blockData.Rollup.Vars); err != nil {
 			return err
--- a/db/migrations/0001.sql
+++ b/db/migrations/0001.sql
@@ -448,7 +448,7 @@ DECLARE
    _tx_timestamp TIMESTAMP;
 BEGIN
    IF NEW.is_l1  THEN
-        -- Validate
+        -- Validate L1 Tx
        IF NEW.user_origin IS NULL OR
        NEW.from_eth_addr IS NULL OR
        NEW.from_bjj IS NULL OR
@@ -458,7 +458,7 @@ BEGIN
            RAISE EXCEPTION 'Invalid L1 tx: %', NEW;
        END IF;
    ELSE
-        -- Validate
+        -- Validate L2 Tx
        IF NEW.batch_num IS NULL OR NEW.nonce IS NULL THEN
            RAISE EXCEPTION 'Invalid L2 tx: %', NEW;
        END IF;
@@ -474,17 +474,22 @@ BEGIN
    -- Set USD related
    SELECT INTO _value, _usd_update, _tx_timestamp 
        usd / POWER(10, decimals), usd_update, timestamp FROM token INNER JOIN block on token.eth_block_num = block.eth_block_num WHERE token_id = NEW.token_id;
-    IF _tx_timestamp - interval '24 hours' < _usd_update AND _tx_timestamp + interval '24 hours' > _usd_update THEN
-        NEW."amount_usd" = (SELECT _value * NEW.amount_f);
-        IF NOT NEW.is_l1 THEN
+    IF _usd_update - interval '24 hours' < _usd_update AND _usd_update + interval '24 hours' > _usd_update THEN
+        IF _value > 0.0 THEN
+            IF NEW."amount_f" > 0.0 THEN
+                NEW."amount_usd" = (SELECT _value * NEW."amount_f");
+                IF NOT NEW."is_l1" AND NEW."fee" > 0 THEN
                    NEW."fee_usd" = (SELECT NEW."amount_usd" * fee_percentage(NEW.fee::NUMERIC));
-        ELSE 
+                END IF;
+            END IF;
+            IF NEW."is_l1" AND NEW."load_amount_f" > 0.0 THEN
                NEW."load_amount_usd" = (SELECT _value * NEW.load_amount_f);
            END IF;
        END IF;
+    END IF;
    -- Set to_{eth_addr,bjj}
-    IF NEW.to_idx > 255 THEN
-        SELECT INTO NEW."to_eth_addr", NEW."to_bjj" eth_addr, bjj FROM account WHERE idx = NEW.to_idx;
+    IF NEW."to_idx" > 255 THEN
+        SELECT INTO NEW."to_eth_addr", NEW."to_bjj" eth_addr, bjj FROM account WHERE idx = NEW."to_idx";
    END IF;
    RETURN NEW;
 END;
--- a/go.sum
+++ b/go.sum
@@ -174,6 +174,7 @@ github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x
 github.com/getkin/kin-openapi v0.22.0 h1:J5IFyKd/5yuB6AZAgwK0CMBKnabWcmkowtsl6bRkz4s=
 github.com/getkin/kin-openapi v0.22.0/go.mod h1:WGRs2ZMM1Q8LR1QBEwUxC6RJEfaBcD0s+pcEVXFuAjw=
 github.com/getkin/kin-openapi v0.23.0 h1:RKtVNKk8kxcTIWEswgZ3Olvn1RxWOJ0zz8cP3d9aHIA=
+github.com/getkin/kin-openapi v0.29.0 h1:YAJ8s2UFkhAfJ/bpDcBiUPD4spfVa1ur0FqhBuubaRw=
 github.com/getsentry/raven-go v0.2.0 h1:no+xWJRb5ZI7eE8TWgIq1jLulQiIoLG0IfYxv5JYMGs=
 github.com/getsentry/raven-go v0.2.0/go.mod h1:KungGk8q33+aIAZUIVWZDr2OfAEBsO49PX4NzFV5kcQ=
 github.com/ghemawat/stream v0.0.0-20171120220530-696b145b53b9/go.mod h1:106OIgooyS7OzLDOpUGgm9fA3bQENb/cFSyyBmMoJDs=