Add lll to linter checks

Updated: batchbuilder common coordinator db/statedb eth log node priceupdater prover synchronizer test/* txprocessor txselector Pending (once https://github.com/hermeznetwork/hermez-node/tree/feature/serveapicli is merged to master): Update golangci-lint version to v1.37.1 api apitypes cli config db/historydb db/l2db
2026-02-06 19:06:42 +01:00 · 2021-03-01 12:19:27 +01:00
parent 73c3a91746
commit 93b7866d3e
63 changed files with 1570 additions and 757 deletions
--- a/test/debugapi/debugapi_test.go
+++ b/test/debugapi/debugapi_test.go
@@ -44,7 +44,8 @@ func TestDebugAPI(t *testing.T) {
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.Nil(t, err)

-	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128, Type: statedb.TypeSynchronizer, NLevels: 32})
+	sdb, err := statedb.NewStateDB(statedb.Config{Path: dir, Keep: 128,
+		Type: statedb.TypeSynchronizer, NLevels: 32})
 	require.Nil(t, err)
 	err = sdb.MakeCheckpoint() // Make a checkpoint to increment the batchNum
 	require.Nil(t, err)
--- a/test/ethclient.go
+++ b/test/ethclient.go
@@ -48,7 +48,8 @@ func (w *WDelayerBlock) addTransaction(tx *types.Transaction) *types.Transaction
 	return tx
 }

-func (w *WDelayerBlock) deposit(txHash ethCommon.Hash, owner, token ethCommon.Address, amount *big.Int) {
+func (w *WDelayerBlock) deposit(txHash ethCommon.Hash, owner, token ethCommon.Address,
+	amount *big.Int) {
 	w.Events.Deposit = append(w.Events.Deposit, eth.WDelayerEventDeposit{
 		Owner:            owner,
 		Token:            token,
@@ -182,7 +183,8 @@ func (a *AuctionBlock) canForge(forger ethCommon.Address, blockNum int64) (bool,

 	slotToForge := a.getSlotNumber(blockNum)
 	// Get the relativeBlock to check if the slotDeadline has been exceeded
-	relativeBlock := blockNum - (a.Constants.GenesisBlockNum + (slotToForge * int64(a.Constants.BlocksPerSlot)))
+	relativeBlock := blockNum - (a.Constants.GenesisBlockNum + (slotToForge *
+		int64(a.Constants.BlocksPerSlot)))

 	// If the closedMinBid is 0 it means that we have to take as minBid the
 	// one that is set for this slot set, otherwise the one that has been
@@ -281,10 +283,6 @@ type ClientSetup struct {
 // and 1 will be premined.
 //nolint:gomnd
 func NewClientSetupExample() *ClientSetup {
-	// rfield, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
-	// if !ok {
-	// 	panic("bad rfield")
-	// }
 	initialMinimalBidding, ok := new(big.Int).SetString("10000000000000000000", 10) // 10 * (1e18)
 	if !ok {
 		panic("bad initialMinimalBidding")
@@ -626,7 +624,8 @@ func (c *Client) EthPendingNonceAt(ctx context.Context, account ethCommon.Addres

 // EthNonceAt returns the account nonce of the given account. The block number can
 // be nil, in which case the nonce is taken from the latest known block.
-func (c *Client) EthNonceAt(ctx context.Context, account ethCommon.Address, blockNumber *big.Int) (uint64, error) {
+func (c *Client) EthNonceAt(ctx context.Context, account ethCommon.Address,
+	blockNumber *big.Int) (uint64, error) {
 	// NOTE: For now Client doesn't simulate nonces
 	return 0, nil
 }
@@ -645,7 +644,8 @@ func (c *Client) EthKeyStore() *ethKeystore.KeyStore {

 // EthCall runs the transaction as a call (without paying) in the local node at
 // blockNum.
-func (c *Client) EthCall(ctx context.Context, tx *types.Transaction, blockNum *big.Int) ([]byte, error) {
+func (c *Client) EthCall(ctx context.Context, tx *types.Transaction,
+	blockNum *big.Int) ([]byte, error) {
 	return nil, tracerr.Wrap(common.ErrTODO)
 }

@@ -662,7 +662,8 @@ func (c *Client) EthLastBlock() (int64, error) {
 }

 // EthTransactionReceipt returns the transaction receipt of the given txHash
-func (c *Client) EthTransactionReceipt(ctx context.Context, txHash ethCommon.Hash) (*types.Receipt, error) {
+func (c *Client) EthTransactionReceipt(ctx context.Context,
+	txHash ethCommon.Hash) (*types.Receipt, error) {
 	c.rw.RLock()
 	defer c.rw.RUnlock()

@@ -778,7 +779,9 @@ var errTODO = fmt.Errorf("TODO: Not implemented yet")
 // }

 // RollupL1UserTxERC20Permit is the interface to call the smart contract function
-func (c *Client) RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64, deadline *big.Int) (tx *types.Transaction, err error) {
+func (c *Client) RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp, fromIdx int64,
+	depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64,
+	deadline *big.Int) (tx *types.Transaction, err error) {
 	log.Error("TODO")
 	return nil, tracerr.Wrap(errTODO)
 }
@@ -845,7 +848,9 @@ func (c *Client) RollupL1UserTxERC20ETH(
 }

 // RollupL1UserTxERC777 is the interface to call the smart contract function
-// func (c *Client) RollupL1UserTxERC777(fromBJJ *babyjub.PublicKey, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error) {
+// func (c *Client) RollupL1UserTxERC777(fromBJJ *babyjub.PublicKey, fromIdx int64,
+// 	depositAmount *big.Int, amount *big.Int, tokenID uint32,
+//	toIdx int64) (*types.Transaction, error) {
 // 	log.Error("TODO")
 // 	return nil, errTODO
 // }
@@ -867,13 +872,17 @@ func (c *Client) RollupLastForgedBatch() (int64, error) {
 }

 // RollupWithdrawCircuit is the interface to call the smart contract function
-func (c *Client) RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int, tokenID uint32, numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction, error) {
+func (c *Client) RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int,
+	tokenID uint32, numExitRoot, idx int64, amount *big.Int,
+	instantWithdraw bool) (*types.Transaction, error) {
 	log.Error("TODO")
 	return nil, tracerr.Wrap(errTODO)
 }

 // RollupWithdrawMerkleProof is the interface to call the smart contract function
-func (c *Client) RollupWithdrawMerkleProof(babyPubKey babyjub.PublicKeyComp, tokenID uint32, numExitRoot, idx int64, amount *big.Int, siblings []*big.Int, instantWithdraw bool) (tx *types.Transaction, err error) {
+func (c *Client) RollupWithdrawMerkleProof(babyPubKey babyjub.PublicKeyComp,
+	tokenID uint32, numExitRoot, idx int64, amount *big.Int, siblings []*big.Int,
+	instantWithdraw bool) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -945,7 +954,8 @@ func (c *Client) newTransaction(name string, value interface{}) *types.Transacti
 }

 // RollupForgeBatch is the interface to call the smart contract function
-func (c *Client) RollupForgeBatch(args *eth.RollupForgeBatchArgs, auth *bind.TransactOpts) (tx *types.Transaction, err error) {
+func (c *Client) RollupForgeBatch(args *eth.RollupForgeBatchArgs,
+	auth *bind.TransactOpts) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -973,7 +983,8 @@ func (c *Client) RollupForgeBatch(args *eth.RollupForgeBatchArgs, auth *bind.Tra

 	// TODO: If successful, store the tx in a successful array.
 	// TODO: If failed, store the tx in a failed array.
-	// TODO: Add method to move the tx to another block, reapply it there, and possibly go from successful to failed.
+	// TODO: Add method to move the tx to another block, reapply it there, and possibly go from
+	// successful to failed.

 	return c.addBatch(args)
 }
@@ -1018,7 +1029,8 @@ func (c *Client) addBatch(args *eth.RollupForgeBatchArgs) (*types.Transaction, e

 // RollupAddTokenSimple is a wrapper around RollupAddToken that automatically
 // sets `deadlie`.
-func (c *Client) RollupAddTokenSimple(tokenAddress ethCommon.Address, feeAddToken *big.Int) (tx *types.Transaction, err error) {
+func (c *Client) RollupAddTokenSimple(tokenAddress ethCommon.Address,
+	feeAddToken *big.Int) (tx *types.Transaction, err error) {
 	return c.RollupAddToken(tokenAddress, feeAddToken, big.NewInt(9999)) //nolint:gomnd
 }

@@ -1039,13 +1051,16 @@ func (c *Client) RollupAddToken(tokenAddress ethCommon.Address, feeAddToken *big
 		return nil, tracerr.Wrap(fmt.Errorf("Token %v already registered", tokenAddress))
 	}
 	if feeAddToken.Cmp(r.Vars.FeeAddToken) != 0 {
-		return nil, tracerr.Wrap(fmt.Errorf("Expected fee: %v but got: %v", r.Vars.FeeAddToken, feeAddToken))
+		return nil,
+			tracerr.Wrap(fmt.Errorf("Expected fee: %v but got: %v",
+				r.Vars.FeeAddToken, feeAddToken))
 	}

 	r.State.TokenMap[tokenAddress] = true
 	r.State.TokenList = append(r.State.TokenList, tokenAddress)
-	r.Events.AddToken = append(r.Events.AddToken, eth.RollupEventAddToken{TokenAddress: tokenAddress,
-		TokenID: uint32(len(r.State.TokenList) - 1)})
+	r.Events.AddToken = append(r.Events.AddToken, eth.RollupEventAddToken{
+		TokenAddress: tokenAddress,
+		TokenID:      uint32(len(r.State.TokenList) - 1)})
 	return r.addTransaction(c.newTransaction("addtoken", tokenAddress)), nil
 }

@@ -1059,7 +1074,8 @@ func (c *Client) RollupGetCurrentTokens() (*big.Int, error) {
 }

 // RollupUpdateForgeL1L2BatchTimeout is the interface to call the smart contract function
-func (c *Client) RollupUpdateForgeL1L2BatchTimeout(newForgeL1Timeout int64) (tx *types.Transaction, err error) {
+func (c *Client) RollupUpdateForgeL1L2BatchTimeout(newForgeL1Timeout int64) (tx *types.Transaction,
+	err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1078,7 +1094,8 @@ func (c *Client) RollupUpdateForgeL1L2BatchTimeout(newForgeL1Timeout int64) (tx
 }

 // RollupUpdateFeeAddToken is the interface to call the smart contract function
-func (c *Client) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *types.Transaction, err error) {
+func (c *Client) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *types.Transaction,
+	err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1092,7 +1109,8 @@ func (c *Client) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *types.Tra
 }

 // RollupUpdateTokensHEZ is the interface to call the smart contract function
-// func (c *Client) RollupUpdateTokensHEZ(newTokenHEZ ethCommon.Address) (tx *types.Transaction, err error) {
+// func (c *Client) RollupUpdateTokensHEZ(newTokenHEZ ethCommon.Address) (tx *types.Transaction,
+// 	err error) {
 // 	c.rw.Lock()
 // 	defer c.rw.Unlock()
 // 	cpy := c.nextBlock().copy()
@@ -1103,7 +1121,8 @@ func (c *Client) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *types.Tra
 // }

 // RollupUpdateGovernance is the interface to call the smart contract function
-// func (c *Client) RollupUpdateGovernance() (*types.Transaction, error) { // TODO (Not defined in Hermez.sol)
+// func (c *Client) RollupUpdateGovernance() (*types.Transaction, error) {
+// 	// TODO (Not defined in Hermez.sol)
 // 	return nil, errTODO
 // }

@@ -1142,8 +1161,10 @@ func (c *Client) RollupEventInit() (*eth.RollupEventInitialize, int64, error) {
 	}, 1, nil
 }

-// RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the Rollup Smart Contract in the given transaction
-func (c *Client) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsLen uint16) (*eth.RollupForgeBatchArgs, *ethCommon.Address, error) {
+// RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the Rollup Smart Contract
+// in the given transaction
+func (c *Client) RollupForgeBatchArgs(ethTxHash ethCommon.Hash,
+	l1UserTxsLen uint16) (*eth.RollupForgeBatchArgs, *ethCommon.Address, error) {
 	c.rw.RLock()
 	defer c.rw.RUnlock()

@@ -1182,7 +1203,8 @@ func (c *Client) AuctionGetSlotDeadline() (uint8, error) {
 }

 // AuctionSetOpenAuctionSlots is the interface to call the smart contract function
-func (c *Client) AuctionSetOpenAuctionSlots(newOpenAuctionSlots uint16) (tx *types.Transaction, err error) {
+func (c *Client) AuctionSetOpenAuctionSlots(newOpenAuctionSlots uint16) (tx *types.Transaction,
+	err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1210,7 +1232,8 @@ func (c *Client) AuctionGetOpenAuctionSlots() (uint16, error) {
 }

 // AuctionSetClosedAuctionSlots is the interface to call the smart contract function
-func (c *Client) AuctionSetClosedAuctionSlots(newClosedAuctionSlots uint16) (tx *types.Transaction, err error) {
+func (c *Client) AuctionSetClosedAuctionSlots(newClosedAuctionSlots uint16) (tx *types.Transaction,
+	err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1256,7 +1279,8 @@ func (c *Client) AuctionGetOutbidding() (uint16, error) {
 }

 // AuctionSetAllocationRatio is the interface to call the smart contract function
-func (c *Client) AuctionSetAllocationRatio(newAllocationRatio [3]uint16) (tx *types.Transaction, err error) {
+func (c *Client) AuctionSetAllocationRatio(newAllocationRatio [3]uint16) (tx *types.Transaction,
+	err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1279,7 +1303,8 @@ func (c *Client) AuctionGetAllocationRatio() ([3]uint16, error) {
 }

 // AuctionSetDonationAddress is the interface to call the smart contract function
-func (c *Client) AuctionSetDonationAddress(newDonationAddress ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *Client) AuctionSetDonationAddress(
+	newDonationAddress ethCommon.Address) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1302,7 +1327,8 @@ func (c *Client) AuctionGetDonationAddress() (*ethCommon.Address, error) {
 }

 // AuctionSetBootCoordinator is the interface to call the smart contract function
-func (c *Client) AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address, newBootCoordinatorURL string) (tx *types.Transaction, err error) {
+func (c *Client) AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address,
+	newBootCoordinatorURL string) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1327,7 +1353,8 @@ func (c *Client) AuctionGetBootCoordinator() (*ethCommon.Address, error) {
 }

 // AuctionChangeDefaultSlotSetBid is the interface to call the smart contract function
-func (c *Client) AuctionChangeDefaultSlotSetBid(slotSet int64, newInitialMinBid *big.Int) (tx *types.Transaction, err error) {
+func (c *Client) AuctionChangeDefaultSlotSetBid(slotSet int64,
+	newInitialMinBid *big.Int) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1341,7 +1368,8 @@ func (c *Client) AuctionChangeDefaultSlotSetBid(slotSet int64, newInitialMinBid
 }

 // AuctionSetCoordinator is the interface to call the smart contract function
-func (c *Client) AuctionSetCoordinator(forger ethCommon.Address, URL string) (tx *types.Transaction, err error) {
+func (c *Client) AuctionSetCoordinator(forger ethCommon.Address,
+	URL string) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1370,7 +1398,8 @@ func (c *Client) AuctionSetCoordinator(forger ethCommon.Address, URL string) (tx
 		ForgerAddress ethCommon.Address
 		URL           string
 	}
-	return a.addTransaction(c.newTransaction("registercoordinator", data{*c.addr, forger, URL})), nil
+	return a.addTransaction(c.newTransaction("registercoordinator", data{*c.addr, forger, URL})),
+		nil
 }

 // AuctionIsRegisteredCoordinator is the interface to call the smart contract function
@@ -1383,7 +1412,8 @@ func (c *Client) AuctionIsRegisteredCoordinator(forgerAddress ethCommon.Address)
 }

 // AuctionUpdateCoordinatorInfo is the interface to call the smart contract function
-func (c *Client) AuctionUpdateCoordinatorInfo(forgerAddress ethCommon.Address, newWithdrawAddress ethCommon.Address, newURL string) (tx *types.Transaction, err error) {
+func (c *Client) AuctionUpdateCoordinatorInfo(forgerAddress ethCommon.Address,
+	newWithdrawAddress ethCommon.Address, newURL string) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1443,12 +1473,14 @@ func (c *Client) AuctionGetSlotSet(slot int64) (*big.Int, error) {
 }

 // AuctionTokensReceived is the interface to call the smart contract function
-// func (c *Client) AuctionTokensReceived(operator, from, to ethCommon.Address, amount *big.Int, userData, operatorData []byte) error {
+// func (c *Client) AuctionTokensReceived(operator, from, to ethCommon.Address, amount *big.Int,
+// 	userData, operatorData []byte) error {
 // 	return errTODO
 // }

 // AuctionBidSimple is a wrapper around AuctionBid that automatically sets `amount` and `deadline`.
-func (c *Client) AuctionBidSimple(slot int64, bidAmount *big.Int) (tx *types.Transaction, err error) {
+func (c *Client) AuctionBidSimple(slot int64, bidAmount *big.Int) (tx *types.Transaction,
+	err error) {
 	return c.AuctionBid(bidAmount, slot, bidAmount, big.NewInt(99999)) //nolint:gomnd
 }

@@ -1471,7 +1503,8 @@ func (c *Client) AuctionBid(amount *big.Int, slot int64, bidAmount *big.Int,
 		return nil, tracerr.Wrap(errBidClosed)
 	}

-	if slot > a.getCurrentSlotNumber()+int64(a.Vars.ClosedAuctionSlots)+int64(a.Vars.OpenAuctionSlots) {
+	if slot >
+		a.getCurrentSlotNumber()+int64(a.Vars.ClosedAuctionSlots)+int64(a.Vars.OpenAuctionSlots) {
 		return nil, tracerr.Wrap(errBidNotOpen)
 	}

@@ -1508,8 +1541,8 @@ func (c *Client) AuctionBid(amount *big.Int, slot int64, bidAmount *big.Int,

 // AuctionMultiBid is the interface to call the smart contract function.  This
 // implementation behaves as if any address has infinite tokens.
-func (c *Client) AuctionMultiBid(amount *big.Int, startingSlot int64, endingSlot int64, slotSet [6]bool,
-	maxBid, closedMinBid, deadline *big.Int) (tx *types.Transaction, err error) {
+func (c *Client) AuctionMultiBid(amount *big.Int, startingSlot int64, endingSlot int64,
+	slotSet [6]bool, maxBid, closedMinBid, deadline *big.Int) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1623,7 +1656,8 @@ func (c *Client) WDelayerGetHermezGovernanceAddress() (*ethCommon.Address, error
 }

 // WDelayerTransferGovernance is the interface to call the smart contract function
-func (c *Client) WDelayerTransferGovernance(newAddress ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *Client) WDelayerTransferGovernance(newAddress ethCommon.Address) (tx *types.Transaction,
+	err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1660,7 +1694,8 @@ func (c *Client) WDelayerGetEmergencyCouncil() (*ethCommon.Address, error) {
 }

 // WDelayerTransferEmergencyCouncil is the interface to call the smart contract function
-func (c *Client) WDelayerTransferEmergencyCouncil(newAddress ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *Client) WDelayerTransferEmergencyCouncil(newAddress ethCommon.Address) (
+	tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1729,7 +1764,8 @@ func (c *Client) WDelayerEnableEmergencyMode() (tx *types.Transaction, err error
 }

 // WDelayerChangeWithdrawalDelay is the interface to call the smart contract function
-func (c *Client) WDelayerChangeWithdrawalDelay(newWithdrawalDelay uint64) (tx *types.Transaction, err error) {
+func (c *Client) WDelayerChangeWithdrawalDelay(newWithdrawalDelay uint64) (tx *types.Transaction,
+	err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1757,7 +1793,8 @@ func (c *Client) WDelayerDepositInfo(owner, token ethCommon.Address) (eth.Deposi
 }

 // WDelayerDeposit is the interface to call the smart contract function
-func (c *Client) WDelayerDeposit(onwer, token ethCommon.Address, amount *big.Int) (tx *types.Transaction, err error) {
+func (c *Client) WDelayerDeposit(onwer, token ethCommon.Address, amount *big.Int) (
+	tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1771,7 +1808,8 @@ func (c *Client) WDelayerDeposit(onwer, token ethCommon.Address, amount *big.Int
 }

 // WDelayerWithdrawal is the interface to call the smart contract function
-func (c *Client) WDelayerWithdrawal(owner, token ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *Client) WDelayerWithdrawal(owner, token ethCommon.Address) (tx *types.Transaction,
+	err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1785,7 +1823,8 @@ func (c *Client) WDelayerWithdrawal(owner, token ethCommon.Address) (tx *types.T
 }

 // WDelayerEscapeHatchWithdrawal is the interface to call the smart contract function
-func (c *Client) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address, amount *big.Int) (tx *types.Transaction, err error) {
+func (c *Client) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address, amount *big.Int) (
+	tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1843,14 +1882,16 @@ func (c *Client) CtlAddBlocks(blocks []common.BlockData) (err error) {
 		rollup := nextBlock.Rollup
 		auction := nextBlock.Auction
 		for _, token := range block.Rollup.AddedTokens {
-			if _, err := c.RollupAddTokenSimple(token.EthAddr, rollup.Vars.FeeAddToken); err != nil {
+			if _, err := c.RollupAddTokenSimple(token.EthAddr,
+				rollup.Vars.FeeAddToken); err != nil {
 				return tracerr.Wrap(err)
 			}
 		}
 		for _, tx := range block.Rollup.L1UserTxs {
 			c.CtlSetAddr(tx.FromEthAddr)
-			if _, err := c.RollupL1UserTxERC20ETH(tx.FromBJJ, int64(tx.FromIdx), tx.DepositAmount, tx.Amount,
-				uint32(tx.TokenID), int64(tx.ToIdx)); err != nil {
+			if _, err := c.RollupL1UserTxERC20ETH(tx.FromBJJ, int64(tx.FromIdx),
+				tx.DepositAmount, tx.Amount, uint32(tx.TokenID),
+				int64(tx.ToIdx)); err != nil {
 				return tracerr.Wrap(err)
 			}
 		}
--- a/test/ethclient_test.go
+++ b/test/ethclient_test.go
@@ -49,7 +49,9 @@ func TestClientEth(t *testing.T) {
 	require.Nil(t, err)
 	assert.Equal(t, int64(0), block.Num)
 	assert.Equal(t, time.Unix(0, 0), block.Timestamp)
-	assert.Equal(t, "0x0000000000000000000000000000000000000000000000000000000000000000", block.Hash.Hex())
+	assert.Equal(t,
+		"0x0000000000000000000000000000000000000000000000000000000000000000",
+		block.Hash.Hex())

 	// Mine some empty blocks

--- a/test/historydb.go
+++ b/test/historydb.go
@@ -40,7 +40,8 @@ var EthToken common.Token = common.Token{
 // WARNING: the generators in this file doesn't necessary follow the protocol
 // they are intended to check that the parsers between struct <==> DB are correct

-// GenBlocks generates block from, to block numbers. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol.
+// GenBlocks generates block from, to block numbers. WARNING: This is meant for DB/API testing, and
+// may not be fully consistent with the protocol.
 func GenBlocks(from, to int64) []common.Block {
 	var blocks []common.Block
 	for i := from; i < to; i++ {
@@ -54,8 +55,10 @@ func GenBlocks(from, to int64) []common.Block {
 	return blocks
 }

-// GenTokens generates tokens. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol.
-func GenTokens(nTokens int, blocks []common.Block) (tokensToAddInDB []common.Token, ethToken common.Token) {
+// GenTokens generates tokens. WARNING: This is meant for DB/API testing, and may not be fully
+// consistent with the protocol.
+func GenTokens(nTokens int, blocks []common.Block) (tokensToAddInDB []common.Token,
+	ethToken common.Token) {
 	tokensToAddInDB = []common.Token{}
 	for i := 1; i < nTokens; i++ {
 		token := common.Token{
@@ -78,7 +81,8 @@ func GenTokens(nTokens int, blocks []common.Block) (tokensToAddInDB []common.Tok
 	}
 }

-// GenBatches generates batches. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol.
+// GenBatches generates batches. WARNING: This is meant for DB/API testing, and may not be fully
+// consistent with the protocol.
 func GenBatches(nBatches int, blocks []common.Block) []common.Batch {
 	batches := []common.Batch{}
 	collectedFees := make(map[common.TokenID]*big.Int)
@@ -108,8 +112,10 @@ func GenBatches(nBatches int, blocks []common.Block) []common.Batch {
 	return batches
 }

-// GenAccounts generates accounts. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol.
-func GenAccounts(totalAccounts, userAccounts int, tokens []common.Token, userAddr *ethCommon.Address, userBjj *babyjub.PublicKey, batches []common.Batch) []common.Account {
+// GenAccounts generates accounts. WARNING: This is meant for DB/API testing, and may not be fully
+// consistent with the protocol.
+func GenAccounts(totalAccounts, userAccounts int, tokens []common.Token,
+	userAddr *ethCommon.Address, userBjj *babyjub.PublicKey, batches []common.Batch) []common.Account {
 	if totalAccounts < userAccounts {
 		panic("totalAccounts must be greater than userAccounts")
 	}
@@ -137,7 +143,8 @@ func GenAccounts(totalAccounts, userAccounts int, tokens []common.Token, userAdd
 	return accs
 }

-// GenL1Txs generates L1 txs. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol.
+// GenL1Txs generates L1 txs. WARNING: This is meant for DB/API testing, and may not be fully
+// consistent with the protocol.
 func GenL1Txs(
 	fromIdx int,
 	totalTxs, nUserTxs int,
@@ -263,7 +270,8 @@ func setFromToAndAppend(
 	}
 }

-// GenL2Txs generates L2 txs. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol.
+// GenL2Txs generates L2 txs. WARNING: This is meant for DB/API testing, and may not be fully
+// consistent with the protocol.
 func GenL2Txs(
 	fromIdx int,
 	totalTxs, nUserTxs int,
@@ -282,7 +290,9 @@ func GenL2Txs(
 		amount := big.NewInt(int64(i + 1))
 		fee := common.FeeSelector(i % 256) //nolint:gomnd
 		tx := common.L2Tx{
-			TxID:        common.TxID([common.TxIDLen]byte{2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, byte(i)}), // only for testing purposes
+			// only for testing purposes
+			TxID: common.TxID([common.TxIDLen]byte{2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, byte(i)}),
 			BatchNum:    batches[i%len(batches)].BatchNum,
 			Position:    i - fromIdx,
 			Amount:      amount,
@@ -337,7 +347,8 @@ func GenL2Txs(
 	return userTxs, othersTxs
 }

-// GenCoordinators generates coordinators. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol.
+// GenCoordinators generates coordinators. WARNING: This is meant for DB/API testing, and may not be
+// fully consistent with the protocol.
 func GenCoordinators(nCoords int, blocks []common.Block) []common.Coordinator {
 	coords := []common.Coordinator{}
 	for i := 0; i < nCoords; i++ {
@@ -351,7 +362,8 @@ func GenCoordinators(nCoords int, blocks []common.Block) []common.Coordinator {
 	return coords
 }

-// GenBids generates bids. WARNING: This is meant for DB/API testing, and may not be fully consistent with the protocol.
+// GenBids generates bids. WARNING: This is meant for DB/API testing, and may not be fully
+// consistent with the protocol.
 func GenBids(nBids int, blocks []common.Block, coords []common.Coordinator) []common.Bid {
 	bids := []common.Bid{}
 	for i := 0; i < nBids*2; i = i + 2 { //nolint:gomnd
@@ -373,7 +385,8 @@ func GenBids(nBids int, blocks []common.Block, coords []common.Coordinator) []co

 // GenExitTree generates an exitTree (as an array of Exits)
 //nolint:gomnd
-func GenExitTree(n int, batches []common.Batch, accounts []common.Account, blocks []common.Block) []common.ExitInfo {
+func GenExitTree(n int, batches []common.Batch, accounts []common.Account,
+	blocks []common.Block) []common.ExitInfo {
 	exitTree := make([]common.ExitInfo, n)
 	for i := 0; i < n; i++ {
 		exitTree[i] = common.ExitInfo{
@@ -412,7 +425,8 @@ func GenExitTree(n int, batches []common.Batch, accounts []common.Account, block
 	return exitTree
 }

-func randomAccount(seed int, userAccount bool, userAddr *ethCommon.Address, accs []common.Account) (*common.Account, error) {
+func randomAccount(seed int, userAccount bool, userAddr *ethCommon.Address,
+	accs []common.Account) (*common.Account, error) {
 	i := seed % len(accs)
 	firstI := i
 	for {
--- a/test/l2db.go
+++ b/test/l2db.go
@@ -67,7 +67,8 @@ func GenPoolTxs(n int, tokens []common.Token) []*common.PoolL2Tx {
 }

 // GenAuths generates account creation authorizations
-func GenAuths(nAuths int, chainID uint16, hermezContractAddr ethCommon.Address) []*common.AccountCreationAuth {
+func GenAuths(nAuths int, chainID uint16,
+	hermezContractAddr ethCommon.Address) []*common.AccountCreationAuth {
 	auths := []*common.AccountCreationAuth{}
 	for i := 0; i < nAuths; i++ {
 		// Generate keys
--- a/test/proofserver/proofserver.go
+++ b/test/proofserver/proofserver.go
@@ -68,6 +68,7 @@ func (s *Mock) handleCancel(c *gin.Context) {
 	c.JSON(http.StatusOK, "OK")
 }

+//nolint:lll
 /* Status example from the real server proof:

 Status:
--- a/test/til/lang.go
+++ b/test/til/lang.go
@@ -310,7 +310,8 @@ func (p *parser) parseLine(setType setType) (*Instruction, error) {
 		} else if lit == "PoolL2" {
 			return &Instruction{Typ: "PoolL2"}, setTypeLine
 		} else {
-			return c, tracerr.Wrap(fmt.Errorf("Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", lit))
+			return c,
+				tracerr.Wrap(fmt.Errorf("Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", lit))
 		}
 	} else if lit == "AddToken" {
 		if err := p.expectChar(c, "("); err != nil {
@@ -391,7 +392,9 @@ func (p *parser) parseLine(setType setType) (*Instruction, error) {
 			return c, tracerr.Wrap(fmt.Errorf("Unexpected PoolL2 tx type: %s", lit))
 		}
 	} else {
-		return c, tracerr.Wrap(fmt.Errorf("Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", setType))
+		return c,
+			tracerr.Wrap(fmt.Errorf("Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'",
+				setType))
 	}

 	if err := p.expectChar(c, "("); err != nil {
@@ -522,14 +525,18 @@ func (p *parser) parse() (*parsedSet, error) {
 		}
 		if tracerr.Unwrap(err) == setTypeLine {
 			if ps.typ != "" {
-				return ps, tracerr.Wrap(fmt.Errorf("Line %d: Instruction of 'Type: %s' when there is already a previous instruction 'Type: %s' defined", i, instruction.Typ, ps.typ))
+				return ps,
+					tracerr.Wrap(fmt.Errorf("Line %d: Instruction of 'Type: %s' when "+
+						"there is already a previous instruction 'Type: %s' defined",
+						i, instruction.Typ, ps.typ))
 			}
 			if instruction.Typ == "PoolL2" {
 				ps.typ = SetTypePoolL2
 			} else if instruction.Typ == "Blockchain" {
 				ps.typ = SetTypeBlockchain
 			} else {
-				log.Fatalf("Line %d: Invalid set type: '%s'. Valid set types: 'Blockchain', 'PoolL2'", i, instruction.Typ)
+				log.Fatalf("Line %d: Invalid set type: '%s'. Valid set types: "+
+					"'Blockchain', 'PoolL2'", i, instruction.Typ)
 			}
 			continue
 		}
@@ -552,7 +559,9 @@ func (p *parser) parse() (*parsedSet, error) {
 		}
 		ps.instructions = append(ps.instructions, *instruction)
 		users[instruction.From] = true
-		if instruction.Typ == common.TxTypeTransfer || instruction.Typ == common.TxTypeTransferToEthAddr || instruction.Typ == common.TxTypeTransferToBJJ { // type: Transfer
+		if instruction.Typ == common.TxTypeTransfer ||
+			instruction.Typ == common.TxTypeTransferToEthAddr ||
+			instruction.Typ == common.TxTypeTransferToBJJ { // type: Transfer
 			users[instruction.To] = true
 		}
 	}
--- a/test/til/lang_test.go
+++ b/test/til/lang_test.go
@@ -72,12 +72,19 @@ func TestParseBlockchainTxs(t *testing.T) {
 	assert.Equal(t, TxTypeCreateAccountDepositCoordinator, instructions.instructions[7].Typ)
 	assert.Equal(t, TypeNewBatch, instructions.instructions[11].Typ)
 	assert.Equal(t, "Deposit(1)User0:20", instructions.instructions[16].raw())
-	assert.Equal(t, "Type: DepositTransfer, From: A, To: B, DepositAmount: 15, Amount: 10, Fee: 0, TokenID: 1\n", instructions.instructions[13].String())
-	assert.Equal(t, "Type: Transfer, From: User1, To: User0, Amount: 15, Fee: 1, TokenID: 3\n", instructions.instructions[19].String())
+	assert.Equal(t,
+		"Type: DepositTransfer, From: A, To: B, DepositAmount: 15, Amount: 10, Fee: 0, TokenID: 1\n",
+		instructions.instructions[13].String())
+	assert.Equal(t,
+		"Type: Transfer, From: User1, To: User0, Amount: 15, Fee: 1, TokenID: 3\n",
+		instructions.instructions[19].String())
 	assert.Equal(t, "Transfer(2)A-B:15(1)", instructions.instructions[15].raw())
-	assert.Equal(t, "Type: Transfer, From: A, To: B, Amount: 15, Fee: 1, TokenID: 2\n", instructions.instructions[15].String())
+	assert.Equal(t,
+		"Type: Transfer, From: A, To: B, Amount: 15, Fee: 1, TokenID: 2\n",
+		instructions.instructions[15].String())
 	assert.Equal(t, "Exit(1)A:5", instructions.instructions[24].raw())
-	assert.Equal(t, "Type: Exit, From: A, Amount: 5, TokenID: 1\n", instructions.instructions[24].String())
+	assert.Equal(t, "Type: Exit, From: A, Amount: 5, TokenID: 1\n",
+		instructions.instructions[24].String())
 }

 func TestParsePoolTxs(t *testing.T) {
@@ -158,7 +165,9 @@ func TestParseErrors(t *testing.T) {
 	`
 	parser = newParser(strings.NewReader(s))
 	_, err = parser.parse()
-	assert.Equal(t, "Line 2: Transfer(1)A-B:10(256)\n, err: Fee 256 can not be bigger than 255", err.Error())
+	assert.Equal(t,
+		"Line 2: Transfer(1)A-B:10(256)\n, err: Fee 256 can not be bigger than 255",
+		err.Error())

 	// check that the PoolTransfer & Transfer are only accepted in the
 	// correct case case (PoolTxs/BlockchainTxs)
@@ -175,7 +184,9 @@ func TestParseErrors(t *testing.T) {
 	`
 	parser = newParser(strings.NewReader(s))
 	_, err = parser.parse()
-	assert.Equal(t, "Line 2: PoolTransfer, err: Unexpected Blockchain tx type: PoolTransfer", err.Error())
+	assert.Equal(t,
+		"Line 2: PoolTransfer, err: Unexpected Blockchain tx type: PoolTransfer",
+		err.Error())

 	s = `
 		Type: Blockchain
@@ -183,7 +194,9 @@ func TestParseErrors(t *testing.T) {
 	`
 	parser = newParser(strings.NewReader(s))
 	_, err = parser.parse()
-	assert.Equal(t, "Line 2: >, err: Unexpected '> btch', expected '> batch' or '> block'", err.Error())
+	assert.Equal(t,
+		"Line 2: >, err: Unexpected '> btch', expected '> batch' or '> block'",
+		err.Error())

 	// check definition of set Type
 	s = `PoolTransfer(1) A-B: 10 (1)`
@@ -193,17 +206,23 @@ func TestParseErrors(t *testing.T) {
 	s = `Type: PoolL1`
 	parser = newParser(strings.NewReader(s))
 	_, err = parser.parse()
-	assert.Equal(t, "Line 1: Type:, err: Invalid set type: 'PoolL1'. Valid set types: 'Blockchain', 'PoolL2'", err.Error())
+	assert.Equal(t,
+		"Line 1: Type:, err: Invalid set type: 'PoolL1'. Valid set types: 'Blockchain', 'PoolL2'",
+		err.Error())
 	s = `Type: PoolL1
 		Type: Blockchain`
 	parser = newParser(strings.NewReader(s))
 	_, err = parser.parse()
-	assert.Equal(t, "Line 1: Type:, err: Invalid set type: 'PoolL1'. Valid set types: 'Blockchain', 'PoolL2'", err.Error())
+	assert.Equal(t,
+		"Line 1: Type:, err: Invalid set type: 'PoolL1'. Valid set types: 'Blockchain', 'PoolL2'",
+		err.Error())
 	s = `Type: PoolL2
 		Type: Blockchain`
 	parser = newParser(strings.NewReader(s))
 	_, err = parser.parse()
-	assert.Equal(t, "Line 2: Instruction of 'Type: Blockchain' when there is already a previous instruction 'Type: PoolL2' defined", err.Error())
+	assert.Equal(t,
+		"Line 2: Instruction of 'Type: Blockchain' when there is already a previous "+
+			"instruction 'Type: PoolL2' defined", err.Error())

 	s = `Type: Blockchain
 		AddToken(1)
--- a/test/til/txs.go
+++ b/test/til/txs.go
@@ -161,7 +161,9 @@ func (tc *Context) GenerateBlocks(set string) ([]common.BlockData, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	if parsedSet.typ != SetTypeBlockchain {
-		return nil, tracerr.Wrap(fmt.Errorf("Expected set type: %s, found: %s", SetTypeBlockchain, parsedSet.typ))
+		return nil,
+			tracerr.Wrap(fmt.Errorf("Expected set type: %s, found: %s",
+				SetTypeBlockchain, parsedSet.typ))
 	}

 	tc.instructions = parsedSet.instructions
@@ -209,7 +211,9 @@ func (tc *Context) generateBlocks() ([]common.BlockData, error) {
 				TokenID:       inst.TokenID,
 				Amount:        big.NewInt(0),
 				DepositAmount: big.NewInt(0),
-				Type:          common.TxTypeCreateAccountDeposit, // as TxTypeCreateAccountDepositCoordinator is not valid oustide Til package
+				// as TxTypeCreateAccountDepositCoordinator is
+				// not valid oustide Til package
+				Type: common.TxTypeCreateAccountDeposit,
 			}
 			testTx := L1Tx{
 				lineNum:     inst.LineNum,
@@ -218,7 +222,8 @@ func (tc *Context) generateBlocks() ([]common.BlockData, error) {
 			}

 			tc.currBatchTest.l1CoordinatorTxs = append(tc.currBatchTest.l1CoordinatorTxs, testTx)
-		case common.TxTypeCreateAccountDeposit, common.TxTypeCreateAccountDepositTransfer: // tx source: L1UserTx
+		case common.TxTypeCreateAccountDeposit, common.TxTypeCreateAccountDepositTransfer:
+			// tx source: L1UserTx
 			if err := tc.checkIfTokenIsRegistered(inst); err != nil {
 				log.Error(err)
 				return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error()))
@@ -281,7 +286,8 @@ func (tc *Context) generateBlocks() ([]common.BlockData, error) {
 				Type:        common.TxTypeTransfer,
 				EthBlockNum: tc.blockNum,
 			}
-			tx.BatchNum = common.BatchNum(tc.currBatchNum) // when converted to PoolL2Tx BatchNum parameter is lost
+			// when converted to PoolL2Tx BatchNum parameter is lost
+			tx.BatchNum = common.BatchNum(tc.currBatchNum)
 			testTx := L2Tx{
 				lineNum:     inst.LineNum,
 				fromIdxName: inst.From,
@@ -322,7 +328,8 @@ func (tc *Context) generateBlocks() ([]common.BlockData, error) {
 				Type:        common.TxTypeExit,
 				EthBlockNum: tc.blockNum,
 			}
-			tx.BatchNum = common.BatchNum(tc.currBatchNum) // when converted to PoolL2Tx BatchNum parameter is lost
+			// when converted to PoolL2Tx BatchNum parameter is lost
+			tx.BatchNum = common.BatchNum(tc.currBatchNum)
 			testTx := L2Tx{
 				lineNum:     inst.LineNum,
 				fromIdxName: inst.From,
@@ -395,7 +402,10 @@ func (tc *Context) generateBlocks() ([]common.BlockData, error) {
 				EthBlockNum: tc.blockNum,
 			}
 			if inst.TokenID != tc.LastRegisteredTokenID+1 {
-				return nil, tracerr.Wrap(fmt.Errorf("Line %d: AddToken TokenID should be sequential, expected TokenID: %d, defined TokenID: %d", inst.LineNum, tc.LastRegisteredTokenID+1, inst.TokenID))
+				return nil,
+					tracerr.Wrap(fmt.Errorf("Line %d: AddToken TokenID should be "+
+						"sequential, expected TokenID: %d, defined TokenID: %d",
+						inst.LineNum, tc.LastRegisteredTokenID+1, inst.TokenID))
 			}
 			tc.LastRegisteredTokenID++
 			tc.currBlock.Rollup.AddedTokens = append(tc.currBlock.Rollup.AddedTokens, newToken)
@@ -413,9 +423,13 @@ func (tc *Context) calculateIdxForL1Txs(isCoordinatorTxs bool, txs []L1Tx) error
 	// for each batch.L1CoordinatorTxs of the Queues[ToForgeNum], calculate the Idx
 	for i := 0; i < len(txs); i++ {
 		tx := txs[i]
-		if tx.L1Tx.Type == common.TxTypeCreateAccountDeposit || tx.L1Tx.Type == common.TxTypeCreateAccountDepositTransfer {
-			if tc.Users[tx.fromIdxName].Accounts[tx.L1Tx.TokenID] != nil { // if account already exists, return error
-				return tracerr.Wrap(fmt.Errorf("Can not create same account twice (same User (%s) & same TokenID (%d)) (this is a design property of Til)", tx.fromIdxName, tx.L1Tx.TokenID))
+		if tx.L1Tx.Type == common.TxTypeCreateAccountDeposit ||
+			tx.L1Tx.Type == common.TxTypeCreateAccountDepositTransfer {
+			if tc.Users[tx.fromIdxName].Accounts[tx.L1Tx.TokenID] != nil {
+				// if account already exists, return error
+				return tracerr.Wrap(fmt.Errorf("Can not create same account twice "+
+					"(same User (%s) & same TokenID (%d)) (this is a design property of Til)",
+					tx.fromIdxName, tx.L1Tx.TokenID))
 			}
 			tc.Users[tx.fromIdxName].Accounts[tx.L1Tx.TokenID] = &Account{
 				Idx:      common.Idx(tc.idx),
@@ -423,7 +437,8 @@ func (tc *Context) calculateIdxForL1Txs(isCoordinatorTxs bool, txs []L1Tx) error
 				Nonce:    common.Nonce(0),
 				BatchNum: tc.currBatchNum,
 			}
-			tc.l1CreatedAccounts[idxTokenIDToString(tx.fromIdxName, tx.L1Tx.TokenID)] = tc.Users[tx.fromIdxName].Accounts[tx.L1Tx.TokenID]
+			tc.l1CreatedAccounts[idxTokenIDToString(tx.fromIdxName, tx.L1Tx.TokenID)] =
+				tc.Users[tx.fromIdxName].Accounts[tx.L1Tx.TokenID]
 			tc.accountsByIdx[tc.idx] = tc.Users[tx.fromIdxName].Accounts[tx.L1Tx.TokenID]
 			tc.UsersByIdx[tc.idx] = tc.Users[tx.fromIdxName]
 			tc.idx++
@@ -442,11 +457,15 @@ func (tc *Context) setIdxs() error {
 		testTx := &tc.currBatchTest.l2Txs[i]

 		if tc.Users[testTx.fromIdxName].Accounts[testTx.tokenID] == nil {
-			return tracerr.Wrap(fmt.Errorf("Line %d: %s from User %s for TokenID %d while account not created yet", testTx.lineNum, testTx.L2Tx.Type, testTx.fromIdxName, testTx.tokenID))
+			return tracerr.Wrap(fmt.Errorf("Line %d: %s from User %s for TokenID %d "+
+				"while account not created yet",
+				testTx.lineNum, testTx.L2Tx.Type, testTx.fromIdxName, testTx.tokenID))
 		}
 		if testTx.L2Tx.Type == common.TxTypeTransfer {
 			if _, ok := tc.l1CreatedAccounts[idxTokenIDToString(testTx.toIdxName, testTx.tokenID)]; !ok {
-				return tracerr.Wrap(fmt.Errorf("Line %d: Can not create Transfer for a non existing account. Batch %d, ToIdx name: %s, TokenID: %d", testTx.lineNum, tc.currBatchNum, testTx.toIdxName, testTx.tokenID))
+				return tracerr.Wrap(fmt.Errorf("Line %d: Can not create Transfer for a non "+
+					"existing account. Batch %d, ToIdx name: %s, TokenID: %d",
+					testTx.lineNum, tc.currBatchNum, testTx.toIdxName, testTx.tokenID))
 			}
 		}
 		tc.Users[testTx.fromIdxName].Accounts[testTx.tokenID].Nonce++
@@ -498,7 +517,8 @@ func (tc *Context) addToL1UserQueue(tx L1Tx) error {
 	tx.L1Tx.Position = len(tc.Queues[tc.openToForge])

 	// When an L1UserTx is generated, all idxs must be available (except when idx == 0 or idx == 1)
-	if tx.L1Tx.Type != common.TxTypeCreateAccountDeposit && tx.L1Tx.Type != common.TxTypeCreateAccountDepositTransfer {
+	if tx.L1Tx.Type != common.TxTypeCreateAccountDeposit &&
+		tx.L1Tx.Type != common.TxTypeCreateAccountDepositTransfer {
 		tx.L1Tx.FromIdx = tc.Users[tx.fromIdxName].Accounts[tx.L1Tx.TokenID].Idx
 	}
 	tx.L1Tx.FromEthAddr = tc.Users[tx.fromIdxName].Addr
@@ -530,14 +550,16 @@ func (tc *Context) addToL1UserQueue(tx L1Tx) error {

 func (tc *Context) checkIfAccountExists(tf string, inst Instruction) error {
 	if tc.Users[tf].Accounts[inst.TokenID] == nil {
-		return tracerr.Wrap(fmt.Errorf("%s at User: %s, for TokenID: %d, while account not created yet", inst.Typ, tf, inst.TokenID))
+		return tracerr.Wrap(fmt.Errorf("%s at User: %s, for TokenID: %d, while account not created yet",
+			inst.Typ, tf, inst.TokenID))
 	}
 	return nil
 }

 func (tc *Context) checkIfTokenIsRegistered(inst Instruction) error {
 	if inst.TokenID > tc.LastRegisteredTokenID {
-		return tracerr.Wrap(fmt.Errorf("Can not process %s: TokenID %d not registered, last registered TokenID: %d", inst.Typ, inst.TokenID, tc.LastRegisteredTokenID))
+		return tracerr.Wrap(fmt.Errorf("Can not process %s: TokenID %d not registered, "+
+			"last registered TokenID: %d", inst.Typ, inst.TokenID, tc.LastRegisteredTokenID))
 	}
 	return nil
 }
@@ -551,7 +573,8 @@ func (tc *Context) GeneratePoolL2Txs(set string) ([]common.PoolL2Tx, error) {
 		return nil, tracerr.Wrap(err)
 	}
 	if parsedSet.typ != SetTypePoolL2 {
-		return nil, tracerr.Wrap(fmt.Errorf("Expected set type: %s, found: %s", SetTypePoolL2, parsedSet.typ))
+		return nil, tracerr.Wrap(fmt.Errorf("Expected set type: %s, found: %s",
+			SetTypePoolL2, parsedSet.typ))
 	}

 	tc.instructions = parsedSet.instructions
@@ -668,7 +691,9 @@ func (tc *Context) generatePoolL2Txs() ([]common.PoolL2Tx, error) {
 			tx.Signature = sig.Compress()
 			txs = append(txs, tx)
 		default:
-			return nil, tracerr.Wrap(fmt.Errorf("Line %d: instruction type unrecognized: %s", inst.LineNum, inst.Typ))
+			return nil,
+				tracerr.Wrap(fmt.Errorf("Line %d: instruction type unrecognized: %s",
+					inst.LineNum, inst.Typ))
 		}
 	}

--- a/test/til/txs_test.go
+++ b/test/til/txs_test.go
@@ -119,49 +119,66 @@ func TestGenerateBlocks(t *testing.T) {

 	// Check expected values generated by each line
 	// #0: Deposit(1) A: 10
-	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[0], common.TxTypeCreateAccountDeposit, 1, "A", "", big.NewInt(10), nil)
+	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[0], common.TxTypeCreateAccountDeposit, 1,
+		"A", "", big.NewInt(10), nil)
 	// #1: Deposit(2) A: 20
-	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[1], common.TxTypeCreateAccountDeposit, 2, "A", "", big.NewInt(20), nil)
+	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[1], common.TxTypeCreateAccountDeposit, 2,
+		"A", "", big.NewInt(20), nil)
 	// // #2: Deposit(1) A: 20
-	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[2], common.TxTypeCreateAccountDeposit, 1, "B", "", big.NewInt(5), nil)
+	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[2], common.TxTypeCreateAccountDeposit, 1,
+		"B", "", big.NewInt(5), nil)
 	// // #3: CreateAccountDeposit(1) C: 5
-	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[3], common.TxTypeCreateAccountDeposit, 1, "C", "", big.NewInt(5), nil)
+	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[3], common.TxTypeCreateAccountDeposit, 1,
+		"C", "", big.NewInt(5), nil)
 	// // #4: CreateAccountDeposit(1) D: 5
-	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[4], common.TxTypeCreateAccountDeposit, 1, "D", "", big.NewInt(5), nil)
+	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[4], common.TxTypeCreateAccountDeposit, 1,
+		"D", "", big.NewInt(5), nil)
 	// #5: Transfer(1) A-B: 6 (1)
-	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[2].L2Txs[0], common.TxTypeTransfer, 1, "A", "B", big.NewInt(6), common.BatchNum(3))
+	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[2].L2Txs[0], common.TxTypeTransfer, 1, "A",
+		"B", big.NewInt(6), common.BatchNum(3))
 	// #6: Transfer(1) B-D: 3 (1)
-	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[2].L2Txs[1], common.TxTypeTransfer, 1, "B", "D", big.NewInt(3), common.BatchNum(3))
+	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[2].L2Txs[1], common.TxTypeTransfer, 1, "B",
+		"D", big.NewInt(3), common.BatchNum(3))
 	// #7: Transfer(1) A-D: 1 (1)
-	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[2].L2Txs[2], common.TxTypeTransfer, 1, "A", "D", big.NewInt(1), common.BatchNum(3))
-	// change of Batch
-	// #8: CreateAccountDepositTransfer(1) F-A: 15, 10 (3)
-	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[5], common.TxTypeCreateAccountDepositTransfer, 1, "F", "A", big.NewInt(15), big.NewInt(10))
+	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[2].L2Txs[2], common.TxTypeTransfer, 1, "A",
+		"D", big.NewInt(1), common.BatchNum(3))
+	// change of Batch #8: CreateAccountDepositTransfer(1) F-A: 15, 10 (3)
+	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[5],
+		common.TxTypeCreateAccountDepositTransfer, 1, "F", "A", big.NewInt(15), big.NewInt(10))
 	// #9: DepositTransfer(1) A-B: 15, 10 (1)
-	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[6], common.TxTypeDepositTransfer, 1, "A", "B", big.NewInt(15), big.NewInt(10))
+	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[6], common.TxTypeDepositTransfer, 1, "A",
+		"B", big.NewInt(15), big.NewInt(10))
 	// #11: Transfer(1) C-A : 3 (1)
-	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[3].L2Txs[0], common.TxTypeTransfer, 1, "C", "A", big.NewInt(3), common.BatchNum(4))
+	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[3].L2Txs[0], common.TxTypeTransfer, 1, "C",
+		"A", big.NewInt(3), common.BatchNum(4))
 	// #12: Transfer(2) A-B: 15 (1)
-	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[3].L2Txs[1], common.TxTypeTransfer, 2, "A", "B", big.NewInt(15), common.BatchNum(4))
+	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[3].L2Txs[1], common.TxTypeTransfer, 2, "A",
+		"B", big.NewInt(15), common.BatchNum(4))
 	// #13: Deposit(1) User0: 20
-	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[7], common.TxTypeCreateAccountDeposit, 1, "User0", "", big.NewInt(20), nil)
+	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[7], common.TxTypeCreateAccountDeposit, 1,
+		"User0", "", big.NewInt(20), nil)
 	// // #14: Deposit(3) User1: 20
-	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[8], common.TxTypeCreateAccountDeposit, 3, "User1", "", big.NewInt(20), nil)
+	tc.checkL1TxParams(t, blocks[0].Rollup.L1UserTxs[8], common.TxTypeCreateAccountDeposit, 3,
+		"User1", "", big.NewInt(20), nil)
 	// #15: Transfer(1) User0-User1: 15 (1)
-	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[4].L2Txs[0], common.TxTypeTransfer, 1, "User0", "User1", big.NewInt(15), common.BatchNum(5))
+	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[4].L2Txs[0], common.TxTypeTransfer, 1,
+		"User0", "User1", big.NewInt(15), common.BatchNum(5))
 	// #16: Transfer(3) User1-User0: 15 (1)
-	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[4].L2Txs[1], common.TxTypeTransfer, 3, "User1", "User0", big.NewInt(15), common.BatchNum(5))
+	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[4].L2Txs[1], common.TxTypeTransfer, 3,
+		"User1", "User0", big.NewInt(15), common.BatchNum(5))
 	// #17: Transfer(1) A-C: 1 (1)
-	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[4].L2Txs[2], common.TxTypeTransfer, 1, "A", "C", big.NewInt(1), common.BatchNum(5))
-	// change of Batch
-	// #18: Transfer(1) User1-User0: 1 (1)
-	tc.checkL2TxParams(t, blocks[1].Rollup.Batches[0].L2Txs[0], common.TxTypeTransfer, 1, "User1", "User0", big.NewInt(1), common.BatchNum(6))
-	// change of Block (implies also a change of batch)
-	// #19: Transfer(1) A-B: 1 (1)
-	tc.checkL2TxParams(t, blocks[1].Rollup.Batches[0].L2Txs[1], common.TxTypeTransfer, 1, "A", "B", big.NewInt(1), common.BatchNum(6))
+	tc.checkL2TxParams(t, blocks[0].Rollup.Batches[4].L2Txs[2], common.TxTypeTransfer, 1, "A",
+		"C", big.NewInt(1), common.BatchNum(5))
+	// change of Batch #18: Transfer(1) User1-User0: 1 (1)
+	tc.checkL2TxParams(t, blocks[1].Rollup.Batches[0].L2Txs[0], common.TxTypeTransfer, 1,
+		"User1", "User0", big.NewInt(1), common.BatchNum(6))
+	// change of Block (implies also a change of batch) #19: Transfer(1) A-B: 1 (1)
+	tc.checkL2TxParams(t, blocks[1].Rollup.Batches[0].L2Txs[1], common.TxTypeTransfer, 1, "A",
+		"B", big.NewInt(1), common.BatchNum(6))
 }

-func (tc *Context) checkL1TxParams(t *testing.T, tx common.L1Tx, typ common.TxType, tokenID common.TokenID, from, to string, depositAmount, amount *big.Int) {
+func (tc *Context) checkL1TxParams(t *testing.T, tx common.L1Tx, typ common.TxType,
+	tokenID common.TokenID, from, to string, depositAmount, amount *big.Int) {
 	assert.Equal(t, typ, tx.Type)
 	if tx.FromIdx != common.Idx(0) {
 		assert.Equal(t, tc.Users[from].Accounts[tokenID].Idx, tx.FromIdx)
@@ -179,7 +196,8 @@ func (tc *Context) checkL1TxParams(t *testing.T, tx common.L1Tx, typ common.TxTy
 	}
 }

-func (tc *Context) checkL2TxParams(t *testing.T, tx common.L2Tx, typ common.TxType, tokenID common.TokenID, from, to string, amount *big.Int, batchNum common.BatchNum) {
+func (tc *Context) checkL2TxParams(t *testing.T, tx common.L2Tx, typ common.TxType,
+	tokenID common.TokenID, from, to string, amount *big.Int, batchNum common.BatchNum) {
 	assert.Equal(t, typ, tx.Type)
 	assert.Equal(t, tc.Users[from].Accounts[tokenID].Idx, tx.FromIdx)
 	if tx.Type != common.TxTypeExit {
@@ -367,7 +385,9 @@ func TestGenerateErrors(t *testing.T) {
 		`
 	tc := NewContext(0, common.RollupConstMaxL1UserTx)
 	_, err := tc.GenerateBlocks(set)
-	assert.Equal(t, "Line 2: Can not process CreateAccountDeposit: TokenID 1 not registered, last registered TokenID: 0", err.Error())
+	assert.Equal(t,
+		"Line 2: Can not process CreateAccountDeposit: TokenID 1 not registered, "+
+			"last registered TokenID: 0", err.Error())

 	// ensure AddToken sequentiality and not using 0
 	set = `
@@ -384,7 +404,8 @@ func TestGenerateErrors(t *testing.T) {
 	`
 	tc = NewContext(0, common.RollupConstMaxL1UserTx)
 	_, err = tc.GenerateBlocks(set)
-	require.Equal(t, "Line 2: AddToken TokenID should be sequential, expected TokenID: 1, defined TokenID: 2", err.Error())
+	require.Equal(t, "Line 2: AddToken TokenID should be sequential, expected TokenID: "+
+		"1, defined TokenID: 2", err.Error())

 	set = `
 		Type: Blockchain
@@ -395,7 +416,8 @@ func TestGenerateErrors(t *testing.T) {
 	`
 	tc = NewContext(0, common.RollupConstMaxL1UserTx)
 	_, err = tc.GenerateBlocks(set)
-	require.Equal(t, "Line 5: AddToken TokenID should be sequential, expected TokenID: 4, defined TokenID: 5", err.Error())
+	require.Equal(t, "Line 5: AddToken TokenID should be sequential, expected TokenID: "+
+		"4, defined TokenID: 5", err.Error())

 	// check transactions when account is not created yet
 	set = `
@@ -409,7 +431,8 @@ func TestGenerateErrors(t *testing.T) {
 	`
 	tc = NewContext(0, common.RollupConstMaxL1UserTx)
 	_, err = tc.GenerateBlocks(set)
-	require.Equal(t, "Line 5: CreateAccountDeposit(1)BTransfer(1) A-B: 6 (1)\n, err: Expected ':', found 'Transfer'", err.Error())
+	require.Equal(t, "Line 5: CreateAccountDeposit(1)BTransfer(1) A-B: 6 (1)\n, err: "+
+		"Expected ':', found 'Transfer'", err.Error())
 	set = `
 		Type: Blockchain
 		AddToken(1)
@@ -434,7 +457,8 @@ func TestGenerateErrors(t *testing.T) {
 		CreateAccountCoordinator(1) B
 		> batchL1
 		Transfer(1) A-B: 6 (1)
-		Transfer(1) A-B: 6 (1) // on purpose this is moving more money that what it has in the account, Til should not fail
+		Transfer(1) A-B: 6 (1) // on purpose this is moving more money that
+				       // what it has in the account, Til should not fail
 		Transfer(1) B-A: 6 (1)
 		Exit(1) A: 3 (1)
 		> batch
@@ -558,7 +582,8 @@ func TestGenerateFromInstructions(t *testing.T) {
 		CreateAccountCoordinator(1) B
 		> batchL1
 		Transfer(1) A-B: 6 (1)
-		Transfer(1) A-B: 6 (1) // on purpose this is moving more money that what it has in the account, Til should not fail
+		Transfer(1) A-B: 6 (1) // on purpose this is moving more money that
+				       // what it has in the account, Til should not fail
 		Transfer(1) B-A: 6 (1)
 		Exit(1) A: 3 (1)
 		> batch
--- a/test/txsets/tilsets.go
+++ b/test/txsets/tilsets.go
@@ -181,7 +181,8 @@ Transfer(1) H-O: 5 (1)
 Transfer(1) I-H: 5 (1)
 Exit(1) A: 5 (1)

-// create CoordinatorTx CreateAccount for D, TokenId 2, used at SetPool0 for 'PoolTransfer(2) B-D: 3 (1)'
+// create CoordinatorTx CreateAccount for D, TokenId 2, used at SetPool0 for
+// 'PoolTransfer(2) B-D: 3 (1)'
 CreateAccountCoordinator(2) D

 > batchL1
--- a/test/txsets/txhelpers.go
+++ b/test/txsets/txhelpers.go
@@ -25,8 +25,14 @@ import (
 func GenerateJsUsers(t *testing.T) []til.User {
 	// same values than in the js test
 	// skJsHex is equivalent to the 0000...000i js private key in commonjs
-	skJsHex := []string{"7eb258e61862aae75c6c1d1f7efae5006ffc9e4d5596a6ff95f3df4ea209ea7f", "c005700f76f4b4cec710805c21595688648524df0a9d467afae537b7a7118819", "b373d14c67fb2a517bf4ac831c93341eec8e1b38dbc14e7d725b292a7cf84707", "2064b68d04a7aaae0ac3b36bf6f1850b380f1423be94a506c531940bd4a48b76"}
-	addrHex := []string{"0x7e5f4552091a69125d5dfcb7b8c2659029395bdf", "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf", "0x6813eb9362372eef6200f3b1dbc3f819671cba69", "0x1eff47bc3a10a45d4b230b5d10e37751fe6aa718"}
+	skJsHex := []string{"7eb258e61862aae75c6c1d1f7efae5006ffc9e4d5596a6ff95f3df4ea209ea7f",
+		"c005700f76f4b4cec710805c21595688648524df0a9d467afae537b7a7118819",
+		"b373d14c67fb2a517bf4ac831c93341eec8e1b38dbc14e7d725b292a7cf84707",
+		"2064b68d04a7aaae0ac3b36bf6f1850b380f1423be94a506c531940bd4a48b76"}
+	addrHex := []string{"0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+		"0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
+		"0x6813eb9362372eef6200f3b1dbc3f819671cba69",
+		"0x1eff47bc3a10a45d4b230b5d10e37751fe6aa718"}
 	var users []til.User
 	for i := 0; i < len(skJsHex); i++ {
 		skJs, err := hex.DecodeString(skJsHex[i])
@@ -41,10 +47,14 @@ func GenerateJsUsers(t *testing.T) []til.User {
 		}
 		users = append(users, user)
 	}
-	assert.Equal(t, "d746824f7d0ac5044a573f51b278acb56d823bec39551d1d7bf7378b68a1b021", users[0].BJJ.Public().String())
-	assert.Equal(t, "4d05c307400c65795f02db96b1b81c60386fd53e947d9d3f749f3d99b1853909", users[1].BJJ.Public().String())
-	assert.Equal(t, "38ffa002724562eb2a952a2503e206248962406cf16392ff32759b6f2a41fe11", users[2].BJJ.Public().String())
-	assert.Equal(t, "c719e6401190be7fa7fbfcd3448fe2755233c01575341a3b09edadf5454f760b", users[3].BJJ.Public().String())
+	assert.Equal(t, "d746824f7d0ac5044a573f51b278acb56d823bec39551d1d7bf7378b68a1b021",
+		users[0].BJJ.Public().String())
+	assert.Equal(t, "4d05c307400c65795f02db96b1b81c60386fd53e947d9d3f749f3d99b1853909",
+		users[1].BJJ.Public().String())
+	assert.Equal(t, "38ffa002724562eb2a952a2503e206248962406cf16392ff32759b6f2a41fe11",
+		users[2].BJJ.Public().String())
+	assert.Equal(t, "c719e6401190be7fa7fbfcd3448fe2755233c01575341a3b09edadf5454f760b",
+		users[3].BJJ.Public().String())

 	return users
 }
@@ -58,7 +68,9 @@ func signL2Tx(t *testing.T, chainID uint16, user til.User, l2Tx common.PoolL2Tx)
 }

 // GenerateTxsZKInputsHash0 generates the transactions for the TestZKInputsHash0
-func GenerateTxsZKInputsHash0(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
+func GenerateTxsZKInputsHash0(t *testing.T, chainID uint16) (users []til.User,
+	coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx,
+	l2Txs []common.PoolL2Tx) {
 	// same values than in the js test
 	users = GenerateJsUsers(t)

@@ -93,7 +105,9 @@ func GenerateTxsZKInputsHash0(t *testing.T, chainID uint16) (users []til.User, c
 }

 // GenerateTxsZKInputsHash1 generates the transactions for the TestZKInputsHash1
-func GenerateTxsZKInputsHash1(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
+func GenerateTxsZKInputsHash1(t *testing.T, chainID uint16) (users []til.User,
+	coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx,
+	l2Txs []common.PoolL2Tx) {
 	// same values than in the js test
 	users = GenerateJsUsers(t)
 	l1UserTxs = []common.L1Tx{
@@ -138,7 +152,9 @@ func GenerateTxsZKInputsHash1(t *testing.T, chainID uint16) (users []til.User, c
 }

 // GenerateTxsZKInputs0 generates the transactions for the TestZKInputs0
-func GenerateTxsZKInputs0(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
+func GenerateTxsZKInputs0(t *testing.T, chainID uint16) (users []til.User,
+	coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx,
+	l2Txs []common.PoolL2Tx) {
 	// same values than in the js test
 	users = GenerateJsUsers(t)

@@ -175,7 +191,8 @@ func GenerateTxsZKInputs0(t *testing.T, chainID uint16) (users []til.User, coord
 }

 // GenerateTxsZKInputs1 generates the transactions for the TestZKInputs1
-func GenerateTxsZKInputs1(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
+func GenerateTxsZKInputs1(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx,
+	l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
 	// same values than in the js test
 	users = GenerateJsUsers(t)

@@ -222,7 +239,8 @@ func GenerateTxsZKInputs1(t *testing.T, chainID uint16) (users []til.User, coord
 }

 // GenerateTxsZKInputs2 generates the transactions for the TestZKInputs2
-func GenerateTxsZKInputs2(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
+func GenerateTxsZKInputs2(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx,
+	l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
 	// same values than in the js test
 	users = GenerateJsUsers(t)

@@ -301,7 +319,8 @@ func GenerateTxsZKInputs2(t *testing.T, chainID uint16) (users []til.User, coord
 }

 // GenerateTxsZKInputs3 generates the transactions for the TestZKInputs3
-func GenerateTxsZKInputs3(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
+func GenerateTxsZKInputs3(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx,
+	l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
 	// same values than in the js test
 	users = GenerateJsUsers(t)

@@ -380,7 +399,8 @@ func GenerateTxsZKInputs3(t *testing.T, chainID uint16) (users []til.User, coord
 }

 // GenerateTxsZKInputs4 generates the transactions for the TestZKInputs4
-func GenerateTxsZKInputs4(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
+func GenerateTxsZKInputs4(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx,
+	l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
 	// same values than in the js test
 	users = GenerateJsUsers(t)

@@ -469,7 +489,8 @@ func GenerateTxsZKInputs4(t *testing.T, chainID uint16) (users []til.User, coord
 }

 // GenerateTxsZKInputs5 generates the transactions for the TestZKInputs5
-func GenerateTxsZKInputs5(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx, l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
+func GenerateTxsZKInputs5(t *testing.T, chainID uint16) (users []til.User, coordIdxs []common.Idx,
+	l1UserTxs []common.L1Tx, l1CoordTxs []common.L1Tx, l2Txs []common.PoolL2Tx) {
 	// same values than in the js test
 	users = GenerateJsUsers(t)

--- a/test/zkproof/flows_test.go
+++ b/test/zkproof/flows_test.go
@@ -55,7 +55,8 @@ func addL2Txs(t *testing.T, l2DB *l2db.L2DB, poolL2Txs []common.PoolL2Tx) {
 	}
 }

-func addAccCreationAuth(t *testing.T, tc *til.Context, l2DB *l2db.L2DB, chainID uint16, hermezContractAddr ethCommon.Address, username string) []byte {
+func addAccCreationAuth(t *testing.T, tc *til.Context, l2DB *l2db.L2DB, chainID uint16,
+	hermezContractAddr ethCommon.Address, username string) []byte {
 	user := tc.Users[username]
 	auth := &common.AccountCreationAuth{
 		EthAddr: user.Addr,
@@ -71,7 +72,8 @@ func addAccCreationAuth(t *testing.T, tc *til.Context, l2DB *l2db.L2DB, chainID
 	return auth.Signature
 }

-func initTxSelector(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address, coordUser *til.User) (*txselector.TxSelector, *l2db.L2DB, *statedb.StateDB) {
+func initTxSelector(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address,
+	coordUser *til.User) (*txselector.TxSelector, *l2db.L2DB, *statedb.StateDB) {
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
@@ -145,7 +147,11 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 	}

 	// loop over the first 6 batches
-	expectedRoots := []string{"0", "0", "13644148972047617726265275926674266298636745191961029124811988256139761111521", "12433441613247342495680642890662773367605896324555599297255745922589338651261", "12433441613247342495680642890662773367605896324555599297255745922589338651261", "4191361650490017591061467288209836928064232431729236465872209988325272262963"}
+	expectedRoots := []string{"0", "0",
+		"13644148972047617726265275926674266298636745191961029124811988256139761111521",
+		"12433441613247342495680642890662773367605896324555599297255745922589338651261",
+		"12433441613247342495680642890662773367605896324555599297255745922589338651261",
+		"4191361650490017591061467288209836928064232431729236465872209988325272262963"}
 	for i := 0; i < 6; i++ {
 		log.Debugf("block:0 batch:%d", i+1)
 		var l1UserTxs []common.L1Tx
@@ -153,7 +159,8 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 			l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[i].Batch.ForgeL1TxsNum])
 		}
 		// TxSelector select the transactions for the next Batch
-		coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err := txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
+		coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err :=
+			txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
 		require.NoError(t, err)
 		// BatchBuilder build Batch
 		zki, err := bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
@@ -176,14 +183,18 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 	addL2Txs(t, l2DBTxSel, l2Txs) // Add L2s to TxSelector.L2DB
 	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(selectionConfig, l1UserTxs)
+	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
+		txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err := bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
 	require.NoError(t, err)
-	assert.Equal(t, "7614010373759339299470010949167613050707822522530721724565424494781010548240", bb.LocalStateDB().MT.Root().BigInt().String())
+	assert.Equal(t,
+		"7614010373759339299470010949167613050707822522530721724565424494781010548240",
+		bb.LocalStateDB().MT.Root().BigInt().String())
 	sendProofAndCheckResp(t, zki)
-	err = l2DBTxSel.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.LocalAccountsDB().CurrentBatch())
+	err = l2DBTxSel.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs),
+		txsel.LocalAccountsDB().CurrentBatch())
 	require.NoError(t, err)
 	err = l2DBTxSel.UpdateTxsInfo(discardedL2Txs)
 	require.NoError(t, err)
@@ -201,14 +212,18 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 	addL2Txs(t, l2DBTxSel, l2Txs) // Add L2s to TxSelector.L2DB
 	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(selectionConfig, l1UserTxs)
+	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
+		txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err = bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
 	require.NoError(t, err)
-	assert.Equal(t, "21231789250434471575486264439945776732824482207853465397552873521865656677689", bb.LocalStateDB().MT.Root().BigInt().String())
+	assert.Equal(t,
+		"21231789250434471575486264439945776732824482207853465397552873521865656677689",
+		bb.LocalStateDB().MT.Root().BigInt().String())
 	sendProofAndCheckResp(t, zki)
-	err = l2DBTxSel.StartForging(common.TxIDsFromPoolL2Txs(l2Txs), txsel.LocalAccountsDB().CurrentBatch())
+	err = l2DBTxSel.StartForging(common.TxIDsFromPoolL2Txs(l2Txs),
+		txsel.LocalAccountsDB().CurrentBatch())
 	require.NoError(t, err)
 	err = l2DBTxSel.UpdateTxsInfo(discardedL2Txs)
 	require.NoError(t, err)
@@ -224,14 +239,18 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 	addL2Txs(t, l2DBTxSel, l2Txs) // Add L2s to TxSelector.L2DB
 	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(selectionConfig, l1UserTxs)
+	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
+		txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err = bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
 	require.NoError(t, err)
-	assert.Equal(t, "11289313644810782435120113035387729451095637380468777086895109386127538554246", bb.LocalStateDB().MT.Root().BigInt().String())
+	assert.Equal(t,
+		"11289313644810782435120113035387729451095637380468777086895109386127538554246",
+		bb.LocalStateDB().MT.Root().BigInt().String())
 	sendProofAndCheckResp(t, zki)
-	err = l2DBTxSel.StartForging(common.TxIDsFromPoolL2Txs(l2Txs), txsel.LocalAccountsDB().CurrentBatch())
+	err = l2DBTxSel.StartForging(common.TxIDsFromPoolL2Txs(l2Txs),
+		txsel.LocalAccountsDB().CurrentBatch())
 	require.NoError(t, err)
 	err = l2DBTxSel.UpdateTxsInfo(discardedL2Txs)
 	require.NoError(t, err)
@@ -240,16 +259,20 @@ func TestTxSelectorBatchBuilderZKInputsMinimumFlow0(t *testing.T) {
 	l2Txs = []common.PoolL2Tx{}
 	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(selectionConfig, l1UserTxs)
+	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
+		txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err = bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
 	require.NoError(t, err)
 	// same root as previous batch, as the L1CoordinatorTxs created by the
 	// Til set is not created by the TxSelector in this test
-	assert.Equal(t, "11289313644810782435120113035387729451095637380468777086895109386127538554246", bb.LocalStateDB().MT.Root().BigInt().String())
+	assert.Equal(t,
+		"11289313644810782435120113035387729451095637380468777086895109386127538554246",
+		bb.LocalStateDB().MT.Root().BigInt().String())
 	sendProofAndCheckResp(t, zki)
-	err = l2DBTxSel.StartForging(common.TxIDsFromPoolL2Txs(l2Txs), txsel.LocalAccountsDB().CurrentBatch())
+	err = l2DBTxSel.StartForging(common.TxIDsFromPoolL2Txs(l2Txs),
+		txsel.LocalAccountsDB().CurrentBatch())
 	require.NoError(t, err)
 	err = l2DBTxSel.UpdateTxsInfo(discardedL2Txs)
 	require.NoError(t, err)
@@ -303,15 +326,20 @@ func TestZKInputsExitWithFee0(t *testing.T) {
 	// batch2
 	// 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(selectionConfig, l1UserTxs)
+	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, _, err :=
+		txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
 	require.NoError(t, err)
 	// BatchBuilder build Batch
 	zki, err := bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
 	require.NoError(t, err)
-	assert.Equal(t, "8737171572459172806192626402462788826264011087579491137542380589998149683116", bb.LocalStateDB().MT.Root().BigInt().String())
+	assert.Equal(t,
+		"8737171572459172806192626402462788826264011087579491137542380589998149683116",
+		bb.LocalStateDB().MT.Root().BigInt().String())
 	h, err := zki.HashGlobalData()
 	require.NoError(t, err)
-	assert.Equal(t, "18608843755023673022528019960628191162333429206359207449879743919826610006009", h.String())
+	assert.Equal(t,
+		"18608843755023673022528019960628191162333429206359207449879743919826610006009",
+		h.String())
 	sendProofAndCheckResp(t, zki)

 	// batch3
@@ -321,7 +349,8 @@ func TestZKInputsExitWithFee0(t *testing.T) {
 	l2Txs, err := tc.GeneratePoolL2Txs(batchPoolL2)
 	require.NoError(t, err)
 	addL2Txs(t, l2DBTxSel, l2Txs) // Add L2s to TxSelector.L2DB
-	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err := txsel.GetL1L2TxSelection(selectionConfig, nil)
+	coordIdxs, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
+		txsel.GetL1L2TxSelection(selectionConfig, nil)
 	require.NoError(t, err)
 	assert.Equal(t, 1, len(coordIdxs))
 	assert.Equal(t, 0, len(oL1UserTxs))
@@ -331,10 +360,14 @@ func TestZKInputsExitWithFee0(t *testing.T) {
 	// BatchBuilder build Batch
 	zki, err = bb.BuildBatch(coordIdxs, configBatch, oL1UserTxs, oL1CoordTxs, oL2Txs)
 	require.NoError(t, err)
-	assert.Equal(t, "18306761925365215381387147754881756804475668085493847010988306480531520370130", bb.LocalStateDB().MT.Root().BigInt().String())
+	assert.Equal(t,
+		"18306761925365215381387147754881756804475668085493847010988306480531520370130",
+		bb.LocalStateDB().MT.Root().BigInt().String())
 	h, err = zki.HashGlobalData()
 	require.NoError(t, err)
-	assert.Equal(t, "6651837443119278772088559395433504719862425648816904171510845286897104469889", h.String())
+	assert.Equal(t,
+		"6651837443119278772088559395433504719862425648816904171510845286897104469889",
+		h.String())
 	assert.Equal(t, common.EthAddrToBigInt(tc.Users["Coord"].Addr), zki.EthAddr3[0])
 	assert.Equal(t, "0", zki.EthAddr3[1].String())
 	sendProofAndCheckResp(t, zki)
--- a/test/zkproof/zkproof_test.go
+++ b/test/zkproof/zkproof_test.go
@@ -246,7 +246,8 @@ func TestZKInputs6(t *testing.T) {
 	coordIdxs := []common.Idx{261, 262}
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[6].Batch.ForgeL1TxsNum])
 	l2Txs = poolL2Txs
-	ptOut, err = tp.ProcessTxs(coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[6].L1CoordinatorTxs, l2Txs)
+	ptOut, err = tp.ProcessTxs(coordIdxs, l1UserTxs,
+		blocks[0].Rollup.Batches[6].L1CoordinatorTxs, l2Txs)
 	require.NoError(t, err)

 	sendProofAndCheckResp(t, ptOut.ZKInputs)
@@ -264,7 +265,8 @@ func TestZKInputs6(t *testing.T) {

 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[7].Batch.ForgeL1TxsNum])
 	l2Txs = poolL2Txs
-	ptOut, err = tp.ProcessTxs(coordIdxs, l1UserTxs, blocks[0].Rollup.Batches[7].L1CoordinatorTxs, l2Txs)
+	ptOut, err = tp.ProcessTxs(coordIdxs, l1UserTxs,
+		blocks[0].Rollup.Batches[7].L1CoordinatorTxs, l2Txs)
 	require.NoError(t, err)

 	sendProofAndCheckResp(t, ptOut.ZKInputs)
@@ -281,7 +283,8 @@ func TestZKInputs6(t *testing.T) {
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[1].Rollup.Batches[0].Batch.ForgeL1TxsNum])
 	l2Txs = poolL2Txs
 	coordIdxs = []common.Idx{262}
-	ptOut, err = tp.ProcessTxs(coordIdxs, l1UserTxs, blocks[1].Rollup.Batches[0].L1CoordinatorTxs, l2Txs)
+	ptOut, err = tp.ProcessTxs(coordIdxs, l1UserTxs,
+		blocks[1].Rollup.Batches[0].L1CoordinatorTxs, l2Txs)
 	require.NoError(t, err)

 	sendProofAndCheckResp(t, ptOut.ZKInputs)
@@ -290,7 +293,8 @@ func TestZKInputs6(t *testing.T) {
 	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[1].Rollup.Batches[1].Batch.ForgeL1TxsNum])
 	l2Txs = []common.PoolL2Tx{}
 	coordIdxs = []common.Idx{}
-	ptOut, err = tp.ProcessTxs(coordIdxs, l1UserTxs, blocks[1].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
+	ptOut, err = tp.ProcessTxs(coordIdxs, l1UserTxs,
+		blocks[1].Rollup.Batches[1].L1CoordinatorTxs, l2Txs)
 	require.NoError(t, err)

 	sendProofAndCheckResp(t, ptOut.ZKInputs)