package eth import ( "context" "crypto/ecdsa" "encoding/binary" "encoding/hex" "math/big" "testing" ethCommon "github.com/ethereum/go-ethereum/common" ethCrypto "github.com/ethereum/go-ethereum/crypto" "github.com/hermeznetwork/hermez-node/common" "github.com/iden3/go-iden3-crypto/babyjub" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var rollupClient *RollupClient var auctionClient *AuctionClient var ethHashForge ethCommon.Hash var argsForge *RollupForgeBatchArgs var absoluteMaxL1L2BatchTimeout = int64(240) var maxTx = int64(512) var nLevels = int64(32) var tokenIDERC777 uint32 var tokenHEZID uint32 var L1UserTxs []common.L1Tx var blockStampBucket int64 type keys struct { BJJSecretKey *babyjub.PrivateKey BJJPublicKey *babyjub.PublicKey Addr ethCommon.Address } func genKeysBjj(i int64) *keys { i++ // i = 0 doesn't work for the ecdsa key generation var sk babyjub.PrivateKey binary.LittleEndian.PutUint64(sk[:], uint64(i)) // eth address var key ecdsa.PrivateKey key.D = big.NewInt(i) // only for testing key.PublicKey.X, key.PublicKey.Y = ethCrypto.S256().ScalarBaseMult(key.D.Bytes()) key.Curve = ethCrypto.S256() return &keys{ BJJSecretKey: &sk, BJJPublicKey: sk.Public(), } } func TestRollupEventInit(t *testing.T) { rollupInit, blockNum, err := rollupClient.RollupEventInit() require.NoError(t, err) assert.Equal(t, int64(19), blockNum) assert.Equal(t, uint8(10), rollupInit.ForgeL1L2BatchTimeout) assert.Equal(t, big.NewInt(10), rollupInit.FeeAddToken) assert.Equal(t, uint64(60*60*24*7*2), rollupInit.WithdrawalDelay) } func TestRollupConstants(t *testing.T) { rollupConstants, err := rollupClient.RollupConstants() require.NoError(t, err) assert.Equal(t, absoluteMaxL1L2BatchTimeout, rollupConstants.AbsoluteMaxL1L2BatchTimeout) assert.Equal(t, auctionAddressConst, rollupConstants.HermezAuctionContract) assert.Equal(t, tokenHEZAddressConst, rollupConstants.TokenHEZ) assert.Equal(t, maxTx, rollupConstants.Verifiers[0].MaxTx) assert.Equal(t, nLevels, rollupConstants.Verifiers[0].NLevels) assert.Equal(t, governanceAddressConst, rollupConstants.HermezGovernanceAddress) assert.Equal(t, wdelayerAddressConst, rollupConstants.WithdrawDelayerContract) } func TestRollupRegisterTokensCount(t *testing.T) { registerTokensCount, err := rollupClient.RollupRegisterTokensCount() require.NoError(t, err) assert.Equal(t, big.NewInt(1), registerTokensCount) } func TestRollupAddToken(t *testing.T) { feeAddToken := big.NewInt(10) // Addtoken ERC20Permit registerTokensCount, err := rollupClient.RollupRegisterTokensCount() require.NoError(t, err) _, err = rollupClient.RollupAddToken(tokenHEZAddressConst, feeAddToken, deadline) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, tokenHEZAddressConst, rollupEvents.AddToken[0].TokenAddress) assert.Equal(t, registerTokensCount, common.TokenID(rollupEvents.AddToken[0].TokenID).BigInt()) tokenHEZID = rollupEvents.AddToken[0].TokenID } func TestRollupForgeBatch(t *testing.T) { chainid, _ := auctionClient.client.Client().ChainID(context.Background()) // Register Coordinator forgerAddress := governanceAddressConst _, err := auctionClient.AuctionSetCoordinator(forgerAddress, URL) require.NoError(t, err) // MultiBid currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber() require.NoError(t, err) slotSet := [6]bool{true, false, true, false, true, false} maxBid := new(big.Int) maxBid.SetString("15000000000000000000", 10) minBid := new(big.Int) minBid.SetString("11000000000000000000", 10) budget := new(big.Int) budget.SetString("45200000000000000000", 10) _, err = auctionClient.AuctionMultiBid(budget, currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, deadline) require.NoError(t, err) // Add Blocks blockNum := int64(int(blocksPerSlot)*int(currentSlot+4) + int(genesisBlock)) currentBlockNum, err := auctionClient.client.EthLastBlock() require.NoError(t, err) blocksToAdd := blockNum - currentBlockNum addBlocks(blocksToAdd, ethClientDialURL) // Forge Batch 1 args := new(RollupForgeBatchArgs) args.FeeIdxCoordinator = []common.Idx{} // When encoded, 64 times the 0 idx means that no idx to collect fees is specified. l1CoordinatorBytes, err := hex.DecodeString("1c660323607bb113e586183609964a333d07ebe4bef3be82ec13af453bae9590bd7711cdb6abf42f176eadfbe5506fbef5e092e5543733f91b0061d9a7747fa10694a915a6470fa230de387b51e6f4db0b09787867778687b55197ad6d6a86eac000000001") require.NoError(t, err) numTxsL1 := len(l1CoordinatorBytes) / common.L1CoordinatorTxBytesLen for i := 0; i < numTxsL1; i++ { bytesL1Coordinator := l1CoordinatorBytes[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen] var signature []byte v := bytesL1Coordinator[0] s := bytesL1Coordinator[1:33] r := bytesL1Coordinator[33:65] signature = append(signature, r[:]...) signature = append(signature, s[:]...) signature = append(signature, v) l1Tx, err := common.L1CoordinatorTxFromBytes(bytesL1Coordinator, chainid, rollupClient.address) require.NoError(t, err) args.L1CoordinatorTxs = append(args.L1CoordinatorTxs, *l1Tx) args.L1CoordinatorTxsAuths = append(args.L1CoordinatorTxsAuths, signature) } args.L1UserTxs = []common.L1Tx{} args.L2TxsData = []common.L2Tx{} newStateRoot := new(big.Int) newStateRoot.SetString("18317824016047294649053625209337295956588174734569560016974612130063629505228", 10) newExitRoot := new(big.Int) bytesNumExitRoot, err := hex.DecodeString("10a89d5fe8d488eda1ba371d633515739933c706c210c604f5bd209180daa43b") require.NoError(t, err) newExitRoot.SetBytes(bytesNumExitRoot) args.NewLastIdx = int64(300) args.NewStRoot = newStateRoot args.NewExitRoot = newExitRoot args.L1Batch = true args.VerifierIdx = 0 args.ProofA[0] = big.NewInt(0) args.ProofA[1] = big.NewInt(0) args.ProofB[0][0] = big.NewInt(0) args.ProofB[0][1] = big.NewInt(0) args.ProofB[1][0] = big.NewInt(0) args.ProofB[1][1] = big.NewInt(0) args.ProofC[0] = big.NewInt(0) args.ProofC[1] = big.NewInt(0) argsForge = args _, err = rollupClient.RollupForgeBatch(argsForge) require.NoError(t, err) currentBlockNum, err = rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, int64(1), rollupEvents.ForgeBatch[0].BatchNum) assert.Equal(t, uint16(len(L1UserTxs)), rollupEvents.ForgeBatch[0].L1UserTxsLen) ethHashForge = rollupEvents.ForgeBatch[0].EthTxHash } func TestRollupForgeBatchArgs(t *testing.T) { args, sender, err := rollupClient.RollupForgeBatchArgs(ethHashForge, uint16(len(L1UserTxs))) require.NoError(t, err) assert.Equal(t, *sender, rollupClient.client.account.Address) assert.Equal(t, argsForge.FeeIdxCoordinator, args.FeeIdxCoordinator) assert.Equal(t, argsForge.L1Batch, args.L1Batch) assert.Equal(t, argsForge.L1CoordinatorTxs, args.L1CoordinatorTxs) assert.Equal(t, argsForge.L1CoordinatorTxsAuths, args.L1CoordinatorTxsAuths) assert.Equal(t, argsForge.L2TxsData, args.L2TxsData) assert.Equal(t, argsForge.NewLastIdx, args.NewLastIdx) assert.Equal(t, argsForge.NewStRoot, args.NewStRoot) assert.Equal(t, argsForge.VerifierIdx, args.VerifierIdx) } func TestRollupUpdateForgeL1L2BatchTimeout(t *testing.T) { newForgeL1L2BatchTimeout := int64(222) _, err := rollupClient.RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, newForgeL1L2BatchTimeout, rollupEvents.UpdateForgeL1L2BatchTimeout[0].NewForgeL1L2BatchTimeout) } func TestRollupUpdateFeeAddToken(t *testing.T) { newFeeAddToken := big.NewInt(12) _, err := rollupClient.RollupUpdateFeeAddToken(newFeeAddToken) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, newFeeAddToken, rollupEvents.UpdateFeeAddToken[0].NewFeeAddToken) } func TestRollupUpdateBucketsParameters(t *testing.T) { var bucketsParameters [common.RollupConstNumBuckets]RollupUpdateBucketsParameters for i := range bucketsParameters { bucketsParameters[i].CeilUSD = big.NewInt(int64((i + 1) * 100)) bucketsParameters[i].Withdrawals = big.NewInt(int64(i + 1)) bucketsParameters[i].BlockWithdrawalRate = big.NewInt(int64(i+1) * 100) bucketsParameters[i].MaxWithdrawals = big.NewInt(int64(100000000000)) } _, err := rollupClient.RollupUpdateBucketsParameters(bucketsParameters) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) blockStampBucket = currentBlockNum rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, bucketsParameters, rollupEvents.UpdateBucketsParameters[0].ArrayBuckets) } func TestRollupUpdateWithdrawalDelay(t *testing.T) { newWithdrawalDelay := int64(100000) _, err := rollupClient.RollupUpdateWithdrawalDelay(newWithdrawalDelay) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, newWithdrawalDelay, int64(rollupEvents.UpdateWithdrawalDelay[0].NewWithdrawalDelay)) } func TestRollupUpdateTokenExchange(t *testing.T) { var addressArray []ethCommon.Address var valueArray []uint64 addressToken1, err := rollupClient.hermez.TokenList(nil, big.NewInt(1)) addressArray = append(addressArray, addressToken1) tokenPrice := 10 valueArray = append(valueArray, uint64(tokenPrice*1e14)) require.NoError(t, err) _, err = rollupClient.RollupUpdateTokenExchange(addressArray, valueArray) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, addressArray, rollupEvents.UpdateTokenExchange[0].AddressArray) assert.Equal(t, valueArray, rollupEvents.UpdateTokenExchange[0].ValueArray) } func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) key := genKeysBjj(2) fromIdxInt64 := int64(0) toIdxInt64 := int64(0) tokenIDUint32 := uint32(0) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) l1Tx := common.L1Tx{ FromBJJ: key.BJJPublicKey, FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenIDUint32), Amount: big.NewInt(0), } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) key := genKeysBjj(1) fromIdxInt64 := int64(0) toIdxInt64 := int64(0) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) l1Tx := common.L1Tx{ FromBJJ: key.BJJPublicKey, FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenHEZID), Amount: big.NewInt(0), } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) key := genKeysBjj(3) fromIdxInt64 := int64(0) toIdxInt64 := int64(0) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) l1Tx := common.L1Tx{ FromBJJ: key.BJJPublicKey, FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenIDERC777), Amount: big.NewInt(0), } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxETHDeposit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(0) tokenIDUint32 := uint32(0) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) l1Tx := common.L1Tx{ FromBJJ: nil, FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenIDUint32), Amount: big.NewInt(0), } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20Deposit(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(0) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) l1Tx := common.L1Tx{ FromBJJ: nil, FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenHEZID), Amount: big.NewInt(0), } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(258) toIdxInt64 := int64(0) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenIDERC777), Amount: big.NewInt(0), } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxETHDepositTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(257) tokenIDUint32 := uint32(0) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) amount, _ := new(big.Int).SetString("100000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenIDUint32), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(258) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) amount, _ := new(big.Int).SetString("100000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenHEZID), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(258) toIdxInt64 := int64(259) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) amount, _ := new(big.Int).SetString("100000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenIDERC777), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(257) tokenIDUint32 := uint32(0) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) amount, _ := new(big.Int).SetString("20000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenIDUint32), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(258) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) amount, _ := new(big.Int).SetString("30000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenHEZID), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(258) toIdxInt64 := int64(259) depositAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) amount, _ := new(big.Int).SetString("40000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: depositAmount, TokenID: common.TokenID(tokenIDERC777), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxETHForceTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(257) tokenIDUint32 := uint32(0) amount, _ := new(big.Int).SetString("20000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: big.NewInt(0), TokenID: common.TokenID(tokenIDUint32), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(258) amount, _ := new(big.Int).SetString("10000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: big.NewInt(0), TokenID: common.TokenID(tokenHEZID), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(259) toIdxInt64 := int64(260) amount, _ := new(big.Int).SetString("30000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: big.NewInt(0), TokenID: common.TokenID(tokenIDERC777), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxETHForceExit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(1) tokenIDUint32 := uint32(0) amount, _ := new(big.Int).SetString("10000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: big.NewInt(0), TokenID: common.TokenID(tokenIDUint32), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20ForceExit(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(1) amount, _ := new(big.Int).SetString("20000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: big.NewInt(0), TokenID: common.TokenID(tokenHEZID), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) fromIdxInt64 := int64(258) toIdxInt64 := int64(1) fromIdx := new(common.Idx) *fromIdx = 0 amount, _ := new(big.Int).SetString("30000000000000000000", 10) l1Tx := common.L1Tx{ FromIdx: common.Idx(fromIdxInt64), ToIdx: common.Idx(toIdxInt64), DepositAmount: big.NewInt(0), TokenID: common.TokenID(tokenIDERC777), Amount: amount, } L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.DepositAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.DepositAmount, rollupEvents.L1UserTx[0].L1UserTx.DepositAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount) assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr) } func TestRollupForgeBatch2(t *testing.T) { // Forge Batch 2 _, err := rollupClient.RollupForgeBatch(argsForge) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, int64(2), rollupEvents.ForgeBatch[0].BatchNum) // Forge Batch 3 args := new(RollupForgeBatchArgs) args.FeeIdxCoordinator = []common.Idx{} // When encoded, 64 times the 0 idx means that no idx to collect fees is specified. args.L1CoordinatorTxs = argsForge.L1CoordinatorTxs args.L1CoordinatorTxsAuths = argsForge.L1CoordinatorTxsAuths for i := 0; i < len(L1UserTxs); i++ { l1UserTx := L1UserTxs[i] l1UserTx.EffectiveAmount = l1UserTx.Amount l1Bytes, err := l1UserTx.BytesDataAvailability(uint32(nLevels)) require.NoError(t, err) l1UserTxDataAvailability, err := common.L1TxFromDataAvailability(l1Bytes, uint32(nLevels)) require.NoError(t, err) args.L1UserTxs = append(args.L1UserTxs, *l1UserTxDataAvailability) } newStateRoot := new(big.Int) newStateRoot.SetString("18317824016047294649053625209337295956588174734569560016974612130063629505228", 10) newExitRoot := new(big.Int) newExitRoot.SetString("1114281409737474688393837964161044726766678436313681099613347372031079422302", 10) amount := new(big.Int) amount.SetString("79000000", 10) l2Tx := common.L2Tx{ ToIdx: 256, Amount: amount, FromIdx: 257, Fee: 201, } l2Txs := []common.L2Tx{} l2Txs = append(l2Txs, l2Tx) l2Txs = append(l2Txs, l2Tx) args.L2TxsData = l2Txs args.NewLastIdx = int64(1000) args.NewStRoot = newStateRoot args.NewExitRoot = newExitRoot args.L1Batch = true args.VerifierIdx = 0 args.ProofA[0] = big.NewInt(0) args.ProofA[1] = big.NewInt(0) args.ProofB[0] = [2]*big.Int{big.NewInt(0), big.NewInt(0)} args.ProofB[1] = [2]*big.Int{big.NewInt(0), big.NewInt(0)} args.ProofC[0] = big.NewInt(0) args.ProofC[1] = big.NewInt(0) argsForge = args _, err = rollupClient.RollupForgeBatch(argsForge) require.NoError(t, err) currentBlockNum, err = rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err = rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, int64(3), rollupEvents.ForgeBatch[0].BatchNum) assert.Equal(t, uint16(len(L1UserTxs)), rollupEvents.ForgeBatch[0].L1UserTxsLen) ethHashForge = rollupEvents.ForgeBatch[0].EthTxHash } func TestRollupForgeBatchArgs2(t *testing.T) { args, sender, err := rollupClient.RollupForgeBatchArgs(ethHashForge, uint16(len(L1UserTxs))) require.NoError(t, err) assert.Equal(t, *sender, rollupClient.client.account.Address) assert.Equal(t, argsForge.FeeIdxCoordinator, args.FeeIdxCoordinator) assert.Equal(t, argsForge.L1Batch, args.L1Batch) assert.Equal(t, argsForge.L1UserTxs, args.L1UserTxs) assert.Equal(t, argsForge.L1CoordinatorTxs, args.L1CoordinatorTxs) assert.Equal(t, argsForge.L1CoordinatorTxsAuths, args.L1CoordinatorTxsAuths) assert.Equal(t, argsForge.L2TxsData, args.L2TxsData) assert.Equal(t, argsForge.NewLastIdx, args.NewLastIdx) assert.Equal(t, argsForge.NewStRoot, args.NewStRoot) assert.Equal(t, argsForge.VerifierIdx, args.VerifierIdx) } func TestRollupWithdrawMerkleProof(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) require.NoError(t, err) var pkComp babyjub.PublicKeyComp pkCompBE, err := hex.DecodeString("adc3b754f8da621967b073a787bef8eec7052f2ba712b23af57d98f65beea8b2") require.NoError(t, err) pkCompLE := common.SwapEndianness(pkCompBE) copy(pkComp[:], pkCompLE) pk, err := pkComp.Decompress() require.NoError(t, err) require.NoError(t, err) tokenID := uint32(tokenHEZID) numExitRoot := int64(3) fromIdx := int64(256) amount, _ := new(big.Int).SetString("20000000000000000000", 10) // siblingBytes0, err := new(big.Int).SetString("19508838618377323910556678335932426220272947530531646682154552299216398748115", 10) // require.NoError(t, err) // siblingBytes1, err := new(big.Int).SetString("15198806719713909654457742294233381653226080862567104272457668857208564789571", 10) // require.NoError(t, err) var siblings []*big.Int // siblings = append(siblings, siblingBytes0) // siblings = append(siblings, siblingBytes1) instantWithdraw := true _, err = rollupClientAux.RollupWithdrawMerkleProof(pk, tokenID, numExitRoot, fromIdx, amount, siblings, instantWithdraw) require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) assert.Equal(t, uint64(fromIdx), rollupEvents.Withdraw[0].Idx) assert.Equal(t, instantWithdraw, rollupEvents.Withdraw[0].InstantWithdraw) assert.Equal(t, uint64(numExitRoot), rollupEvents.Withdraw[0].NumExitRoot) // tokenAmount = 20 // amountUSD = tokenAmount * tokenPrice = 20 * 10 = 200 // Bucket[0].ceilUSD = 100, Bucket[1].ceilUSD = 200, ... // Bucket 1 // Bucket[0].withdrawals = 1, Bucket[1].withdrawals = 2, ... // Bucket[1].withdrawals - 1 = 1 assert.Equal(t, 1, rollupEvents.UpdateBucketWithdraw[0].NumBucket) assert.Equal(t, blockStampBucket, rollupEvents.UpdateBucketWithdraw[0].BlockStamp) assert.Equal(t, big.NewInt(1), rollupEvents.UpdateBucketWithdraw[0].Withdrawals) } func TestRollupSafeMode(t *testing.T) { _, err := rollupClient.RollupSafeMode() require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) require.NoError(t, err) auxEvent := new(RollupEventSafeMode) assert.Equal(t, auxEvent, &rollupEvents.SafeMode[0]) }