Update some eth types, update eth dependencies to new changes
Eduard S eduard@iden3.io
Thu, 03 Dec 2020 18:05:33 +0100
11 files changed,
241 insertions(+),
202 deletions(-)
M
common/ethauction.go
→
common/ethauction.go
@@ -58,6 +58,8 @@ // Boot Coordinator Address
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
M
common/ethwdelayer.go
→
common/ethwdelayer.go
@@ -16,8 +16,8 @@ // WDelayerVariables are the variables of the Withdrawal Delayer Smart Contract
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"`
M
common/l1tx_test.go
→
common/l1tx_test.go
@@ -96,6 +96,7 @@ }
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 @@ }
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)
M
db/historydb/historydb_test.go
→
db/historydb/historydb_test.go
@@ -654,6 +654,7 @@ auction := &common.AuctionVariables{
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 @@ wDelayer := &common.WDelayerVariables{
0, ethCommon.BigToAddress(big.NewInt(2)), ethCommon.BigToAddress(big.NewInt(3)), - ethCommon.BigToAddress(big.NewInt(4)), 13, 14, false,
M
db/migrations/0001.sql
→
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 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
M
eth/README.md
→
eth/README.md
@@ -8,7 +8,7 @@ `git clone https://github.com/hermeznetwork/contracts.git`
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:
M
eth/rollup.go
→
eth/rollup.go
@@ -59,7 +59,7 @@ L1UserTx common.L1Tx
} // 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,10 +97,16 @@ InstantWithdraw bool
TxHash ethCommon.Hash // Hash of the transaction that generated this event } +type rollupEventUpdateBucketWithdrawAux struct { + NumBucket uint8 + BlockStamp *big.Int + Withdrawals *big.Int +} + // RollupEventUpdateBucketWithdraw is an event of the Rollup Smart Contract type RollupEventUpdateBucketWithdraw struct { - NumBucket uint8 - BlockStamp *big.Int + NumBucket int + BlockStamp int64 // blockNum Withdrawals *big.Int }@@ -109,9 +115,22 @@ 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 @@ ProofC [2]*big.Int
} // 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 @@ return tx, nil
} // 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 @@ return tx, nil
} // 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 @@ return nil, nil, tracerr.Wrap(ErrBlockHashMismatchEvent)
} 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 @@ }
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,10 +773,17 @@ return nil, nil, tracerr.Wrap(err)
} 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:@@ -766,7 +803,7 @@ }
// 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 @@ sender, err := c.client.client.TransactionSender(context.Background(), tx, receipt.Logs[0].BlockHash, receipt.Logs[0].Index)
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 @@ return nil, nil, tracerr.Wrap(err)
} 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)
M
eth/rollup_test.go
→
eth/rollup_test.go
@@ -57,7 +57,7 @@ }
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 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 @@ chainid, _ := auctionClient.client.Client().ChainID(context.Background())
// 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 @@ 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.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 @@ // 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.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 @@ signature = append(signature, r[:]...)
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 @@ newStateRoot := new(big.Int)
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 @@ args.ProofC[1] = big.NewInt(0)
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 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 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 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 @@ addressToken1, err := rollupClient.hermez.TokenList(nil, big.NewInt(1))
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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ }
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 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 @@ for i := 0; i < len(L1UserTxs); i++ {
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 @@
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 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 @@ // 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, 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]) }
M
synchronizer/synchronizer.go
→
synchronizer/synchronizer.go
@@ -736,7 +736,8 @@ batchData := common.NewBatchData()
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 @@ for _, evt := range wDelayerEvents.NewWithdrawalDelay {
s.vars.WDelayer.WithdrawalDelay = evt.WithdrawalDelay varsUpdate = true } - for _, evt := range wDelayerEvents.NewHermezKeeperAddress { - s.vars.WDelayer.HermezKeeperAddress = evt.NewHermezKeeperAddress - varsUpdate = true - } - for _, evt := range wDelayerEvents.NewWhiteHackGroupAddress { - s.vars.WDelayer.WhiteHackGroupAddress = evt.NewWhiteHackGroupAddress + for _, evt := range wDelayerEvents.NewEmergencyCouncil { + s.vars.WDelayer.EmergencyCouncilAddress = evt.NewEmergencyCouncil 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 }
M
test/ethclient.go
→
test/ethclient.go
@@ -311,8 +311,9 @@ TokenHEZ: tokenHEZ,
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 @@ }
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 @@ return &block.Rollup.Events, &block.Eth.Hash, nil
} // RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the Rollup Smart Contract in the given transaction -func (c *Client) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, 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,22 @@ log.Error("TODO")
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() + defer func() { c.revertIfErr(err, cpy) }() + if c.addr == nil { + return nil, tracerr.Wrap(eth.ErrAccountNil) + } + + log.Error("TODO") + return nil, tracerr.Wrap(errTODO) +} + +// 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()@@ -1532,8 +1548,8 @@ log.Error("TODO")
return nil, tracerr.Wrap(errTODO) } -// WDelayerGetHermezKeeperAddress is the interface to call the smart contract function -func (c *Client) WDelayerGetHermezKeeperAddress() (*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()@@ -1541,8 +1557,8 @@ 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) { +// 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()@@ -1555,17 +1571,8 @@ log.Error("TODO")
return nil, tracerr.Wrap(errTODO) } -// WDelayerGetWhiteHackGroupAddress is the interface to call the smart contract function -func (c *Client) WDelayerGetWhiteHackGroupAddress() (*ethCommon.Address, error) { - c.rw.RLock() - defer c.rw.RUnlock() - - log.Error("TODO") - 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) { +// 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()
M
test/ethclient_test.go
→
test/ethclient_test.go
@@ -235,7 +235,8 @@ require.Nil(t, err)
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)