Upgrade contracts and parse init events

2026-02-06 19:06:42 +01:00 · 2020-12-17 17:22:23 +01:00
parent 8a59296cb8
commit ac400bad77
16 changed files with 1641 additions and 594 deletions
--- 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 `6335252b073dc59afafc45040dae8630c72ecdf3`)
+`git checkout feature/newDeploymentScript-eth-1` (tested with commit `071926ea2bce1c673cb1ff2728297191a396d350`)

 Now, install the dependencies:

--- a/eth/auction.go
+++ b/eth/auction.go
@@ -56,6 +56,19 @@ type AuctionState struct {
 	Coordinators map[ethCommon.Address]*Coordinator
 }

+// AuctionEventInitialize is the InitializeHermezAuctionProtocolEvent event of
+// the Smart Contract
+type AuctionEventInitialize struct {
+	DonationAddress        ethCommon.Address
+	BootCoordinatorAddress ethCommon.Address
+	BootCoordinatorURL     string
+	Outbidding             uint16
+	SlotDeadline           uint8
+	ClosedAuctionSlots     uint16
+	OpenAuctionSlots       uint16
+	AllocationRatio        [3]uint16
+}
+
 // AuctionEventNewBid is an event of the Auction Smart Contract
 type AuctionEventNewBid struct {
 	Slot      int64
@@ -726,8 +739,38 @@ var (
 	logAuctionNewDefaultSlotSetBid  = crypto.Keccak256Hash([]byte("NewDefaultSlotSetBid(uint128,uint128)"))
 	logAuctionNewForge              = crypto.Keccak256Hash([]byte("NewForge(address,uint128)"))
 	logAuctionHEZClaimed            = crypto.Keccak256Hash([]byte("HEZClaimed(address,uint128)"))
+	logAuctionInitialize            = crypto.Keccak256Hash([]byte(
+		"InitializeHermezAuctionProtocolEvent(address,address,string,uint16,uint8,uint16,uint16,uint16[3])"))
 )

+// AuctionEventInit returns the initialize event with its corresponding block number
+func (c *AuctionClient) AuctionEventInit() (*AuctionEventInitialize, int64, error) {
+	query := ethereum.FilterQuery{
+		Addresses: []ethCommon.Address{
+			c.address,
+		},
+		Topics: [][]ethCommon.Hash{{logAuctionInitialize}},
+	}
+	logs, err := c.client.client.FilterLogs(context.Background(), query)
+	if err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	if len(logs) != 1 {
+		return nil, 0, fmt.Errorf("no event of type InitializeHermezAuctionProtocolEvent found")
+	}
+	vLog := logs[0]
+	if vLog.Topics[0] != logAuctionInitialize {
+		return nil, 0, fmt.Errorf("event is not InitializeHermezAuctionProtocolEvent")
+	}
+
+	var auctionInit AuctionEventInitialize
+	if err := c.contractAbi.UnpackIntoInterface(&auctionInit,
+		"InitializeHermezAuctionProtocolEvent", vLog.Data); err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	return &auctionInit, int64(vLog.BlockNumber), err
+}
+
 // AuctionEventsByBlock returns the events in a block that happened in the
 // Auction Smart Contract and the blockHash where the eents happened.  If there
 // are no events in that block, blockHash is nil.
@@ -764,7 +807,7 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *e
 				Address   ethCommon.Address
 			}
 			var newBid AuctionEventNewBid
