Migrate all packages to use Float40

Migrate all packages to use Float40 & Add more test vectors at common

common/accountcreationauths.go

@@ -17,11 +17,6 @@ const AccountCreationAuthMsg = "I authorize this babyjubjub key for hermez rollu
 // EthMsgPrefix is the prefix for message signing at the Ethereum ecosystem
 const EthMsgPrefix = "\x19Ethereum Signed Message:\n"
 
-var (
-	// EmptyEthSignature is an ethereum signature of all zeroes
-	EmptyEthSignature = make([]byte, 65)
-)
-
 // AccountCreationAuth authorizations sent by users to the L2DB, to be used for
 // account creations when necessary
 type AccountCreationAuth struct {

common/float40.go

@@ -18,9 +18,6 @@ const (
 	// maxFloat40Value is the maximum value that the Float40 can have
 	// (40 bits: maxFloat40Value=2**40-1)
 	maxFloat40Value = 0xffffffffff
-	// Float40BytesLength defines the length of the Float40 values
-	// represented as byte arrays
-	Float40BytesLength = 5
 )
 
 var (

common/l1tx.go

@@ -15,7 +15,7 @@ import (
 type L1Tx struct {
 	// Stored in DB: mandatory fileds
 
-	// TxID (32 bytes) for L1Tx is the Keccak256 (ethereum) hash of:
+	// TxID (12 bytes) for L1Tx is:
 	// bytes:  |  1   |        8        |    2     |      1      |
 	// values: | type | ToForgeL1TxsNum | Position | 0 (padding) |
 	// where type:
@@ -225,7 +225,7 @@ func (tx *L1Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 		if err != nil {
 			return nil, tracerr.Wrap(err)
 		}
-		copy(b[idxLen*2:idxLen*2+Float40BytesLength], amountFloat40Bytes)
+		copy(b[idxLen*2:idxLen*2+5], amountFloat40Bytes)
 	}
 	// fee = 0 (as is L1Tx)
 	return b[:], nil
@@ -237,7 +237,7 @@ func L1TxFromDataAvailability(b []byte, nLevels uint32) (*L1Tx, error) {
 
 	fromIdxBytes := b[0:idxLen]
 	toIdxBytes := b[idxLen : idxLen*2]
-	amountBytes := b[idxLen*2 : idxLen*2+Float40BytesLength]
+	amountBytes := b[idxLen*2 : idxLen*2+5]
 
 	l1tx := L1Tx{}
 	fromIdx, err := IdxFromBytes(ethCommon.LeftPadBytes(fromIdxBytes, 6))

common/l2tx.go

@@ -200,8 +200,8 @@ func (tx L2Tx) BytesDataAvailability(nLevels uint32) ([]byte, error) {
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	copy(b[idxLen*2:idxLen*2+Float40BytesLength], amountFloat40Bytes)
-	b[idxLen*2+Float40BytesLength] = byte(tx.Fee)
+	copy(b[idxLen*2:idxLen*2+5], amountFloat40Bytes)
+	b[idxLen*2+5] = byte(tx.Fee)
 
 	return b[:], nil
 }
@@ -226,10 +226,10 @@ func L2TxFromBytesDataAvailability(b []byte, nLevels int) (*L2Tx, error) {
 		return nil, tracerr.Wrap(err)
 	}
 
-	tx.Amount, err = Float40FromBytes(b[idxLen*2 : idxLen*2+Float40BytesLength]).BigInt()
+	tx.Amount, err = Float40FromBytes(b[idxLen*2 : idxLen*2+5]).BigInt()
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	tx.Fee = FeeSelector(b[idxLen*2+Float40BytesLength])
+	tx.Fee = FeeSelector(b[idxLen*2+5])
 	return tx, nil
 }

common/zk.go

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

eth/rollup.go

@@ -939,7 +939,7 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 		FeeIdxCoordinator:     []common.Idx{},
 	}
 	nLevels := c.consts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels
-	lenL1L2TxsBytes := int((nLevels/8)*2 + common.Float40BytesLength + 1)
+	lenL1L2TxsBytes := int((nLevels/8)*2 + 2 + 1)
 	numBytesL1TxUser := int(l1UserTxsLen) * lenL1L2TxsBytes
 	numTxsL1Coord := len(aux.EncodedL1CoordinatorTx) / common.RollupConstL1CoordinatorTotalBytes
 	numBytesL1TxCoord := numTxsL1Coord * lenL1L2TxsBytes

test/txsets/txhelpers.go

@@ -142,12 +142,10 @@ func GenerateTxsZKInputs0(t *testing.T, chainID uint16) (users []til.User, coord
 	// same values than in the js test
 	users = GenerateJsUsers(t)
 
-	depositAmount, err := common.Float40(10400).BigInt()
-	require.Nil(t, err)
 	l1UserTxs = []common.L1Tx{
 		{
 			FromIdx:       0,
-			DepositAmount: depositAmount,
+			DepositAmount: big.NewInt(16000000),
 			Amount:        big.NewInt(0),
 			TokenID:       1,
 			FromBJJ:       users[0].BJJ.Public().Compress(),

test/zkproof/flows_test.go

@@ -311,7 +311,7 @@ func TestZKInputsExitWithFee0(t *testing.T) {
 	assert.Equal(t, "8737171572459172806192626402462788826264011087579491137542380589998149683116", bb.LocalStateDB().MT.Root().BigInt().String())
 	h, err := zki.HashGlobalData()
 	require.NoError(t, err)
-	assert.Equal(t, "18608843755023673022528019960628191162333429206359207449879743919826610006009", h.String())
+	assert.Equal(t, "12174727174629825205577542675894290689387326670869871089988393208259924373499", h.String())
 	sendProofAndCheckResp(t, zki)
 
 	// batch3
@@ -334,7 +334,7 @@ func TestZKInputsExitWithFee0(t *testing.T) {
 	assert.Equal(t, "18306761925365215381387147754881756804475668085493847010988306480531520370130", bb.LocalStateDB().MT.Root().BigInt().String())
 	h, err = zki.HashGlobalData()
 	require.NoError(t, err)
-	assert.Equal(t, "6651837443119278772088559395433504719862425648816904171510845286897104469889", h.String())
+	assert.Equal(t, "16351950370739934361208977436603065280805499094788807090831605833717933916063", h.String())
 	assert.Equal(t, common.EthAddrToBigInt(tc.Users["Coord"].Addr), zki.EthAddr3[0])
 	assert.Equal(t, "0", zki.EthAddr3[1].String())
 	sendProofAndCheckResp(t, zki)

test/zkproof/zkproof_test.go

@@ -31,7 +31,7 @@ func TestMain(m *testing.M) {
 	os.Exit(exitVal)
 }
 
-const MaxTx = 352
+const MaxTx = 376
 const NLevels = 32
 const MaxL1Tx = 256
 const MaxFeeTx = 64
@@ -61,7 +61,6 @@ func sendProofAndCheckResp(t *testing.T, zki *common.ZKInputs) {
 		return
 	}
 
-	log.Infof("sending proof to %s", proofServerURL)
 	// Store zkinputs json for debugging purposes
 	zkInputsJSON, err := json.Marshal(zki)
 	require.NoError(t, err)

txprocessor/txprocessor.go

@@ -515,20 +515,6 @@ func (tp *TxProcessor) ProcessL1Tx(exitTree *merkletree.MerkleTree, tx *common.L
 		if tp.i < len(tp.zki.ISOnChain) { // len(tp.zki.ISOnChain) == nTx
 			tp.zki.ISOnChain[tp.i] = big.NewInt(1)
 		}
-
-		if tx.Type == common.TxTypeForceTransfer ||
-			tx.Type == common.TxTypeDepositTransfer ||
-			tx.Type == common.TxTypeCreateAccountDepositTransfer ||
-			tx.Type == common.TxTypeForceExit {
-			// in the cases where at L1Tx there is usage of the
-			// Amount parameter, add it at the ZKInputs.AmountF
-			// slot
-			amountF40, err := common.NewFloat40(tx.Amount)
-			if err != nil {
-				return nil, nil, false, nil, tracerr.Wrap(err)
-			}
-			tp.zki.AmountF[tp.i] = big.NewInt(int64(amountF40))
-		}
 	}
 
 	switch tx.Type {
@@ -671,11 +657,6 @@ func (tp *TxProcessor) ProcessL2Tx(coordIdxsMap map[common.TokenID]common.Idx,
 		tp.zki.ToEthAddr[tp.i] = common.EthAddrToBigInt(tx.ToEthAddr)
 
 		tp.zki.OnChain[tp.i] = big.NewInt(0)
-		amountF40, err := common.NewFloat40(tx.Amount)
-		if err != nil {
-			return nil, nil, false, tracerr.Wrap(err)
-		}
-		tp.zki.AmountF[tp.i] = big.NewInt(int64(amountF40))
 		tp.zki.NewAccount[tp.i] = big.NewInt(0)
 
 		// L2Txs

txselector/txselector.go

@@ -3,6 +3,7 @@ package txselector
 // current: very simple version of TxSelector
 
 import (
+	"bytes"
 	"fmt"
 	"math/big"
 	"sort"
@@ -235,8 +236,7 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 			if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1UserTxs)-len(l1UserTxs) {
 				// discard L2Tx, and update Info parameter of
 				// the tx, and add it to the discardedTxs array
-				l2Txs0[i].Info = "Tx not selected because the L2Tx depends on a " +
-					"L1CoordinatorTx and there is not enough space for L1Coordinator"
+				l2Txs0[i].Info = "Tx not selected due the L2Tx depends on a L1CoordinatorTx and there is not enough space for L1Coordinator"
 				discardedL2Txs = append(discardedL2Txs, l2Txs0[i])
 				continue
 			}
@@ -261,9 +261,7 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 			// not valid Amount with current Balance. Discard L2Tx,
 			// and update Info parameter of the tx, and add it to
 			// the discardedTxs array
-			l2Txs[i].Info = fmt.Sprintf("Tx not selected due to not enough Balance at the sender. "+
-				"Current sender account Balance: %s, Amount+Fee: %s",
-				balance.String(), feeAndAmount.String())
+			l2Txs[i].Info = fmt.Sprintf("Tx not selected due not enough Balance at the sender. Current sender account Balance: %s, Amount+Fee: %s", balance.String(), feeAndAmount.String())
 			discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 			continue
 		}
@@ -275,8 +273,7 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 			// not valid Nonce at tx. Discard L2Tx, and update Info
 			// parameter of the tx, and add it to the discardedTxs
 			// array
-			l2Txs[i].Info = fmt.Sprintf("Tx not selected due to not current Nonce. "+
-				"Tx.Nonce: %d, Account.Nonce: %d", l2Txs[i].Nonce, nonce)
+			l2Txs[i].Info = fmt.Sprintf("Tx not selected due not current Nonce. Tx.Nonce: %d, Account.Nonce: %d", l2Txs[i].Nonce, nonce)
 			discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 			continue
 		}
@@ -294,31 +291,18 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 				txsel.processTxToEthAddrBJJ(validTxs, selectionConfig,
 					len(l1UserTxs), l1CoordinatorTxs, positionL1, l2Txs[i])
 			if err != nil {
-				log.Debugw("txsel.processTxToEthAddrBJJ", "err", err)
+				log.Debug(err)
 				// Discard L2Tx, and update Info parameter of
 				// the tx, and add it to the discardedTxs array
-				l2Txs[i].Info = fmt.Sprintf("Tx not selected (in processTxToEthAddrBJJ) due to %s",
-					err.Error())
+				l2Txs[i].Info = fmt.Sprintf("Tx not selected (in processTxToEthAddrBJJ) due %s", err.Error())
 				discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 				continue
 			}
-			if l1CoordinatorTx != nil {
-				// If ToEthAddr == 0xff.. this means that we
-				// are handling a TransferToBJJ, which doesn't
-				// require an authorization because it doesn't
-				// contain a valid ethereum address.
-				// Otherwise only create the account if we have
-				// the corresponding authorization
-				if validL2Tx.ToEthAddr == common.FFAddr {
-					accAuths = append(accAuths, common.EmptyEthSignature)
-					l1CoordinatorTxs = append(l1CoordinatorTxs, *l1CoordinatorTx)
-					positionL1++
-				} else if accAuth != nil {
+			if accAuth != nil && l1CoordinatorTx != nil {
 				accAuths = append(accAuths, accAuth.Signature)
 				l1CoordinatorTxs = append(l1CoordinatorTxs, *l1CoordinatorTx)
 				positionL1++
 			}
-			}
 			if validL2Tx != nil {
 				validTxs = append(validTxs, *validL2Tx)
 			}
@@ -330,8 +314,8 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 					"ToIdx", l2Txs[i].ToIdx)
 				// Discard L2Tx, and update Info parameter of
 				// the tx, and add it to the discardedTxs array
-				l2Txs[i].Info = fmt.Sprintf("Tx not selected due to tx.ToIdx not found in StateDB. "+
-					"ToIdx: %d", l2Txs[i].ToIdx)
+				l2Txs[i].Info = fmt.Sprintf("Tx not selected due tx.ToIdx not found in StateDB. ToIdx: %d",
+					l2Txs[i].ToIdx)
 				discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 				continue
 			}
@@ -343,9 +327,7 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 					// Discard L2Tx, and update Info
 					// parameter of the tx, and add it to
 					// the discardedTxs array
-					l2Txs[i].Info = fmt.Sprintf("Tx not selected because ToEthAddr "+
-						"does not correspond to the Account.EthAddr. "+
-						"tx.ToIdx: %d, tx.ToEthAddr: %s, account.EthAddr: %s",
+					l2Txs[i].Info = fmt.Sprintf("Tx not selected due ToEthAddr does not correspond to the Account.EthAddr. tx.ToIdx: %d, tx.ToEthAddr: %s, account.EthAddr: %s",
 						l2Txs[i].ToIdx, l2Txs[i].ToEthAddr, receiverAcc.EthAddr)
 					discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 					continue
@@ -359,9 +341,7 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 					// Discard L2Tx, and update Info
 					// parameter of the tx, and add it to
 					// the discardedTxs array
-					l2Txs[i].Info = fmt.Sprintf("Tx not selected because tx.ToBJJ "+
-						"does not correspond to the Account.BJJ. "+
-						"tx.ToIdx: %d, tx.ToEthAddr: %s, tx.ToBJJ: %s, account.BJJ: %s",
+					l2Txs[i].Info = fmt.Sprintf("Tx not selected due tx.ToBJJ does not correspond to the Account.BJJ. tx.ToIdx: %d, tx.ToEthAddr: %s, tx.ToBJJ: %s, account.BJJ: %s",
 						l2Txs[i].ToIdx, l2Txs[i].ToEthAddr, l2Txs[i].ToBJJ, receiverAcc.BJJ)
 					discardedL2Txs = append(discardedL2Txs, l2Txs[i])
 					continue
@@ -435,7 +415,7 @@ func (txsel *TxSelector) GetL1L2TxSelection(selectionConfig *SelectionConfig,
 			log.Error(err)
 			// Discard L2Tx, and update Info parameter of the tx,
 			// and add it to the discardedTxs array
-			selectedL2Txs[i].Info = fmt.Sprintf("Tx not selected (in ProcessL2Tx) due to %s", err.Error())
+			selectedL2Txs[i].Info = fmt.Sprintf("Tx not selected (in ProcessL2Tx) due %s", err.Error())
 			discardedL2Txs = append(discardedL2Txs, selectedL2Txs[i])
 			continue
 		}
@@ -491,7 +471,8 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 
 	var l1CoordinatorTx *common.L1Tx
 	var accAuth *common.AccountCreationAuth
-	if l2Tx.ToEthAddr != common.EmptyAddr && l2Tx.ToEthAddr != common.FFAddr {
+	if !bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.EmptyAddr.Bytes()) &&
+		!bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.FFAddr.Bytes()) {
 		// case: ToEthAddr != 0x00 neither 0xff
 		if l2Tx.ToBJJ != common.EmptyBJJComp {
 			// case: ToBJJ!=0:
@@ -547,7 +528,8 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 			DepositAmount: big.NewInt(0),
 			Type:          common.TxTypeCreateAccountDeposit,
 		}
-	} else if l2Tx.ToEthAddr == common.FFAddr && l2Tx.ToBJJ != common.EmptyBJJComp {
+	} else if bytes.Equal(l2Tx.ToEthAddr.Bytes(), common.FFAddr.Bytes()) &&
+		l2Tx.ToBJJ != common.EmptyBJJComp {
 		// if idx exist for EthAddr&BJJ use it
 		_, err := txsel.localAccountsDB.GetIdxByEthAddrBJJ(l2Tx.ToEthAddr, l2Tx.ToBJJ,
 			l2Tx.TokenID)
@@ -573,8 +555,7 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 	}
 	if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1UserTxs)-nL1UserTxs {
 		// L2Tx discarded
-		return nil, nil, nil, tracerr.Wrap(fmt.Errorf("L2Tx discarded due to no available slots " +
-			"for L1CoordinatorTx to create a new account for receiver of L2Tx"))
+		return nil, nil, nil, tracerr.Wrap(fmt.Errorf("L2Tx discarded due not slots for L1CoordinatorTx to create a new account for receiver of L2Tx"))
 	}
 
 	return &l2Tx, l1CoordinatorTx, accAuth, nil
@@ -583,7 +564,7 @@ func (txsel *TxSelector) processTxToEthAddrBJJ(validTxs []common.PoolL2Tx,
 func checkAlreadyPendingToCreate(l1CoordinatorTxs []common.L1Tx, tokenID common.TokenID,
 	addr ethCommon.Address, bjj babyjub.PublicKeyComp) bool {
 	for i := 0; i < len(l1CoordinatorTxs); i++ {
-		if l1CoordinatorTxs[i].FromEthAddr == addr &&
+		if bytes.Equal(l1CoordinatorTxs[i].FromEthAddr.Bytes(), addr.Bytes()) &&
 			l1CoordinatorTxs[i].TokenID == tokenID &&
 			l1CoordinatorTxs[i].FromBJJ == bjj {
 			return true

txselector/txselector_test.go

@@ -48,7 +48,7 @@ func initTest(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address
 		BJJ:                 coordUser.BJJ.Public().Compress(),
 		AccountCreationAuth: nil,
 	}
-	// fmt.Printf("%v\n", coordAccount)
+	fmt.Printf("%v", coordAccount)
 	auth := common.AccountCreationAuth{
 		EthAddr: coordUser.Addr,
 		BJJ:     coordUser.BJJ.Public().Compress(),
@@ -497,134 +497,3 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
 	require.NoError(t, err)
 }
-
-func TestTransferToBjj(t *testing.T) {
-	set := `
-		Type: Blockchain
-		AddToken(1)
-
-		CreateAccountDeposit(0) Coord: 0
-		CreateAccountDeposit(0) A: 1000
-		CreateAccountDeposit(0) B: 1000
-		CreateAccountDeposit(1) B: 1000
-
-		> batchL1 // freeze L1User{1}
-		> batchL1 // forge L1User{1}
-		> block
-	`
-
-	chainID := uint16(0)
-	tc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
-	blocks, err := tc.GenerateBlocks(set)
-	assert.NoError(t, err)
-
-	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	txsel := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
-
-	// restart nonces of TilContext, as will be set by generating directly
-	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
-	tc.RestartNonces()
-
-	addTokens(t, tc, txsel.l2db.DB())
-
-	tpc := txprocessor.Config{
-		NLevels:  16,
-		MaxFeeTx: 10,
-		MaxTx:    20,
-		MaxL1Tx:  10,
-		ChainID:  chainID,
-	}
-	selectionConfig := &SelectionConfig{
-		MaxL1UserTxs:      5,
-		TxProcessorConfig: tpc,
-	}
-	// batch1 to create some accounts with positive balance
-	l1UserTxs := []common.L1Tx{}
-	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-
-	// Transfer is ToBJJ to a BJJ-only account that doesn't exist
-	// and the coordinator will create it via L1CoordTx.
-
-	batchPoolL2 := `
-	Type: PoolL2
-	PoolTransferToBJJ(0) A-B: 50 (126)
-	`
-	poolL2Txs, err := tc.GeneratePoolL2Txs(batchPoolL2)
-	require.NoError(t, err)
-
-	// add the PoolL2Txs to the l2DB
-	addL2Txs(t, txsel, poolL2Txs)
-
-	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[1].Batch.ForgeL1TxsNum])
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err := txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-	assert.Equal(t, 4, len(oL1UserTxs))
-	// We expect the coordinator to add an L1CoordTx to create an account for the recipient of the l2tx
-	require.Equal(t, 1, len(oL1CoordTxs))
-	assert.Equal(t, poolL2Txs[0].ToEthAddr, oL1CoordTxs[0].FromEthAddr)
-	assert.Equal(t, poolL2Txs[0].ToBJJ, oL1CoordTxs[0].FromBJJ)
-	// fmt.Printf("DBG l1CoordTx[0]: %+v\n", oL1CoordTxs[0])
-	assert.Equal(t, 1, len(oL2Txs))
-	assert.Equal(t, 0, len(discardedL2Txs))
-	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
-	require.NoError(t, err)
-
-	// Now the BJJ-only account for B is already created, so the transfer
-	// happens without an L1CoordTx that creates the user account.
-
-	batchPoolL2 = `
-	Type: PoolL2
-	PoolTransferToBJJ(0) A-B: 50 (126)
-	`
-
-	poolL2Txs, err = tc.GeneratePoolL2Txs(batchPoolL2)
-	require.NoError(t, err)
-	addL2Txs(t, txsel, poolL2Txs)
-
-	l1UserTxs = []common.L1Tx{}
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err = txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(oL1UserTxs))
-	// Since the BJJ-only account B already exists, the coordinator doesn't add any L1CoordTxs
-	assert.Equal(t, 0, len(oL1CoordTxs))
-	assert.Equal(t, 1, len(oL2Txs))
-	assert.Equal(t, 0, len(discardedL2Txs))
-	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
-	require.NoError(t, err)
-
-	// The transfer now is ToBJJ to a BJJ-only account that doesn't exist
-	// and the coordinator will create it via L1CoordTx.   Since it's a
-	// transfer of a token for which the coordinator doesn't have a fee
-	// account, another L1CoordTx will be created for the coordinator to
-	// receive the fees.
-
-	batchPoolL2 = `
-	Type: PoolL2
-	PoolTransferToBJJ(1) B-A: 50 (126)
-	`
-
-	poolL2Txs, err = tc.GeneratePoolL2Txs(batchPoolL2)
-	require.NoError(t, err)
-	addL2Txs(t, txsel, poolL2Txs)
-
-	l1UserTxs = []common.L1Tx{}
-	_, _, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err = txsel.GetL1L2TxSelection(selectionConfig, l1UserTxs)
-	require.NoError(t, err)
-	assert.Equal(t, 0, len(oL1UserTxs))
-	// We expect the coordinator to add an L1CoordTx to create an account
-	// to receive the fees by the coordinator and another one for the
-	// recipient of the l2tx
-	assert.Equal(t, 2, len(oL1CoordTxs))
-	// [0] Coordinator account cration for token 1
-	assert.Equal(t, tc.Users["Coord"].Addr, oL1CoordTxs[0].FromEthAddr)
-	// [1] User A BJJ-only account creation for token 1
-	assert.Equal(t, poolL2Txs[0].ToEthAddr, oL1CoordTxs[1].FromEthAddr)
-	assert.Equal(t, poolL2Txs[0].ToBJJ, oL1CoordTxs[1].FromBJJ)
-	assert.Equal(t, common.TokenID(1), oL1CoordTxs[1].TokenID)
-
-	assert.Equal(t, 1, len(oL2Txs))
-	assert.Equal(t, 0, len(discardedL2Txs))
-	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs), txsel.localAccountsDB.CurrentBatch())
-	require.NoError(t, err)
-}