Merge pull request #182 from hermeznetwork/feature/ethclient14-sc

Update ethclient contracts & rollup iteration 1

common/account.go

@@ -21,7 +21,8 @@ const (
 	// maxBalanceBytes is the maximum bytes that can use the Account.Balance *big.Int
 	maxBalanceBytes = 24
 
-	idxBytesLen = 6
+	// IdxBytesLen idx bytes
+	IdxBytesLen = 6
 	// maxIdxValue is the maximum value that Idx can have (48 bits: maxIdxValue=2**48-1)
 	maxIdxValue = 0xffffffffffff
 
@@ -66,8 +67,8 @@ func (idx Idx) BigInt() *big.Int {
 
 // IdxFromBytes returns Idx from a byte array
 func IdxFromBytes(b []byte) (Idx, error) {
-	if len(b) != idxBytesLen {
-		return 0, fmt.Errorf("can not parse Idx, bytes len %d, expected %d", len(b), idxBytesLen)
+	if len(b) != IdxBytesLen {
+		return 0, fmt.Errorf("can not parse Idx, bytes len %d, expected %d", len(b), IdxBytesLen)
 	}
 	var idxBytes [8]byte
 	copy(idxBytes[2:], b[:])

common/bid.go

@@ -9,7 +9,7 @@ import (
 // Bid is a struct that represents one bid in the PoH
 type Bid struct {
 	SlotNum     SlotNum           `meddler:"slot_num"`
-	ForgerAddr  ethCommon.Address `meddler:"forger_addr"` // Coordinator reference
 	BidValue    *big.Int          `meddler:"bid_value,bigint"`
 	EthBlockNum int64             `meddler:"eth_block_num"`
+	Bidder      ethCommon.Address `meddler:"bidder_addr"` // Coordinator reference
 }

common/coordinator.go

@@ -7,8 +7,8 @@ import (
 // Coordinator represents a Hermez network coordinator who wins an auction for an specific slot
 // WARNING: this is strongly based on the previous implementation, once the new spec is done, this may change a lot.
 type Coordinator struct {
-	Forger       ethCommon.Address `meddler:"forger_addr"`   // address of the forger
-	EthBlockNum  int64             `meddler:"eth_block_num"` // block in which the coordinator was registered
-	WithdrawAddr ethCommon.Address `meddler:"withdraw_addr"` // address of the withdraw
-	URL          string            `meddler:"url"`           // URL of the coordinators API
+	Bidder      ethCommon.Address `meddler:"bidder_addr"`   // address of the bidder
+	Forger      ethCommon.Address `meddler:"forger_addr"`   // address of the forger
+	EthBlockNum int64             `meddler:"eth_block_num"` // block in which the coordinator was registered
+	URL         string            `meddler:"url"`           // URL of the coordinators API
 }

coordinator/coordinator_test.go

@@ -168,15 +168,16 @@ func TestCoordinator(t *testing.T) {
 
 	var timer timer
 	ethClientSetup := test.NewClientSetupExample()
-	addr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	ethClient := test.NewClient(true, &timer, &addr, ethClientSetup)
+	bidder := ethCommon.HexToAddress("0x6b175474e89094c44da98b954eedeac495271d0f")
+	forger := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
+	ethClient := test.NewClient(true, &timer, &bidder, ethClientSetup)
 
 	// Bid for slot 2 and 4
-	_, err := ethClient.AuctionRegisterCoordinator(addr, "https://foo.bar")
+	_, err := ethClient.AuctionSetCoordinator(forger, "https://foo.bar")
 	require.Nil(t, err)
-	_, err = ethClient.AuctionBid(2, big.NewInt(9999), addr)
+	_, err = ethClient.AuctionBid(2, big.NewInt(9999))
 	require.Nil(t, err)
-	_, err = ethClient.AuctionBid(4, big.NewInt(9999), addr)
+	_, err = ethClient.AuctionBid(4, big.NewInt(9999))
 	require.Nil(t, err)
 
 	c := NewCoordinator(conf, hdb, txsel, bb, serverProofs, ethClient)

db/historydb/historydb.go

@@ -195,7 +195,7 @@ func (hdb *HistoryDB) addBids(d meddler.DB, bids []common.Bid) error {
 	// TODO: check the coordinator info
 	return db.BulkInsert(
 		d,
-		"INSERT INTO bid (slot_num, forger_addr, bid_value, eth_block_num) VALUES %s;",
+		"INSERT INTO bid (slot_num, bid_value, eth_block_num, bidder_addr) VALUES %s;",
 		bids[:],
 	)
 }
@@ -217,7 +217,7 @@ func (hdb *HistoryDB) AddCoordinators(coordinators []common.Coordinator) error {
 func (hdb *HistoryDB) addCoordinators(d meddler.DB, coordinators []common.Coordinator) error {
 	return db.BulkInsert(
 		d,
-		"INSERT INTO coordinator (forger_addr, eth_block_num, withdraw_addr, url) VALUES %s;",
+		"INSERT INTO coordinator (bidder_addr, forger_addr, eth_block_num, url) VALUES %s;",
 		coordinators[:],
 	)
 }

db/migrations/0001.sql

@@ -8,11 +8,11 @@ CREATE TABLE block (
 );
 
 CREATE TABLE coordinator (
+    bidder_addr BYTEA NOT NULL,
     forger_addr BYTEA NOT NULL,
     eth_block_num BIGINT NOT NULL REFERENCES block (eth_block_num) ON DELETE CASCADE,
-    withdraw_addr BYTEA NOT NULL,
     url VARCHAR(200) NOT NULL,
-    PRIMARY KEY (forger_addr, eth_block_num)
+    PRIMARY KEY (bidder_addr, eth_block_num)
 );
 
 CREATE TABLE batch (
@@ -43,7 +43,7 @@ CREATE TABLE bid (
     slot_num BIGINT NOT NULL,
     bid_value BYTEA NOT NULL,
     eth_block_num BIGINT NOT NULL REFERENCES block (eth_block_num) ON DELETE CASCADE,
-    forger_addr BYTEA NOT NULL, -- fake foreign key for coordinator
+    bidder_addr BYTEA NOT NULL, -- fake foreign key for coordinator
     PRIMARY KEY (slot_num, bid_value)
 );
 

eth/auction.go

@@ -27,37 +27,37 @@ type AuctionConstants struct {
 	InitialMinimalBidding *big.Int
 	// First block where the first slot begins
 	GenesisBlockNum int64
-	// Hermez Governanze Token smartcontract address who controls some parameters and collects HEZ fee
-	// Only for test
-	GovernanceAddress ethCommon.Address
 	// ERC777 token with which the bids will be made
 	TokenHEZ ethCommon.Address
 	// HermezRollup smartcontract address
 	HermezRollup ethCommon.Address
+	// Hermez Governanze Token smartcontract address who controls some parameters and collects HEZ fee
+	// Only for test
+	GovernanceAddress ethCommon.Address
 }
 
 // SlotState is the state of a slot
 type SlotState struct {
-	Forger       ethCommon.Address
+	Bidder       ethCommon.Address
+	Fulfilled    bool
 	BidAmount    *big.Int
 	ClosedMinBid *big.Int
-	Fulfilled    bool
 }
 
 // NewSlotState returns an empty SlotState
 func NewSlotState() *SlotState {
 	return &SlotState{
-		Forger:       ethCommon.Address{},
+		Bidder:       ethCommon.Address{},
+		Fulfilled:    false,
 		BidAmount:    big.NewInt(0),
 		ClosedMinBid: big.NewInt(0),
-		Fulfilled:    false,
 	}
 }
 
 // Coordinator is the details of the Coordinator identified by the forger address
 type Coordinator struct {
-	WithdrawalAddress ethCommon.Address
-	URL               string
+	Forger ethCommon.Address
+	URL    string
 }
 
 // AuctionVariables are the variables of the Auction Smart Contract
@@ -92,9 +92,9 @@ type AuctionState struct {
 
 // AuctionEventNewBid is an event of the Auction Smart Contract
 type AuctionEventNewBid struct {
-	Slot              int64
-	BidAmount         *big.Int
-	CoordinatorForger ethCommon.Address
+	Slot      int64
+	BidAmount *big.Int
+	Bidder    ethCommon.Address
 }
 
 // AuctionEventNewSlotDeadline is an event of the Auction Smart Contract
@@ -132,24 +132,18 @@ type AuctionEventNewAllocationRatio struct {
 	NewAllocationRatio [3]uint16
 }
 
-// AuctionEventNewCoordinator is an event of the Auction Smart Contract
-type AuctionEventNewCoordinator struct {
-	ForgerAddress     ethCommon.Address
-	WithdrawalAddress ethCommon.Address
-	CoordinatorURL    string
-}
-
-// AuctionEventCoordinatorUpdated is an event of the Auction Smart Contract
-type AuctionEventCoordinatorUpdated struct {
-	ForgerAddress     ethCommon.Address
-	WithdrawalAddress ethCommon.Address
-	CoordinatorURL    string
+// AuctionEventSetCoordinator is an event of the Auction Smart Contract
+type AuctionEventSetCoordinator struct {
+	BidderAddress  ethCommon.Address
+	ForgerAddress  ethCommon.Address
+	CoordinatorURL string
 }
 
 // AuctionEventNewForgeAllocated is an event of the Auction Smart Contract
 type AuctionEventNewForgeAllocated struct {
+	Bidder           ethCommon.Address
 	Forger           ethCommon.Address
-	CurrentSlot      int64
+	SlotToForge      int64
 	BurnAmount       *big.Int
 	DonationAmount   *big.Int
 	GovernanceAmount *big.Int
@@ -164,7 +158,7 @@ type AuctionEventNewDefaultSlotSetBid struct {
 // AuctionEventNewForge is an event of the Auction Smart Contract
 type AuctionEventNewForge struct {
 	Forger      ethCommon.Address
-	CurrentSlot int64
+	SlotToForge int64
 }
 
 // AuctionEventHEZClaimed is an event of the Auction Smart Contract
@@ -183,8 +177,7 @@ type AuctionEvents struct { //nolint:structcheck
 	NewBootCoordinator    []AuctionEventNewBootCoordinator
 	NewOpenAuctionSlots   []AuctionEventNewOpenAuctionSlots
 	NewAllocationRatio    []AuctionEventNewAllocationRatio
-	NewCoordinator        []AuctionEventNewCoordinator
-	CoordinatorUpdated    []AuctionEventCoordinatorUpdated
+	SetCoordinator        []AuctionEventSetCoordinator
 	NewForgeAllocated     []AuctionEventNewForgeAllocated
 	NewDefaultSlotSetBid  []AuctionEventNewDefaultSlotSetBid
 	NewForge              []AuctionEventNewForge
@@ -202,8 +195,7 @@ func NewAuctionEvents() AuctionEvents {
 		NewBootCoordinator:    make([]AuctionEventNewBootCoordinator, 0),
 		NewOpenAuctionSlots:   make([]AuctionEventNewOpenAuctionSlots, 0),
 		NewAllocationRatio:    make([]AuctionEventNewAllocationRatio, 0),
-		NewCoordinator:        make([]AuctionEventNewCoordinator, 0),
-		CoordinatorUpdated:    make([]AuctionEventCoordinatorUpdated, 0),
+		SetCoordinator:        make([]AuctionEventSetCoordinator, 0),
 		NewForgeAllocated:     make([]AuctionEventNewForgeAllocated, 0),
 		NewDefaultSlotSetBid:  make([]AuctionEventNewDefaultSlotSetBid, 0),
 		NewForge:              make([]AuctionEventNewForge, 0),
@@ -235,9 +227,7 @@ type AuctionInterface interface {
 	AuctionChangeDefaultSlotSetBid(slotSet int64, newInitialMinBid *big.Int) (*types.Transaction, error)
 
 	// Coordinator Management
-	AuctionRegisterCoordinator(forgerAddress ethCommon.Address, URL string) (*types.Transaction, error)
-	AuctionIsRegisteredCoordinator(forgerAddress ethCommon.Address) (bool, error)
-	AuctionUpdateCoordinatorInfo(forgerAddress ethCommon.Address, newWithdrawAddress ethCommon.Address, newURL string) (*types.Transaction, error)
+	AuctionSetCoordinator(forger ethCommon.Address, coordinatorURL string) (*types.Transaction, error)
 
 	// Slot Info
 	AuctionGetSlotNumber(blockNum int64) (int64, error)
@@ -247,17 +237,16 @@ type AuctionInterface interface {
 	AuctionGetSlotSet(slot int64) (*big.Int, error)
 
 	// Bidding
-	// AuctionTokensReceived(operator, from, to ethCommon.Address, amount *big.Int,
-	// 	userData, operatorData []byte) error // Only called from another smart contract
-	AuctionBid(slot int64, bidAmount *big.Int, forger ethCommon.Address) (*types.Transaction, error)
-	AuctionMultiBid(startingSlot int64, endingSlot int64, slotSet [6]bool, maxBid, closedMinBid, budget *big.Int, forger ethCommon.Address) (*types.Transaction, error)
+	AuctionBid(slot int64, bidAmount *big.Int) (*types.Transaction, error)
+	AuctionMultiBid(startingSlot int64, endingSlot int64, slotSet [6]bool, maxBid, closedMinBid, budget *big.Int) (*types.Transaction, error)
 
 	// Forge
 	AuctionCanForge(forger ethCommon.Address, blockNum int64) (bool, error)
-	// AuctionForge(forger ethCommon.Address) (bool, error) // Only called from another smart contract
+	AuctionForge(forger ethCommon.Address) (*types.Transaction, error)
 
 	// Fees
-	AuctionClaimHEZ(claimAddress ethCommon.Address) (*types.Transaction, error)
+	AuctionClaimHEZ() (*types.Transaction, error)
+	AuctionGetClaimableHEZ(bidder ethCommon.Address) (*big.Int, error)
 
 	//
 	// Smart Contract Status
@@ -576,43 +565,8 @@ func (c *AuctionClient) AuctionGetClaimableHEZ(claimAddress ethCommon.Address) (
 	return claimableHEZ, nil
 }
 
-// AuctionRegisterCoordinator is the interface to call the smart contract function
-func (c *AuctionClient) AuctionRegisterCoordinator(forgerAddress ethCommon.Address, URL string) (*types.Transaction, error) {
-	var tx *types.Transaction
-	var err error
-	if tx, err = c.client.CallAuth(
-		c.gasLimit,
-		func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
-			auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
-			if err != nil {
-				return nil, err
-			}
-			return auction.RegisterCoordinator(auth, forgerAddress, URL)
-		},
-	); err != nil {
-		return nil, fmt.Errorf("Failed register coordinator: %w", err)
-	}
-	return tx, nil
-}
-
-// AuctionIsRegisteredCoordinator is the interface to call the smart contract function
-func (c *AuctionClient) AuctionIsRegisteredCoordinator(forgerAddress ethCommon.Address) (bool, error) {
-	var registered bool
-	if err := c.client.Call(func(ec *ethclient.Client) error {
-		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
-		if err != nil {
-			return err
-		}
-		registered, err = auction.IsRegisteredCoordinator(nil, forgerAddress)
-		return err
-	}); err != nil {
-		return false, err
-	}
-	return registered, nil
-}
-
-// AuctionUpdateCoordinatorInfo is the interface to call the smart contract function
-func (c *AuctionClient) AuctionUpdateCoordinatorInfo(forgerAddress ethCommon.Address, newWithdrawAddress ethCommon.Address, newURL string) (*types.Transaction, error) {
+// AuctionSetCoordinator is the interface to call the smart contract function
+func (c *AuctionClient) AuctionSetCoordinator(forger ethCommon.Address, coordinatorURL string) (*types.Transaction, error) {
 	var tx *types.Transaction
 	var err error
 	if tx, err = c.client.CallAuth(
@@ -622,10 +576,10 @@ func (c *AuctionClient) AuctionUpdateCoordinatorInfo(forgerAddress ethCommon.Add
 			if err != nil {
 				return nil, err
 			}
-			return auction.UpdateCoordinatorInfo(auth, forgerAddress, newWithdrawAddress, newURL)
+			return auction.SetCoordinator(auth, forger, coordinatorURL)
 		},
 	); err != nil {
-		return nil, fmt.Errorf("Failed update coordinator info: %w", err)
+		return nil, fmt.Errorf("Failed set coordinator: %w", err)
 	}
 	return tx, nil
 }
@@ -715,7 +669,7 @@ func (c *AuctionClient) AuctionGetSlotNumber(blockNum int64) (int64, error) {
 }
 
 // AuctionBid is the interface to call the smart contract function
-func (c *AuctionClient) AuctionBid(slot int64, bidAmount *big.Int, forger ethCommon.Address) (*types.Transaction, error) {
+func (c *AuctionClient) AuctionBid(slot int64, bidAmount *big.Int) (*types.Transaction, error) {
 	var tx *types.Transaction
 	var err error
 	if tx, err = c.client.CallAuth(
@@ -725,7 +679,7 @@ func (c *AuctionClient) AuctionBid(slot int64, bidAmount *big.Int, forger ethCom
 			if err != nil {
 				return nil, err
 			}
-			bidFnSignature := []byte("bid(uint128,uint128,address)")
+			bidFnSignature := []byte("bid(uint128,uint128)")
 			hash := sha3.NewLegacyKeccak256()
 			_, err = hash.Write(bidFnSignature)
 			if err != nil {
@@ -736,12 +690,10 @@ func (c *AuctionClient) AuctionBid(slot int64, bidAmount *big.Int, forger ethCom
 			binary.BigEndian.PutUint64(slotBytes, uint64(slot))
 			paddedSlot := ethCommon.LeftPadBytes(slotBytes, 32)
 			paddedAmount := ethCommon.LeftPadBytes(bidAmount.Bytes(), 32)
-			paddedAddress := ethCommon.LeftPadBytes(forger.Bytes(), 32)
 			var userData []byte
 			userData = append(userData, methodID...)
 			userData = append(userData, paddedSlot...)
 			userData = append(userData, paddedAmount...)
-			userData = append(userData, paddedAddress...)
 			return tokens.Send(auth, c.address, bidAmount, userData)
 		},
 	); err != nil {
@@ -751,7 +703,7 @@ func (c *AuctionClient) AuctionBid(slot int64, bidAmount *big.Int, forger ethCom
 }
 
 // AuctionMultiBid is the interface to call the smart contract function
-func (c *AuctionClient) AuctionMultiBid(startingSlot int64, endingSlot int64, slotSet [6]bool, maxBid, closedMinBid, budget *big.Int, forger ethCommon.Address) (*types.Transaction, error) {
+func (c *AuctionClient) AuctionMultiBid(startingSlot int64, endingSlot int64, slotSet [6]bool, maxBid, closedMinBid, budget *big.Int) (*types.Transaction, error) {
 	var tx *types.Transaction
 	var err error
 	if tx, err = c.client.CallAuth(
@@ -761,7 +713,7 @@ func (c *AuctionClient) AuctionMultiBid(startingSlot int64, endingSlot int64, sl
 			if err != nil {
 				return nil, err
 			}
-			multiBidFnSignature := []byte("multiBid(uint128,uint128,bool[6],uint128,uint128,address)")
+			multiBidFnSignature := []byte("multiBid(uint128,uint128,bool[6],uint128,uint128)")
 			hash := sha3.NewLegacyKeccak256()
 			_, err = hash.Write(multiBidFnSignature)
 			if err != nil {
@@ -776,7 +728,6 @@ func (c *AuctionClient) AuctionMultiBid(startingSlot int64, endingSlot int64, sl
 			paddedEndingSlot := ethCommon.LeftPadBytes(endingSlotBytes, 32)
 			paddedMinBid := ethCommon.LeftPadBytes(closedMinBid.Bytes(), 32)
 			paddedMaxBid := ethCommon.LeftPadBytes(maxBid.Bytes(), 32)
-			paddedAddress := ethCommon.LeftPadBytes(forger.Bytes(), 32)
 			var userData []byte
 			userData = append(userData, methodID...)
 			userData = append(userData, paddedStartingSlot...)
@@ -792,7 +743,6 @@ func (c *AuctionClient) AuctionMultiBid(startingSlot int64, endingSlot int64, sl
 			}
 			userData = append(userData, paddedMaxBid...)
 			userData = append(userData, paddedMinBid...)
-			userData = append(userData, paddedAddress...)
 			return tokens.Send(auth, c.address, budget, userData)
 		},
 	); err != nil {
@@ -817,13 +767,8 @@ func (c *AuctionClient) AuctionCanForge(forger ethCommon.Address, blockNum int64
 	return canForge, nil
 }
 
-// AuctionForge is the interface to call the smart contract function
-// func (c *AuctionClient) AuctionForge(forger ethCommon.Address) (bool, error) {
-// 	return false, errTODO
-// }
-
 // AuctionClaimHEZ is the interface to call the smart contract function
-func (c *AuctionClient) AuctionClaimHEZ(claimAddress ethCommon.Address) (*types.Transaction, error) {
+func (c *AuctionClient) AuctionClaimHEZ() (*types.Transaction, error) {
 	var tx *types.Transaction
 	var err error
 	if tx, err = c.client.CallAuth(
@@ -833,7 +778,7 @@ func (c *AuctionClient) AuctionClaimHEZ(claimAddress ethCommon.Address) (*types.
 			if err != nil {
 				return nil, err
 			}
-			return auction.ClaimHEZ(auth, claimAddress)
+			return auction.ClaimHEZ(auth)
 		},
 	); err != nil {
 		return nil, fmt.Errorf("Failed claim HEZ: %w", err)
@@ -942,20 +887,19 @@ func (c *AuctionClient) AuctionVariables() (*AuctionVariables, error) {
 }
 
 var (
-	logNewBid                = crypto.Keccak256Hash([]byte("NewBid(uint128,uint128,address)"))
-	logNewSlotDeadline       = crypto.Keccak256Hash([]byte("NewSlotDeadline(uint8)"))
-	logNewClosedAuctionSlots = crypto.Keccak256Hash([]byte("NewClosedAuctionSlots(uint16)"))
-	logNewOutbidding         = crypto.Keccak256Hash([]byte("NewOutbidding(uint16)"))
-	logNewDonationAddress    = crypto.Keccak256Hash([]byte("NewDonationAddress(address)"))
-	logNewBootCoordinator    = crypto.Keccak256Hash([]byte("NewBootCoordinator(address)"))
-	logNewOpenAuctionSlots   = crypto.Keccak256Hash([]byte("NewOpenAuctionSlots(uint16)"))
-	logNewAllocationRatio    = crypto.Keccak256Hash([]byte("NewAllocationRatio(uint16[3])"))
-	logNewCoordinator        = crypto.Keccak256Hash([]byte("NewCoordinator(address,address,string)"))
-	logCoordinatorUpdated    = crypto.Keccak256Hash([]byte("CoordinatorUpdated(address,address,string)"))
-	logNewForgeAllocated     = crypto.Keccak256Hash([]byte("NewForgeAllocated(address,uint128,uint128,uint128,uint128)"))
-	logNewDefaultSlotSetBid  = crypto.Keccak256Hash([]byte("NewDefaultSlotSetBid(uint128,uint128)"))
-	logNewForge              = crypto.Keccak256Hash([]byte("NewForge(address,uint128)"))
-	logHEZClaimed            = crypto.Keccak256Hash([]byte("HEZClaimed(address,uint128)"))
+	logAuctionNewBid                = crypto.Keccak256Hash([]byte("NewBid(uint128,uint128,address)"))
+	logAuctionNewSlotDeadline       = crypto.Keccak256Hash([]byte("NewSlotDeadline(uint8)"))
+	logAuctionNewClosedAuctionSlots = crypto.Keccak256Hash([]byte("NewClosedAuctionSlots(uint16)"))
+	logAuctionNewOutbidding         = crypto.Keccak256Hash([]byte("NewOutbidding(uint16)"))
+	logAuctionNewDonationAddress    = crypto.Keccak256Hash([]byte("NewDonationAddress(address)"))
+	logAuctionNewBootCoordinator    = crypto.Keccak256Hash([]byte("NewBootCoordinator(address)"))
+	logAuctionNewOpenAuctionSlots   = crypto.Keccak256Hash([]byte("NewOpenAuctionSlots(uint16)"))
+	logAuctionNewAllocationRatio    = crypto.Keccak256Hash([]byte("NewAllocationRatio(uint16[3])"))
+	logAuctionSetCoordinator        = crypto.Keccak256Hash([]byte("SetCoordinator(address,address,string)"))
+	logAuctionNewForgeAllocated     = crypto.Keccak256Hash([]byte("NewForgeAllocated(address,address,uint128,uint128,uint128,uint128)"))
+	logAuctionNewDefaultSlotSetBid  = crypto.Keccak256Hash([]byte("NewDefaultSlotSetBid(uint128,uint128)"))
+	logAuctionNewForge              = crypto.Keccak256Hash([]byte("NewForge(address,uint128)"))
+	logAuctionHEZClaimed            = crypto.Keccak256Hash([]byte("HEZClaimed(address,uint128)"))
 )
 
 // AuctionEventsByBlock returns the events in a block that happened in the
@@ -986,7 +930,7 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *e
 			return nil, nil, ErrBlockHashMismatchEvent
 		}
 		switch vLog.Topics[0] {
-		case logNewBid:
+		case logAuctionNewBid:
 			var auxNewBid struct {
 				Slot      *big.Int
 				BidAmount *big.Int
@@ -998,71 +942,64 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *e
 			}
 			newBid.BidAmount = auxNewBid.BidAmount
 			newBid.Slot = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
-			newBid.CoordinatorForger = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
+			newBid.Bidder = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
 			auctionEvents.NewBid = append(auctionEvents.NewBid, newBid)
-		case logNewSlotDeadline:
+		case logAuctionNewSlotDeadline:
 			var newSlotDeadline AuctionEventNewSlotDeadline
 			if err := c.contractAbi.Unpack(&newSlotDeadline, "NewSlotDeadline", vLog.Data); err != nil {
 				return nil, nil, err
 			}
 			auctionEvents.NewSlotDeadline = append(auctionEvents.NewSlotDeadline, newSlotDeadline)
-		case logNewClosedAuctionSlots:
+		case logAuctionNewClosedAuctionSlots:
 			var newClosedAuctionSlots AuctionEventNewClosedAuctionSlots
 			if err := c.contractAbi.Unpack(&newClosedAuctionSlots, "NewClosedAuctionSlots", vLog.Data); err != nil {
 				return nil, nil, err
 			}
 			auctionEvents.NewClosedAuctionSlots = append(auctionEvents.NewClosedAuctionSlots, newClosedAuctionSlots)
-		case logNewOutbidding:
+		case logAuctionNewOutbidding:
 			var newOutbidding AuctionEventNewOutbidding
 			if err := c.contractAbi.Unpack(&newOutbidding, "NewOutbidding", vLog.Data); err != nil {
 				return nil, nil, err
 			}
 			auctionEvents.NewOutbidding = append(auctionEvents.NewOutbidding, newOutbidding)
-		case logNewDonationAddress:
+		case logAuctionNewDonationAddress:
 			var newDonationAddress AuctionEventNewDonationAddress
-			if err := c.contractAbi.Unpack(&newDonationAddress, "NewDonationAddress", vLog.Data); err != nil {
-				return nil, nil, err
-			}
+			newDonationAddress.NewDonationAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			auctionEvents.NewDonationAddress = append(auctionEvents.NewDonationAddress, newDonationAddress)
-		case logNewBootCoordinator:
+		case logAuctionNewBootCoordinator:
 			var newBootCoordinator AuctionEventNewBootCoordinator
-			if err := c.contractAbi.Unpack(&newBootCoordinator, "NewBootCoordinator", vLog.Data); err != nil {
-				return nil, nil, err
-			}
+			newBootCoordinator.NewBootCoordinator = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			auctionEvents.NewBootCoordinator = append(auctionEvents.NewBootCoordinator, newBootCoordinator)
-		case logNewOpenAuctionSlots:
+		case logAuctionNewOpenAuctionSlots:
 			var newOpenAuctionSlots AuctionEventNewOpenAuctionSlots
 			if err := c.contractAbi.Unpack(&newOpenAuctionSlots, "NewOpenAuctionSlots", vLog.Data); err != nil {
 				return nil, nil, err
 			}
 			auctionEvents.NewOpenAuctionSlots = append(auctionEvents.NewOpenAuctionSlots, newOpenAuctionSlots)
-		case logNewAllocationRatio:
+		case logAuctionNewAllocationRatio:
 			var newAllocationRatio AuctionEventNewAllocationRatio
 			if err := c.contractAbi.Unpack(&newAllocationRatio, "NewAllocationRatio", vLog.Data); err != nil {
 				return nil, nil, err
 			}
 			auctionEvents.NewAllocationRatio = append(auctionEvents.NewAllocationRatio, newAllocationRatio)
-		case logNewCoordinator:
-			var newCoordinator AuctionEventNewCoordinator
-			if err := c.contractAbi.Unpack(&newCoordinator, "NewCoordinator", vLog.Data); err != nil {
-				return nil, nil, err
-			}
-			auctionEvents.NewCoordinator = append(auctionEvents.NewCoordinator, newCoordinator)
-		case logCoordinatorUpdated:
-			var coordinatorUpdated AuctionEventCoordinatorUpdated
-			if err := c.contractAbi.Unpack(&coordinatorUpdated, "CoordinatorUpdated", vLog.Data); err != nil {
+		case logAuctionSetCoordinator:
+			var setCoordinator AuctionEventSetCoordinator
+			if err := c.contractAbi.Unpack(&setCoordinator, "SetCoordinator", vLog.Data); err != nil {
 				return nil, nil, err
 			}
-			auctionEvents.CoordinatorUpdated = append(auctionEvents.CoordinatorUpdated, coordinatorUpdated)
-		case logNewForgeAllocated:
+			setCoordinator.BidderAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
+			setCoordinator.ForgerAddress = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
+			auctionEvents.SetCoordinator = append(auctionEvents.SetCoordinator, setCoordinator)
+		case logAuctionNewForgeAllocated:
 			var newForgeAllocated AuctionEventNewForgeAllocated
 			if err := c.contractAbi.Unpack(&newForgeAllocated, "NewForgeAllocated", vLog.Data); err != nil {
 				return nil, nil, err
 			}
-			newForgeAllocated.Forger = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
-			newForgeAllocated.CurrentSlot = new(big.Int).SetBytes(vLog.Topics[2][:]).Int64()
+			newForgeAllocated.Bidder = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
+			newForgeAllocated.Forger = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
+			newForgeAllocated.SlotToForge = new(big.Int).SetBytes(vLog.Topics[3][:]).Int64()
 			auctionEvents.NewForgeAllocated = append(auctionEvents.NewForgeAllocated, newForgeAllocated)
-		case logNewDefaultSlotSetBid:
+		case logAuctionNewDefaultSlotSetBid:
 			var auxNewDefaultSlotSetBid struct {
 				SlotSet          *big.Int
 				NewInitialMinBid *big.Int
@@ -1074,12 +1011,12 @@ func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *e
 			newDefaultSlotSetBid.NewInitialMinBid = auxNewDefaultSlotSetBid.NewInitialMinBid
 			newDefaultSlotSetBid.SlotSet = auxNewDefaultSlotSetBid.SlotSet.Int64()
 			auctionEvents.NewDefaultSlotSetBid = append(auctionEvents.NewDefaultSlotSetBid, newDefaultSlotSetBid)
-		case logNewForge:
+		case logAuctionNewForge:
 			var newForge AuctionEventNewForge
 			newForge.Forger = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
-			newForge.CurrentSlot = new(big.Int).SetBytes(vLog.Topics[2][:]).Int64()
+			newForge.SlotToForge = new(big.Int).SetBytes(vLog.Topics[2][:]).Int64()
 			auctionEvents.NewForge = append(auctionEvents.NewForge, newForge)
-		case logHEZClaimed:
+		case logAuctionHEZClaimed:
 			var HEZClaimed AuctionEventHEZClaimed
 			if err := c.contractAbi.Unpack(&HEZClaimed, "HEZClaimed", vLog.Data); err != nil {
 				return nil, nil, err

eth/auction_test.go

@@ -16,18 +16,19 @@ const currentSlotConst = 0
 
 var allocationRatioConst [3]uint16 = [3]uint16{4000, 4000, 2000}
 
-var auctionClient *AuctionClient
+var auctionClientTest *AuctionClient
 
-//var genesisBlock = 91
-var genesisBlock = 98
+//var genesisBlock = 93
+var genesisBlock = 100
 
 var minBidStr = "10000000000000000000"
 var URL = "http://localhost:3000"
-var newURL = "http://localhost:3002"
+
+// var newURL = "http://localhost:3002"
 var BLOCKSPERSLOT = uint8(40)
 
 func TestAuctionGetCurrentSlotNumber(t *testing.T) {
-	currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
+	currentSlot, err := auctionClientTest.AuctionGetCurrentSlotNumber()
 	require.Nil(t, err)
 	currentSlotInt := int(currentSlot)
 	assert.Equal(t, currentSlotConst, currentSlotInt)
@@ -37,13 +38,13 @@ func TestAuctionConstants(t *testing.T) {
 	INITMINBID := new(big.Int)
 	INITMINBID.SetString(minBidStr, 10)
 
-	auctionConstants, err := auctionClient.AuctionConstants()
+	auctionConstants, err := auctionClientTest.AuctionConstants()
 	require.Nil(t, err)
 	assert.Equal(t, auctionConstants.BlocksPerSlot, BLOCKSPERSLOT)
-	// assert.Equal(t, auctionConstants.GenesisBlockNum, GENESISBLOCKNUM)
+	assert.Equal(t, auctionConstants.GenesisBlockNum, int64(genesisBlock))
 	assert.Equal(t, auctionConstants.HermezRollup, hermezRollupAddressTestConst)
 	assert.Equal(t, auctionConstants.InitialMinimalBidding, INITMINBID)
-	assert.Equal(t, auctionConstants.TokenHEZ, tokenHezAddressConst)
+	assert.Equal(t, auctionConstants.TokenHEZ, tokenHEZAddressConst)
 }
 
 func TestAuctionVariables(t *testing.T) {
@@ -51,7 +52,7 @@ func TestAuctionVariables(t *testing.T) {
 	INITMINBID.SetString(minBidStr, 10)
 	defaultSlotSetBid := [6]*big.Int{INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID, INITMINBID}
 
-	auctionVariables, err := auctionClient.AuctionVariables()
+	auctionVariables, err := auctionClientTest.AuctionVariables()
 	require.Nil(t, err)
 	assert.Equal(t, auctionVariables.AllocationRatio, allocationRatioConst)
 	assert.Equal(t, auctionVariables.BootCoordinator, bootCoordinatorAddressConst)
@@ -64,7 +65,7 @@ func TestAuctionVariables(t *testing.T) {
 }
 
 func TestAuctionGetSlotDeadline(t *testing.T) {
-	slotDeadline, err := auctionClient.AuctionGetSlotDeadline()
+	slotDeadline, err := auctionClientTest.AuctionGetSlotDeadline()
 	require.Nil(t, err)
 	assert.Equal(t, slotDeadlineConst, slotDeadline)
 }
@@ -72,18 +73,18 @@ func TestAuctionGetSlotDeadline(t *testing.T) {
 func TestAuctionSetSlotDeadline(t *testing.T) {
 	newSlotDeadline := uint8(25)
 
-	_, err := auctionClient.AuctionSetSlotDeadline(newSlotDeadline)
+	_, err := auctionClientTest.AuctionSetSlotDeadline(newSlotDeadline)
 	require.Nil(t, err)
-	slotDeadline, err := auctionClient.AuctionGetSlotDeadline()
+	slotDeadline, err := auctionClientTest.AuctionGetSlotDeadline()
 	require.Nil(t, err)
 	assert.Equal(t, newSlotDeadline, slotDeadline)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, newSlotDeadline, auctionEvents.NewSlotDeadline[0].NewSlotDeadline)
 }
 
 func TestAuctionGetOpenAuctionSlots(t *testing.T) {
-	openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots()
+	openAuctionSlots, err := auctionClientTest.AuctionGetOpenAuctionSlots()
 	require.Nil(t, err)
 	assert.Equal(t, openAuctionSlotsConst, openAuctionSlots)
 }
@@ -91,18 +92,18 @@ func TestAuctionGetOpenAuctionSlots(t *testing.T) {
 func TestAuctionSetOpenAuctionSlots(t *testing.T) {
 	newOpenAuctionSlots := uint16(4500)
 
-	_, err := auctionClient.AuctionSetOpenAuctionSlots(newOpenAuctionSlots)
+	_, err := auctionClientTest.AuctionSetOpenAuctionSlots(newOpenAuctionSlots)
 	require.Nil(t, err)
-	openAuctionSlots, err := auctionClient.AuctionGetOpenAuctionSlots()
+	openAuctionSlots, err := auctionClientTest.AuctionGetOpenAuctionSlots()
 	require.Nil(t, err)
 	assert.Equal(t, newOpenAuctionSlots, openAuctionSlots)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, newOpenAuctionSlots, auctionEvents.NewOpenAuctionSlots[0].NewOpenAuctionSlots)
 }
 
 func TestAuctionGetClosedAuctionSlots(t *testing.T) {
-	closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots()
+	closedAuctionSlots, err := auctionClientTest.AuctionGetClosedAuctionSlots()
 	require.Nil(t, err)
 	assert.Equal(t, closedAuctionSlotsConst, closedAuctionSlots)
 }
@@ -110,20 +111,20 @@ func TestAuctionGetClosedAuctionSlots(t *testing.T) {
 func TestAuctionSetClosedAuctionSlots(t *testing.T) {
 	newClosedAuctionSlots := uint16(1)
 
-	_, err := auctionClient.AuctionSetClosedAuctionSlots(newClosedAuctionSlots)
+	_, err := auctionClientTest.AuctionSetClosedAuctionSlots(newClosedAuctionSlots)
 	require.Nil(t, err)
-	closedAuctionSlots, err := auctionClient.AuctionGetClosedAuctionSlots()
+	closedAuctionSlots, err := auctionClientTest.AuctionGetClosedAuctionSlots()
 	require.Nil(t, err)
 	assert.Equal(t, newClosedAuctionSlots, closedAuctionSlots)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, newClosedAuctionSlots, auctionEvents.NewClosedAuctionSlots[0].NewClosedAuctionSlots)
-	_, err = auctionClient.AuctionSetClosedAuctionSlots(closedAuctionSlots)
+	_, err = auctionClientTest.AuctionSetClosedAuctionSlots(closedAuctionSlots)
 	require.Nil(t, err)
 }
 
 func TestAuctionGetOutbidding(t *testing.T) {
-	outbidding, err := auctionClient.AuctionGetOutbidding()
+	outbidding, err := auctionClientTest.AuctionGetOutbidding()
 	require.Nil(t, err)
 	assert.Equal(t, outbiddingConst, outbidding)
 }
@@ -131,20 +132,20 @@ func TestAuctionGetOutbidding(t *testing.T) {
 func TestAuctionSetOutbidding(t *testing.T) {
 	newOutbidding := uint16(0xb)
 
-	_, err := auctionClient.AuctionSetOutbidding(newOutbidding)
+	_, err := auctionClientTest.AuctionSetOutbidding(newOutbidding)
 	require.Nil(t, err)
-	outbidding, err := auctionClient.AuctionGetOutbidding()
+	outbidding, err := auctionClientTest.AuctionGetOutbidding()
 	require.Nil(t, err)
 	assert.Equal(t, newOutbidding, outbidding)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, newOutbidding, auctionEvents.NewOutbidding[0].NewOutbidding)
-	_, err = auctionClient.AuctionSetOutbidding(outbiddingConst)
+	_, err = auctionClientTest.AuctionSetOutbidding(outbiddingConst)
 	require.Nil(t, err)
 }
 
 func TestAuctionGetAllocationRatio(t *testing.T) {
-	allocationRatio, err := auctionClient.AuctionGetAllocationRatio()
+	allocationRatio, err := auctionClientTest.AuctionGetAllocationRatio()
 	require.Nil(t, err)
 	assert.Equal(t, allocationRatioConst, allocationRatio)
 }
@@ -152,26 +153,26 @@ func TestAuctionGetAllocationRatio(t *testing.T) {
 func TestAuctionSetAllocationRatio(t *testing.T) {
 	newAllocationRatio := [3]uint16{3000, 3000, 4000}
 
-	_, err := auctionClient.AuctionSetAllocationRatio(newAllocationRatio)
+	_, err := auctionClientTest.AuctionSetAllocationRatio(newAllocationRatio)
 	require.Nil(t, err)
-	allocationRatio, err := auctionClient.AuctionGetAllocationRatio()
+	allocationRatio, err := auctionClientTest.AuctionGetAllocationRatio()
 	require.Nil(t, err)
 	assert.Equal(t, newAllocationRatio, allocationRatio)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, newAllocationRatio, auctionEvents.NewAllocationRatio[0].NewAllocationRatio)
-	_, err = auctionClient.AuctionSetAllocationRatio(allocationRatioConst)
+	_, err = auctionClientTest.AuctionSetAllocationRatio(allocationRatioConst)
 	require.Nil(t, err)
 }
 
 func TestAuctionGetDonationAddress(t *testing.T) {
-	donationAddress, err := auctionClient.AuctionGetDonationAddress()
+	donationAddress, err := auctionClientTest.AuctionGetDonationAddress()
 	require.Nil(t, err)
 	assert.Equal(t, &donationAddressConst, donationAddress)
 }
 
 func TestAuctionGetBootCoordinator(t *testing.T) {
-	bootCoordinator, err := auctionClient.AuctionGetBootCoordinator()
+	bootCoordinator, err := auctionClientTest.AuctionGetBootCoordinator()
 	require.Nil(t, err)
 	assert.Equal(t, &bootCoordinatorAddressConst, bootCoordinator)
 }
@@ -179,37 +180,37 @@ func TestAuctionGetBootCoordinator(t *testing.T) {
 func TestAuctionSetDonationAddress(t *testing.T) {
 	newDonationAddress := governanceAddressConst
 
-	_, err := auctionClient.AuctionSetDonationAddress(newDonationAddress)
+	_, err := auctionClientTest.AuctionSetDonationAddress(newDonationAddress)
 	require.Nil(t, err)
-	donationAddress, err := auctionClient.AuctionGetDonationAddress()
+	donationAddress, err := auctionClientTest.AuctionGetDonationAddress()
 	require.Nil(t, err)
 	assert.Equal(t, &newDonationAddress, donationAddress)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, newDonationAddress, auctionEvents.NewDonationAddress[0].NewDonationAddress)
-	_, err = auctionClient.AuctionSetDonationAddress(donationAddressConst)
+	_, err = auctionClientTest.AuctionSetDonationAddress(donationAddressConst)
 	require.Nil(t, err)
 }
 
 func TestAuctionSetBootCoordinator(t *testing.T) {
 	newBootCoordinator := governanceAddressConst
 
-	_, err := auctionClient.AuctionSetBootCoordinator(newBootCoordinator)
+	_, err := auctionClientTest.AuctionSetBootCoordinator(newBootCoordinator)
 	require.Nil(t, err)
-	bootCoordinator, err := auctionClient.AuctionGetBootCoordinator()
+	bootCoordinator, err := auctionClientTest.AuctionGetBootCoordinator()
 	require.Nil(t, err)
 	assert.Equal(t, &newBootCoordinator, bootCoordinator)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, newBootCoordinator, auctionEvents.NewBootCoordinator[0].NewBootCoordinator)
-	_, err = auctionClient.AuctionSetBootCoordinator(bootCoordinatorAddressConst)
+	_, err = auctionClientTest.AuctionSetBootCoordinator(bootCoordinatorAddressConst)
 	require.Nil(t, err)
 }
 
 func TestAuctionGetSlotSet(t *testing.T) {
 	slot := int64(10)
 
-	slotSet, err := auctionClient.AuctionGetSlotSet(slot)
+	slotSet, err := auctionClientTest.AuctionGetSlotSet(slot)
 	require.Nil(t, err)
 	assert.Equal(t, slotSet, big.NewInt(4))
 }
@@ -217,7 +218,7 @@ func TestAuctionGetSlotSet(t *testing.T) {
 func TestAuctionGetDefaultSlotSetBid(t *testing.T) {
 	slotSet := uint8(3)
 
-	minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(slotSet)
+	minBid, err := auctionClientTest.AuctionGetDefaultSlotSetBid(slotSet)
 	require.Nil(t, err)
 	assert.Equal(t, minBid.String(), minBidStr)
 }
@@ -228,81 +229,54 @@ func TestAuctionChangeDefaultSlotSetBid(t *testing.T) {
 	newInitialMinBid := new(big.Int)
 	newInitialMinBid.SetString("20000000000000000000", 10)
 
-	_, err := auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newInitialMinBid)
+	_, err := auctionClientTest.AuctionChangeDefaultSlotSetBid(slotSet, newInitialMinBid)
 	require.Nil(t, err)
-	minBid, err := auctionClient.AuctionGetDefaultSlotSetBid(set)
+	minBid, err := auctionClientTest.AuctionGetDefaultSlotSetBid(set)
 	require.Nil(t, err)
 	assert.Equal(t, minBid, newInitialMinBid)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, slotSet, auctionEvents.NewDefaultSlotSetBid[0].SlotSet)
 	assert.Equal(t, newInitialMinBid, auctionEvents.NewDefaultSlotSetBid[0].NewInitialMinBid)
 	newMinBid := new(big.Int)
 	newMinBid.SetString("10000000000000000000", 10)
-	_, err = auctionClient.AuctionChangeDefaultSlotSetBid(slotSet, newMinBid)
+	_, err = auctionClientTest.AuctionChangeDefaultSlotSetBid(slotSet, newMinBid)
 	require.Nil(t, err)
 }
 
 func TestAuctionGetClaimableHEZ(t *testing.T) {
-	forgerAddress := governanceAddressConst
+	bidderAddress := governanceAddressConst
 
-	claimableHEZ, err := auctionClient.AuctionGetClaimableHEZ(forgerAddress)
+	claimableHEZ, err := auctionClientTest.AuctionGetClaimableHEZ(bidderAddress)
 	require.Nil(t, err)
 	assert.Equal(t, claimableHEZ.Int64(), int64(0))
 }
 
-func TestAuctionIsRegisteredCoordinator(t *testing.T) {
-	forgerAddress := governanceAddressConst
-
-	registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
-	require.Nil(t, err)
-	assert.Equal(t, registered, false)
-}
-
 func TestAuctionRegisterCoordinator(t *testing.T) {
 	forgerAddress := governanceAddressConst
+	bidderAddress := governanceAddressConst
 
-	_, err := auctionClient.AuctionRegisterCoordinator(forgerAddress, URL)
-	require.Nil(t, err)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
-	assert.Equal(t, forgerAddress, auctionEvents.NewCoordinator[0].ForgerAddress)
-	assert.Equal(t, forgerAddress, auctionEvents.NewCoordinator[0].WithdrawalAddress)
-	assert.Equal(t, URL, auctionEvents.NewCoordinator[0].CoordinatorURL)
-}
-
-func TestAuctionIsRegisteredCoordinatorTrue(t *testing.T) {
-	forgerAddress := governanceAddressConst
-
-	registered, err := auctionClient.AuctionIsRegisteredCoordinator(forgerAddress)
-	require.Nil(t, err)
-	assert.Equal(t, registered, true)
-}
-
-func TestAuctionUpdateCoordinatorInfo(t *testing.T) {
-	forgerAddress := governanceAddressConst
-
-	_, err := auctionClient.AuctionUpdateCoordinatorInfo(forgerAddress, forgerAddress, newURL)
+	_, err := auctionClientTest.AuctionSetCoordinator(forgerAddress, URL)
 	require.Nil(t, err)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
-	assert.Equal(t, forgerAddress, auctionEvents.CoordinatorUpdated[0].ForgerAddress)
-	assert.Equal(t, forgerAddress, auctionEvents.CoordinatorUpdated[0].WithdrawalAddress)
-	assert.Equal(t, newURL, auctionEvents.CoordinatorUpdated[0].CoordinatorURL)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
+	assert.Equal(t, forgerAddress, auctionEvents.SetCoordinator[0].ForgerAddress)
+	assert.Equal(t, bidderAddress, auctionEvents.SetCoordinator[0].BidderAddress)
+	assert.Equal(t, URL, auctionEvents.SetCoordinator[0].CoordinatorURL)
 }
 
 func TestAuctionBid(t *testing.T) {
-	currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
+	currentSlot, err := auctionClientTest.AuctionGetCurrentSlotNumber()
 	require.Nil(t, err)
 	bidAmount := new(big.Int)
 	bidAmount.SetString("12000000000000000000", 10)
-	forgerAddress := governanceAddressConst
-	_, err = auctionClient.AuctionBid(currentSlot+4, bidAmount, forgerAddress)
+	bidderAddress := governanceAddressConst
+	_, err = auctionClientTest.AuctionBid(currentSlot+4, bidAmount)
 	require.Nil(t, err)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, bidAmount, auctionEvents.NewBid[0].BidAmount)
-	assert.Equal(t, forgerAddress, auctionEvents.NewBid[0].CoordinatorForger)
+	assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
 	assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
 }
 
@@ -310,22 +284,22 @@ func TestAuctionGetSlotNumber(t *testing.T) {
 	slotConst := 4
 	blockNum := int(BLOCKSPERSLOT)*slotConst + genesisBlock
 
-	slot, err := auctionClient.AuctionGetSlotNumber(int64(blockNum))
+	slot, err := auctionClientTest.AuctionGetSlotNumber(int64(blockNum))
 	require.Nil(t, err)
-	assert.Equal(t, slot, big.NewInt(int64(slotConst)))
+	assert.Equal(t, slot, int64(slotConst))
 }
 
 func TestAuctionCanForge(t *testing.T) {
 	slotConst := 4
 	blockNum := int(BLOCKSPERSLOT)*slotConst + genesisBlock
 
-	canForge, err := auctionClient.AuctionCanForge(governanceAddressConst, int64(blockNum))
+	canForge, err := auctionClientTest.AuctionCanForge(governanceAddressConst, int64(blockNum))
 	require.Nil(t, err)
 	assert.Equal(t, canForge, true)
 }
 
 func TestAuctionMultiBid(t *testing.T) {
-	currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
+	currentSlot, err := auctionClientTest.AuctionGetCurrentSlotNumber()
 	require.Nil(t, err)
 	slotSet := [6]bool{true, false, true, false, true, false}
 	maxBid := new(big.Int)
@@ -334,27 +308,27 @@ func TestAuctionMultiBid(t *testing.T) {
 	minBid.SetString("11000000000000000000", 10)
 	budget := new(big.Int)
 	budget.SetString("45200000000000000000", 10)
-	forgerAddress := governanceAddressConst
-	_, err = auctionClient.AuctionMultiBid(currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, budget, forgerAddress)
+	bidderAddress := governanceAddressConst
+	_, err = auctionClientTest.AuctionMultiBid(currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, budget)
 	require.Nil(t, err)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
-	assert.Equal(t, forgerAddress, auctionEvents.NewBid[0].CoordinatorForger)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
+	assert.Equal(t, bidderAddress, auctionEvents.NewBid[0].Bidder)
 	assert.Equal(t, currentSlot+4, auctionEvents.NewBid[0].Slot)
-	assert.Equal(t, forgerAddress, auctionEvents.NewBid[1].CoordinatorForger)
+	assert.Equal(t, bidderAddress, auctionEvents.NewBid[1].Bidder)
 	assert.Equal(t, currentSlot+6, auctionEvents.NewBid[1].Slot)
-	assert.Equal(t, forgerAddress, auctionEvents.NewBid[2].CoordinatorForger)
+	assert.Equal(t, bidderAddress, auctionEvents.NewBid[2].Bidder)
 	assert.Equal(t, currentSlot+8, auctionEvents.NewBid[2].Slot)
-	assert.Equal(t, forgerAddress, auctionEvents.NewBid[3].CoordinatorForger)
+	assert.Equal(t, bidderAddress, auctionEvents.NewBid[3].Bidder)
 	assert.Equal(t, currentSlot+10, auctionEvents.NewBid[3].Slot)
 }
 
 func TestAuctionGetClaimableHEZ2(t *testing.T) {
-	forgerAddress := governanceAddressConst
+	bidderAddress := governanceAddressConst
 	amount := new(big.Int)
 	amount.SetString("11000000000000000000", 10)
 
-	claimableHEZ, err := auctionClient.AuctionGetClaimableHEZ(forgerAddress)
+	claimableHEZ, err := auctionClientTest.AuctionGetClaimableHEZ(bidderAddress)
 	require.Nil(t, err)
 	assert.Equal(t, claimableHEZ, amount)
 }
@@ -363,26 +337,26 @@ func TestAuctionClaimHEZ(t *testing.T) {
 	amount := new(big.Int)
 	amount.SetString("11000000000000000000", 10)
 
-	_, err := auctionClient.AuctionClaimHEZ(governanceAddressConst)
+	_, err := auctionClientTest.AuctionClaimHEZ()
 	require.Nil(t, err)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
-	auctionEvents, _, _ := auctionClient.AuctionEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
+	auctionEvents, _, _ := auctionClientTest.AuctionEventsByBlock(currentBlockNum)
 	assert.Equal(t, amount, auctionEvents.HEZClaimed[0].Amount)
 	assert.Equal(t, governanceAddressConst, auctionEvents.HEZClaimed[0].Owner)
 }
 
 func TestAuctionForge(t *testing.T) {
-	auctionClientHermez, err := NewAuctionClient(ethereumClientHermez, auctionAddressConst, tokenHezAddressConst)
+	auctionClientTestHermez, err := NewAuctionClient(ethereumClientHermez, auctionTestAddressConst, tokenHEZAddressConst)
 	require.Nil(t, err)
 	slotConst := 4
 	blockNum := int64(int(BLOCKSPERSLOT)*slotConst + genesisBlock)
-	currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
+	currentBlockNum, _ := auctionClientTest.client.EthCurrentBlock()
 	blocksToAdd := blockNum - currentBlockNum
 	addBlocks(blocksToAdd, ethClientDialURL)
-	currentBlockNum, _ = auctionClient.client.EthCurrentBlock()
+	currentBlockNum, _ = auctionClientTest.client.EthCurrentBlock()
 	assert.Equal(t, currentBlockNum, blockNum)
-	_, err = auctionClientHermez.AuctionForge(bootCoordinatorAddressConst)
+	_, err = auctionClientTestHermez.AuctionForge(bootCoordinatorAddressConst)
 	require.Contains(t, err.Error(), "Can't forge")
-	_, err = auctionClientHermez.AuctionForge(governanceAddressConst)
+	_, err = auctionClientTestHermez.AuctionForge(governanceAddressConst)
 	require.Nil(t, err)
 }

eth/contracts/README.md

@@ -6,10 +6,11 @@ The go code of the contracts has been generated with the following command:
 abigen --abi=WithdrawalDelayer.abi --bin=WithdrawalDelayer.bin --pkg=WithdrawalDelayer --out=WithdrawalDelayer.go
 abigen --abi=Hermez.abi --bin=Hermez.bin --pkg=Hermez --out=Hermez.go
 abigen --abi=HermezAuctionProtocol.abi --bin=HermezAuctionProtocol.bin --pkg=HermezAuctionProtocol --out=HermezAuctionProtocol.go
+abigen --abi=ERC777.abi --bin=ERC777.bin --pkg=ERC777 --out=ERC777.go
 ```
-You must compile the contracts to get the `.bin` and `.abi` files. The contracts used are in the repo: https://github.com/hermeznetwork/contracts-circuits
+You must compile the contracts to get the `.bin` and `.abi` files. The contracts used are in the repo: https://github.com/hermeznetwork/contracts
 
-Specifically they have been processed in the commit with hash: `745e8d588496d7762d4084a54bafd4435061ae35`
+Specifically they have been processed in the commit with hash: `60e03e981f1ce607c27d405952bfc98de376f0c5`
 
 > abigen version 1.9.21
 

eth/main_test.go

@@ -25,20 +25,27 @@ var password = "pass"
 
 // Smart Contract Addresses
 var (
-	// auctionAddressStr           = "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5"
-	// wdelayerAddressStr          = "0x1A1FEe7EeD918BD762173e4dc5EfDB8a78C924A8"
-	auctionAddressStr           = "0x8B5B7a6055E54a36fF574bbE40cf2eA68d5554b3"
+	auctionAddressStr           = "0x500D1d6A4c7D8Ae28240b47c8FCde034D827fD5e"
 	auctionAddressConst         = ethCommon.HexToAddress(auctionAddressStr)
+	auctionTestAddressStr       = "0x1d80315fac6aBd3EfeEbE97dEc44461ba7556160"
+	auctionTestAddressConst     = ethCommon.HexToAddress(auctionTestAddressStr)
 	donationAddressStr          = "0x6c365935CA8710200C7595F0a72EB6023A7706Cd"
 	donationAddressConst        = ethCommon.HexToAddress(donationAddressStr)
 	bootCoordinatorAddressStr   = "0xc783df8a850f42e7f7e57013759c285caa701eb6"
 	bootCoordinatorAddressConst = ethCommon.HexToAddress(bootCoordinatorAddressStr)
-	tokenHezAddressStr          = "0xf4e77E5Da47AC3125140c470c71cBca77B5c638c" //nolint:gosec
-	tokenHezAddressConst        = ethCommon.HexToAddress(tokenHezAddressStr)
-	hermezRollupAddressStr      = "0xc4905364b78a742ccce7B890A89514061E47068D"
+	tokenERC777AddressStr       = "0xf784709d2317D872237C4bC22f867d1BAe2913AB" //nolint:gosec
+	tokenERC777AddressConst     = ethCommon.HexToAddress(tokenERC777AddressStr)
+	tokenERC20AddressStr        = "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5" //nolint:gosec
+	tokenERC20AddressConst      = ethCommon.HexToAddress(tokenERC20AddressStr)
+	tokenHEZAddressConst        = tokenERC777AddressConst
+	hermezRollupAddressStr      = "0xEcc0a6dbC0bb4D51E4F84A315a9e5B0438cAD4f0"
 	hermezRollupAddressConst    = ethCommon.HexToAddress(hermezRollupAddressStr)
-	wdelayerAddressStr          = "0x20Ce94F404343aD2752A2D01b43fa407db9E0D00"
+	wdelayerAddressStr          = "0xD6C850aeBFDC46D7F4c207e445cC0d6B0919BDBe"
 	wdelayerAddressConst        = ethCommon.HexToAddress(wdelayerAddressStr)
+	wdelayerTestAddressStr      = "0x52d3b94181f8654db2530b0fEe1B19173f519C52"
+	wdelayerTestAddressConst    = ethCommon.HexToAddress(wdelayerTestAddressStr)
+	safetyAddressStr            = "0xE5904695748fe4A84b40b3fc79De2277660BD1D3"
+	safetyAddressConst          = ethCommon.HexToAddress(safetyAddressStr)
 )
 
 // Ethereum Accounts
@@ -126,15 +133,22 @@ func TestMain(m *testing.M) {
 		// Controllable Governance Address
 
 		ethereumClientGov := NewEthereumClient(ethClient, accountGov, ks, nil)
-		auctionClient, err = NewAuctionClient(ethereumClientGov, auctionAddressConst, tokenHezAddressConst)
+		auctionClientTest, err = NewAuctionClient(ethereumClientGov, auctionTestAddressConst, tokenHEZAddressConst)
+		if err != nil {
+			panic(err)
+		}
+		rollupClient, err = NewRollupClient(ethereumClientGov, hermezRollupAddressConst)
 		if err != nil {
 			panic(err)
 		}
-		rollupClient = NewRollupClient(ethereumClientGov, hermezRollupAddressConst)
 		wdelayerClient, err = NewWDelayerClient(ethereumClientGov, wdelayerAddressConst)
 		if err != nil {
 			panic(err)
 		}
+		wdelayerClientTest, err = NewWDelayerClient(ethereumClientGov, wdelayerTestAddressConst)
+		if err != nil {
+			panic(err)
+		}
 
 		ethereumClientKep = NewEthereumClient(ethClient, accountKep, ks, nil)
 		ethereumClientWhite = NewEthereumClient(ethClient, accountWhite, ks, nil)

eth/rollup.go

@@ -1,10 +1,15 @@
 package eth
 
 import (
+	"context"
 	"math/big"
+	"strings"
 
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/hermeznetwork/hermez-node/common"
 	Hermez "github.com/hermeznetwork/hermez-node/eth/contracts/hermez"
@@ -13,15 +18,85 @@ import (
 )
 
 const (
-	// FeeIdxCoordinatorLen is the number of tokens the coordinator can use
+	// RollupConstFeeIdxCoordinatorLen is the number of tokens the coordinator can use
 	// to collect fees (determines the number of tokens that the
 	// coordinator can collect fees from).  This value is determined by the
 	// circuit.
-	FeeIdxCoordinatorLen = 64
+	RollupConstFeeIdxCoordinatorLen = 64
+	// RollupConstReservedIDx First 256 indexes reserved, first user index will be the 256
+	RollupConstReservedIDx = 255
+	// RollupConstExitIDx IDX 1 is reserved for exits
+	RollupConstExitIDx = 1
+	// RollupConstLimitLoadAmount Max load amount allowed (loadAmount: L1 --> L2)
+	RollupConstLimitLoadAmount = (1 << 128)
+	// RollupConstLimitL2TransferAmount Max amount allowed (amount L2 --> L2)
+	RollupConstLimitL2TransferAmount = (1 << 192)
+	// RollupConstLimitTokens Max number of tokens allowed to be registered inside the rollup
+	RollupConstLimitTokens = (1 << 32)
+	// RollupConstL1CoordinatorTotalBytes [4 bytes] token + [32 bytes] babyjub + [65 bytes] compressedSignature
+	RollupConstL1CoordinatorTotalBytes = 101
+	// RollupConstL1UserTotalBytes [20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6 bytes] fromIdx +
+	// [2 bytes] loadAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx
+	RollupConstL1UserTotalBytes = 72
+	// RollupConstMaxL1UserTx Maximum L1-user transactions allowed to be queued in a batch
+	RollupConstMaxL1UserTx = 128
+	// RollupConstMaxL1Tx Maximum L1 transactions allowed to be queued in a batch
+	RollupConstMaxL1Tx = 256
+	// RollupConstInputSHAConstantBytes [6 bytes] lastIdx + [6 bytes] newLastIdx  + [32 bytes] stateRoot  + [32 bytes] newStRoot  + [32 bytes] newExitRoot +
+	// [_MAX_L1_TX * _L1_USER_TOTALBYTES bytes] l1TxsData + totalL2TxsDataLength + feeIdxCoordinatorLength + [2 bytes] chainID =
+	// 18542 bytes +  totalL2TxsDataLength + feeIdxCoordinatorLength
+	RollupConstInputSHAConstantBytes = 18542
+	// RollupConstNumBuckets Number of buckets
+	RollupConstNumBuckets = 5
+	// RollupConstMaxWithdrawalDelay max withdrawal delay in seconds
+	RollupConstMaxWithdrawalDelay = 2 * 7 * 24 * 60 * 60
+	// RollupConstExchangeMultiplier exchange multiplier
+	RollupConstExchangeMultiplier = 1e14
+	// LenVerifiers number of Rollup Smart Contract Verifiers
+	LenVerifiers = 1
+)
+
+var (
+	// RollupConstEthAddressInternalOnly This ethereum address is used internally for rollup accounts that don't have ethereum address, only Babyjubjub
+	// This non-ethereum accounts can be created by the coordinator and allow users to have a rollup
+	// account without needing an ethereum address
+	RollupConstEthAddressInternalOnly = ethCommon.HexToAddress("0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF")
+	// RollupConstRfield Modulus zkSNARK
+	RollupConstRfield, _ = new(big.Int).SetString(
+		"21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
+
+	// RollupConstERC1820 ERC1820Registry address
+	RollupConstERC1820 = ethCommon.HexToAddress("0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24")
+
+	// ERC777 tokens signatures
+
+	// RollupConstRecipientInterfaceHash ERC777 recipient interface hash
+	RollupConstRecipientInterfaceHash = crypto.Keccak256([]byte("ERC777TokensRecipient"))
+	// RollupConstPerformL1UserTxSignature the signature of the function that can be called thru an ERC777 `send`
+	RollupConstPerformL1UserTxSignature = crypto.Keccak256([]byte("addL1Transaction(uint256,uint48,uint16,uint16,uint32,uint48)"))
+	// RollupConstAddTokenSignature the signature of the function that can be called thru an ERC777 `send`
+	RollupConstAddTokenSignature = crypto.Keccak256([]byte("addToken(address)"))
+	// RollupConstSendSignature ERC777 Signature
+	RollupConstSendSignature = crypto.Keccak256([]byte("send(address,uint256,bytes)"))
+	// RollupConstERC777Granularity ERC777 Signature
+	RollupConstERC777Granularity = crypto.Keccak256([]byte("granularity()"))
+	// RollupConstWithdrawalDelayerDeposit  This constant are used to deposit tokens from ERC77 tokens into withdrawal delayer
+	RollupConstWithdrawalDelayerDeposit = crypto.Keccak256([]byte("deposit(address,address,uint192)"))
+
+	// ERC20 signature
+
+	// RollupConstTransferSignature This constant is used in the _safeTransfer internal method in order to safe GAS.
+	RollupConstTransferSignature = crypto.Keccak256([]byte("transfer(address,uint256)"))
+	// RollupConstTransferFromSignature This constant is used in the _safeTransfer internal method in order to safe GAS.
+	RollupConstTransferFromSignature = crypto.Keccak256([]byte("transferFrom(address,address,uint256)"))
+	// RollupConstApproveSignature This constant is used in the _safeTransfer internal method in order to safe GAS.
+	RollupConstApproveSignature = crypto.Keccak256([]byte("approve(address,uint256)"))
+	// RollupConstERC20Signature ERC20 decimals signature
+	RollupConstERC20Signature = crypto.Keccak256([]byte("decimals()"))
 )
 
 // RollupConstants are the constants of the Rollup Smart Contract
-type RollupConstants struct {
+/* type RollupConstants struct {
 	// Maxim Deposit allowed
 	MaxAmountDeposit *big.Int
 	MaxAmountL2      *big.Int
@@ -50,12 +125,24 @@ type RollupConstants struct {
 	NoLimitToken       int
 	NumBuckets         int
 	MaxWDelay          int64
+}*/
+
+// RollupPublicConstants are the constants of the Rollup Smart Contract
+type RollupPublicConstants struct {
+	AbsoluteMaxL1L2BatchTimeout int64
+	TokenHEZ                    ethCommon.Address
+	Verifiers                   []RollupVerifierStruct
+	HermezAuctionContract       ethCommon.Address
+	HermezGovernanceDAOAddress  ethCommon.Address
+	SafetyAddress               ethCommon.Address
+	WithdrawDelayerContract     ethCommon.Address
 }
 
 // RollupVariables are the variables of the Rollup Smart Contract
 type RollupVariables struct {
-	FeeAddToken    *big.Int
-	ForgeL1Timeout int64
+	FeeAddToken           *big.Int
+	ForgeL1L2BatchTimeout int64
+	WithdrawalDelay       uint64
 }
 
 // QueueStruct is the queue of L1Txs for a batch
@@ -73,6 +160,12 @@ func NewQueueStruct() *QueueStruct {
 	}
 }
 
+// RollupVerifierStruct is the information about verifiers of the Rollup Smart Contract
+type RollupVerifierStruct struct {
+	MaxTx   int64
+	NLevels int64
+}
+
 // RollupState represents the state of the Rollup in the Smart Contract
 //nolint:structcheck,unused
 type RollupState struct {
@@ -90,9 +183,16 @@ type RollupState struct {
 
 // RollupEventL1UserTx is an event of the Rollup Smart Contract
 type RollupEventL1UserTx struct {
-	L1Tx            common.L1Tx
 	ToForgeL1TxsNum int64 // QueueIndex       *big.Int
 	Position        int   // TransactionIndex *big.Int
+	L1Tx            common.L1Tx
+}
+
+// RollupEventL1UserTxAux is an event of the Rollup Smart Contract
+type RollupEventL1UserTxAux struct {
+	ToForgeL1TxsNum uint64 // QueueIndex       *big.Int
+	Position        uint8  // TransactionIndex *big.Int
+	L1Tx            []byte
 }
 
 // RollupEventAddToken is an event of the Rollup Smart Contract
@@ -109,7 +209,7 @@ type RollupEventForgeBatch struct {
 
 // RollupEventUpdateForgeL1L2BatchTimeout is an event of the Rollup Smart Contract
 type RollupEventUpdateForgeL1L2BatchTimeout struct {
-	ForgeL1Timeout *big.Int
+	ForgeL1L2BatchTimeout uint8
 }
 
 // RollupEventUpdateFeeAddToken is an event of the Rollup Smart Contract
@@ -119,8 +219,8 @@ type RollupEventUpdateFeeAddToken struct {
 
 // RollupEventWithdrawEvent is an event of the Rollup Smart Contract
 type RollupEventWithdrawEvent struct {
-	Idx             *big.Int
-	NumExitRoot     *big.Int
+	Idx             uint64
+	NumExitRoot     uint64
 	InstantWithdraw bool
 }
 
@@ -149,19 +249,35 @@ func NewRollupEvents() RollupEvents {
 // RollupForgeBatchArgs are the arguments to the ForgeBatch function in the Rollup Smart Contract
 //nolint:structcheck,unused
 type RollupForgeBatchArgs struct {
-	ProofA                [2]*big.Int
-	ProofB                [2][2]*big.Int
-	ProofC                [2]*big.Int
-	NewLastIdx            int64
-	NewStRoot             *big.Int
-	NewExitRoot           *big.Int
-	L1CoordinatorTxs      []*common.L1Tx
-	L1CoordinatorTxsAuths [][]byte // Authorization for accountCreations for each L1CoordinatorTxs
-	L2Txs                 []*common.L2Tx
-	FeeIdxCoordinator     []common.Idx
+	NewLastIdx        int64
+	NewStRoot         *big.Int
+	NewExitRoot       *big.Int
+	L1CoordinatorTxs  []*common.L1Tx
+	L2TxsData         []*common.L2Tx
+	FeeIdxCoordinator []common.Idx
 	// Circuit selector
-	VerifierIdx int64
+	VerifierIdx uint8
 	L1Batch     bool
+	ProofA      [2]*big.Int
+	ProofB      [2][2]*big.Int
+	ProofC      [2]*big.Int
+}
+
+// RollupForgeBatchArgsAux are the arguments to the ForgeBatch function in the Rollup Smart Contract
+//nolint:structcheck,unused
+type RollupForgeBatchArgsAux struct {
+	NewLastIdx        uint64
+	NewStRoot         *big.Int
+	NewExitRoot       *big.Int
+	L1CoordinatorTxs  []byte
+	L2TxsData         []byte
+	FeeIdxCoordinator []byte
+	// Circuit selector
+	VerifierIdx uint8
+	L1Batch     bool
+	ProofA      [2]*big.Int
+	ProofB      [2][2]*big.Int
+	ProofC      [2]*big.Int
 }
 
 // RollupInterface is the inteface to to Rollup Smart Contract
@@ -201,7 +317,7 @@ type RollupInterface interface {
 	// Smart Contract Status
 	//
 
-	RollupConstants() (*RollupConstants, error)
+	RollupConstants() (*RollupPublicConstants, error)
 	RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error)
 	RollupForgeBatchArgs(ethCommon.Hash) (*RollupForgeBatchArgs, error)
 }
@@ -212,16 +328,22 @@ type RollupInterface interface {
 
 // RollupClient is the implementation of the interface to the Rollup Smart Contract in ethereum.
 type RollupClient struct {
-	client  *EthereumClient
-	address ethCommon.Address
+	client      *EthereumClient
+	address     ethCommon.Address
+	contractAbi abi.ABI
 }
 
 // NewRollupClient creates a new RollupClient
-func NewRollupClient(client *EthereumClient, address ethCommon.Address) *RollupClient {
-	return &RollupClient{
-		client:  client,
-		address: address,
+func NewRollupClient(client *EthereumClient, address ethCommon.Address) (*RollupClient, error) {
+	contractAbi, err := abi.JSON(strings.NewReader(string(Hermez.HermezABI)))
+	if err != nil {
+		return nil, err
 	}
+	return &RollupClient{
+		client:      client,
+		address:     address,
+		contractAbi: contractAbi,
+	}, nil
 }
 
 // RollupForgeBatch is the interface to call the smart contract function
@@ -323,99 +445,210 @@ func (c *RollupClient) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (*types.
 }
 
 // RollupConstants returns the Constants of the Rollup Smart Contract
-func (c *RollupClient) RollupConstants() (*RollupConstants, error) {
-	rollupConstants := new(RollupConstants)
+func (c *RollupClient) RollupConstants() (*RollupPublicConstants, error) {
+	rollupConstants := new(RollupPublicConstants)
 	if err := c.client.Call(func(ec *ethclient.Client) error {
-		rollup, err := Hermez.NewHermez(c.address, ec)
-		if err != nil {
-			return err
-		}
-		// rollupConstants.GovernanceAddress :=
-		l1CoordinatorBytes, err := rollup.L1COORDINATORBYTES(nil)
-		if err != nil {
-			return err
-		}
-		rollupConstants.L1CoordinatorBytes = int(l1CoordinatorBytes.Int64())
-		l1UserBytes, err := rollup.L1USERBYTES(nil)
-		if err != nil {
-			return err
-		}
-		rollupConstants.L1UserBytes = int(l1UserBytes.Int64())
-		l2Bytes, err := rollup.L2BYTES(nil)
-		if err != nil {
-			return err
-		}
-		rollupConstants.L2Bytes = int(l2Bytes.Int64())
-		rollupConstants.LastIDx, err = rollup.LASTIDX(nil)
-		if err != nil {
-			return err
-		}
-		rollupConstants.MaxAmountDeposit, err = rollup.MAXLOADAMOUNT(nil)
-		if err != nil {
-			return err
-		}
-		rollupConstants.MaxAmountL2, err = rollup.MAXAMOUNT(nil)
+		hermez, err := Hermez.NewHermez(c.address, ec)
 		if err != nil {
 			return err
 		}
-		maxL1Tx, err := rollup.MAXL1TX(nil)
+		absoluteMaxL1L2BatchTimeout, err := hermez.ABSOLUTEMAXL1L2BATCHTIMEOUT(nil)
 		if err != nil {
 			return err
 		}
-		rollupConstants.MaxL1Tx = int(maxL1Tx.Int64())
-		maxL1UserTx, err := rollup.MAXL1USERTX(nil)
+		rollupConstants.AbsoluteMaxL1L2BatchTimeout = int64(absoluteMaxL1L2BatchTimeout)
+		rollupConstants.TokenHEZ, err = hermez.TokenHEZ(nil)
 		if err != nil {
 			return err
 		}
-		rollupConstants.MaxL1UserTx = int(maxL1UserTx.Int64())
-		maxTokens, err := rollup.MAXTOKENS(nil)
-		if err != nil {
-			return err
+		for i := int64(0); i < int64(LenVerifiers); i++ {
+			var newRollupVerifier RollupVerifierStruct
+			rollupVerifier, err := hermez.RollupVerifiers(nil, big.NewInt(i))
+			if err != nil {
+				return err
+			}
+			newRollupVerifier.MaxTx = rollupVerifier.MaxTx.Int64()
+			newRollupVerifier.NLevels = rollupVerifier.NLevels.Int64()
+			rollupConstants.Verifiers = append(rollupConstants.Verifiers, newRollupVerifier)
 		}
-		rollupConstants.MaxTokens = maxTokens.Int64()
-		maxWDelay, err := rollup.MAXWITHDRAWALDELAY(nil)
+		rollupConstants.HermezAuctionContract, err = hermez.HermezAuctionContract(nil)
 		if err != nil {
 			return err
 		}
-		rollupConstants.MaxWDelay = maxWDelay.Int64()
-		noLimitToken, err := rollup.NOLIMIT(nil)
+		rollupConstants.HermezGovernanceDAOAddress, err = hermez.HermezGovernanceDAOAddress(nil)
 		if err != nil {
 			return err
 		}
-		rollupConstants.NoLimitToken = int(noLimitToken.Int64())
-		numBuckets, err := rollup.NUMBUCKETS(nil)
+		rollupConstants.SafetyAddress, err = hermez.SafetyAddress(nil)
 		if err != nil {
 			return err
 		}
-		rollupConstants.NumBuckets = int(numBuckets.Int64())
-		// rollupConstants.ReservedIDx =
-		rollupConstants.Rfield, err = rollup.RFIELD(nil)
-		if err != nil {
-			return err
-		}
-		// rollupConstants.SafetyBot =
-		// rollupConstants.TokenHEZ =
-		// rollupConstants.WithdrawalContract =
-		return nil
+		rollupConstants.WithdrawDelayerContract, err = hermez.WithdrawDelayerContract(nil)
+		return err
 	}); err != nil {
 		return nil, err
 	}
 	return rollupConstants, nil
 }
 
+var (
+	logHermezL1UserTxEvent               = crypto.Keccak256Hash([]byte("L1UserTxEvent(uint64,uint8,bytes)"))
+	logHermezAddToken                    = crypto.Keccak256Hash([]byte("AddToken(address,uint32)"))
+	logHermezForgeBatch                  = crypto.Keccak256Hash([]byte("ForgeBatch(uint64)"))
+	logHermezUpdateForgeL1L2BatchTimeout = crypto.Keccak256Hash([]byte("UpdateForgeL1L2BatchTimeout(uint8)"))
+	logHermezUpdateFeeAddToken           = crypto.Keccak256Hash([]byte("UpdateFeeAddToken(uint256)"))
+	logHermezWithdrawEvent               = crypto.Keccak256Hash([]byte("WithdrawEvent(uint48,uint48,bool)"))
+)
+
 // RollupEventsByBlock returns the events in a block that happened in the Rollup Smart Contract
 func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error) {
-	log.Error("TODO")
-	return nil, nil, errTODO
+	var rollupEvents RollupEvents
+	var blockHash ethCommon.Hash
+
+	query := ethereum.FilterQuery{
+		FromBlock: big.NewInt(blockNum),
+		ToBlock:   big.NewInt(blockNum),
+		Addresses: []ethCommon.Address{
+			c.address,
+		},
+		BlockHash: nil,
+		Topics:    [][]ethCommon.Hash{},
+	}
+	logs, err := c.client.client.FilterLogs(context.Background(), query)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(logs) > 0 {
+		blockHash = logs[0].BlockHash
+	}
+	for _, vLog := range logs {
+		if vLog.BlockHash != blockHash {
+			return nil, nil, ErrBlockHashMismatchEvent
+		}
+		switch vLog.Topics[0] {
+		case logHermezL1UserTxEvent:
+			var L1UserTxAux RollupEventL1UserTxAux
+			var L1UserTx RollupEventL1UserTx
+			err := c.contractAbi.Unpack(&L1UserTxAux, "L1UserTxEvent", vLog.Data)
+			if err != nil {
+				return nil, nil, err
+			}
+			L1Tx, err := common.L1TxFromBytes(L1UserTxAux.L1Tx)
+			if err != nil {
+				return nil, nil, err
+			}
+			L1UserTx.ToForgeL1TxsNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
+			L1UserTx.Position = int(new(big.Int).SetBytes(vLog.Topics[2][:]).Int64())
+			L1UserTx.L1Tx = *L1Tx
+			rollupEvents.L1UserTx = append(rollupEvents.L1UserTx, L1UserTx)
+		case logHermezAddToken:
+			var addToken RollupEventAddToken
+			err := c.contractAbi.Unpack(&addToken, "AddToken", vLog.Data)
+			if err != nil {
+				return nil, nil, err
+			}
+			addToken.Address = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
+			rollupEvents.AddToken = append(rollupEvents.AddToken, addToken)
+		case logHermezForgeBatch:
+			var forgeBatch RollupEventForgeBatch
+			forgeBatch.BatchNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
+			forgeBatch.EthTxHash = vLog.TxHash
+			rollupEvents.ForgeBatch = append(rollupEvents.ForgeBatch, forgeBatch)
+		case logHermezUpdateForgeL1L2BatchTimeout:
+			var updateForgeL1L2BatchTimeout RollupEventUpdateForgeL1L2BatchTimeout
+			err := c.contractAbi.Unpack(&updateForgeL1L2BatchTimeout, "UpdateForgeL1L2BatchTimeout", vLog.Data)
+			if err != nil {
+				return nil, nil, err
+			}
+			rollupEvents.UpdateForgeL1L2BatchTimeout = append(rollupEvents.UpdateForgeL1L2BatchTimeout, updateForgeL1L2BatchTimeout)
+		case logHermezUpdateFeeAddToken:
+			var updateFeeAddToken RollupEventUpdateFeeAddToken
+			err := c.contractAbi.Unpack(&updateFeeAddToken, "UpdateFeeAddToken", vLog.Data)
+			if err != nil {
+				return nil, nil, err
+			}
+			rollupEvents.UpdateFeeAddToken = append(rollupEvents.UpdateFeeAddToken, updateFeeAddToken)
+		case logHermezWithdrawEvent:
+			var withdraw RollupEventWithdrawEvent
+			err := c.contractAbi.Unpack(&withdraw, "WithdrawEvent", vLog.Data)
+			if err != nil {
+				return nil, nil, err
+			}
+			withdraw.Idx = new(big.Int).SetBytes(vLog.Topics[1][:]).Uint64()
+			withdraw.NumExitRoot = new(big.Int).SetBytes(vLog.Topics[2][:]).Uint64()
+			rollupEvents.WithdrawEvent = append(rollupEvents.WithdrawEvent, withdraw)
+		}
+	}
+	return &rollupEvents, &blockHash, nil
 }
 
 // RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the Rollup Smart Contract in the given transaction
 func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash) (*RollupForgeBatchArgs, error) {
+	tx, _, err := c.client.client.TransactionByHash(context.Background(), ethTxHash)
+	if err != nil {
+		return nil, err
+	}
+	txData := tx.Data()
+	method, err := c.contractAbi.MethodById(txData)
+	if err != nil {
+		return nil, err
+	}
+	var aux RollupForgeBatchArgsAux
+	if err := method.Inputs.Unpack(&aux, txData); err != nil {
+		return nil, err
+	}
+	var rollupForgeBatchArgs RollupForgeBatchArgs
+	rollupForgeBatchArgs.L1Batch = aux.L1Batch
+	rollupForgeBatchArgs.NewExitRoot = aux.NewExitRoot
+	rollupForgeBatchArgs.NewLastIdx = int64(aux.NewLastIdx)
+	rollupForgeBatchArgs.NewStRoot = aux.NewStRoot
+	rollupForgeBatchArgs.ProofA = aux.ProofA
+	rollupForgeBatchArgs.ProofB = aux.ProofB
+	rollupForgeBatchArgs.ProofC = aux.ProofC
+	rollupForgeBatchArgs.VerifierIdx = aux.VerifierIdx
+
+	numTxsL1 := len(aux.L1CoordinatorTxs) / common.L1TxBytesLen
+	for i := 0; i < numTxsL1; i++ {
+		l1Tx, err := common.L1TxFromCoordinatorBytes(aux.L1CoordinatorTxs[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen])
+		if err != nil {
+			return nil, err
+		}
+		rollupForgeBatchArgs.L1CoordinatorTxs = append(rollupForgeBatchArgs.L1CoordinatorTxs, l1Tx)
+	}
+	rollupConsts, err := c.RollupConstants()
+	if err != nil {
+		return nil, err
+	}
+	nLevels := rollupConsts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels
+	lenL2TxsBytes := int((nLevels/8)*2 + 2 + 1)
+	numTxsL2 := len(aux.L2TxsData) / lenL2TxsBytes
+	for i := 0; i < numTxsL2; i++ {
+		l2Tx, err := common.L2TxFromBytes(aux.L2TxsData[i*lenL2TxsBytes:(i+1)*lenL2TxsBytes], int(nLevels))
+		if err != nil {
+			return nil, err
+		}
+		rollupForgeBatchArgs.L2TxsData = append(rollupForgeBatchArgs.L2TxsData, l2Tx)
+	}
+	lenFeeIdxCoordinatorBytes := int(nLevels / 8) //nolint:gomnd
+	numFeeIdxCoordinator := len(aux.FeeIdxCoordinator) / lenFeeIdxCoordinatorBytes
+	for i := 0; i < numFeeIdxCoordinator; i++ {
+		var paddedFeeIdx [6]byte
+		// TODO: This check is not necessary: the first case will always work.  Test it before removing the if.
+		if lenFeeIdxCoordinatorBytes < common.IdxBytesLen {
+			copy(paddedFeeIdx[6-lenFeeIdxCoordinatorBytes:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
+		} else {
+			copy(paddedFeeIdx[:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
+		}
+		FeeIdxCoordinator, err := common.IdxFromBytes(paddedFeeIdx[:])
+		if err != nil {
+			return nil, err
+		}
+		rollupForgeBatchArgs.FeeIdxCoordinator = append(rollupForgeBatchArgs.FeeIdxCoordinator, FeeIdxCoordinator)
+	}
+	return &rollupForgeBatchArgs, nil
 	// tx := client.TransactionByHash(ethTxHash) -> types.Transaction
 	// txData := types.Transaction -> Data()
 	// m := abi.MethodById(txData) -> Method
 	// m.Inputs.Unpack(txData) -> Args
 	// client.TransactionReceipt()?
-	log.Error("TODO")
-	return nil, errTODO
 }

eth/rollup_test.go

@@ -1,16 +1,28 @@
 package eth
 
 import (
+	"math/big"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 var rollupClient *RollupClient
 
+var absoluteMaxL1L2BatchTimeout = uint8(240)
+var maxTx = big.NewInt(512)
+var nLevels = big.NewInt(32)
+
 func TestRollupConstants(t *testing.T) {
-	if rollupClient != nil {
-		_, err := rollupClient.RollupConstants()
-		require.Nil(t, err)
-	}
+	rollupConstants, err := rollupClient.RollupConstants()
+	require.Nil(t, err)
+	assert.Equal(t, absoluteMaxL1L2BatchTimeout, rollupConstants.AbsoluteMaxL1L2BatchTimeout)
+	assert.Equal(t, auctionAddressConst, rollupConstants.HermezAuctionContract)
+	assert.Equal(t, tokenERC777AddressConst, rollupConstants.TokenHEZ)
+	assert.Equal(t, maxTx, rollupConstants.Verifiers[0].MaxTx)
+	assert.Equal(t, nLevels, rollupConstants.Verifiers[0].NLevels)
+	assert.Equal(t, governanceAddressConst, rollupConstants.HermezGovernanceDAOAddress)
+	assert.Equal(t, safetyAddressConst, rollupConstants.SafetyAddress)
+	assert.Equal(t, wdelayerAddressConst, rollupConstants.WithdrawDelayerContract)
 }

eth/wdelayer.go

@@ -58,9 +58,10 @@ type WDelayerEventNewWithdrawalDelay struct {
 
 // WDelayerEventEscapeHatchWithdrawal an event of the WithdrawalDelayer Smart Contract
 type WDelayerEventEscapeHatchWithdrawal struct {
-	Who   ethCommon.Address
-	To    ethCommon.Address
-	Token ethCommon.Address
+	Who    ethCommon.Address
+	To     ethCommon.Address
+	Token  ethCommon.Address
+	Amount *big.Int
 }
 
 // WDelayerEventNewHermezKeeperAddress an event of the WithdrawalDelayer Smart Contract
@@ -124,7 +125,7 @@ type WDelayerInterface interface {
 	WDelayerDepositInfo(owner, token ethCommon.Address) (*big.Int, uint64)
 	WDelayerDeposit(onwer, token ethCommon.Address, amount *big.Int) (*types.Transaction, error)
 	WDelayerWithdrawal(owner, token ethCommon.Address) (*types.Transaction, error)
-	WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address) (*types.Transaction, error)
+	WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address, amount *big.Int) (*types.Transaction, error)
 }
 
 //
@@ -401,7 +402,7 @@ func (c *WDelayerClient) WDelayerWithdrawal(owner, token ethCommon.Address) (*ty
 }
 
 // WDelayerEscapeHatchWithdrawal is the interface to call the smart contract function
-func (c *WDelayerClient) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address) (*types.Transaction, error) {
+func (c *WDelayerClient) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address, amount *big.Int) (*types.Transaction, error) {
 	var tx *types.Transaction
 	var err error
 	if tx, err = c.client.CallAuth(
@@ -411,7 +412,7 @@ func (c *WDelayerClient) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Addre
 			if err != nil {
 				return nil, err
 			}
-			return wdelayer.EscapeHatchWithdrawal(auth, to, token)
+			return wdelayer.EscapeHatchWithdrawal(auth, to, token, amount)
 		},
 	); err != nil {
 		return nil, fmt.Errorf("Failed escapeHatchWithdrawal: %w", err)
@@ -420,14 +421,14 @@ func (c *WDelayerClient) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Addre
 }
 
 var (
-	logDeposit                       = crypto.Keccak256Hash([]byte("Deposit(address,address,uint192,uint64)"))
-	logWithdraw                      = crypto.Keccak256Hash([]byte("Withdraw(address,address,uint192)"))
-	logEmergencyModeEnabled          = crypto.Keccak256Hash([]byte("EmergencyModeEnabled()"))
-	logNewWithdrawalDelay            = crypto.Keccak256Hash([]byte("NewWithdrawalDelay(uint64)"))
-	logEscapeHatchWithdrawal         = crypto.Keccak256Hash([]byte("EscapeHatchWithdrawal(address,address,address)"))
-	logNewHermezKeeperAddress        = crypto.Keccak256Hash([]byte("NewHermezKeeperAddress(address)"))
-	logNewWhiteHackGroupAddress      = crypto.Keccak256Hash([]byte("NewWhiteHackGroupAddress(address)"))
-	logNewHermezGovernanceDAOAddress = crypto.Keccak256Hash([]byte("NewHermezGovernanceDAOAddress(address)"))
+	logWDelayerDeposit                       = crypto.Keccak256Hash([]byte("Deposit(address,address,uint192,uint64)"))
+	logWDelayerWithdraw                      = crypto.Keccak256Hash([]byte("Withdraw(address,address,uint192)"))
+	logWDelayerEmergencyModeEnabled          = crypto.Keccak256Hash([]byte("EmergencyModeEnabled()"))
+	logWDelayerNewWithdrawalDelay            = crypto.Keccak256Hash([]byte("NewWithdrawalDelay(uint64)"))
+	logWDelayerEscapeHatchWithdrawal         = crypto.Keccak256Hash([]byte("EscapeHatchWithdrawal(address,address,address,uint256)"))
+	logWDelayerNewHermezKeeperAddress        = crypto.Keccak256Hash([]byte("NewHermezKeeperAddress(address)"))
+	logWDelayerNewWhiteHackGroupAddress      = crypto.Keccak256Hash([]byte("NewWhiteHackGroupAddress(address)"))
+	logWDelayerNewHermezGovernanceDAOAddress = crypto.Keccak256Hash([]byte("NewHermezGovernanceDAOAddress(address)"))
 )
 
 // WDelayerEventsByBlock returns the events in a block that happened in the
@@ -459,7 +460,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,
 			return nil, nil, ErrBlockHashMismatchEvent
 		}
 		switch vLog.Topics[0] {
-		case logDeposit:
+		case logWDelayerDeposit:
 			var deposit WDelayerEventDeposit
 			err := c.contractAbi.Unpack(&deposit, "Deposit", vLog.Data)
 			if err != nil {
@@ -469,7 +470,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,
 			deposit.Token = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
 			wdelayerEvents.Deposit = append(wdelayerEvents.Deposit, deposit)
 
-		case logWithdraw:
+		case logWDelayerWithdraw:
 			var withdraw WDelayerEventWithdraw
 			err := c.contractAbi.Unpack(&withdraw, "Withdraw", vLog.Data)
 			if err != nil {
@@ -479,11 +480,11 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,
 			withdraw.Owner = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
 			wdelayerEvents.Withdraw = append(wdelayerEvents.Withdraw, withdraw)
 
-		case logEmergencyModeEnabled:
+		case logWDelayerEmergencyModeEnabled:
 			var emergencyModeEnabled WDelayerEventEmergencyModeEnabled
 			wdelayerEvents.EmergencyModeEnabled = append(wdelayerEvents.EmergencyModeEnabled, emergencyModeEnabled)
 
-		case logNewWithdrawalDelay:
+		case logWDelayerNewWithdrawalDelay:
 			var withdrawalDelay WDelayerEventNewWithdrawalDelay
 			err := c.contractAbi.Unpack(&withdrawalDelay, "NewWithdrawalDelay", vLog.Data)
 			if err != nil {
@@ -491,14 +492,18 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,
 			}
 			wdelayerEvents.NewWithdrawalDelay = append(wdelayerEvents.NewWithdrawalDelay, withdrawalDelay)
 
-		case logEscapeHatchWithdrawal:
+		case logWDelayerEscapeHatchWithdrawal:
 			var escapeHatchWithdrawal WDelayerEventEscapeHatchWithdrawal
+			err := c.contractAbi.Unpack(&escapeHatchWithdrawal, "EscapeHatchWithdrawal", vLog.Data)
+			if err != nil {
+				return nil, nil, err
+			}
 			escapeHatchWithdrawal.Who = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
 			escapeHatchWithdrawal.To = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
 			escapeHatchWithdrawal.Token = ethCommon.BytesToAddress(vLog.Topics[3].Bytes())
 			wdelayerEvents.EscapeHatchWithdrawal = append(wdelayerEvents.EscapeHatchWithdrawal, escapeHatchWithdrawal)
 
-		case logNewHermezKeeperAddress:
+		case logWDelayerNewHermezKeeperAddress:
 			var keeperAddress WDelayerEventNewHermezKeeperAddress
 			err := c.contractAbi.Unpack(&keeperAddress, "NewHermezKeeperAddress", vLog.Data)
 			if err != nil {
@@ -506,7 +511,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,
 			}
 			wdelayerEvents.NewHermezKeeperAddress = append(wdelayerEvents.NewHermezKeeperAddress, keeperAddress)
 
-		case logNewWhiteHackGroupAddress:
+		case logWDelayerNewWhiteHackGroupAddress:
 			var whiteHackGroupAddress WDelayerEventNewWhiteHackGroupAddress
 			err := c.contractAbi.Unpack(&whiteHackGroupAddress, "NewWhiteHackGroupAddress", vLog.Data)
 			if err != nil {
@@ -514,7 +519,7 @@ func (c *WDelayerClient) WDelayerEventsByBlock(blockNum int64) (*WDelayerEvents,
 			}
 			wdelayerEvents.NewWhiteHackGroupAddress = append(wdelayerEvents.NewWhiteHackGroupAddress, whiteHackGroupAddress)
 
-		case logNewHermezGovernanceDAOAddress:
+		case logWDelayerNewHermezGovernanceDAOAddress:
 			var governanceDAOAddress WDelayerEventNewHermezGovernanceDAOAddress
 			err := c.contractAbi.Unpack(&governanceDAOAddress, "NewHermezGovernanceDAOAddress", vLog.Data)
 			if err != nil {

eth/wdelayer_test.go

@@ -10,6 +10,7 @@ import (
 )
 
 var wdelayerClient *WDelayerClient
+var wdelayerClientTest *WDelayerClient
 
 // var wdelayerClientKep *WDelayerClient
 
@@ -18,117 +19,117 @@ var newWithdrawalDelay = big.NewInt(79)
 var maxEmergencyModeTime = time.Hour * 24 * 7 * 26
 
 func TestWDelayerGetHermezGovernanceDAOAddress(t *testing.T) {
-	governanceAddress, err := wdelayerClient.WDelayerGetHermezGovernanceDAOAddress()
+	governanceAddress, err := wdelayerClientTest.WDelayerGetHermezGovernanceDAOAddress()
 	require.Nil(t, err)
 	assert.Equal(t, &hermezGovernanceDAOAddressConst, governanceAddress)
 }
 
 func TestWDelayerSetHermezGovernanceDAOAddress(t *testing.T) {
-	wdelayerClientGov, err := NewWDelayerClient(ethereumClientGovDAO, wdelayerAddressConst)
+	wdelayerClientGov, err := NewWDelayerClient(ethereumClientGovDAO, wdelayerTestAddressConst)
 	require.Nil(t, err)
 	_, err = wdelayerClientGov.WDelayerSetHermezGovernanceDAOAddress(auxAddressConst)
 	require.Nil(t, err)
-	auxAddress, err := wdelayerClient.WDelayerGetHermezGovernanceDAOAddress()
+	auxAddress, err := wdelayerClientTest.WDelayerGetHermezGovernanceDAOAddress()
 	require.Nil(t, err)
 	assert.Equal(t, &auxAddressConst, auxAddress)
-	currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock()
-	wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := wdelayerClientTest.client.EthCurrentBlock()
+	wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezGovernanceDAOAddress[0].NewHermezGovernanceDAOAddress)
-	wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerAddressConst)
+	wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
 	require.Nil(t, err)
 	_, err = wdelayerClientAux.WDelayerSetHermezGovernanceDAOAddress(hermezGovernanceDAOAddressConst)
 	require.Nil(t, err)
 }
 
 func TestWDelayerGetHermezKeeperAddress(t *testing.T) {
-	keeperAddress, err := wdelayerClient.WDelayerGetHermezKeeperAddress()
+	keeperAddress, err := wdelayerClientTest.WDelayerGetHermezKeeperAddress()
 	require.Nil(t, err)
 	assert.Equal(t, &hermezKeeperAddressConst, keeperAddress)
 }
 
 func TestWDelayerSetHermezKeeperAddress(t *testing.T) {
-	wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst)
+	wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerTestAddressConst)
 	require.Nil(t, err)
 	_, err = wdelayerClientKep.WDelayerSetHermezKeeperAddress(auxAddressConst)
 	require.Nil(t, err)
-	auxAddress, err := wdelayerClient.WDelayerGetHermezKeeperAddress()
+	auxAddress, err := wdelayerClientTest.WDelayerGetHermezKeeperAddress()
 	require.Nil(t, err)
 	assert.Equal(t, &auxAddressConst, auxAddress)
-	currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock()
-	wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := wdelayerClientTest.client.EthCurrentBlock()
+	wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezKeeperAddress[0].NewHermezKeeperAddress)
-	wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerAddressConst)
+	wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
 	require.Nil(t, err)
 	_, err = wdelayerClientAux.WDelayerSetHermezKeeperAddress(hermezKeeperAddressConst)
 	require.Nil(t, err)
 }
 
 func TestWDelayerGetWhiteHackGroupAddress(t *testing.T) {
-	whiteHackGroupAddress, err := wdelayerClient.WDelayerGetWhiteHackGroupAddress()
+	whiteHackGroupAddress, err := wdelayerClientTest.WDelayerGetWhiteHackGroupAddress()
 	require.Nil(t, err)
 	assert.Equal(t, &whiteHackGroupAddressConst, whiteHackGroupAddress)
 }
 
 func TestWDelayerSetWhiteHackGroupAddress(t *testing.T) {
-	wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerAddressConst)
+	wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerTestAddressConst)
 	require.Nil(t, err)
 	_, err = wdelayerClientWhite.WDelayerSetWhiteHackGroupAddress(auxAddressConst)
 	require.Nil(t, err)
-	auxAddress, err := wdelayerClient.WDelayerGetWhiteHackGroupAddress()
+	auxAddress, err := wdelayerClientTest.WDelayerGetWhiteHackGroupAddress()
 	require.Nil(t, err)
 	assert.Equal(t, &auxAddressConst, auxAddress)
-	currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock()
-	wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := wdelayerClientTest.client.EthCurrentBlock()
+	wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.NewWhiteHackGroupAddress[0].NewWhiteHackGroupAddress)
-	wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerAddressConst)
+	wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
 	require.Nil(t, err)
 	_, err = wdelayerClientAux.WDelayerSetWhiteHackGroupAddress(whiteHackGroupAddressConst)
 	require.Nil(t, err)
 }
 
 func TestWDelayerIsEmergencyMode(t *testing.T) {
-	emergencyMode, err := wdelayerClient.WDelayerIsEmergencyMode()
+	emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
 	require.Nil(t, err)
 	assert.Equal(t, false, emergencyMode)
 }
 
 func TestWDelayerGetWithdrawalDelay(t *testing.T) {
-	withdrawalDelay, err := wdelayerClient.WDelayerGetWithdrawalDelay()
+	withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
 	require.Nil(t, err)
 	assert.Equal(t, initWithdrawalDelay, withdrawalDelay)
 }
 
 func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
-	wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst)
+	wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerTestAddressConst)
 	require.Nil(t, err)
 	_, err = wdelayerClientKep.WDelayerChangeWithdrawalDelay(newWithdrawalDelay.Uint64())
 	require.Nil(t, err)
-	withdrawalDelay, err := wdelayerClient.WDelayerGetWithdrawalDelay()
+	withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
 	require.Nil(t, err)
 	assert.Equal(t, newWithdrawalDelay, withdrawalDelay)
-	currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock()
-	wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := wdelayerClientTest.client.EthCurrentBlock()
+	wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	assert.Equal(t, newWithdrawalDelay.Uint64(), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay)
 }
 
 func TestWDelayerDeposit(t *testing.T) {
 	amount := new(big.Int)
 	amount.SetString("1100000000000000000", 10)
-	wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerAddressConst)
+	wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
 	require.Nil(t, err)
-	_, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHezAddressConst, amount)
+	_, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenERC20AddressConst, amount)
 	require.Nil(t, err)
-	currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock()
-	wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := wdelayerClientTest.client.EthCurrentBlock()
+	wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
-	assert.Equal(t, tokenHezAddressConst, wdelayerEvents.Deposit[0].Token)
+	assert.Equal(t, tokenERC20AddressConst, wdelayerEvents.Deposit[0].Token)
 }
 
 func TestWDelayerDepositInfo(t *testing.T) {
 	amount := new(big.Int)
 	amount.SetString("1100000000000000000", 10)
-	state, err := wdelayerClient.WDelayerDepositInfo(auxAddressConst, tokenHezAddressConst)
+	state, err := wdelayerClientTest.WDelayerDepositInfo(auxAddressConst, tokenERC20AddressConst)
 	require.Nil(t, err)
 	assert.Equal(t, state.Amount, amount)
 }
@@ -136,34 +137,48 @@ func TestWDelayerDepositInfo(t *testing.T) {
 func TestWDelayerWithdrawal(t *testing.T) {
 	amount := new(big.Int)
 	amount.SetString("1100000000000000000", 10)
-	_, err := wdelayerClient.WDelayerWithdrawal(auxAddressConst, tokenHezAddressConst)
+	_, err := wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenERC20AddressConst)
 	require.Contains(t, err.Error(), "Withdrawal not allowed yet")
 	addBlocks(newWithdrawalDelay.Int64(), ethClientDialURL)
-	_, err = wdelayerClient.WDelayerWithdrawal(auxAddressConst, tokenHezAddressConst)
+	_, err = wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenERC20AddressConst)
 	require.Nil(t, err)
-	currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock()
-	wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := wdelayerClientTest.client.EthCurrentBlock()
+	wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	assert.Equal(t, amount, wdelayerEvents.Withdraw[0].Amount)
 	assert.Equal(t, auxAddressConst, wdelayerEvents.Withdraw[0].Owner)
-	assert.Equal(t, tokenHezAddressConst, wdelayerEvents.Withdraw[0].Token)
+	assert.Equal(t, tokenERC20AddressConst, wdelayerEvents.Withdraw[0].Token)
+}
+
+func TestWDelayerSecondDeposit(t *testing.T) {
+	amount := new(big.Int)
+	amount.SetString("1100000000000000000", 10)
+	wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
+	require.Nil(t, err)
+	_, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenERC20AddressConst, amount)
+	require.Nil(t, err)
+	currentBlockNum, _ := wdelayerClientTest.client.EthCurrentBlock()
+	wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
+	assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
+	assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
+	assert.Equal(t, tokenERC20AddressConst, wdelayerEvents.Deposit[0].Token)
 }
 
 func TestWDelayerEnableEmergencyMode(t *testing.T) {
-	wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerAddressConst)
+	wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerTestAddressConst)
 	require.Nil(t, err)
 	_, err = wdelayerClientKep.WDelayerEnableEmergencyMode()
 	require.Nil(t, err)
-	emergencyMode, err := wdelayerClient.WDelayerIsEmergencyMode()
+	emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
 	require.Nil(t, err)
 	assert.Equal(t, true, emergencyMode)
-	currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock()
-	wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum)
+	currentBlockNum, _ := wdelayerClientTest.client.EthCurrentBlock()
+	wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
 	auxEvent := new(WDelayerEventEmergencyModeEnabled)
 	assert.Equal(t, auxEvent, &wdelayerEvents.EmergencyModeEnabled[0])
 }
 
 func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {
-	emergencyModeStartingTime, err := wdelayerClient.WDelayerGetEmergencyModeStartingTime()
+	emergencyModeStartingTime, err := wdelayerClientTest.WDelayerGetEmergencyModeStartingTime()
 	require.Nil(t, err)
 	// `emergencyModeStartingTime` is initialized to 0 in the smart
 	// contract construction.  Since we called WDelayerEnableEmergencyMode
@@ -173,17 +188,20 @@ func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {
 }
 
 func TestWDelayerEscapeHatchWithdrawal(t *testing.T) {
-	wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerAddressConst)
+	amount := new(big.Int)
+	amount.SetString("10000000000000000", 10)
+	wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerTestAddressConst)
 	require.Nil(t, err)
-	_, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHezAddressConst)
+	_, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenERC20AddressConst, amount)
 	require.Contains(t, err.Error(), "NO MAX_EMERGENCY_MODE_TIME")
 	seconds := maxEmergencyModeTime.Seconds()
 	addTime(seconds, ethClientDialURL)
-	_, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHezAddressConst)
+	_, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenERC20AddressConst, amount)
 	require.Nil(t, err)
-	currentBlockNum, _ := wdelayerClient.client.EthCurrentBlock()
-	wdelayerEvents, _, _ := wdelayerClient.WDelayerEventsByBlock(currentBlockNum)
-	assert.Equal(t, tokenHezAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token)
+	currentBlockNum, _ := wdelayerClientTest.client.EthCurrentBlock()
+	wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
+	assert.Equal(t, tokenERC20AddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token)
 	assert.Equal(t, governanceAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].To)
 	assert.Equal(t, whiteHackGroupAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Who)
+	assert.Equal(t, amount, wdelayerEvents.EscapeHatchWithdrawal[0].Amount)
 }

synchronizer/synchronizer.go

@@ -429,7 +429,7 @@ func (s *Synchronizer) rollupSync(blockNum int64) (*rollupData, error) {
 		}
 
 		// Get L2Txs
-		poolL2Txs := common.L2TxsToPoolL2Txs(forgeBatchArgs.L2Txs) // TODO: This is a big uggly, find a better way
+		poolL2Txs := common.L2TxsToPoolL2Txs(forgeBatchArgs.L2TxsData) // TODO: This is a big uggly, find a better way
 
 		// Get exitTree
 		// TODO: Get createdAccounts from ProcessTxs()
@@ -502,18 +502,18 @@ func (s *Synchronizer) auctionSync(blockNum int64) (*auctionData, error) {
 		bid := &common.Bid{
 			SlotNum:     common.SlotNum(eNewBid.Slot),
 			BidValue:    eNewBid.BidAmount,
-			ForgerAddr:  eNewBid.CoordinatorForger,
+			Bidder:      eNewBid.Bidder,
 			EthBlockNum: blockNum,
 		}
 		auctionData.bids = append(auctionData.bids, bid)
 	}
 
 	// Get Coordinators
-	for _, eNewCoordinator := range auctionEvents.NewCoordinator {
+	for _, eNewCoordinator := range auctionEvents.SetCoordinator {
 		coordinator := &common.Coordinator{
-			Forger:       eNewCoordinator.ForgerAddress,
-			WithdrawAddr: eNewCoordinator.WithdrawalAddress,
-			URL:          eNewCoordinator.CoordinatorURL,
+			Bidder: eNewCoordinator.BidderAddress,
+			Forger: eNewCoordinator.ForgerAddress,
+			URL:    eNewCoordinator.CoordinatorURL,
 		}
 		auctionData.coordinators = append(auctionData.coordinators, coordinator)
 	}
@@ -530,18 +530,6 @@ func (s *Synchronizer) auctionSync(blockNum int64) (*auctionData, error) {
 	// TODO: NewForge
 	// TODO: HEZClaimed
 
-	// TODO: Think about separating new coordinaors from coordinator updated
-
-	// Get Coordinators from updates
-	for _, eCoordinatorUpdated := range auctionEvents.CoordinatorUpdated {
-		coordinator := &common.Coordinator{
-			Forger:       eCoordinatorUpdated.ForgerAddress,
-			WithdrawAddr: eCoordinatorUpdated.WithdrawalAddress,
-			URL:          eCoordinatorUpdated.CoordinatorURL,
-		}
-		auctionData.coordinators = append(auctionData.coordinators, coordinator)
-	}
-
 	// TODO: VARS
 	// TODO: CONSTANTS
 

test/ethclient.go

@@ -34,7 +34,7 @@ type RollupBlock struct {
 	Vars      eth.RollupVariables
 	Events    eth.RollupEvents
 	Txs       map[ethCommon.Hash]*types.Transaction
-	Constants *eth.RollupConstants
+	Constants *eth.RollupPublicConstants
 	Eth       *EthereumBlock
 }
 
@@ -128,7 +128,7 @@ func (a *AuctionBlock) forge(forger ethCommon.Address) error {
 
 	a.Events.NewForge = append(a.Events.NewForge, eth.AuctionEventNewForge{
 		Forger:      forger,
-		CurrentSlot: slotToForge,
+		SlotToForge: slotToForge,
 	})
 	return nil
 }
@@ -159,7 +159,9 @@ func (a *AuctionBlock) canForge(forger ethCommon.Address, blockNum int64) (bool,
 	if !slotState.Fulfilled && (relativeBlock >= int64(a.Vars.SlotDeadline)) {
 		// if the relative block has exceeded the slotDeadline and no batch has been forged, anyone can forge
 		return true, nil
-	} else if slotState.Forger == forger && slotState.BidAmount.Cmp(minBid) >= 0 {
+		// TODO, find the forger set by the Bidder
+	} else if coord, ok := a.State.Coordinators[slotState.Bidder]; ok &&
+		coord.Forger == forger && slotState.BidAmount.Cmp(minBid) >= 0 {
 		// if forger bidAmount has exceeded the minBid it can forge
 		return true, nil
 	} else if a.Vars.BootCoordinator == forger && slotState.BidAmount.Cmp(minBid) == -1 {
@@ -216,7 +218,7 @@ func (b *Block) Next() *Block {
 // ClientSetup is used to initialize the constants of the Smart Contracts and
 // other details of the test Client
 type ClientSetup struct {
-	RollupConstants  *eth.RollupConstants
+	RollupConstants  *eth.RollupPublicConstants
 	RollupVariables  *eth.RollupVariables
 	AuctionConstants *eth.AuctionConstants
 	AuctionVariables *eth.AuctionVariables
@@ -226,36 +228,33 @@ type ClientSetup struct {
 // NewClientSetupExample returns a ClientSetup example with hardcoded realistic values.
 //nolint:gomnd
 func NewClientSetupExample() *ClientSetup {
-	rfield, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
-	if !ok {
-		panic("bad rfield")
-	}
+	// rfield, ok := new(big.Int).SetString("21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
+	// if !ok {
+	// 	panic("bad rfield")
+	// }
 	initialMinimalBidding, ok := new(big.Int).SetString("10000000000000000000", 10) // 10 * (1e18)
 	if !ok {
 		panic("bad initialMinimalBidding")
 	}
 	tokenHEZ := ethCommon.HexToAddress("0x51D243D62852Bba334DD5cc33f242BAc8c698074")
 	governanceAddress := ethCommon.HexToAddress("0x688EfD95BA4391f93717CF02A9aED9DBD2855cDd")
-	rollupConstants := &eth.RollupConstants{
-		MaxAmountDeposit:   new(big.Int).Lsh(big.NewInt(1), 128),
-		MaxAmountL2:        new(big.Int).Lsh(big.NewInt(1), 192),
-		MaxTokens:          0xffffffff,
-		MaxL1Tx:            256,
-		MaxL1UserTx:        128,
-		Rfield:             rfield,
-		L1CoordinatorBytes: 101,
-		L1UserBytes:        68,
-		L2Bytes:            11,
-		MaxTxVerifiers:     []int{512, 1024, 2048},
-		TokenHEZ:           tokenHEZ,
-		GovernanceAddress:  governanceAddress,
-		SafetyBot:          ethCommon.HexToAddress("0x84d8B79E84fe87B14ad61A554e740f6736bF4c20"),
-		ConsensusContract:  ethCommon.HexToAddress("0x8E442975805fb1908f43050c9C1A522cB0e28D7b"),
-		WithdrawalContract: ethCommon.HexToAddress("0x5CB7979cBdbf65719BEE92e4D15b7b7Ed3D79114"),
+	rollupConstants := &eth.RollupPublicConstants{
+		Verifiers: []eth.RollupVerifierStruct{
+			{
+				MaxTx:   2048,
+				NLevels: 32,
+			},
+		},
+		TokenHEZ:                   tokenHEZ,
+		HermezGovernanceDAOAddress: governanceAddress,
+		SafetyAddress:              ethCommon.HexToAddress("0x84d8B79E84fe87B14ad61A554e740f6736bF4c20"),
+		HermezAuctionContract:      ethCommon.HexToAddress("0x8E442975805fb1908f43050c9C1A522cB0e28D7b"),
+		WithdrawDelayerContract:    ethCommon.HexToAddress("0x5CB7979cBdbf65719BEE92e4D15b7b7Ed3D79114"),
 	}
 	rollupVariables := &eth.RollupVariables{
-		FeeAddToken:    big.NewInt(11),
-		ForgeL1Timeout: 9,
+		FeeAddToken:           big.NewInt(11),
+		ForgeL1L2BatchTimeout: 9,
+		WithdrawalDelay:       80,
 	}
 	auctionConstants := &eth.AuctionConstants{
 		BlocksPerSlot:         40,
@@ -303,7 +302,7 @@ type Client struct {
 	rw               *sync.RWMutex
 	log              bool
 	addr             *ethCommon.Address
-	rollupConstants  *eth.RollupConstants
+	rollupConstants  *eth.RollupPublicConstants
 	auctionConstants *eth.AuctionConstants
 	blocks           map[int64]*Block
 	// state            state
@@ -434,6 +433,11 @@ func (c *Client) currentBlock() *Block {
 	return c.blocks[c.blockNum]
 }
 
+// CtlSetAddr sets the address of the client
+func (c *Client) CtlSetAddr(addr ethCommon.Address) {
+	c.addr = &addr
+}
+
 // CtlMineBlock moves one block forward
 func (c *Client) CtlMineBlock() {
 	c.rw.Lock()
@@ -581,7 +585,7 @@ func (c *Client) CtlAddL1TxUser(l1Tx *common.L1Tx) {
 	nextBlock := c.nextBlock()
 	r := nextBlock.Rollup
 	queue := r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum]
-	if len(queue.L1TxQueue) >= c.rollupConstants.MaxL1UserTx {
+	if len(queue.L1TxQueue) >= eth.RollupConstMaxL1UserTx {
 		r.State.LastToForgeL1TxsNum++
 		r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum] = eth.NewQueueStruct()
 		queue = r.State.MapL1TxQueue[r.State.LastToForgeL1TxsNum]
@@ -901,7 +905,7 @@ func (c *Client) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *types.Tra
 // }
 
 // RollupConstants returns the Constants of the Rollup Smart Contract
-func (c *Client) RollupConstants() (*eth.RollupConstants, error) {
+func (c *Client) RollupConstants() (*eth.RollupPublicConstants, error) {
 	c.rw.RLock()
 	defer c.rw.RUnlock()
 
@@ -1114,8 +1118,8 @@ func (c *Client) AuctionChangeDefaultSlotSetBid(slotSet int64, newInitialMinBid
 	return nil, errTODO
 }
 
-// AuctionRegisterCoordinator is the interface to call the smart contract function
-func (c *Client) AuctionRegisterCoordinator(forgerAddress ethCommon.Address, URL string) (tx *types.Transaction, err error) {
+// AuctionSetCoordinator is the interface to call the smart contract function
+func (c *Client) AuctionSetCoordinator(forger ethCommon.Address, URL string) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1127,26 +1131,24 @@ func (c *Client) AuctionRegisterCoordinator(forgerAddress ethCommon.Address, URL
 	nextBlock := c.nextBlock()
 	a := nextBlock.Auction
 
-	if _, ok := a.State.Coordinators[forgerAddress]; ok {
-		return nil, fmt.Errorf("Already registered")
-	}
-	a.State.Coordinators[forgerAddress] = &eth.Coordinator{
-		WithdrawalAddress: *c.addr,
-		URL:               URL,
+	a.State.Coordinators[*c.addr] = &eth.Coordinator{
+		Forger: forger,
+		URL:    URL,
 	}
 
-	a.Events.NewCoordinator = append(a.Events.NewCoordinator,
-		eth.AuctionEventNewCoordinator{
-			ForgerAddress:     forgerAddress,
-			WithdrawalAddress: *c.addr,
-			CoordinatorURL:    URL,
+	a.Events.SetCoordinator = append(a.Events.SetCoordinator,
+		eth.AuctionEventSetCoordinator{
+			BidderAddress:  *c.addr,
+			ForgerAddress:  forger,
+			CoordinatorURL: URL,
 		})
 
 	type data struct {
+		BidderAddress ethCommon.Address
 		ForgerAddress ethCommon.Address
 		URL           string
 	}
-	return a.addTransaction(newTransaction("registercoordinator", data{forgerAddress, URL})), nil
+	return a.addTransaction(newTransaction("registercoordinator", data{*c.addr, forger, URL})), nil
 }
 
 // AuctionIsRegisteredCoordinator is the interface to call the smart contract function
@@ -1224,7 +1226,7 @@ func (c *Client) AuctionGetSlotSet(slot int64) (*big.Int, error) {
 // }
 
 // AuctionBid is the interface to call the smart contract function
-func (c *Client) AuctionBid(slot int64, bidAmount *big.Int, forger ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *Client) AuctionBid(slot int64, bidAmount *big.Int) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1252,7 +1254,7 @@ func (c *Client) AuctionBid(slot int64, bidAmount *big.Int, forger ethCommon.Add
 		return nil, errBidBelowMin
 	}
 
-	if _, ok := a.State.Coordinators[forger]; !ok {
+	if _, ok := a.State.Coordinators[*c.addr]; !ok {
 		return nil, errCoordNotReg
 	}
 
@@ -1261,22 +1263,22 @@ func (c *Client) AuctionBid(slot int64, bidAmount *big.Int, forger ethCommon.Add
 		slotState = eth.NewSlotState()
 		a.State.Slots[slot] = slotState
 	}
-	slotState.Forger = forger
+	slotState.Bidder = *c.addr
 	slotState.BidAmount = bidAmount
 
 	a.Events.NewBid = append(a.Events.NewBid,
-		eth.AuctionEventNewBid{Slot: slot, BidAmount: bidAmount, CoordinatorForger: forger})
+		eth.AuctionEventNewBid{Slot: slot, BidAmount: bidAmount, Bidder: *c.addr})
 
 	type data struct {
 		Slot      int64
 		BidAmount *big.Int
-		Forger    ethCommon.Address
+		Bidder    ethCommon.Address
 	}
-	return a.addTransaction(newTransaction("bid", data{slot, bidAmount, forger})), nil
+	return a.addTransaction(newTransaction("bid", data{slot, bidAmount, *c.addr})), nil
 }
 
 // AuctionMultiBid is the interface to call the smart contract function
-func (c *Client) AuctionMultiBid(startingSlot int64, endingSlot int64, slotSet [6]bool, maxBid, closedMinBid, budget *big.Int, forger ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *Client) AuctionMultiBid(startingSlot int64, endingSlot int64, slotSet [6]bool, maxBid, closedMinBid, budget *big.Int) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1300,12 +1302,21 @@ func (c *Client) AuctionCanForge(forger ethCommon.Address, blockNum int64) (bool
 }
 
 // AuctionForge is the interface to call the smart contract function
-// func (c *Client) AuctionForge(forger ethCommon.Address) (bool, error) {
-// 	return false, errTODO
-// }
+func (c *Client) AuctionForge(forger 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, eth.ErrAccountNil
+	}
+
+	log.Error("TODO")
+	return nil, errTODO
+}
 
 // AuctionClaimHEZ is the interface to call the smart contract function
-func (c *Client) AuctionClaimHEZ(claimAddress ethCommon.Address) (tx *types.Transaction, err error) {
+func (c *Client) AuctionClaimHEZ() (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1318,6 +1329,15 @@ func (c *Client) AuctionClaimHEZ(claimAddress ethCommon.Address) (tx *types.Tran
 	return nil, errTODO
 }
 
+// AuctionGetClaimableHEZ is the interface to call the smart contract function
+func (c *Client) AuctionGetClaimableHEZ(bidder ethCommon.Address) (*big.Int, error) {
+	c.rw.RLock()
+	defer c.rw.RUnlock()
+
+	log.Error("TODO")
+	return nil, errTODO
+}
+
 // AuctionConstants returns the Constants of the Auction Smart Contract
 func (c *Client) AuctionConstants() (*eth.AuctionConstants, error) {
 	c.rw.RLock()

test/ethclient_test.go

@@ -78,7 +78,8 @@ func TestClientEth(t *testing.T) {
 }
 
 func TestClientAuction(t *testing.T) {
-	addrWithdraw := ethCommon.HexToAddress("0x6b175474e89094c44da98b954eedeac495271d0f")
+	addrBidder1 := ethCommon.HexToAddress("0x6b175474e89094c44da98b954eedeac495271d0f")
+	addrBidder2 := ethCommon.HexToAddress("0xc27cadc437d067a6ec869502cc9f7F834cFc087a")
 	addrForge := ethCommon.HexToAddress("0xCfAA413eEb796f328620a3630Ae39124cabcEa92")
 	addrForge2 := ethCommon.HexToAddress("0x1fCb4ac309428feCc61B1C8cA5823C15A5e1a800")
 
@@ -89,37 +90,38 @@ func TestClientAuction(t *testing.T) {
 	clientSetup.AuctionVariables.DefaultSlotSetBid = [6]*big.Int{
 		big.NewInt(1000), big.NewInt(1100), big.NewInt(1200),
 		big.NewInt(1300), big.NewInt(1400), big.NewInt(1500)}
-	c := NewClient(true, &timer, &addrWithdraw, clientSetup)
+	c := NewClient(true, &timer, &addrBidder1, clientSetup)
 
 	// Check several cases in which bid doesn't succed, and also do 2 successful bids.
 
-	_, err := c.AuctionBid(0, big.NewInt(1), addrForge)
+	_, err := c.AuctionBid(0, big.NewInt(1))
 	assert.Equal(t, errBidClosed, err)
 
-	_, err = c.AuctionBid(4322, big.NewInt(1), addrForge)
+	_, err = c.AuctionBid(4322, big.NewInt(1))
 	assert.Equal(t, errBidNotOpen, err)
 
 	// 101 % 6 = 5;  defaultSlotSetBid[5] = 1500;  1500 + 10% = 1650
-	_, err = c.AuctionBid(101, big.NewInt(1650), addrForge)
+	_, err = c.AuctionBid(101, big.NewInt(1650))
 	assert.Equal(t, errCoordNotReg, err)
 
-	_, err = c.AuctionRegisterCoordinator(addrForge, "https://foo.bar")
+	_, err = c.AuctionSetCoordinator(addrForge, "https://foo.bar")
 	assert.Nil(t, err)
 
-	_, err = c.AuctionBid(3, big.NewInt(1), addrForge)
+	_, err = c.AuctionBid(3, big.NewInt(1))
 	assert.Equal(t, errBidBelowMin, err)
 
-	_, err = c.AuctionBid(3, big.NewInt(1650), addrForge)
+	_, err = c.AuctionBid(3, big.NewInt(1650))
 	assert.Nil(t, err)
 
-	_, err = c.AuctionRegisterCoordinator(addrForge2, "https://foo2.bar")
+	c.CtlSetAddr(addrBidder2)
+	_, err = c.AuctionSetCoordinator(addrForge2, "https://foo2.bar")
 	assert.Nil(t, err)
 
-	_, err = c.AuctionBid(3, big.NewInt(16), addrForge2)
+	_, err = c.AuctionBid(3, big.NewInt(16))
 	assert.Equal(t, errBidBelowMin, err)
 
 	// 1650 + 10% = 1815
-	_, err = c.AuctionBid(3, big.NewInt(1815), addrForge2)
+	_, err = c.AuctionBid(3, big.NewInt(1815))
 	assert.Nil(t, err)
 
 	c.CtlMineBlock()
@@ -177,8 +179,8 @@ func TestClientRollup(t *testing.T) {
 		NewStRoot:         big.NewInt(1),
 		NewExitRoot:       big.NewInt(100),
 		L1CoordinatorTxs:  []*common.L1Tx{},
-		L2Txs:             []*common.L2Tx{},
-		FeeIdxCoordinator: make([]common.Idx, eth.FeeIdxCoordinatorLen),
+		L2TxsData:         []*common.L2Tx{},
+		FeeIdxCoordinator: make([]common.Idx, eth.RollupConstFeeIdxCoordinatorLen),
 		VerifierIdx:       0,
 		L1Batch:           true,
 	})
@@ -214,8 +216,8 @@ func TestClientRollup(t *testing.T) {
 		NewStRoot:         big.NewInt(1),
 		NewExitRoot:       big.NewInt(100),
 		L1CoordinatorTxs:  []*common.L1Tx{},
-		L2Txs:             []*common.L2Tx{},
-		FeeIdxCoordinator: make([]common.Idx, eth.FeeIdxCoordinatorLen),
+		L2TxsData:         []*common.L2Tx{},
+		FeeIdxCoordinator: make([]common.Idx, eth.RollupConstFeeIdxCoordinatorLen),
 		VerifierIdx:       0,
 		L1Batch:           true,
 	}

test/historydb.go

@@ -363,10 +363,10 @@ func GenCoordinators(nCoords int, blocks []common.Block) []common.Coordinator {
 	coords := []common.Coordinator{}
 	for i := 0; i < nCoords; i++ {
 		coords = append(coords, common.Coordinator{
-			EthBlockNum:  blocks[i%len(blocks)].EthBlockNum,
-			Forger:       ethCommon.BigToAddress(big.NewInt(int64(i))),
-			WithdrawAddr: ethCommon.BigToAddress(big.NewInt(int64(i))),
-			URL:          "https://foo.bar",
+			EthBlockNum: blocks[i%len(blocks)].EthBlockNum,
+			Forger:      ethCommon.BigToAddress(big.NewInt(int64(i))),
+			Bidder:      ethCommon.BigToAddress(big.NewInt(int64(i))),
+			URL:         "https://foo.bar",
 		})
 	}
 	return coords
@@ -380,7 +380,7 @@ func GenBids(nBids int, blocks []common.Block, coords []common.Coordinator) []co
 			SlotNum:     common.SlotNum(i),
 			BidValue:    big.NewInt(int64(i)),
 			EthBlockNum: blocks[i%len(blocks)].EthBlockNum,
-			ForgerAddr:  coords[i%len(blocks)].Forger,
+			Bidder:      coords[i%len(blocks)].Bidder,
 		})
 	}
 	return bids