-			if err := c.contractAbi.Unpack(&auxNewBid, "NewBid", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&auxNewBid, "NewBid", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			newBid.BidAmount = auxNewBid.BidAmount
@@ -773,19 +816,19 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *e
 			auctionEvents.NewBid = append(auctionEvents.NewBid, newBid)
 		case logAuctionNewSlotDeadline:
 			var newSlotDeadline AuctionEventNewSlotDeadline
-			if err := c.contractAbi.Unpack(&newSlotDeadline, "NewSlotDeadline", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newSlotDeadline, "NewSlotDeadline", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewSlotDeadline = append(auctionEvents.NewSlotDeadline, newSlotDeadline)
 		case logAuctionNewClosedAuctionSlots:
 			var newClosedAuctionSlots AuctionEventNewClosedAuctionSlots
-			if err := c.contractAbi.Unpack(&newClosedAuctionSlots, "NewClosedAuctionSlots", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newClosedAuctionSlots, "NewClosedAuctionSlots", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewClosedAuctionSlots = append(auctionEvents.NewClosedAuctionSlots, newClosedAuctionSlots)
 		case logAuctionNewOutbidding:
 			var newOutbidding AuctionEventNewOutbidding
-			if err := c.contractAbi.Unpack(&newOutbidding, "NewOutbidding", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newOutbidding, "NewOutbidding", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewOutbidding = append(auctionEvents.NewOutbidding, newOutbidding)
@@ -795,26 +838,26 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *e
 			auctionEvents.NewDonationAddress = append(auctionEvents.NewDonationAddress, newDonationAddress)
 		case logAuctionNewBootCoordinator:
 			var newBootCoordinator AuctionEventNewBootCoordinator
-			if err := c.contractAbi.Unpack(&newBootCoordinator, "NewBootCoordinator", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newBootCoordinator, "NewBootCoordinator", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			newBootCoordinator.NewBootCoordinator = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			auctionEvents.NewBootCoordinator = append(auctionEvents.NewBootCoordinator, newBootCoordinator)
 		case logAuctionNewOpenAuctionSlots:
 			var newOpenAuctionSlots AuctionEventNewOpenAuctionSlots
-			if err := c.contractAbi.Unpack(&newOpenAuctionSlots, "NewOpenAuctionSlots", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newOpenAuctionSlots, "NewOpenAuctionSlots", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewOpenAuctionSlots = append(auctionEvents.NewOpenAuctionSlots, newOpenAuctionSlots)
 		case logAuctionNewAllocationRatio:
 			var newAllocationRatio AuctionEventNewAllocationRatio
-			if err := c.contractAbi.Unpack(&newAllocationRatio, "NewAllocationRatio", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newAllocationRatio, "NewAllocationRatio", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			auctionEvents.NewAllocationRatio = append(auctionEvents.NewAllocationRatio, newAllocationRatio)
 		case logAuctionSetCoordinator:
 			var setCoordinator AuctionEventSetCoordinator
-			if err := c.contractAbi.Unpack(&setCoordinator, "SetCoordinator", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&setCoordinator, "SetCoordinator", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			setCoordinator.BidderAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
@@ -822,7 +865,7 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *e
 			auctionEvents.SetCoordinator = append(auctionEvents.SetCoordinator, setCoordinator)
 		case logAuctionNewForgeAllocated:
 			var newForgeAllocated AuctionEventNewForgeAllocated
-			if err := c.contractAbi.Unpack(&newForgeAllocated, "NewForgeAllocated", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&newForgeAllocated, "NewForgeAllocated", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			newForgeAllocated.Bidder = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
@@ -835,7 +878,7 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *e
 				NewInitialMinBid *big.Int
 			}
 			var newDefaultSlotSetBid AuctionEventNewDefaultSlotSetBid
-			if err := c.contractAbi.Unpack(&auxNewDefaultSlotSetBid, "NewDefaultSlotSetBid", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&auxNewDefaultSlotSetBid, "NewDefaultSlotSetBid", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			newDefaultSlotSetBid.NewInitialMinBid = auxNewDefaultSlotSetBid.NewInitialMinBid
@@ -848,7 +891,7 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *e
 			auctionEvents.NewForge = append(auctionEvents.NewForge, newForge)
 		case logAuctionHEZClaimed:
 			var HEZClaimed AuctionEventHEZClaimed
-			if err := c.contractAbi.Unpack(&HEZClaimed, "HEZClaimed", vLog.Data); err != nil {
+			if err := c.contractAbi.UnpackIntoInterface(&HEZClaimed, "HEZClaimed", vLog.Data); err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
 			HEZClaimed.Owner = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
--- a/eth/auction_test.go
+++ b/eth/auction_test.go
@@ -27,6 +27,20 @@ func TestAuctionGetCurrentSlotNumber(t *testing.T) {
 	assert.Equal(t, currentSlotConst, currentSlotInt)
 }

+func TestAuctionEventInit(t *testing.T) {
+	auctionInit, blockNum, err := auctionClientTest.AuctionEventInit()
+	require.NoError(t, err)
+	assert.Equal(t, int64(18), blockNum)
+	assert.Equal(t, donationAddressConst, auctionInit.DonationAddress)
+	assert.Equal(t, bootCoordinatorAddressConst, auctionInit.BootCoordinatorAddress)
+	assert.Equal(t, "https://boot.coordinator.io", auctionInit.BootCoordinatorURL)
+	assert.Equal(t, uint16(1000), auctionInit.Outbidding)
+	assert.Equal(t, uint8(20), auctionInit.SlotDeadline)
+	assert.Equal(t, uint16(2), auctionInit.ClosedAuctionSlots)
+	assert.Equal(t, uint16(4320), auctionInit.OpenAuctionSlots)
+	assert.Equal(t, [3]uint16{4000, 4000, 2000}, auctionInit.AllocationRatio)
+}
+
 func TestAuctionConstants(t *testing.T) {
 	INITMINBID := new(big.Int)
 	INITMINBID.SetString(minBidStr, 10)
--- a/eth/contracts/auction/HermezAuctionProtocol.go
+++ b/eth/contracts/auction/HermezAuctionProtocol.go
--- a/eth/contracts/hermez/Hermez.go
+++ b/eth/contracts/hermez/Hermez.go
--- a/eth/contracts/tokenHEZ/HEZ.go
+++ b/eth/contracts/tokenHEZ/HEZ.go
--- a/eth/contracts/update.sh
+++ b/eth/contracts/update.sh
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+set -e
+
+gen() {
+    local name=$1
+    local pkg=$2
+    local folder=$3
+    if [ -z "$3" ]; then
+        folder=$name
+    fi
+
+    jq .abi "${CONTRACTS}/artifacts/${pkg}.json" > /tmp/${name}.abi
+    abigen --abi /tmp/${name}.abi --pkg=${pkg} --out=${folder}/${pkg}.go
+}
+
+if [ "$1" = "" ]; then
+    echo "Usage: $0 CONTRACTS_REPO_PATH"
+    exit 1
+fi
+
+CONTRACTS="$1"
+
+gen hermez Hermez
+gen auction HermezAuctionProtocol
+gen withdrawdelayer WithdrawalDelayer
+gen HEZ HEZ tokenHEZ
--- a/eth/contracts/withdrawdelayer/WithdrawalDelayer.go
+++ b/eth/contracts/withdrawdelayer/WithdrawalDelayer.go
--- a/eth/ethereum.go
+++ b/eth/ethereum.go
@@ -137,7 +137,8 @@ func (c *EthereumClient) CallAuth(gasLimit uint64,
 	gasPrice.Add(gasPrice, inc)
 	log.Debugw("Transaction metadata", "gasPrice", gasPrice)

-	auth, err := bind.NewKeyStoreTransactor(c.ks, *c.account)
+	// TODO: Set the correct chainID
+	auth, err := bind.NewKeyStoreTransactorWithChainID(c.ks, *c.account, big.NewInt(0))
 	if err != nil {
 		return nil, tracerr.Wrap(err)
 	}
--- a/eth/rollup.go
+++ b/eth/rollup.go
@@ -51,6 +51,14 @@ type RollupState struct {
 	CurrentIdx             int64
 }

+// RollupEventInitialize is the InitializeHermezEvent event of the
+// Smart Contract
+type RollupEventInitialize struct {
+	ForgeL1L2BatchTimeout uint8
+	FeeAddToken           *big.Int
+	WithdrawalDelay       uint64
+}
+
 // RollupEventL1UserTx is an event of the Rollup Smart Contract
 type RollupEventL1UserTx struct {
 	// ToForgeL1TxsNum int64 // QueueIndex       *big.Int
@@ -660,11 +668,40 @@ var (
 	logHermezWithdrawEvent               = crypto.Keccak256Hash([]byte("WithdrawEvent(uint48,uint32,bool)"))
 	logHermezUpdateBucketWithdraw        = crypto.Keccak256Hash([]byte("UpdateBucketWithdraw(uint8,uint256,uint256)"))
 	logHermezUpdateWithdrawalDelay       = crypto.Keccak256Hash([]byte("UpdateWithdrawalDelay(uint64)"))
-	logHermezUpdateBucketsParameters     = crypto.Keccak256Hash([]byte("UpdateBucketsParameters(uint256[4][" + strconv.Itoa(common.RollupConstNumBuckets) + "])"))
-	logHermezUpdateTokenExchange         = crypto.Keccak256Hash([]byte("UpdateTokenExchange(address[],uint64[])"))
-	logHermezSafeMode                    = crypto.Keccak256Hash([]byte("SafeMode()"))
+	logHermezUpdateBucketsParameters     = crypto.Keccak256Hash([]byte("UpdateBucketsParameters(uint256[4][" +
+		strconv.Itoa(common.RollupConstNumBuckets) + "])"))
+	logHermezUpdateTokenExchange = crypto.Keccak256Hash([]byte("UpdateTokenExchange(address[],uint64[])"))
+	logHermezSafeMode            = crypto.Keccak256Hash([]byte("SafeMode()"))
+	logHermezInitialize          = crypto.Keccak256Hash([]byte("InitializeHermezEvent(uint8,uint256,uint64)"))
 )

+// RollupEventInit returns the initialize event with its corresponding block number
+func (c *RollupClient) RollupEventInit() (*RollupEventInitialize, int64, error) {
+	query := ethereum.FilterQuery{
+		Addresses: []ethCommon.Address{
+			c.address,
+		},
+		Topics: [][]ethCommon.Hash{{logHermezInitialize}},
+	}
+	logs, err := c.client.client.FilterLogs(context.Background(), query)
+	if err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	if len(logs) != 1 {
+		return nil, 0, fmt.Errorf("no event of type InitializeHermezEvent found")
+	}
+	vLog := logs[0]
+	if vLog.Topics[0] != logHermezInitialize {
+		return nil, 0, fmt.Errorf("event is not InitializeHermezEvent")
+	}
+
+	var rollupInit RollupEventInitialize
+	if err := c.contractAbi.UnpackIntoInterface(&rollupInit, "InitializeHermezEvent", vLog.Data); err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	return &rollupInit, int64(vLog.BlockNumber), err
+}
+
 // RollupEventsByBlock returns the events in a block that happened in the Rollup Smart Contract
 func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error) {
 	var rollupEvents RollupEvents
@@ -695,7 +732,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
 		case logHermezL1UserTxEvent:
 			var L1UserTxAux rollupEventL1UserTxAux
 			var L1UserTx RollupEventL1UserTx
-			err := c.contractAbi.Unpack(&L1UserTxAux, "L1UserTxEvent", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&L1UserTxAux, "L1UserTxEvent", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -711,7 +748,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
 			rollupEvents.L1UserTx = append(rollupEvents.L1UserTx, L1UserTx)
 		case logHermezAddToken:
 			var addToken RollupEventAddToken
-			err := c.contractAbi.Unpack(&addToken, "AddToken", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&addToken, "AddToken", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -719,7 +756,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
 			rollupEvents.AddToken = append(rollupEvents.AddToken, addToken)
 		case logHermezForgeBatch:
 			var forgeBatch RollupEventForgeBatch
-			err := c.contractAbi.Unpack(&forgeBatch, "ForgeBatch", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&forgeBatch, "ForgeBatch", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -731,7 +768,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
 			var updateForgeL1L2BatchTimeout struct {
 				NewForgeL1L2BatchTimeout uint8
 			}
-			err := c.contractAbi.Unpack(&updateForgeL1L2BatchTimeout, "UpdateForgeL1L2BatchTimeout", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&updateForgeL1L2BatchTimeout, "UpdateForgeL1L2BatchTimeout", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -741,7 +778,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
 				})
 		case logHermezUpdateFeeAddToken:
 			var updateFeeAddToken RollupEventUpdateFeeAddToken
-			err := c.contractAbi.Unpack(&updateFeeAddToken, "UpdateFeeAddToken", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&updateFeeAddToken, "UpdateFeeAddToken", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -759,7 +796,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
 		case logHermezUpdateBucketWithdraw:
 			var updateBucketWithdrawAux rollupEventUpdateBucketWithdrawAux
 			var updateBucketWithdraw RollupEventUpdateBucketWithdraw
-			err := c.contractAbi.Unpack(&updateBucketWithdrawAux, "UpdateBucketWithdraw", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&updateBucketWithdrawAux, "UpdateBucketWithdraw", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -770,7 +807,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC

 		case logHermezUpdateWithdrawalDelay:
 			var withdrawalDelay RollupEventUpdateWithdrawalDelay
-			err := c.contractAbi.Unpack(&withdrawalDelay, "UpdateWithdrawalDelay", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&withdrawalDelay, "UpdateWithdrawalDelay", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -778,7 +815,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
 		case logHermezUpdateBucketsParameters:
 			var bucketsParametersAux rollupEventUpdateBucketsParametersAux
 			var bucketsParameters RollupEventUpdateBucketsParameters
-			err := c.contractAbi.Unpack(&bucketsParametersAux, "UpdateBucketsParameters", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&bucketsParametersAux, "UpdateBucketsParameters", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -791,7 +828,7 @@ func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethC
 			rollupEvents.UpdateBucketsParameters = append(rollupEvents.UpdateBucketsParameters, bucketsParameters)
 		case logHermezUpdateTokenExchange:
 			var tokensExchange RollupEventUpdateTokenExchange
-			err := c.contractAbi.Unpack(&tokensExchange, "UpdateTokenExchange", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&tokensExchange, "UpdateTokenExchange", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -840,7 +877,9 @@ func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsL
 		return nil, nil, tracerr.Wrap(err)
 	}
 	var aux rollupForgeBatchArgsAux
-	if err := method.Inputs.Unpack(&aux, txData[4:]); err != nil {
+	if values, err := method.Inputs.Unpack(txData[4:]); err != nil {
+		return nil, nil, tracerr.Wrap(err)
+	} else if err := method.Inputs.Copy(&aux, values); err != nil {
 		return nil, nil, tracerr.Wrap(err)
 	}
 	rollupForgeBatchArgs := RollupForgeBatchArgs{
--- a/eth/rollup_test.go
+++ b/eth/rollup_test.go
@@ -55,6 +55,15 @@ func genKeysBjj(i int64) *keys {
 	}
 }

+func TestRollupEventInit(t *testing.T) {
+	rollupInit, blockNum, err := rollupClient.RollupEventInit()
+	require.NoError(t, err)
+	assert.Equal(t, int64(19), blockNum)
+	assert.Equal(t, uint8(10), rollupInit.ForgeL1L2BatchTimeout)
+	assert.Equal(t, big.NewInt(10), rollupInit.FeeAddToken)
+	assert.Equal(t, uint64(60*60*24*7*2), rollupInit.WithdrawalDelay)
+}
+
 func TestRollupConstants(t *testing.T) {
 	rollupConstants, err := rollupClient.RollupConstants()
 	require.NoError(t, err)
--- a/eth/wdelayer.go
+++ b/eth/wdelayer.go
@@ -25,6 +25,14 @@ type DepositState struct {
 	DepositTimestamp uint64
 }

+// WDelayerEventInitialize is the InitializeWithdrawalDelayerEvent event of the
+// Smart Contract
+type WDelayerEventInitialize struct {
+	InitialWithdrawalDelay         uint64
+	InitialHermezGovernanceAddress ethCommon.Address
+	InitialEmergencyCouncil        ethCommon.Address
+}
+
 // WDelayerEventDeposit is an event of the WithdrawalDelayer Smart Contract
 type WDelayerEventDeposit struct {
 	Owner            ethCommon.Address
@@ -105,8 +113,8 @@ type WDelayerInterface interface {
 	WDelayerTransferEmergencyCouncil(newAddress ethCommon.Address) (*types.Transaction, error)
 	WDelayerClaimEmergencyCouncil() (*types.Transaction, error)
 	WDelayerIsEmergencyMode() (bool, error)
-	WDelayerGetWithdrawalDelay() (*big.Int, error)
-	WDelayerGetEmergencyModeStartingTime() (*big.Int, error)
+	WDelayerGetWithdrawalDelay() (int64, error)
+	WDelayerGetEmergencyModeStartingTime() (int64, error)
 	WDelayerEnableEmergencyMode() (*types.Transaction, error)
 	WDelayerChangeWithdrawalDelay(newWithdrawalDelay uint64) (*types.Transaction, error)
 	WDelayerDepositInfo(owner, token ethCommon.Address) (depositInfo DepositState, err error)
@@ -238,25 +246,27 @@ func (c *WDelayerClient) WDelayerIsEmergencyMode() (ermergencyMode bool, err err
 }

 // WDelayerGetWithdrawalDelay is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerGetWithdrawalDelay() (withdrawalDelay *big.Int, err error) {
+func (c *WDelayerClient) WDelayerGetWithdrawalDelay() (withdrawalDelay int64, err error) {
+	var _withdrawalDelay uint64
 	if err := c.client.Call(func(ec *ethclient.Client) error {
-		withdrawalDelay, err = c.wdelayer.GetWithdrawalDelay(c.opts)
+		_withdrawalDelay, err = c.wdelayer.GetWithdrawalDelay(c.opts)
 		return tracerr.Wrap(err)
 	}); err != nil {
-		return nil, tracerr.Wrap(err)
+		return 0, tracerr.Wrap(err)
 	}
-	return withdrawalDelay, nil
+	return int64(_withdrawalDelay), nil
 }

 // WDelayerGetEmergencyModeStartingTime is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerGetEmergencyModeStartingTime() (emergencyModeStartingTime *big.Int, err error) {
+func (c *WDelayerClient) WDelayerGetEmergencyModeStartingTime() (emergencyModeStartingTime int64, err error) {
+	var _emergencyModeStartingTime uint64
 	if err := c.client.Call(func(ec *ethclient.Client) error {
-		emergencyModeStartingTime, err = c.wdelayer.GetEmergencyModeStartingTime(c.opts)
+		_emergencyModeStartingTime, err = c.wdelayer.GetEmergencyModeStartingTime(c.opts)
 		return tracerr.Wrap(err)
 	}); err != nil {
-		return nil, tracerr.Wrap(err)
+		return 0, tracerr.Wrap(err)
 	}
-	return emergencyModeStartingTime, nil
+	return int64(_emergencyModeStartingTime), nil
 }

 // WDelayerEnableEmergencyMode is the interface to call the smart contract function
@@ -368,8 +378,38 @@ var (
 	logWDelayerEscapeHatchWithdrawal      = crypto.Keccak256Hash([]byte("EscapeHatchWithdrawal(address,address,address,uint256)"))
 	logWDelayerNewEmergencyCouncil        = crypto.Keccak256Hash([]byte("NewEmergencyCouncil(address)"))
 	logWDelayerNewHermezGovernanceAddress = crypto.Keccak256Hash([]byte("NewHermezGovernanceAddress(address)"))
+	logWDelayerInitialize                 = crypto.Keccak256Hash([]byte(
+		"InitializeWithdrawalDelayerEvent(uint64,address,address)"))
 )

+// WDelayerEventInit returns the initialize event with its corresponding block number
+func (c *WDelayerClient) WDelayerEventInit() (*WDelayerEventInitialize, int64, error) {
+	query := ethereum.FilterQuery{
+		Addresses: []ethCommon.Address{
+			c.address,
+		},
+		Topics: [][]ethCommon.Hash{{logWDelayerInitialize}},
+	}
+	logs, err := c.client.client.FilterLogs(context.Background(), query)
+	if err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	if len(logs) != 1 {
+		return nil, 0, fmt.Errorf("no event of type InitializeWithdrawalDelayerEvent found")
+	}
+	vLog := logs[0]
+	if vLog.Topics[0] != logWDelayerInitialize {
+		return nil, 0, fmt.Errorf("event is not InitializeWithdrawalDelayerEvent")
+	}
+
+	var wDelayerInit WDelayerEventInitialize
+	if err := c.contractAbi.UnpackIntoInterface(&wDelayerInit, "InitializeWithdrawalDelayerEvent",
+		vLog.Data); err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	return &wDelayerInit, int64(vLog.BlockNumber), err
+}
+
 // WDelayerEventsByBlock returns the events in a block that happened in the
 // WDelayer Smart Contract and the blockHash where the eents happened.  If
 // there are no events in that block, blockHash is nil.
@@ -402,7 +442,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,
 		switch vLog.Topics[0] {
 		case logWDelayerDeposit:
 			var deposit WDelayerEventDeposit
-			err := c.contractAbi.Unpack(&deposit, "Deposit", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&deposit, "Deposit", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -413,7 +453,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,

 		case logWDelayerWithdraw:
 			var withdraw WDelayerEventWithdraw
-			err := c.contractAbi.Unpack(&withdraw, "Withdraw", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&withdraw, "Withdraw", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -427,7 +467,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,

 		case logWDelayerNewWithdrawalDelay:
 			var withdrawalDelay WDelayerEventNewWithdrawalDelay
-			err := c.contractAbi.Unpack(&withdrawalDelay, "NewWithdrawalDelay", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&withdrawalDelay, "NewWithdrawalDelay", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -435,7 +475,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,

 		case logWDelayerEscapeHatchWithdrawal:
 			var escapeHatchWithdrawal WDelayerEventEscapeHatchWithdrawal
-			err := c.contractAbi.Unpack(&escapeHatchWithdrawal, "EscapeHatchWithdrawal", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&escapeHatchWithdrawal, "EscapeHatchWithdrawal", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -446,7 +486,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,

 		case logWDelayerNewEmergencyCouncil:
 			var emergencyCouncil WDelayerEventNewEmergencyCouncil
-			err := c.contractAbi.Unpack(&emergencyCouncil, "NewEmergencyCouncil", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&emergencyCouncil, "NewEmergencyCouncil", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
@@ -454,7 +494,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,

 		case logWDelayerNewHermezGovernanceAddress:
 			var governanceAddress WDelayerEventNewHermezGovernanceAddress
-			err := c.contractAbi.Unpack(&governanceAddress, "NewHermezGovernanceAddress", vLog.Data)
+			err := c.contractAbi.UnpackIntoInterface(&governanceAddress, "NewHermezGovernanceAddress", vLog.Data)
 			if err != nil {
 				return nil, nil, tracerr.Wrap(err)
 			}
--- a/eth/wdelayer_test.go
+++ b/eth/wdelayer_test.go
@@ -12,11 +12,20 @@ import (
 var wdelayerClient *WDelayerClient
 var wdelayerClientTest *WDelayerClient

-var initWithdrawalDelay = big.NewInt(60)
-var newWithdrawalDelay = big.NewInt(79)
+var initWithdrawalDelay int64 = 60
+var newWithdrawalDelay int64 = 79
 var maxEmergencyModeTime = time.Hour * 24 * 7 * 26
 var maxWithdrawalDelay = time.Hour * 24 * 7 * 2

+func TestWDelayerInit(t *testing.T) {
+	wDelayerInit, blockNum, err := wdelayerClientTest.WDelayerEventInit()
+	require.NoError(t, err)
+	assert.Equal(t, int64(16), blockNum)
+	assert.Equal(t, uint64(initWithdrawalDelay), wDelayerInit.InitialWithdrawalDelay)
+	assert.Equal(t, governanceAddressConst, wDelayerInit.InitialHermezGovernanceAddress)
+	assert.Equal(t, emergencyCouncilAddressConst, wDelayerInit.InitialEmergencyCouncil)
+}
+
 func TestWDelayerConstants(t *testing.T) {
 	wDelayerConstants, err := wdelayerClientTest.WDelayerConstants()
 	require.Nil(t, err)
@@ -94,7 +103,7 @@ func TestWDelayerGetWithdrawalDelay(t *testing.T) {
 }

 func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
-	_, err := wdelayerClientTest.WDelayerChangeWithdrawalDelay(newWithdrawalDelay.Uint64())
+	_, err := wdelayerClientTest.WDelayerChangeWithdrawalDelay(uint64(newWithdrawalDelay))
 	require.Nil(t, err)
 	withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
 	require.Nil(t, err)
@@ -103,7 +112,7 @@ func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
 	require.Nil(t, err)
 	wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	require.Nil(t, err)
-	assert.Equal(t, newWithdrawalDelay.Uint64(), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay)
+	assert.Equal(t, uint64(newWithdrawalDelay), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay)
 }

 func TestWDelayerDeposit(t *testing.T) {
@@ -135,7 +144,7 @@ func TestWDelayerWithdrawal(t *testing.T) {
 	amount.SetString("1100000000000000000", 10)
 	_, err := wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
 	require.Contains(t, err.Error(), "WITHDRAWAL_NOT_ALLOWED")
-	addTime(float64(newWithdrawalDelay.Int64()), ethClientDialURL)
+	addTime(float64(newWithdrawalDelay), ethClientDialURL)
 	addBlock(ethClientDialURL)
 	_, err = wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
 	require.Nil(t, err)
@@ -185,7 +194,7 @@ func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {
 	// contract construction.  Since we called WDelayerEnableEmergencyMode
 	// previously, `emergencyModeStartingTime` is set to the time when the
 	// call was made, so it's > 0.
-	assert.True(t, emergencyModeStartingTime.Cmp(big.NewInt(0)) == 1)
+	assert.Greater(t, emergencyModeStartingTime, int64(0))
 }

 func TestWDelayerEscapeHatchWithdrawal(t *testing.T) {