diff --git a/common/ethauction.go b/common/ethauction.go index 7692348..e369101 100644 --- a/common/ethauction.go +++ b/common/ethauction.go @@ -58,6 +58,8 @@ type AuctionVariables struct { DonationAddress ethCommon.Address `json:"donationAddress" meddler:"donation_address" validate:"required"` // Boot Coordinator Address BootCoordinator ethCommon.Address `json:"bootCoordinator" meddler:"boot_coordinator" validate:"required"` + // Boot Coordinator URL + BootCoordinatorURL string `json:"bootCoordinatorUrl" meddler:"boot_coordinator_url" validate:"required"` // The minimum bid value in a series of 6 slots DefaultSlotSetBid [6]*big.Int `json:"defaultSlotSetBid" meddler:"default_slot_set_bid,json" validate:"required"` // SlotNum at which the new default_slot_set_bid applies diff --git a/common/ethwdelayer.go b/common/ethwdelayer.go index 3a3b5e2..89d9326 100644 --- a/common/ethwdelayer.go +++ b/common/ethwdelayer.go @@ -16,8 +16,8 @@ type WDelayerConstants struct { type WDelayerVariables struct { EthBlockNum int64 `json:"ethereumBlockNum" meddler:"eth_block_num"` // HermezRollupAddress ethCommon.Address `json:"hermezRollupAddress" meddler:"rollup_address"` - HermezGovernanceAddress ethCommon.Address `json:"hermezGovernanceAddress" meddler:"govdao_address" validate:"required"` - EmergencyCouncilAddress ethCommon.Address `json:"whiteHackGroupAddress" meddler:"whg_address" validate:"required"` + HermezGovernanceAddress ethCommon.Address `json:"hermezGovernanceAddress" meddler:"gov_address" validate:"required"` + EmergencyCouncilAddress ethCommon.Address `json:"emergencyCouncilAddress" meddler:"emg_address" validate:"required"` WithdrawalDelay uint64 `json:"withdrawalDelay" meddler:"withdrawal_delay" validate:"required"` EmergencyModeStartingTime uint64 `json:"emergencyModeStartingTime" meddler:"emergency_start_time"` EmergencyMode bool `json:"emergencyMode" meddler:"emergency_mode"` diff --git a/common/l1tx_test.go b/common/l1tx_test.go index 64d55e7..359282f 100644 --- a/common/l1tx_test.go +++ b/common/l1tx_test.go @@ -96,6 +96,7 @@ func TestL1TxFromDataAvailability(t *testing.T) { txCompressedData, err := tx.BytesDataAvailability(32) assert.Nil(t, err) l1tx, err := L1TxFromDataAvailability(txCompressedData, 32) + require.NoError(t, err) assert.Equal(t, tx.FromIdx, l1tx.FromIdx) assert.Equal(t, tx.ToIdx, l1tx.ToIdx) @@ -107,6 +108,7 @@ func TestL1TxFromDataAvailability(t *testing.T) { txCompressedData, err = tx.BytesDataAvailability(32) assert.Nil(t, err) l1tx, err = L1TxFromDataAvailability(txCompressedData, 32) + require.NoError(t, err) assert.Equal(t, tx.FromIdx, l1tx.FromIdx) assert.Equal(t, tx.ToIdx, l1tx.ToIdx) assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount) diff --git a/db/historydb/historydb_test.go b/db/historydb/historydb_test.go index eb5495e..7246ef8 100644 --- a/db/historydb/historydb_test.go +++ b/db/historydb/historydb_test.go @@ -654,6 +654,7 @@ func exampleInitSCVars() (*common.RollupVariables, *common.AuctionVariables, *co 0, ethCommon.BigToAddress(big.NewInt(2)), ethCommon.BigToAddress(big.NewInt(3)), + "https://boot.coord.com", [6]*big.Int{ big.NewInt(1), big.NewInt(2), big.NewInt(3), big.NewInt(4), big.NewInt(5), big.NewInt(6), @@ -670,7 +671,6 @@ func exampleInitSCVars() (*common.RollupVariables, *common.AuctionVariables, *co 0, ethCommon.BigToAddress(big.NewInt(2)), ethCommon.BigToAddress(big.NewInt(3)), - ethCommon.BigToAddress(big.NewInt(4)), 13, 14, false, diff --git a/db/migrations/0001.sql b/db/migrations/0001.sql index 0ad25b6..bcbd114 100644 --- a/db/migrations/0001.sql +++ b/db/migrations/0001.sql @@ -537,6 +537,7 @@ CREATE TABLE auction_vars ( eth_block_num BIGINT PRIMARY KEY REFERENCES block (eth_block_num) ON DELETE CASCADE, donation_address BYTEA NOT NULL, boot_coordinator BYTEA NOT NULL, + boot_coordinator_url BYTEA NOT NULL, default_slot_set_bid BYTEA NOT NULL, default_slot_set_bid_slot_num BIGINT NOT NULL, -- slot_num after which the new default_slot_set_bid applies closed_auction_slots INT NOT NULL, @@ -548,9 +549,8 @@ CREATE TABLE auction_vars ( CREATE TABLE wdelayer_vars ( eth_block_num BIGINT PRIMARY KEY REFERENCES block (eth_block_num) ON DELETE CASCADE, - govdao_address BYTEA NOT NULL, - whg_address BYTEA NOT NULL, - keeper_address BYTEA NOT NULL, + gov_address BYTEA NOT NULL, + emg_address BYTEA NOT NULL, withdrawal_delay BIGINT NOT NULL, emergency_start_time BIGINT NOT NULL, emergency_mode BOOLEAN NOT NULL diff --git a/eth/README.md b/eth/README.md index f9f345f..850d084 100644 --- a/eth/README.md +++ b/eth/README.md @@ -8,7 +8,7 @@ The first step is to clone the github repository where the contracts are located While the prepared deployment is not found to master, branch in repository must be changed: -`git checkout feature/newDeploymentScript-eth` (tested with commit `f3b627d2145a029fd967f05c1fd32f23d614ec8e`) +`git checkout feature/newDeploymentScript-eth` (tested with commit `6335252b073dc59afafc45040dae8630c72ecdf3`) Now, install the dependencies: diff --git a/eth/rollup.go b/eth/rollup.go index 4506c44..f913bfd 100644 --- a/eth/rollup.go +++ b/eth/rollup.go @@ -59,7 +59,7 @@ type RollupEventL1UserTx struct { } // RollupEventL1UserTxAux is an event of the Rollup Smart Contract -type RollupEventL1UserTxAux struct { +type rollupEventL1UserTxAux struct { ToForgeL1TxsNum uint64 // QueueIndex *big.Int Position uint8 // TransactionIndex *big.Int L1UserTx []byte @@ -97,21 +97,40 @@ type RollupEventWithdraw struct { TxHash ethCommon.Hash // Hash of the transaction that generated this event } -// RollupEventUpdateBucketWithdraw is an event of the Rollup Smart Contract -type RollupEventUpdateBucketWithdraw struct { +type rollupEventUpdateBucketWithdrawAux struct { NumBucket uint8 BlockStamp *big.Int Withdrawals *big.Int } +// RollupEventUpdateBucketWithdraw is an event of the Rollup Smart Contract +type RollupEventUpdateBucketWithdraw struct { + NumBucket int + BlockStamp int64 // blockNum + Withdrawals *big.Int +} + // RollupEventUpdateWithdrawalDelay is an event of the Rollup Smart Contract type RollupEventUpdateWithdrawalDelay struct { NewWithdrawalDelay uint64 } +// RollupUpdateBucketsParameters are the bucket parameters used in an update +type RollupUpdateBucketsParameters struct { + CeilUSD *big.Int + Withdrawals *big.Int + BlockWithdrawalRate *big.Int + MaxWithdrawals *big.Int +} + +type rollupEventUpdateBucketsParametersAux struct { + ArrayBuckets [common.RollupConstNumBuckets][4]*big.Int +} + // RollupEventUpdateBucketsParameters is an event of the Rollup Smart Contract type RollupEventUpdateBucketsParameters struct { - ArrayBuckets [common.RollupConstNumBuckets][4]*big.Int + // ArrayBuckets [common.RollupConstNumBuckets][4]*big.Int + ArrayBuckets [common.RollupConstNumBuckets]RollupUpdateBucketsParameters } // RollupEventUpdateTokenExchange is an event of the Rollup Smart Contract @@ -170,7 +189,7 @@ type RollupForgeBatchArgs struct { } // RollupForgeBatchArgsAux are the arguments to the ForgeBatch function in the Rollup Smart Contract -type RollupForgeBatchArgsAux struct { +type rollupForgeBatchArgsAux struct { NewLastIdx *big.Int NewStRoot *big.Int NewExitRoot *big.Int @@ -519,11 +538,20 @@ func (c *RollupClient) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *typ } // RollupUpdateBucketsParameters is the interface to call the smart contract function -func (c *RollupClient) RollupUpdateBucketsParameters(arrayBuckets [common.RollupConstNumBuckets][4]*big.Int) (tx *types.Transaction, err error) { +func (c *RollupClient) RollupUpdateBucketsParameters( + arrayBuckets [common.RollupConstNumBuckets]RollupUpdateBucketsParameters, +) (tx *types.Transaction, err error) { + params := [common.RollupConstNumBuckets][4]*big.Int{} + for i, bucket := range arrayBuckets { + params[i][0] = bucket.CeilUSD + params[i][1] = bucket.Withdrawals + params[i][2] = bucket.BlockWithdrawalRate + params[i][3] = bucket.MaxWithdrawals + } if tx, err = c.client.CallAuth( - 12500000, + 12500000, //nolint:gomnd func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) { - return c.hermez.UpdateBucketsParameters(auth, arrayBuckets) + return c.hermez.UpdateBucketsParameters(auth, params) }, ); err != nil { return nil, tracerr.Wrap(fmt.Errorf("Failed update Buckets Parameters: %w", err)) @@ -545,11 +573,11 @@ func (c *RollupClient) RollupUpdateTokenExchange(addressArray []ethCommon.Addres } // RollupUpdateWithdrawalDelay is the interface to call the smart contract function -func (c *RollupClient) RollupUpdateWithdrawalDelay(newWithdrawalDelay uint64) (tx *types.Transaction, err error) { +func (c *RollupClient) RollupUpdateWithdrawalDelay(newWithdrawalDelay int64) (tx *types.Transaction, err error) { if tx, err = c.client.CallAuth( 0, func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) { - return c.hermez.UpdateWithdrawalDelay(auth, newWithdrawalDelay) + return c.hermez.UpdateWithdrawalDelay(auth, uint64(newWithdrawalDelay)) }, ); err != nil { return nil, tracerr.Wrap(fmt.Errorf("Failed update WithdrawalDelay: %w", err)) @@ -662,7 +690,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC } switch vLog.Topics[0] { case logHermezL1UserTxEvent: - var L1UserTxAux RollupEventL1UserTxAux + var L1UserTxAux rollupEventL1UserTxAux var L1UserTx RollupEventL1UserTx err := c.contractAbi.Unpack(&L1UserTxAux, "L1UserTxEvent", vLog.Data) if err != nil { @@ -726,13 +754,15 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC withdraw.TxHash = vLog.TxHash rollupEvents.Withdraw = append(rollupEvents.Withdraw, withdraw) case logHermezUpdateBucketWithdraw: + var updateBucketWithdrawAux rollupEventUpdateBucketWithdrawAux var updateBucketWithdraw RollupEventUpdateBucketWithdraw - err := c.contractAbi.Unpack(&updateBucketWithdraw, "UpdateBucketWithdraw", vLog.Data) + err := c.contractAbi.Unpack(&updateBucketWithdrawAux, "UpdateBucketWithdraw", vLog.Data) if err != nil { return nil, nil, tracerr.Wrap(err) } - updateBucketWithdraw.NumBucket = uint8(new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()) - updateBucketWithdraw.BlockStamp = new(big.Int).SetBytes(vLog.Topics[2][:]) + updateBucketWithdraw.Withdrawals = updateBucketWithdrawAux.Withdrawals + updateBucketWithdraw.NumBucket = int(new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()) + updateBucketWithdraw.BlockStamp = new(big.Int).SetBytes(vLog.Topics[2][:]).Int64() rollupEvents.UpdateBucketWithdraw = append(rollupEvents.UpdateBucketWithdraw, updateBucketWithdraw) case logHermezUpdateWithdrawalDelay: @@ -743,11 +773,18 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC } rollupEvents.UpdateWithdrawalDelay = append(rollupEvents.UpdateWithdrawalDelay, withdrawalDelay) case logHermezUpdateBucketsParameters: + var bucketsParametersAux rollupEventUpdateBucketsParametersAux var bucketsParameters RollupEventUpdateBucketsParameters - err := c.contractAbi.Unpack(&bucketsParameters, "UpdateBucketsParameters", vLog.Data) + err := c.contractAbi.Unpack(&bucketsParametersAux, "UpdateBucketsParameters", vLog.Data) if err != nil { return nil, nil, tracerr.Wrap(err) } + for i, bucket := range bucketsParametersAux.ArrayBuckets { + bucketsParameters.ArrayBuckets[i].CeilUSD = bucket[0] + bucketsParameters.ArrayBuckets[i].Withdrawals = bucket[1] + bucketsParameters.ArrayBuckets[i].BlockWithdrawalRate = bucket[2] + bucketsParameters.ArrayBuckets[i].MaxWithdrawals = bucket[3] + } rollupEvents.UpdateBucketsParameters = append(rollupEvents.UpdateBucketsParameters, bucketsParameters) case logHermezUpdateTokenExchange: var tokensExchange RollupEventUpdateTokenExchange @@ -766,7 +803,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC // RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the // Rollup Smart Contract in the given transaction, and the sender address. -func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, numL1TxUser uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error) { +func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsLen uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error) { tx, _, err := c.client.client.TransactionByHash(context.Background(), ethTxHash) if err != nil { return nil, nil, tracerr.Wrap(err) @@ -785,7 +822,7 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, numL1TxUse if err != nil { return nil, nil, tracerr.Wrap(err) } - var aux RollupForgeBatchArgsAux + var aux rollupForgeBatchArgsAux if err := method.Inputs.Unpack(&aux, txData[4:]); err != nil { return nil, nil, tracerr.Wrap(err) } @@ -809,15 +846,15 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, numL1TxUse } nLevels := rollupConsts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels lenL1L2TxsBytes := int((nLevels/8)*2 + 2 + 1) - numBytesL1TxUser := int(numL1TxUser) * lenL1L2TxsBytes + numBytesL1TxUser := int(l1UserTxsLen) * lenL1L2TxsBytes numTxsL1Coord := len(aux.EncodedL1CoordinatorTx) / common.L1CoordinatorTxBytesLen numBytesL1TxCoord := numTxsL1Coord * lenL1L2TxsBytes numBeginL2Tx := numBytesL1TxCoord + numBytesL1TxUser l1UserTxsData := []byte{} - if numL1TxUser > 0 { + if l1UserTxsLen > 0 { l1UserTxsData = aux.L1L2TxsData[:numBytesL1TxUser] } - for i := 0; i < int(numL1TxUser); i++ { + for i := 0; i < int(l1UserTxsLen); i++ { l1Tx, err := common.L1TxFromDataAvailability(l1UserTxsData[i*lenL1L2TxsBytes:(i+1)*lenL1L2TxsBytes], uint32(nLevels)) if err != nil { return nil, nil, tracerr.Wrap(err) diff --git a/eth/rollup_test.go b/eth/rollup_test.go index e1602a4..5b914dd 100644 --- a/eth/rollup_test.go +++ b/eth/rollup_test.go @@ -57,7 +57,7 @@ func genKeysBjj(i int64) *keys { func TestRollupConstants(t *testing.T) { rollupConstants, err := rollupClient.RollupConstants() - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, absoluteMaxL1L2BatchTimeout, rollupConstants.AbsoluteMaxL1L2BatchTimeout) assert.Equal(t, auctionAddressConst, rollupConstants.HermezAuctionContract) assert.Equal(t, tokenHEZAddressConst, rollupConstants.TokenHEZ) @@ -69,7 +69,7 @@ func TestRollupConstants(t *testing.T) { func TestRollupRegisterTokensCount(t *testing.T) { registerTokensCount, err := rollupClient.RollupRegisterTokensCount() - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, big.NewInt(1), registerTokensCount) } @@ -77,13 +77,13 @@ func TestRollupAddToken(t *testing.T) { feeAddToken := big.NewInt(10) // Addtoken ERC20Permit registerTokensCount, err := rollupClient.RollupRegisterTokensCount() - require.Nil(t, err) + require.NoError(t, err) _, err = rollupClient.RollupAddToken(tokenHEZAddressConst, feeAddToken, deadline) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, tokenHEZAddressConst, rollupEvents.AddToken[0].TokenAddress) assert.Equal(t, registerTokensCount, common.TokenID(rollupEvents.AddToken[0].TokenID).BigInt()) @@ -95,11 +95,11 @@ func TestRollupForgeBatch(t *testing.T) { // Register Coordinator forgerAddress := governanceAddressConst _, err := auctionClient.AuctionSetCoordinator(forgerAddress, URL) - require.Nil(t, err) + require.NoError(t, err) // MultiBid currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber() - require.Nil(t, err) + require.NoError(t, err) slotSet := [6]bool{true, false, true, false, true, false} maxBid := new(big.Int) maxBid.SetString("15000000000000000000", 10) @@ -108,12 +108,12 @@ func TestRollupForgeBatch(t *testing.T) { budget := new(big.Int) budget.SetString("45200000000000000000", 10) _, err = auctionClient.AuctionMultiBid(budget, currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, deadline) - require.Nil(t, err) + require.NoError(t, err) // Add Blocks blockNum := int64(int(blocksPerSlot)*int(currentSlot+4) + int(genesisBlock)) currentBlockNum, err := auctionClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) blocksToAdd := blockNum - currentBlockNum addBlocks(blocksToAdd, ethClientDialURL) @@ -121,7 +121,7 @@ func TestRollupForgeBatch(t *testing.T) { 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.Nil(t, err) + require.NoError(t, err) numTxsL1 := len(l1CoordinatorBytes) / common.L1CoordinatorTxBytesLen for i := 0; i < numTxsL1; i++ { bytesL1Coordinator := l1CoordinatorBytes[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen] @@ -133,7 +133,7 @@ func TestRollupForgeBatch(t *testing.T) { signature = append(signature, s[:]...) signature = append(signature, v) l1Tx, err := common.L1CoordinatorTxFromBytes(bytesL1Coordinator, chainid, rollupClient.address) - require.Nil(t, err) + require.NoError(t, err) args.L1CoordinatorTxs = append(args.L1CoordinatorTxs, *l1Tx) args.L1CoordinatorTxsAuths = append(args.L1CoordinatorTxsAuths, signature) } @@ -143,7 +143,7 @@ func TestRollupForgeBatch(t *testing.T) { newStateRoot.SetString("18317824016047294649053625209337295956588174734569560016974612130063629505228", 10) newExitRoot := new(big.Int) bytesNumExitRoot, err := hex.DecodeString("10a89d5fe8d488eda1ba371d633515739933c706c210c604f5bd209180daa43b") - require.Nil(t, err) + require.NoError(t, err) newExitRoot.SetBytes(bytesNumExitRoot) args.NewLastIdx = int64(300) args.NewStRoot = newStateRoot @@ -161,12 +161,12 @@ func TestRollupForgeBatch(t *testing.T) { argsForge = args _, err = rollupClient.RollupForgeBatch(argsForge) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err = rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, int64(1), rollupEvents.ForgeBatch[0].BatchNum) assert.Equal(t, uint16(len(L1UserTxs)), rollupEvents.ForgeBatch[0].L1UserTxsLen) @@ -175,7 +175,7 @@ func TestRollupForgeBatch(t *testing.T) { func TestRollupForgeBatchArgs(t *testing.T) { args, sender, err := rollupClient.RollupForgeBatchArgs(ethHashForge, uint16(len(L1UserTxs))) - require.Nil(t, err) + 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) @@ -190,12 +190,12 @@ func TestRollupForgeBatchArgs(t *testing.T) { func TestRollupUpdateForgeL1L2BatchTimeout(t *testing.T) { newForgeL1L2BatchTimeout := int64(222) _, err := rollupClient.RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, newForgeL1L2BatchTimeout, rollupEvents.UpdateForgeL1L2BatchTimeout[0].NewForgeL1L2BatchTimeout) } @@ -203,49 +203,43 @@ func TestRollupUpdateForgeL1L2BatchTimeout(t *testing.T) { func TestRollupUpdateFeeAddToken(t *testing.T) { newFeeAddToken := big.NewInt(12) _, err := rollupClient.RollupUpdateFeeAddToken(newFeeAddToken) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, newFeeAddToken, rollupEvents.UpdateFeeAddToken[0].NewFeeAddToken) } func TestRollupUpdateBucketsParameters(t *testing.T) { - var bucketsParameters [common.RollupConstNumBuckets][4]*big.Int + var bucketsParameters [common.RollupConstNumBuckets]RollupUpdateBucketsParameters for i := range bucketsParameters { - bucketsParameters[i][0] = big.NewInt(int64((i + 1) * 100)) // ceilUSD - bucketsParameters[i][1] = big.NewInt(int64(i + 1)) // withdrawals - bucketsParameters[i][2] = big.NewInt(int64(i+1) * 100) // blockWithdrawalRate - bucketsParameters[i][3] = big.NewInt(int64(100000000000)) // maxWithdrawals + 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.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) blockStampBucket = currentBlockNum rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) - for i := range bucketsParameters { - assert.Equal(t, bucketsParameters[i][0].String(), rollupEvents.UpdateBucketsParameters[0].ArrayBuckets[i][0].String()) - assert.Equal(t, bucketsParameters[i][1].String(), rollupEvents.UpdateBucketsParameters[0].ArrayBuckets[i][1].String()) - assert.Equal(t, bucketsParameters[i][2].String(), rollupEvents.UpdateBucketsParameters[0].ArrayBuckets[i][2].String()) - assert.Equal(t, bucketsParameters[i][3].String(), rollupEvents.UpdateBucketsParameters[0].ArrayBuckets[i][3].String()) - } - + require.NoError(t, err) + assert.Equal(t, bucketsParameters, rollupEvents.UpdateBucketsParameters[0].ArrayBuckets) } func TestRollupUpdateWithdrawalDelay(t *testing.T) { - newWithdrawalDelay := uint64(100000) + newWithdrawalDelay := int64(100000) _, err := rollupClient.RollupUpdateWithdrawalDelay(newWithdrawalDelay) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) - assert.Equal(t, newWithdrawalDelay, rollupEvents.UpdateWithdrawalDelay[0].NewWithdrawalDelay) + require.NoError(t, err) + assert.Equal(t, newWithdrawalDelay, int64(rollupEvents.UpdateWithdrawalDelay[0].NewWithdrawalDelay)) } func TestRollupUpdateTokenExchange(t *testing.T) { @@ -255,20 +249,20 @@ func TestRollupUpdateTokenExchange(t *testing.T) { addressArray = append(addressArray, addressToken1) tokenPrice := 10 valueArray = append(valueArray, uint64(tokenPrice*1e14)) - require.Nil(t, err) + require.NoError(t, err) _, err = rollupClient.RollupUpdateTokenExchange(addressArray, valueArray) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + 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.Nil(t, err) + require.NoError(t, err) key := genKeysBjj(2) fromIdxInt64 := int64(0) toIdxInt64 := int64(0) @@ -285,12 +279,12 @@ func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + 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.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) @@ -301,7 +295,7 @@ func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) { func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) key := genKeysBjj(1) fromIdxInt64 := int64(0) toIdxInt64 := int64(0) @@ -317,12 +311,12 @@ func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + 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.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) @@ -333,7 +327,7 @@ func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) { func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) key := genKeysBjj(3) fromIdxInt64 := int64(0) toIdxInt64 := int64(0) @@ -349,12 +343,12 @@ func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + 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.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) @@ -365,7 +359,7 @@ func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) { func TestRollupL1UserTxETHDeposit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(0) tokenIDUint32 := uint32(0) @@ -381,12 +375,12 @@ func TestRollupL1UserTxETHDeposit(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -396,7 +390,7 @@ func TestRollupL1UserTxETHDeposit(t *testing.T) { func TestRollupL1UserTxERC20Deposit(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(0) loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) @@ -411,12 +405,12 @@ func TestRollupL1UserTxERC20Deposit(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -426,7 +420,7 @@ func TestRollupL1UserTxERC20Deposit(t *testing.T) { func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(258) toIdxInt64 := int64(0) loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) @@ -440,12 +434,12 @@ func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -455,7 +449,7 @@ func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) { func TestRollupL1UserTxETHDepositTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(257) tokenIDUint32 := uint32(0) @@ -471,12 +465,12 @@ func TestRollupL1UserTxETHDepositTransfer(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -486,7 +480,7 @@ func TestRollupL1UserTxETHDepositTransfer(t *testing.T) { func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(258) loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) @@ -501,12 +495,12 @@ func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -516,7 +510,7 @@ func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) { func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(258) toIdxInt64 := int64(259) loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) @@ -531,12 +525,12 @@ func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -546,7 +540,7 @@ func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) { func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(257) tokenIDUint32 := uint32(0) @@ -562,12 +556,12 @@ func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -577,7 +571,7 @@ func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) { func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(258) loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) @@ -592,12 +586,12 @@ func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -607,7 +601,7 @@ func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) { func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(258) toIdxInt64 := int64(259) loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10) @@ -622,12 +616,12 @@ func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -637,7 +631,7 @@ func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) { func TestRollupL1UserTxETHForceTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(257) tokenIDUint32 := uint32(0) @@ -652,12 +646,12 @@ func TestRollupL1UserTxETHForceTransfer(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -667,7 +661,7 @@ func TestRollupL1UserTxETHForceTransfer(t *testing.T) { func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(258) amount, _ := new(big.Int).SetString("10000000000000000000", 10) @@ -681,12 +675,12 @@ func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -696,7 +690,7 @@ func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) { func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(259) toIdxInt64 := int64(260) amount, _ := new(big.Int).SetString("30000000000000000000", 10) @@ -710,12 +704,12 @@ func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -725,7 +719,7 @@ func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) { func TestRollupL1UserTxETHForceExit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(256) toIdxInt64 := int64(1) tokenIDUint32 := uint32(0) @@ -740,12 +734,12 @@ func TestRollupL1UserTxETHForceExit(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -755,7 +749,7 @@ func TestRollupL1UserTxETHForceExit(t *testing.T) { func TestRollupL1UserTxERC20ForceExit(t *testing.T) { rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(257) toIdxInt64 := int64(1) amount, _ := new(big.Int).SetString("20000000000000000000", 10) @@ -769,12 +763,12 @@ func TestRollupL1UserTxERC20ForceExit(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -784,7 +778,7 @@ func TestRollupL1UserTxERC20ForceExit(t *testing.T) { func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) fromIdxInt64 := int64(258) toIdxInt64 := int64(1) fromIdx := new(common.Idx) @@ -800,12 +794,12 @@ func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) { L1UserTxs = append(L1UserTxs, l1Tx) _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx) assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount) assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID) @@ -816,11 +810,11 @@ func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) { func TestRollupForgeBatch2(t *testing.T) { // Forge Batch 2 _, err := rollupClient.RollupForgeBatch(argsForge) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, int64(2), rollupEvents.ForgeBatch[0].BatchNum) @@ -833,9 +827,9 @@ func TestRollupForgeBatch2(t *testing.T) { l1UserTx := L1UserTxs[i] l1UserTx.EffectiveAmount = l1UserTx.Amount l1Bytes, err := l1UserTx.BytesDataAvailability(uint32(nLevels)) - require.Nil(t, err) + require.NoError(t, err) l1UserTxDataAvailability, err := common.L1TxFromDataAvailability(l1Bytes, uint32(nLevels)) - require.Nil(t, err) + require.NoError(t, err) args.L1UserTxs = append(args.L1UserTxs, *l1UserTxDataAvailability) } newStateRoot := new(big.Int) @@ -869,22 +863,21 @@ func TestRollupForgeBatch2(t *testing.T) { argsForge = args _, err = rollupClient.RollupForgeBatch(argsForge) - require.Nil(t, err) + require.NoError(t, err) currentBlockNum, err = rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err = rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + 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.Nil(t, err) + 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) @@ -899,38 +892,38 @@ func TestRollupForgeBatchArgs2(t *testing.T) { func TestRollupWithdrawMerkleProof(t *testing.T) { rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ) - require.Nil(t, err) + require.NoError(t, err) var pkComp babyjub.PublicKeyComp pkCompBE, err := hex.DecodeString("adc3b754f8da621967b073a787bef8eec7052f2ba712b23af57d98f65beea8b2") - require.Nil(t, err) + require.NoError(t, err) pkCompLE := common.SwapEndianness(pkCompBE) copy(pkComp[:], pkCompLE) pk, err := pkComp.Decompress() - require.Nil(t, err) + require.NoError(t, err) - require.Nil(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.Nil(t, err) + // require.NoError(t, err) // siblingBytes1, err := new(big.Int).SetString("15198806719713909654457742294233381653226080862567104272457668857208564789571", 10) - // require.Nil(t, err) + // 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.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) assert.Equal(t, uint64(fromIdx), rollupEvents.Withdraw[0].Idx) assert.Equal(t, instantWithdraw, rollupEvents.Withdraw[0].InstantWithdraw) @@ -941,19 +934,19 @@ func TestRollupWithdrawMerkleProof(t *testing.T) { // Bucket 1 // Bucket[0].withdrawals = 1, Bucket[1].withdrawals = 2, ... // Bucket[1].withdrawals - 1 = 1 - assert.Equal(t, uint8(1), rollupEvents.UpdateBucketWithdraw[0].NumBucket) - assert.Equal(t, big.NewInt(blockStampBucket), rollupEvents.UpdateBucketWithdraw[0].BlockStamp) + 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.Nil(t, err) + require.NoError(t, err) currentBlockNum, err := rollupClient.client.EthLastBlock() - require.Nil(t, err) + require.NoError(t, err) rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum) - require.Nil(t, err) + require.NoError(t, err) auxEvent := new(RollupEventSafeMode) assert.Equal(t, auxEvent, &rollupEvents.SafeMode[0]) } diff --git a/synchronizer/synchronizer.go b/synchronizer/synchronizer.go index 7a56bfe..3528831 100644 --- a/synchronizer/synchronizer.go +++ b/synchronizer/synchronizer.go @@ -736,7 +736,8 @@ func (s *Synchronizer) rollupSync(ethBlock *common.Block) (*common.RollupData, e position := 0 // Get the input for each Tx - forgeBatchArgs, sender, err := s.ethClient.RollupForgeBatchArgs(evtForgeBatch.EthTxHash) + forgeBatchArgs, sender, err := s.ethClient.RollupForgeBatchArgs(evtForgeBatch.EthTxHash, + evtForgeBatch.L1UserTxsLen) if err != nil { return nil, tracerr.Wrap(err) } @@ -1074,16 +1075,12 @@ func (s *Synchronizer) wdelayerSync(ethBlock *common.Block) (*common.WDelayerDat s.vars.WDelayer.WithdrawalDelay = evt.WithdrawalDelay varsUpdate = true } - for _, evt := range wDelayerEvents.NewHermezKeeperAddress { - s.vars.WDelayer.HermezKeeperAddress = evt.NewHermezKeeperAddress + for _, evt := range wDelayerEvents.NewEmergencyCouncil { + s.vars.WDelayer.EmergencyCouncilAddress = evt.NewEmergencyCouncil varsUpdate = true } - for _, evt := range wDelayerEvents.NewWhiteHackGroupAddress { - s.vars.WDelayer.WhiteHackGroupAddress = evt.NewWhiteHackGroupAddress - varsUpdate = true - } - for _, evt := range wDelayerEvents.NewHermezGovernanceDAOAddress { - s.vars.WDelayer.HermezGovernanceDAOAddress = evt.NewHermezGovernanceDAOAddress + for _, evt := range wDelayerEvents.NewHermezGovernanceAddress { + s.vars.WDelayer.HermezGovernanceAddress = evt.NewHermezGovernanceAddress varsUpdate = true } diff --git a/test/ethclient.go b/test/ethclient.go index 57b4cb0..da95e70 100644 --- a/test/ethclient.go +++ b/test/ethclient.go @@ -311,8 +311,9 @@ func NewClientSetupExample() *ClientSetup { HermezRollup: ethCommon.HexToAddress("0x474B6e29852257491cf283EfB1A9C61eBFe48369"), } auctionVariables := &common.AuctionVariables{ - DonationAddress: ethCommon.HexToAddress("0x61Ed87CF0A1496b49A420DA6D84B58196b98f2e7"), - BootCoordinator: ethCommon.HexToAddress("0xE39fEc6224708f0772D2A74fd3f9055A90E0A9f2"), + DonationAddress: ethCommon.HexToAddress("0x61Ed87CF0A1496b49A420DA6D84B58196b98f2e7"), + BootCoordinator: ethCommon.HexToAddress("0xE39fEc6224708f0772D2A74fd3f9055A90E0A9f2"), + BootCoordinatorURL: "https://boot.coordinator.com", DefaultSlotSetBid: [6]*big.Int{ big.NewInt(1000), big.NewInt(1100), big.NewInt(1200), big.NewInt(1300), big.NewInt(1400), big.NewInt(1500)}, @@ -940,8 +941,9 @@ func (c *Client) addBatch(args *eth.RollupForgeBatchArgs) (*types.Transaction, e ethTx := r.addTransaction(c.newTransaction("forgebatch", args)) c.forgeBatchArgsPending[ethTx.Hash()] = &batch{*args, *c.addr} r.Events.ForgeBatch = append(r.Events.ForgeBatch, eth.RollupEventForgeBatch{ - BatchNum: int64(len(r.State.ExitRoots)) - 1, - EthTxHash: ethTx.Hash(), + BatchNum: int64(len(r.State.ExitRoots)) - 1, + EthTxHash: ethTx.Hash(), + L1UserTxsLen: uint16(len(args.L1UserTxs)), }) return ethTx, nil @@ -1059,7 +1061,7 @@ func (c *Client) RollupEventsByBlock(blockNum int64) (*eth.RollupEvents, *ethCom } // RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the Rollup Smart Contract in the given transaction -func (c *Client) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, numL1TxUser uint16) (*eth.RollupForgeBatchArgs, *ethCommon.Address, error) { +func (c *Client) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsLen uint16) (*eth.RollupForgeBatchArgs, *ethCommon.Address, error) { c.rw.RLock() defer c.rw.RUnlock() @@ -1518,8 +1520,8 @@ func (c *Client) WDelayerGetHermezGovernanceAddress() (*ethCommon.Address, error return nil, tracerr.Wrap(errTODO) } -// WDelayerSetHermezGovernanceAddress is the interface to call the smart contract function -func (c *Client) WDelayerSetHermezGovernanceAddress(newAddress ethCommon.Address) (tx *types.Transaction, err error) { +// WDelayerTransferGovernance is the interface to call the smart contract function +func (c *Client) WDelayerTransferGovernance(newAddress ethCommon.Address) (tx *types.Transaction, err error) { c.rw.Lock() defer c.rw.Unlock() cpy := c.nextBlock().copy() @@ -1532,17 +1534,8 @@ func (c *Client) WDelayerSetHermezGovernanceAddress(newAddress ethCommon.Address return nil, tracerr.Wrap(errTODO) } -// WDelayerGetHermezKeeperAddress is the interface to call the smart contract function -func (c *Client) WDelayerGetHermezKeeperAddress() (*ethCommon.Address, error) { - c.rw.RLock() - defer c.rw.RUnlock() - - log.Error("TODO") - return nil, tracerr.Wrap(errTODO) -} - -// WDelayerSetHermezKeeperAddress is the interface to call the smart contract function -func (c *Client) WDelayerSetHermezKeeperAddress(newAddress ethCommon.Address) (tx *types.Transaction, err error) { +// WDelayerClaimGovernance is the interface to call the smart contract function +func (c *Client) WDelayerClaimGovernance() (tx *types.Transaction, err error) { c.rw.Lock() defer c.rw.Unlock() cpy := c.nextBlock().copy() @@ -1555,8 +1548,8 @@ func (c *Client) WDelayerSetHermezKeeperAddress(newAddress ethCommon.Address) (t return nil, tracerr.Wrap(errTODO) } -// WDelayerGetWhiteHackGroupAddress is the interface to call the smart contract function -func (c *Client) WDelayerGetWhiteHackGroupAddress() (*ethCommon.Address, error) { +// WDelayerGetEmergencyCouncil is the interface to call the smart contract function +func (c *Client) WDelayerGetEmergencyCouncil() (*ethCommon.Address, error) { c.rw.RLock() defer c.rw.RUnlock() @@ -1564,8 +1557,22 @@ func (c *Client) WDelayerGetWhiteHackGroupAddress() (*ethCommon.Address, error) return nil, tracerr.Wrap(errTODO) } -// WDelayerSetWhiteHackGroupAddress is the interface to call the smart contract function -func (c *Client) WDelayerSetWhiteHackGroupAddress(newAddress ethCommon.Address) (tx *types.Transaction, err error) { +// WDelayerTransferEmergencyCouncil is the interface to call the smart contract function +func (c *Client) WDelayerTransferEmergencyCouncil(newAddress ethCommon.Address) (tx *types.Transaction, err error) { + c.rw.Lock() + defer c.rw.Unlock() + cpy := c.nextBlock().copy() + defer func() { c.revertIfErr(err, cpy) }() + if c.addr == nil { + return nil, tracerr.Wrap(eth.ErrAccountNil) + } + + log.Error("TODO") + return nil, tracerr.Wrap(errTODO) +} + +// WDelayerClaimEmergencyCouncil is the interface to call the smart contract function +func (c *Client) WDelayerClaimEmergencyCouncil() (tx *types.Transaction, err error) { c.rw.Lock() defer c.rw.Unlock() cpy := c.nextBlock().copy() diff --git a/test/ethclient_test.go b/test/ethclient_test.go index a165a5f..4020856 100644 --- a/test/ethclient_test.go +++ b/test/ethclient_test.go @@ -235,7 +235,8 @@ func TestClientRollup(t *testing.T) { rollupEvents, _, err = c.RollupEventsByBlock(blockNum) require.Nil(t, err) - rollupForgeBatchArgs1, sender, err := c.RollupForgeBatchArgs(rollupEvents.ForgeBatch[0].EthTxHash) + rollupForgeBatchArgs1, sender, err := c.RollupForgeBatchArgs(rollupEvents.ForgeBatch[0].EthTxHash, + rollupEvents.ForgeBatch[0].L1UserTxsLen) require.Nil(t, err) assert.Equal(t, *c.addr, *sender) assert.Equal(t, rollupForgeBatchArgs0, rollupForgeBatchArgs1)