package til import ( "crypto/ecdsa" "encoding/binary" "fmt" "math/big" "strings" "time" ethCommon "github.com/ethereum/go-ethereum/common" ethCrypto "github.com/ethereum/go-ethereum/crypto" "github.com/hermeznetwork/hermez-node/common" "github.com/hermeznetwork/hermez-node/log" "github.com/hermeznetwork/tracerr" "github.com/iden3/go-iden3-crypto/babyjub" ) func newBatchData(batchNum int) common.BatchData { return common.BatchData{ L1CoordinatorTxs: []common.L1Tx{}, L2Txs: []common.L2Tx{}, Batch: common.Batch{ BatchNum: common.BatchNum(batchNum), StateRoot: big.NewInt(0), ExitRoot: big.NewInt(0), FeeIdxsCoordinator: make([]common.Idx, 0), CollectedFees: make(map[common.TokenID]*big.Int), }, } } func newBlock(blockNum int64) common.BlockData { return common.BlockData{ Block: common.Block{ Num: blockNum, }, Rollup: common.RollupData{ L1UserTxs: []common.L1Tx{}, }, } } type contextExtra struct { openToForge int64 toForgeL1TxsNum int64 nonces map[common.Idx]common.Nonce idx int idxByTxID map[common.TxID]common.Idx } // Context contains the data of the test type Context struct { instructions []Instruction userNames []string Users map[string]*User // Name -> *User UsersByIdx map[int]*User accountsByIdx map[int]*Account LastRegisteredTokenID common.TokenID l1CreatedAccounts map[string]*Account // (Name, TokenID) -> *Account // rollupConstMaxL1UserTx Maximum L1-user transactions allowed to be // queued in a batch rollupConstMaxL1UserTx int chainID uint16 idx int currBlock common.BlockData currBatch common.BatchData currBatchNum int Queues [][]L1Tx ToForgeNum int openToForge int currBatchTest struct { l1CoordinatorTxs []L1Tx l2Txs []L2Tx } blockNum int64 extra contextExtra } // NewContext returns a new Context func NewContext(chainID uint16, rollupConstMaxL1UserTx int) *Context { currBatchNum := 1 // The protocol defines the first batchNum to be 1 return &Context{ Users: make(map[string]*User), l1CreatedAccounts: make(map[string]*Account), UsersByIdx: make(map[int]*User), accountsByIdx: make(map[int]*Account), LastRegisteredTokenID: 0, rollupConstMaxL1UserTx: rollupConstMaxL1UserTx, chainID: chainID, idx: common.UserThreshold, // We use some placeholder values for StateRoot and ExitTree // because these values will never be nil currBlock: newBlock(2), //nolint:gomnd currBatch: newBatchData(currBatchNum), currBatchNum: currBatchNum, // start with 2 queues, one for toForge, and the other for openToForge Queues: make([][]L1Tx, 2), ToForgeNum: 0, openToForge: 1, //nolint:gomnd blockNum: 2, // rollup genesis blockNum extra: contextExtra{ openToForge: 0, toForgeL1TxsNum: 0, nonces: make(map[common.Idx]common.Nonce), idx: common.UserThreshold, idxByTxID: make(map[common.TxID]common.Idx), }, } } // Account contains the data related to the account for a specific TokenID of a User type Account struct { Idx common.Idx TokenID common.TokenID Nonce common.Nonce BatchNum int } // User contains the data related to a testing user type User struct { Name string BJJ *babyjub.PrivateKey EthSk *ecdsa.PrivateKey Addr ethCommon.Address Accounts map[common.TokenID]*Account } // L1Tx is the data structure used internally for transaction test generation, // which contains a common.L1Tx data plus some intermediate data for the // transaction generation. type L1Tx struct { lineNum int fromIdxName string toIdxName string L1Tx common.L1Tx } // L2Tx is the data structure used internally for transaction test generation, // which contains a common.L2Tx data plus some intermediate data for the // transaction generation. type L2Tx struct { lineNum int fromIdxName string toIdxName string tokenID common.TokenID L2Tx common.L2Tx } // GenerateBlocks returns an array of BlockData for a given set made of a // string. It uses the users (keys & nonces) of the Context. func (tc *Context) GenerateBlocks(set string) ([]common.BlockData, error) { parser := newParser(strings.NewReader(set)) parsedSet, err := parser.parse() if err != nil { return nil, tracerr.Wrap(err) } if parsedSet.typ != SetTypeBlockchain { return nil, tracerr.Wrap(fmt.Errorf("Expected set type: %s, found: %s", SetTypeBlockchain, parsedSet.typ)) } tc.instructions = parsedSet.instructions tc.userNames = parsedSet.users return tc.generateBlocks() } // GenerateBlocksFromInstructions returns an array of BlockData for a given set // made of instructions. It uses the users (keys & nonces) of the Context. func (tc *Context) GenerateBlocksFromInstructions(set []Instruction) ([]common.BlockData, error) { userNames := []string{} addedNames := make(map[string]bool) for _, inst := range set { if _, ok := addedNames[inst.From]; !ok { // If the name wasn't already added userNames = append(userNames, inst.From) addedNames[inst.From] = true } if _, ok := addedNames[inst.To]; !ok { // If the name wasn't already added userNames = append(userNames, inst.To) addedNames[inst.To] = true } } tc.userNames = userNames tc.instructions = set return tc.generateBlocks() } func (tc *Context) generateBlocks() ([]common.BlockData, error) { tc.generateKeys(tc.userNames) var blocks []common.BlockData for _, inst := range tc.instructions { switch inst.Typ { case TxTypeCreateAccountDepositCoordinator: // tx source: L1CoordinatorTx if err := tc.checkIfTokenIsRegistered(inst); err != nil { log.Error(err) return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } tx := common.L1Tx{ FromEthAddr: tc.Users[inst.From].Addr, FromBJJ: tc.Users[inst.From].BJJ.Public().Compress(), TokenID: inst.TokenID, Amount: big.NewInt(0), DepositAmount: big.NewInt(0), // as TxTypeCreateAccountDepositCoordinator is // not valid oustide Til package Type: common.TxTypeCreateAccountDeposit, } testTx := L1Tx{ lineNum: inst.LineNum, fromIdxName: inst.From, L1Tx: tx, } tc.currBatchTest.l1CoordinatorTxs = append(tc.currBatchTest.l1CoordinatorTxs, testTx) 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())) } tx := common.L1Tx{ FromEthAddr: tc.Users[inst.From].Addr, FromBJJ: tc.Users[inst.From].BJJ.Public().Compress(), TokenID: inst.TokenID, Amount: big.NewInt(0), DepositAmount: inst.DepositAmount, Type: inst.Typ, } if inst.Typ == common.TxTypeCreateAccountDepositTransfer { tx.Amount = inst.Amount } testTx := L1Tx{ lineNum: inst.LineNum, fromIdxName: inst.From, toIdxName: inst.To, L1Tx: tx, } if err := tc.addToL1UserQueue(testTx); err != nil { return nil, tracerr.Wrap(err) } case common.TxTypeDeposit, common.TxTypeDepositTransfer: // 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())) } if err := tc.checkIfAccountExists(inst.From, inst); err != nil { log.Error(err) return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } tx := common.L1Tx{ TokenID: inst.TokenID, Amount: big.NewInt(0), DepositAmount: inst.DepositAmount, Type: inst.Typ, } if inst.Typ == common.TxTypeDepositTransfer { tx.Amount = inst.Amount } testTx := L1Tx{ lineNum: inst.LineNum, fromIdxName: inst.From, toIdxName: inst.To, L1Tx: tx, } if err := tc.addToL1UserQueue(testTx); err != nil { return nil, tracerr.Wrap(err) } case common.TxTypeTransfer: // L2Tx if err := tc.checkIfTokenIsRegistered(inst); err != nil { log.Error(err) return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } tx := common.L2Tx{ Amount: inst.Amount, Fee: common.FeeSelector(inst.Fee), Type: common.TxTypeTransfer, EthBlockNum: tc.blockNum, } // when converted to PoolL2Tx BatchNum parameter is lost tx.BatchNum = common.BatchNum(tc.currBatchNum) testTx := L2Tx{ lineNum: inst.LineNum, fromIdxName: inst.From, toIdxName: inst.To, tokenID: inst.TokenID, L2Tx: tx, } tc.currBatchTest.l2Txs = append(tc.currBatchTest.l2Txs, testTx) case common.TxTypeForceTransfer: // 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())) } tx := common.L1Tx{ TokenID: inst.TokenID, Amount: inst.Amount, DepositAmount: big.NewInt(0), Type: common.TxTypeForceTransfer, } testTx := L1Tx{ lineNum: inst.LineNum, fromIdxName: inst.From, toIdxName: inst.To, L1Tx: tx, } if err := tc.addToL1UserQueue(testTx); err != nil { return nil, tracerr.Wrap(err) } case common.TxTypeExit: // tx source: L2Tx if err := tc.checkIfTokenIsRegistered(inst); err != nil { log.Error(err) return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } tx := common.L2Tx{ ToIdx: common.Idx(1), // as is an Exit Fee: common.FeeSelector(inst.Fee), Amount: inst.Amount, Type: common.TxTypeExit, EthBlockNum: tc.blockNum, } // when converted to PoolL2Tx BatchNum parameter is lost tx.BatchNum = common.BatchNum(tc.currBatchNum) testTx := L2Tx{ lineNum: inst.LineNum, fromIdxName: inst.From, toIdxName: inst.To, tokenID: inst.TokenID, L2Tx: tx, } tc.currBatchTest.l2Txs = append(tc.currBatchTest.l2Txs, testTx) case common.TxTypeForceExit: // 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())) } tx := common.L1Tx{ ToIdx: common.Idx(1), // as is an Exit TokenID: inst.TokenID, Amount: inst.Amount, DepositAmount: big.NewInt(0), Type: common.TxTypeForceExit, } testTx := L1Tx{ lineNum: inst.LineNum, fromIdxName: inst.From, toIdxName: inst.To, L1Tx: tx, } if err := tc.addToL1UserQueue(testTx); err != nil { return nil, tracerr.Wrap(err) } case TypeNewBatch: if err := tc.calculateIdxForL1Txs(true, tc.currBatchTest.l1CoordinatorTxs); err != nil { return nil, tracerr.Wrap(err) } if err := tc.setIdxs(); err != nil { log.Error(err) return nil, tracerr.Wrap(err) } case TypeNewBatchL1: // for each L1UserTx of the Queues[ToForgeNum], calculate the Idx if err := tc.calculateIdxForL1Txs(false, tc.Queues[tc.ToForgeNum]); err != nil { return nil, tracerr.Wrap(err) } if err := tc.calculateIdxForL1Txs(true, tc.currBatchTest.l1CoordinatorTxs); err != nil { return nil, tracerr.Wrap(err) } tc.currBatch.L1Batch = true if err := tc.setIdxs(); err != nil { return nil, tracerr.Wrap(err) } toForgeL1TxsNum := int64(tc.openToForge) tc.currBatch.Batch.ForgeL1TxsNum = &toForgeL1TxsNum // advance batch tc.ToForgeNum++ if tc.ToForgeNum == tc.openToForge { tc.openToForge++ newQueue := []L1Tx{} tc.Queues = append(tc.Queues, newQueue) } case TypeNewBlock: blocks = append(blocks, tc.currBlock) tc.blockNum++ tc.currBlock = newBlock(tc.blockNum) case TypeAddToken: newToken := common.Token{ EthAddr: ethCommon.BigToAddress(big.NewInt(int64(inst.TokenID * 100))), //nolint:gomnd // Name: fmt.Sprintf("Token %d", inst.TokenID), // Symbol: fmt.Sprintf("TK%d", inst.TokenID), // Decimals: 18, TokenID: inst.TokenID, 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)) } tc.LastRegisteredTokenID++ tc.currBlock.Rollup.AddedTokens = append(tc.currBlock.Rollup.AddedTokens, newToken) default: return nil, tracerr.Wrap(fmt.Errorf("Line %d: Unexpected type: %s", inst.LineNum, inst.Typ)) } } return blocks, nil } // calculateIdxsForL1Txs calculates new Idx for new created accounts. If // 'isCoordinatorTxs==true', adds the tx to tc.currBatch.L1CoordinatorTxs. 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)) } tc.Users[tx.fromIdxName].Accounts[tx.L1Tx.TokenID] = &Account{ Idx: common.Idx(tc.idx), TokenID: tx.L1Tx.TokenID, Nonce: common.Nonce(0), BatchNum: tc.currBatchNum, } 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++ } if isCoordinatorTxs { tc.currBatch.L1CoordinatorTxs = append(tc.currBatch.L1CoordinatorTxs, tx.L1Tx) } } return nil } // setIdxs sets the Idxs to the transactions of the tc.currBatch func (tc *Context) setIdxs() error { // once Idxs are calculated, update transactions to use the new Idxs for i := 0; i < len(tc.currBatchTest.l2Txs); i++ { 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)) } 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)) } } tc.Users[testTx.fromIdxName].Accounts[testTx.tokenID].Nonce++ // next line is commented to avoid Blockchain L2Txs to have // Nonce different from 0, as from Blockchain those // transactions will come without Nonce // testTx.L2Tx.Nonce = tc.Users[testTx.fromIdxName].Accounts[testTx.tokenID].Nonce // set real Idx testTx.L2Tx.FromIdx = tc.Users[testTx.fromIdxName].Accounts[testTx.tokenID].Idx if testTx.L2Tx.Type == common.TxTypeTransfer { testTx.L2Tx.ToIdx = tc.Users[testTx.toIdxName].Accounts[testTx.tokenID].Idx } // in case Type==Exit, ToIdx=1, already set at the // GenerateBlocks main switch inside TxTypeExit case nTx, err := common.NewL2Tx(&testTx.L2Tx) if err != nil { return tracerr.Wrap(fmt.Errorf("Line %d: %s", testTx.lineNum, err.Error())) } testTx.L2Tx = *nTx tc.currBatch.L2Txs = append(tc.currBatch.L2Txs, testTx.L2Tx) } tc.currBatch.Batch.LastIdx = int64(tc.idx - 1) // `-1` because tc.idx is the next available idx tc.currBlock.Rollup.Batches = append(tc.currBlock.Rollup.Batches, tc.currBatch) tc.currBatchNum++ tc.currBatch = newBatchData(tc.currBatchNum) tc.currBatchTest.l1CoordinatorTxs = nil tc.currBatchTest.l2Txs = nil return nil } // addToL1UserQueue adds the L1UserTx into the queue that is open and has space func (tc *Context) addToL1UserQueue(tx L1Tx) error { if len(tc.Queues[tc.openToForge]) >= tc.rollupConstMaxL1UserTx { // if current OpenToForge queue reached its Max, move into a // new queue tc.openToForge++ newQueue := []L1Tx{} tc.Queues = append(tc.Queues, newQueue) } // Fill L1UserTx specific parameters tx.L1Tx.UserOrigin = true toForgeL1TxsNum := int64(tc.openToForge) tx.L1Tx.ToForgeL1TxsNum = &toForgeL1TxsNum tx.L1Tx.EthBlockNum = tc.blockNum 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 { tx.L1Tx.FromIdx = tc.Users[tx.fromIdxName].Accounts[tx.L1Tx.TokenID].Idx } tx.L1Tx.FromEthAddr = tc.Users[tx.fromIdxName].Addr tx.L1Tx.FromBJJ = tc.Users[tx.fromIdxName].BJJ.Public().Compress() if tx.toIdxName == "" { tx.L1Tx.ToIdx = common.Idx(0) } else { account, ok := tc.Users[tx.toIdxName].Accounts[tx.L1Tx.TokenID] if !ok { return tracerr.Wrap(fmt.Errorf("Line %d: Transfer to User: %s, for TokenID: %d, "+ "while account not created yet", tx.lineNum, tx.toIdxName, tx.L1Tx.TokenID)) } tx.L1Tx.ToIdx = account.Idx } if tx.L1Tx.Type == common.TxTypeForceExit { tx.L1Tx.ToIdx = common.Idx(1) } nTx, err := common.NewL1Tx(&tx.L1Tx) if err != nil { return tracerr.Wrap(fmt.Errorf("Line %d: %s", tx.lineNum, err.Error())) } tx.L1Tx = *nTx tc.Queues[tc.openToForge] = append(tc.Queues[tc.openToForge], tx) tc.currBlock.Rollup.L1UserTxs = append(tc.currBlock.Rollup.L1UserTxs, tx.L1Tx) return nil } 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 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 nil } // GeneratePoolL2Txs returns an array of common.PoolL2Tx from a given set made // of a string. It uses the users (keys) of the Context. func (tc *Context) GeneratePoolL2Txs(set string) ([]common.PoolL2Tx, error) { parser := newParser(strings.NewReader(set)) parsedSet, err := parser.parse() if err != nil { return nil, tracerr.Wrap(err) } if parsedSet.typ != SetTypePoolL2 { return nil, tracerr.Wrap(fmt.Errorf("Expected set type: %s, found: %s", SetTypePoolL2, parsedSet.typ)) } tc.instructions = parsedSet.instructions tc.userNames = parsedSet.users return tc.generatePoolL2Txs() } // GeneratePoolL2TxsFromInstructions returns an array of common.PoolL2Tx from a // given set made of instructions. It uses the users (keys) of the Context. func (tc *Context) GeneratePoolL2TxsFromInstructions(set []Instruction) ([]common.PoolL2Tx, error) { userNames := []string{} addedNames := make(map[string]bool) for _, inst := range set { if _, ok := addedNames[inst.From]; !ok { // If the name wasn't already added userNames = append(userNames, inst.From) addedNames[inst.From] = true } if _, ok := addedNames[inst.To]; !ok { // If the name wasn't already added userNames = append(userNames, inst.To) addedNames[inst.To] = true } } tc.userNames = userNames tc.instructions = set return tc.generatePoolL2Txs() } func (tc *Context) generatePoolL2Txs() ([]common.PoolL2Tx, error) { tc.generateKeys(tc.userNames) txs := []common.PoolL2Tx{} for _, inst := range tc.instructions { switch inst.Typ { case common.TxTypeTransfer, common.TxTypeTransferToEthAddr, common.TxTypeTransferToBJJ: if err := tc.checkIfAccountExists(inst.From, inst); err != nil { log.Error(err) return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } if inst.Typ == common.TxTypeTransfer { // if TxTypeTransfer, need to exist the ToIdx account if err := tc.checkIfAccountExists(inst.To, inst); err != nil { log.Error(err) return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } } // if account of receiver does not exist, don't use // ToIdx, and use only ToEthAddr & ToBJJ tx := common.PoolL2Tx{ FromIdx: tc.Users[inst.From].Accounts[inst.TokenID].Idx, TokenID: inst.TokenID, Amount: inst.Amount, Fee: common.FeeSelector(inst.Fee), Nonce: tc.Users[inst.From].Accounts[inst.TokenID].Nonce, State: common.PoolL2TxStatePending, Timestamp: time.Now(), RqToEthAddr: common.EmptyAddr, RqToBJJ: common.EmptyBJJComp, Type: inst.Typ, } tc.Users[inst.From].Accounts[inst.TokenID].Nonce++ if tx.Type == common.TxTypeTransfer { tx.ToIdx = tc.Users[inst.To].Accounts[inst.TokenID].Idx tx.ToEthAddr = tc.Users[inst.To].Addr tx.ToBJJ = tc.Users[inst.To].BJJ.Public().Compress() } else if tx.Type == common.TxTypeTransferToEthAddr { tx.ToIdx = common.Idx(0) tx.ToEthAddr = tc.Users[inst.To].Addr } else if tx.Type == common.TxTypeTransferToBJJ { tx.ToIdx = common.Idx(0) tx.ToEthAddr = common.FFAddr tx.ToBJJ = tc.Users[inst.To].BJJ.Public().Compress() } nTx, err := common.NewPoolL2Tx(&tx) if err != nil { return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } tx = *nTx // perform signature and set it to tx.Signature toSign, err := tx.HashToSign(tc.chainID) if err != nil { return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } sig := tc.Users[inst.From].BJJ.SignPoseidon(toSign) tx.Signature = sig.Compress() txs = append(txs, tx) case common.TxTypeExit: tx := common.PoolL2Tx{ FromIdx: tc.Users[inst.From].Accounts[inst.TokenID].Idx, ToIdx: common.Idx(1), // as is an Exit Fee: common.FeeSelector(inst.Fee), TokenID: inst.TokenID, Amount: inst.Amount, Nonce: tc.Users[inst.From].Accounts[inst.TokenID].Nonce, State: common.PoolL2TxStatePending, Type: common.TxTypeExit, } tc.Users[inst.From].Accounts[inst.TokenID].Nonce++ nTx, err := common.NewPoolL2Tx(&tx) if err != nil { return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } tx = *nTx // perform signature and set it to tx.Signature toSign, err := tx.HashToSign(tc.chainID) if err != nil { return nil, tracerr.Wrap(fmt.Errorf("Line %d: %s", inst.LineNum, err.Error())) } sig := tc.Users[inst.From].BJJ.SignPoseidon(toSign) 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 txs, nil } // RestartNonces sets all the Users.Accounts.Nonces to 0 func (tc *Context) RestartNonces() { for name, user := range tc.Users { for tokenID := range user.Accounts { tc.Users[name].Accounts[tokenID].Nonce = common.Nonce(0) } } } // generateKeys generates BabyJubJub & Address keys for the given list of user // names in a deterministic way. This means, that for the same given // 'userNames' in a certain order, the keys will be always the same. func (tc *Context) generateKeys(userNames []string) { for i := 1; i < len(userNames)+1; i++ { if _, ok := tc.Users[userNames[i-1]]; ok { // account already created continue } // babyjubjub key var sk babyjub.PrivateKey var iBytes [8]byte binary.LittleEndian.PutUint64(iBytes[:], uint64(i)) copy(sk[:], iBytes[:]) // only for testing // eth address var key ecdsa.PrivateKey key.D = big.NewInt(int64(i)) // only for testing key.PublicKey.X, key.PublicKey.Y = ethCrypto.S256().ScalarBaseMult(key.D.Bytes()) key.Curve = ethCrypto.S256() addr := ethCrypto.PubkeyToAddress(key.PublicKey) u := User{ Name: userNames[i-1], BJJ: &sk, EthSk: &key, Addr: addr, Accounts: make(map[common.TokenID]*Account), } tc.Users[userNames[i-1]] = &u } } // L1TxsToCommonL1Txs converts an array of []til.L1Tx to []common.L1Tx func L1TxsToCommonL1Txs(l1 []L1Tx) []common.L1Tx { var r []common.L1Tx for i := 0; i < len(l1); i++ { r = append(r, l1[i].L1Tx) } return r } // ConfigExtra is the configuration used in FillBlocksExtra to extend the // blocks returned by til. type ConfigExtra struct { // Address to set as forger for each batch BootCoordAddr ethCommon.Address // Coordinator user name used to select the corresponding accounts to // collect coordinator fees CoordUser string } // FillBlocksL1UserTxsBatchNum fills the BatchNum of forged L1UserTxs: // - blocks[].Rollup.L1UserTxs[].BatchNum func (tc *Context) FillBlocksL1UserTxsBatchNum(blocks []common.BlockData) { for i := range blocks { block := &blocks[i] for j := range block.Rollup.Batches { batch := &block.Rollup.Batches[j] if batch.L1Batch { // Set BatchNum for forged L1UserTxs to til blocks bn := batch.Batch.BatchNum for k := range blocks { block := &blocks[k] for l := range block.Rollup.L1UserTxs { tx := &block.Rollup.L1UserTxs[l] if *tx.ToForgeL1TxsNum == tc.extra.openToForge { tx.BatchNum = &bn } } } tc.extra.openToForge++ } } } } // FillBlocksForgedL1UserTxs fills the L1UserTxs of a batch with the L1UserTxs // that are forged in that batch. It always sets `EffectiveAmount` = `Amount` // and `EffectiveDepositAmount` = `DepositAmount`. This function requires a // previous call to `FillBlocksExtra`. // - blocks[].Rollup.L1UserTxs[].BatchNum // - blocks[].Rollup.L1UserTxs[].EffectiveAmount // - blocks[].Rollup.L1UserTxs[].EffectiveDepositAmount // - blocks[].Rollup.L1UserTxs[].EffectiveFromIdx func (tc *Context) FillBlocksForgedL1UserTxs(blocks []common.BlockData) error { for i := range blocks { block := &blocks[i] for j := range block.Rollup.Batches { batch := &block.Rollup.Batches[j] if batch.L1Batch { batchNum := batch.Batch.BatchNum queue := tc.Queues[int(*batch.Batch.ForgeL1TxsNum)] batch.L1UserTxs = make([]common.L1Tx, len(queue)) for k := range queue { tx := &batch.L1UserTxs[k] *tx = queue[k].L1Tx tx.EffectiveAmount = tx.Amount tx.EffectiveDepositAmount = tx.DepositAmount tx.BatchNum = &batchNum _tx, err := common.NewL1Tx(tx) if err != nil { return tracerr.Wrap(err) } *tx = *_tx if tx.FromIdx == 0 { tx.EffectiveFromIdx = tc.extra.idxByTxID[tx.TxID] } else { tx.EffectiveFromIdx = tx.FromIdx } } } } } return nil } // FillBlocksExtra fills extra fields not generated by til in each block, so // that the blockData is closer to what the HistoryDB stores. The filled // fields are: // - blocks[].Rollup.Batch.EthBlockNum // - blocks[].Rollup.Batch.ForgerAddr // - blocks[].Rollup.Batch.ForgeL1TxsNum // - blocks[].Rollup.Batch.L1CoordinatorTxs[].TxID // - blocks[].Rollup.Batch.L1CoordinatorTxs[].BatchNum // - blocks[].Rollup.Batch.L1CoordinatorTxs[].EthBlockNum // - blocks[].Rollup.Batch.L1CoordinatorTxs[].Position // - blocks[].Rollup.Batch.L1CoordinatorTxs[].EffectiveAmount // - blocks[].Rollup.Batch.L1CoordinatorTxs[].EffectiveDepositAmount // - blocks[].Rollup.Batch.L1CoordinatorTxs[].EffectiveFromIdx // - blocks[].Rollup.Batch.L2Txs[].TxID // - blocks[].Rollup.Batch.L2Txs[].Position // - blocks[].Rollup.Batch.L2Txs[].Nonce // - blocks[].Rollup.Batch.L2Txs[].TokenID // - blocks[].Rollup.Batch.ExitTree // - blocks[].Rollup.Batch.CreatedAccounts // - blocks[].Rollup.Batch.FeeIdxCoordinator // - blocks[].Rollup.Batch.CollectedFees func (tc *Context) FillBlocksExtra(blocks []common.BlockData, cfg *ConfigExtra) error { // Fill extra fields not generated by til in til block for i := range blocks { block := &blocks[i] for j := range block.Rollup.Batches { batch := &block.Rollup.Batches[j] batch.Batch.EthBlockNum = block.Block.Num // til doesn't fill the batch forger addr batch.Batch.ForgerAddr = cfg.BootCoordAddr if batch.L1Batch { toForgeL1TxsNumCpy := tc.extra.toForgeL1TxsNum // til doesn't fill the ForgeL1TxsNum batch.Batch.ForgeL1TxsNum = &toForgeL1TxsNumCpy tc.extra.toForgeL1TxsNum++ } batchNum := batch.Batch.BatchNum for k := range batch.L1CoordinatorTxs { tx := &batch.L1CoordinatorTxs[k] tx.BatchNum = &batchNum tx.EthBlockNum = batch.Batch.EthBlockNum } } } // Fill CreatedAccounts for i := range blocks { block := &blocks[i] for j := range block.Rollup.Batches { batch := &block.Rollup.Batches[j] l1Txs := []*common.L1Tx{} if batch.L1Batch { for k := range tc.Queues[*batch.Batch.ForgeL1TxsNum] { l1Txs = append(l1Txs, &tc.Queues[*batch.Batch.ForgeL1TxsNum][k].L1Tx) } } for k := range batch.L1CoordinatorTxs { l1Txs = append(l1Txs, &batch.L1CoordinatorTxs[k]) } for k := range l1Txs { tx := l1Txs[k] if tx.Type == common.TxTypeCreateAccountDeposit || tx.Type == common.TxTypeCreateAccountDepositTransfer { user, ok := tc.UsersByIdx[tc.extra.idx] if !ok { return tracerr.Wrap(fmt.Errorf("Created account with idx: %v not found", tc.extra.idx)) } batch.CreatedAccounts = append(batch.CreatedAccounts, common.Account{ Idx: common.Idx(tc.extra.idx), TokenID: tx.TokenID, BatchNum: batch.Batch.BatchNum, BJJ: user.BJJ.Public().Compress(), EthAddr: user.Addr, Nonce: 0, Balance: big.NewInt(0), }) if !tx.UserOrigin { tx.EffectiveFromIdx = common.Idx(tc.extra.idx) } tc.extra.idxByTxID[tx.TxID] = common.Idx(tc.extra.idx) tc.extra.idx++ } } } } // Fill expected positions in L1CoordinatorTxs and L2Txs for i := range blocks { block := &blocks[i] for j := range block.Rollup.Batches { batch := &block.Rollup.Batches[j] position := 0 if batch.L1Batch { position = len(tc.Queues[*batch.Batch.ForgeL1TxsNum]) } for k := range batch.L1CoordinatorTxs { tx := &batch.L1CoordinatorTxs[k] tx.Position = position position++ tx.EffectiveAmount = big.NewInt(0) tx.EffectiveDepositAmount = big.NewInt(0) nTx, err := common.NewL1Tx(tx) if err != nil { return tracerr.Wrap(err) } *tx = *nTx } for k := range batch.L2Txs { tx := &batch.L2Txs[k] tx.Position = position position++ tx.Nonce = tc.extra.nonces[tx.FromIdx] tx.TokenID = tc.accountsByIdx[int(tx.FromIdx)].TokenID tc.extra.nonces[tx.FromIdx]++ if err := tx.SetID(); err != nil { return tracerr.Wrap(err) } nTx, err := common.NewL2Tx(tx) if err != nil { return tracerr.Wrap(err) } *tx = *nTx } } } // Fill ExitTree (only AccountIdx and Balance) for i := range blocks { block := &blocks[i] for j := range block.Rollup.Batches { batch := &block.Rollup.Batches[j] if batch.L1Batch { for _, _tx := range tc.Queues[*batch.Batch.ForgeL1TxsNum] { tx := _tx.L1Tx if tx.Type == common.TxTypeForceExit { batch.ExitTree = append(batch.ExitTree, common.ExitInfo{ BatchNum: batch.Batch.BatchNum, AccountIdx: tx.FromIdx, Balance: tx.Amount, }) } } } for k := range batch.L2Txs { tx := &batch.L2Txs[k] if tx.Type == common.TxTypeExit { batch.ExitTree = append(batch.ExitTree, common.ExitInfo{ BatchNum: batch.Batch.BatchNum, AccountIdx: tx.FromIdx, Balance: tx.Amount, }) } fee, err := common.CalcFeeAmount(tx.Amount, tx.Fee) if err != nil { return tracerr.Wrap(err) } // Find the TokenID of the tx fromAcc, ok := tc.accountsByIdx[int(tx.FromIdx)] if !ok { return tracerr.Wrap(fmt.Errorf("L2tx.FromIdx idx: %v not found", tx.FromIdx)) } // Find the idx of the CoordUser for the // TokenID, and if it exists, add the fee to // the collectedFees. Only consider the // coordinator account to receive fee if it was // created in this or a previous batch if acc, ok := tc.l1CreatedAccounts[idxTokenIDToString(cfg.CoordUser, fromAcc.TokenID)]; ok && common.BatchNum(acc.BatchNum) <= batch.Batch.BatchNum { found := false for _, idx := range batch.Batch.FeeIdxsCoordinator { if idx == common.Idx(acc.Idx) { found = true break } } if !found { batch.Batch.FeeIdxsCoordinator = append(batch.Batch.FeeIdxsCoordinator, common.Idx(acc.Idx)) batch.Batch.CollectedFees[fromAcc.TokenID] = big.NewInt(0) } collected := batch.Batch.CollectedFees[fromAcc.TokenID] collected.Add(collected, fee) } } } } return nil }