package eth

import (
	"context"
	"encoding/binary"
	"fmt"
	"math/big"
	"strings"

	"github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/accounts/abi"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	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"
	HermezAuctionProtocol "github.com/hermeznetwork/hermez-node/eth/contracts/auction"
	ERC777 "github.com/hermeznetwork/hermez-node/eth/contracts/erc777"
	"golang.org/x/crypto/sha3"
)

// AuctionConstants are the constants of the Rollup Smart Contract
type AuctionConstants struct {
	// Blocks per slot
	BlocksPerSlot uint8
	// Minimum bid when no one has bid yet
	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
}

// SlotState is the state of a slot
type SlotState struct {
	Forger       ethCommon.Address
	BidAmount    *big.Int
	ClosedMinBid *big.Int
	Fulfilled    bool
}

// NewSlotState returns an empty SlotState
func NewSlotState() *SlotState {
	return &SlotState{
		Forger:       ethCommon.Address{},
		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
}

// AuctionVariables are the variables of the Auction Smart Contract
type AuctionVariables struct {
	// Boot Coordinator Address
	DonationAddress ethCommon.Address
	// Boot Coordinator Address
	BootCoordinator ethCommon.Address
	// The minimum bid value in a series of 6 slots
	DefaultSlotSetBid [6]*big.Int
	// Distance (#slots) to the closest slot to which you can bid ( 2 Slots = 2 * 40 Blocks = 20 min )
	ClosedAuctionSlots uint16
	// Distance (#slots) to the farthest slot to which you can bid (30 days = 4320 slots )
	OpenAuctionSlots uint16
	// How the HEZ tokens deposited by the slot winner are distributed (Burn: 40% - Donation: 40% - HGT: 20%)
	AllocationRatio [3]uint16
	// Minimum outbid (percentage) over the previous one to consider it valid
	Outbidding uint16
	// Number of blocks at the end of a slot in which any coordinator can forge if the winner has not forged one before
	SlotDeadline uint8
}

// AuctionState represents the state of the Rollup in the Smart Contract
type AuctionState struct {
	// Mapping to control slot state
	Slots map[int64]*SlotState
	// Mapping to control balances pending to claim
	PendingBalances map[ethCommon.Address]*big.Int
	// Mapping to register all the coordinators. The address used for the mapping is the forger address
	Coordinators map[ethCommon.Address]*Coordinator
}

// AuctionEventNewBid is an event of the Auction Smart Contract
type AuctionEventNewBid struct {
	Slot              int64
	BidAmount         *big.Int
	CoordinatorForger ethCommon.Address
}

// AuctionEventNewSlotDeadline is an event of the Auction Smart Contract
type AuctionEventNewSlotDeadline struct {
	NewSlotDeadline uint8
}

// AuctionEventNewClosedAuctionSlots is an event of the Auction Smart Contract
type AuctionEventNewClosedAuctionSlots struct {
	NewClosedAuctionSlots uint16
}

// AuctionEventNewOutbidding is an event of the Auction Smart Contract
type AuctionEventNewOutbidding struct {
	NewOutbidding uint16
}

// AuctionEventNewDonationAddress is an event of the Auction Smart Contract
type AuctionEventNewDonationAddress struct {
	NewDonationAddress ethCommon.Address
}

// AuctionEventNewBootCoordinator is an event of the Auction Smart Contract
type AuctionEventNewBootCoordinator struct {
	NewBootCoordinator ethCommon.Address
}

// AuctionEventNewOpenAuctionSlots is an event of the Auction Smart Contract
type AuctionEventNewOpenAuctionSlots struct {
	NewOpenAuctionSlots uint16
}

// AuctionEventNewAllocationRatio is an event of the Auction Smart Contract
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
}

// AuctionEventNewForgeAllocated is an event of the Auction Smart Contract
type AuctionEventNewForgeAllocated struct {
	Forger           ethCommon.Address
	CurrentSlot      int64
	BurnAmount       *big.Int
	DonationAmount   *big.Int
	GovernanceAmount *big.Int
}

// AuctionEventNewDefaultSlotSetBid is an event of the Auction Smart Contract
type AuctionEventNewDefaultSlotSetBid struct {
	SlotSet          int64
	NewInitialMinBid *big.Int
}

// AuctionEventNewForge is an event of the Auction Smart Contract
type AuctionEventNewForge struct {
	Forger      ethCommon.Address
	CurrentSlot int64
}

// AuctionEventHEZClaimed is an event of the Auction Smart Contract
type AuctionEventHEZClaimed struct {
	Owner  ethCommon.Address
	Amount *big.Int
}

// AuctionEvents is the list of events in a block of the Auction Smart Contract
type AuctionEvents struct { //nolint:structcheck
	NewBid                []AuctionEventNewBid
	NewSlotDeadline       []AuctionEventNewSlotDeadline
	NewClosedAuctionSlots []AuctionEventNewClosedAuctionSlots
	NewOutbidding         []AuctionEventNewOutbidding
	NewDonationAddress    []AuctionEventNewDonationAddress
	NewBootCoordinator    []AuctionEventNewBootCoordinator
	NewOpenAuctionSlots   []AuctionEventNewOpenAuctionSlots
	NewAllocationRatio    []AuctionEventNewAllocationRatio
	NewCoordinator        []AuctionEventNewCoordinator
	CoordinatorUpdated    []AuctionEventCoordinatorUpdated
	NewForgeAllocated     []AuctionEventNewForgeAllocated
	NewDefaultSlotSetBid  []AuctionEventNewDefaultSlotSetBid
	NewForge              []AuctionEventNewForge
	HEZClaimed            []AuctionEventHEZClaimed
}

// NewAuctionEvents creates an empty AuctionEvents with the slices initialized.
func NewAuctionEvents() AuctionEvents {
	return AuctionEvents{
		NewBid:                make([]AuctionEventNewBid, 0),
		NewSlotDeadline:       make([]AuctionEventNewSlotDeadline, 0),
		NewClosedAuctionSlots: make([]AuctionEventNewClosedAuctionSlots, 0),
		NewOutbidding:         make([]AuctionEventNewOutbidding, 0),
		NewDonationAddress:    make([]AuctionEventNewDonationAddress, 0),
		NewBootCoordinator:    make([]AuctionEventNewBootCoordinator, 0),
		NewOpenAuctionSlots:   make([]AuctionEventNewOpenAuctionSlots, 0),
		NewAllocationRatio:    make([]AuctionEventNewAllocationRatio, 0),
		NewCoordinator:        make([]AuctionEventNewCoordinator, 0),
		CoordinatorUpdated:    make([]AuctionEventCoordinatorUpdated, 0),
		NewForgeAllocated:     make([]AuctionEventNewForgeAllocated, 0),
		NewDefaultSlotSetBid:  make([]AuctionEventNewDefaultSlotSetBid, 0),
		NewForge:              make([]AuctionEventNewForge, 0),
		HEZClaimed:            make([]AuctionEventHEZClaimed, 0),
	}
}

// AuctionInterface is the inteface to to Auction Smart Contract
type AuctionInterface interface {
	//
	// Smart Contract Methods
	//

	// Getter/Setter, where Setter is onlyOwner
	AuctionSetSlotDeadline(newDeadline uint8) (*types.Transaction, error)
	AuctionGetSlotDeadline() (uint8, error)
	AuctionSetOpenAuctionSlots(newOpenAuctionSlots uint16) (*types.Transaction, error)
	AuctionGetOpenAuctionSlots() (uint16, error)
	AuctionSetClosedAuctionSlots(newClosedAuctionSlots uint16) (*types.Transaction, error)
	AuctionGetClosedAuctionSlots() (uint16, error)
	AuctionSetOutbidding(newOutbidding uint16) (*types.Transaction, error)
	AuctionGetOutbidding() (uint16, error)
	AuctionSetAllocationRatio(newAllocationRatio [3]uint16) (*types.Transaction, error)
	AuctionGetAllocationRatio() ([3]uint16, error)
	AuctionSetDonationAddress(newDonationAddress ethCommon.Address) (*types.Transaction, error)
	AuctionGetDonationAddress() (*ethCommon.Address, error)
	AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address) (*types.Transaction, error)
	AuctionGetBootCoordinator() (*ethCommon.Address, error)
	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)

	// Slot Info
	AuctionGetCurrentSlotNumber() (int64, error)
	AuctionGetMinBidBySlot(slot int64) (*big.Int, error)
	AuctionGetDefaultSlotSetBid(slotSet uint8) (*big.Int, error)
	AuctionGetSlotSet(slot int64) (*big.Int, error)
	AuctionGetSlotNumber(blockNum 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)

	// Forge
	AuctionCanForge(forger ethCommon.Address, blockNum int64) (bool, error)
	// AuctionForge(forger ethCommon.Address) (bool, error) // Only called from another smart contract

	// Fees
	AuctionClaimHEZ(claimAddress ethCommon.Address) (*types.Transaction, error)

	//
	// Smart Contract Status
	//

	AuctionConstants() (*AuctionConstants, error)
	AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *ethCommon.Hash, error)
}

//
// Implementation
//

// AuctionClient is the implementation of the interface to the Auction Smart Contract in ethereum.
type AuctionClient struct {
	client       *EthereumClient
	address      ethCommon.Address
	tokenAddress ethCommon.Address
	gasLimit     uint64
	contractAbi  abi.ABI
}

// NewAuctionClient creates a new AuctionClient.  `tokenAddress` is the address of the HEZ tokens.
func NewAuctionClient(client *EthereumClient, address, tokenAddress ethCommon.Address) (*AuctionClient, error) {
	contractAbi, err := abi.JSON(strings.NewReader(string(HermezAuctionProtocol.HermezAuctionProtocolABI)))
	if err != nil {
		return nil, err
	}
	return &AuctionClient{
		client:       client,
		address:      address,
		tokenAddress: tokenAddress,
		gasLimit:     1000000, //nolint:gomnd
		contractAbi:  contractAbi,
	}, nil
}

// AuctionSetSlotDeadline is the interface to call the smart contract function
func (c *AuctionClient) AuctionSetSlotDeadline(newDeadline uint8) (*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.SetSlotDeadline(auth, newDeadline)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed setting slotDeadline: %w", err)
	}
	return tx, nil
}

// AuctionGetSlotDeadline is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetSlotDeadline() (uint8, error) {
	var slotDeadline uint8
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		slotDeadline, err = auction.GetSlotDeadline(nil)
		return err
	}); err != nil {
		return 0, err
	}
	return slotDeadline, nil
}

// AuctionSetOpenAuctionSlots is the interface to call the smart contract function
func (c *AuctionClient) AuctionSetOpenAuctionSlots(newOpenAuctionSlots uint16) (*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.SetOpenAuctionSlots(auth, newOpenAuctionSlots)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed setting openAuctionSlots: %w", err)
	}
	return tx, nil
}

// AuctionGetOpenAuctionSlots is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetOpenAuctionSlots() (uint16, error) {
	var openAuctionSlots uint16
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		openAuctionSlots, err = auction.GetOpenAuctionSlots(nil)
		return err
	}); err != nil {
		return 0, err
	}
	return openAuctionSlots, nil
}

// AuctionSetClosedAuctionSlots is the interface to call the smart contract function
func (c *AuctionClient) AuctionSetClosedAuctionSlots(newClosedAuctionSlots uint16) (*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.SetClosedAuctionSlots(auth, newClosedAuctionSlots)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed setting closedAuctionSlots: %w", err)
	}
	return tx, nil
}

// AuctionGetClosedAuctionSlots is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetClosedAuctionSlots() (uint16, error) {
	var closedAuctionSlots uint16
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		closedAuctionSlots, err = auction.GetClosedAuctionSlots(nil)
		return err
	}); err != nil {
		return 0, err
	}
	return closedAuctionSlots, nil
}

// AuctionSetOutbidding is the interface to call the smart contract function
func (c *AuctionClient) AuctionSetOutbidding(newOutbidding uint16) (*types.Transaction, error) {
	var tx *types.Transaction
	var err error
	if tx, err = c.client.CallAuth(
		12500000, //nolint:gomnd
		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.SetOutbidding(auth, newOutbidding)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed setting setOutbidding: %w", err)
	}
	return tx, nil
}

// AuctionGetOutbidding is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetOutbidding() (uint16, error) {
	var outbidding uint16
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		outbidding, err = auction.GetOutbidding(nil)
		return err
	}); err != nil {
		return 0, err
	}
	return outbidding, nil
}

// AuctionSetAllocationRatio is the interface to call the smart contract function
func (c *AuctionClient) AuctionSetAllocationRatio(newAllocationRatio [3]uint16) (*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.SetAllocationRatio(auth, newAllocationRatio)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed setting allocationRatio: %w", err)
	}
	return tx, nil
}

// AuctionGetAllocationRatio is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetAllocationRatio() ([3]uint16, error) {
	var allocationRation [3]uint16
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		allocationRation, err = auction.GetAllocationRatio(nil)
		return err
	}); err != nil {
		return [3]uint16{}, err
	}
	return allocationRation, nil
}

// AuctionSetDonationAddress is the interface to call the smart contract function
func (c *AuctionClient) AuctionSetDonationAddress(newDonationAddress ethCommon.Address) (*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.SetDonationAddress(auth, newDonationAddress)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed setting donationAddress: %w", err)
	}
	return tx, nil
}

// AuctionGetDonationAddress is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetDonationAddress() (*ethCommon.Address, error) {
	var donationAddress ethCommon.Address
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		donationAddress, err = auction.GetDonationAddress(nil)
		return err
	}); err != nil {
		return nil, err
	}
	return &donationAddress, nil
}

// AuctionSetBootCoordinator is the interface to call the smart contract function
func (c *AuctionClient) AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address) (*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.SetBootCoordinator(auth, newBootCoordinator)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed setting bootCoordinator: %w", err)
	}
	return tx, nil
}

// AuctionGetBootCoordinator is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetBootCoordinator() (*ethCommon.Address, error) {
	var bootCoordinator ethCommon.Address
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		bootCoordinator, err = auction.GetBootCoordinator(nil)
		return err
	}); err != nil {
		return nil, err
	}
	return &bootCoordinator, nil
}

// AuctionChangeDefaultSlotSetBid is the interface to call the smart contract function
func (c *AuctionClient) AuctionChangeDefaultSlotSetBid(slotSet int64, newInitialMinBid *big.Int) (*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
			}
			slotSetToSend := big.NewInt(slotSet)
			return auction.ChangeDefaultSlotSetBid(auth, slotSetToSend, newInitialMinBid)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed changing slotSet Bid: %w", err)
	}
	return tx, nil
}

// AuctionGetClaimableHEZ is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetClaimableHEZ(claimAddress ethCommon.Address) (*big.Int, error) {
	var claimableHEZ *big.Int
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		claimableHEZ, err = auction.GetClaimableHEZ(nil, claimAddress)
		return err
	}); err != nil {
		return nil, err
	}
	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) {
	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.UpdateCoordinatorInfo(auth, forgerAddress, newWithdrawAddress, newURL)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed update coordinator info: %w", err)
	}
	return tx, nil
}

// AuctionGetCurrentSlotNumber is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetCurrentSlotNumber() (int64, error) {
	var _currentSlotNumber *big.Int
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		_currentSlotNumber, err = auction.GetCurrentSlotNumber(nil)
		return err
	}); err != nil {
		return 0, err
	}
	currentSlotNumber := _currentSlotNumber.Int64()
	return currentSlotNumber, nil
}

// AuctionGetMinBidBySlot is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetMinBidBySlot(slot int64) (*big.Int, error) {
	var minBid *big.Int
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		slotToSend := big.NewInt(slot)
		minBid, err = auction.GetMinBidBySlot(nil, slotToSend)
		return err
	}); err != nil {
		return big.NewInt(0), err
	}
	return minBid, nil
}

// AuctionGetSlotSet is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetSlotSet(slot int64) (*big.Int, error) {
	var slotSet *big.Int
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		slotToSend := big.NewInt(slot)
		slotSet, err = auction.GetSlotSet(nil, slotToSend)
		return err
	}); err != nil {
		return big.NewInt(0), err
	}
	return slotSet, nil
}

// AuctionGetDefaultSlotSetBid is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetDefaultSlotSetBid(slotSet uint8) (*big.Int, error) {
	var minBidSlotSet *big.Int
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		minBidSlotSet, err = auction.GetDefaultSlotSetBid(nil, slotSet)
		return err
	}); err != nil {
		return big.NewInt(0), err
	}
	return minBidSlotSet, nil
}

// AuctionGetSlotNumber is the interface to call the smart contract function
func (c *AuctionClient) AuctionGetSlotNumber(blockNum int64) (*big.Int, error) {
	var slot *big.Int
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		blockNumBig := big.NewInt(blockNum)
		slot, err = auction.GetSlotNumber(nil, blockNumBig)
		return err
	}); err != nil {
		return big.NewInt(0), err
	}
	return slot, nil
}

// 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) {
	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) {
			tokens, err := ERC777.NewERC777(c.tokenAddress, ec)
			if err != nil {
				return nil, err
			}
			bidFnSignature := []byte("bid(uint128,uint128,address)")
			hash := sha3.NewLegacyKeccak256()
			_, err = hash.Write(bidFnSignature)
			if err != nil {
				return nil, err
			}
			methodID := hash.Sum(nil)[:4]
			slotBytes := make([]byte, 8)
			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 {
		return nil, fmt.Errorf("Failed bid: %w", err)
	}
	return tx, nil
}

// 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) {
	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) {
			tokens, err := ERC777.NewERC777(c.tokenAddress, ec)
			if err != nil {
				return nil, err
			}
			multiBidFnSignature := []byte("multiBid(uint128,uint128,bool[6],uint128,uint128,address)")
			hash := sha3.NewLegacyKeccak256()
			_, err = hash.Write(multiBidFnSignature)
			if err != nil {
				return nil, err
			}
			methodID := hash.Sum(nil)[:4]
			startingSlotBytes := make([]byte, 8)
			binary.BigEndian.PutUint64(startingSlotBytes, uint64(startingSlot))
			paddedStartingSlot := ethCommon.LeftPadBytes(startingSlotBytes, 32)
			endingSlotBytes := make([]byte, 8)
			binary.BigEndian.PutUint64(endingSlotBytes, uint64(endingSlot))
			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...)
			userData = append(userData, paddedEndingSlot...)
			for i := 0; i < len(slotSet); i++ {
				if slotSet[i] {
					paddedSlotSet := ethCommon.LeftPadBytes([]byte{1}, 32)
					userData = append(userData, paddedSlotSet...)
				} else {
					paddedSlotSet := ethCommon.LeftPadBytes([]byte{0}, 32)
					userData = append(userData, paddedSlotSet...)
				}
			}
			userData = append(userData, paddedMaxBid...)
			userData = append(userData, paddedMinBid...)
			userData = append(userData, paddedAddress...)
			return tokens.Send(auth, c.address, budget, userData)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed multibid: %w", err)
	}
	return tx, nil
}

// AuctionCanForge is the interface to call the smart contract function
func (c *AuctionClient) AuctionCanForge(forger ethCommon.Address, blockNum int64) (bool, error) {
	var canForge bool
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		canForge, err = auction.CanForge(nil, forger, big.NewInt(blockNum))
		return err
	}); err != nil {
		return false, err
	}
	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) {
	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.ClaimHEZ(auth, claimAddress)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed claim HEZ: %w", err)
	}
	return tx, nil
}

// AuctionForge is the interface to call the smart contract function
func (c *AuctionClient) AuctionForge(forger ethCommon.Address) (*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.Forge(auth, forger)
		},
	); err != nil {
		return nil, fmt.Errorf("Failed forge: %w", err)
	}
	return tx, nil
}

// AuctionConstants returns the Constants of the Auction Smart Contract
func (c *AuctionClient) AuctionConstants() (*AuctionConstants, error) {
	auctionConstants := new(AuctionConstants)
	if err := c.client.Call(func(ec *ethclient.Client) error {
		auction, err := HermezAuctionProtocol.NewHermezAuctionProtocol(c.address, ec)
		if err != nil {
			return err
		}
		auctionConstants.BlocksPerSlot, err = auction.BLOCKSPERSLOT(nil)
		if err != nil {
			return err
		}
		genesisBlock, err := auction.GenesisBlock(nil)
		if err != nil {
			return err
		}
		auctionConstants.GenesisBlockNum = genesisBlock.Int64()
		auctionConstants.HermezRollup, err = auction.HermezRollup(nil)
		if err != nil {
			return err
		}
		auctionConstants.InitialMinimalBidding, err = auction.INITIALMINIMALBIDDING(nil)
		if err != nil {
			return err
		}
		auctionConstants.TokenHEZ, err = auction.TokenHEZ(nil)
		return err
	}); err != nil {
		return nil, err
	}
	return auctionConstants, nil
}

// AuctionVariables returns the variables of the Auction Smart Contract
func (c *AuctionClient) AuctionVariables() (*AuctionVariables, error) {
	auctionVariables := new(AuctionVariables)
	if err := c.client.Call(func(ec *ethclient.Client) error {
		var err error
		auctionVariables.AllocationRatio, err = c.AuctionGetAllocationRatio()
		if err != nil {
			return err
		}
		bootCoordinator, err := c.AuctionGetBootCoordinator()
		if err != nil {
			return err
		}
		auctionVariables.BootCoordinator = *bootCoordinator
		auctionVariables.ClosedAuctionSlots, err = c.AuctionGetClosedAuctionSlots()
		if err != nil {
			return err
		}
		var defaultSlotSetBid [6]*big.Int
		for i := uint8(0); i < 6; i++ {
			bid, err := c.AuctionGetDefaultSlotSetBid(i)
			if err != nil {
				return err
			}
			defaultSlotSetBid[i] = bid
		}
		auctionVariables.DefaultSlotSetBid = defaultSlotSetBid
		donationAddress, err := c.AuctionGetDonationAddress()
		if err != nil {
			return err
		}
		auctionVariables.DonationAddress = *donationAddress
		auctionVariables.OpenAuctionSlots, err = c.AuctionGetOpenAuctionSlots()
		if err != nil {
			return err
		}
		auctionVariables.Outbidding, err = c.AuctionGetOutbidding()
		if err != nil {
			return err
		}
		auctionVariables.SlotDeadline, err = c.AuctionGetSlotDeadline()
		return err
	}); err != nil {
		return nil, err
	}
	return auctionVariables, nil
}

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)"))
)

// AuctionEventsByBlock returns the events in a block that happened in the
// Auction Smart Contract and the blockHash where the eents happened.  If there
// are no events in that block, blockHash is nil.
func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *ethCommon.Hash, error) {
	var auctionEvents AuctionEvents
	var blockHash ethCommon.Hash

	query := ethereum.FilterQuery{
		FromBlock: big.NewInt(blockNum),
		ToBlock:   big.NewInt(blockNum),
		Addresses: []ethCommon.Address{
			c.address,
		},
		Topics: [][]ethCommon.Hash{},
	}

	logs, err := c.client.client.FilterLogs(context.TODO(), 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 logNewBid:
			var auxNewBid struct {
				Slot      *big.Int
				BidAmount *big.Int
				Address   ethCommon.Address
			}
			var newBid AuctionEventNewBid
			if err := c.contractAbi.Unpack(&auxNewBid, "NewBid", vLog.Data); err != nil {
				return nil, nil, err
			}
			newBid.BidAmount = auxNewBid.BidAmount
			newBid.Slot = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
			newBid.CoordinatorForger = ethCommon.BytesToAddress(vLog.Topics[2].Bytes())
			auctionEvents.NewBid = append(auctionEvents.NewBid, newBid)
		case logNewSlotDeadline:
			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:
			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:
			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:
			var newDonationAddress AuctionEventNewDonationAddress
			if err := c.contractAbi.Unpack(&newDonationAddress, "NewDonationAddress", vLog.Data); err != nil {
				return nil, nil, err
			}
			auctionEvents.NewDonationAddress = append(auctionEvents.NewDonationAddress, newDonationAddress)
		case logNewBootCoordinator:
			var newBootCoordinator AuctionEventNewBootCoordinator
			if err := c.contractAbi.Unpack(&newBootCoordinator, "NewBootCoordinator", vLog.Data); err != nil {
				return nil, nil, err
			}
			auctionEvents.NewBootCoordinator = append(auctionEvents.NewBootCoordinator, newBootCoordinator)
		case logNewOpenAuctionSlots:
			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:
			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 {
				return nil, nil, err
			}
			auctionEvents.CoordinatorUpdated = append(auctionEvents.CoordinatorUpdated, coordinatorUpdated)
		case logNewForgeAllocated:
			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()
			auctionEvents.NewForgeAllocated = append(auctionEvents.NewForgeAllocated, newForgeAllocated)
		case logNewDefaultSlotSetBid:
			var auxNewDefaultSlotSetBid struct {
				SlotSet          *big.Int
				NewInitialMinBid *big.Int
			}
			var newDefaultSlotSetBid AuctionEventNewDefaultSlotSetBid
			if err := c.contractAbi.Unpack(&auxNewDefaultSlotSetBid, "NewDefaultSlotSetBid", vLog.Data); err != nil {
				return nil, nil, err
			}
			newDefaultSlotSetBid.NewInitialMinBid = auxNewDefaultSlotSetBid.NewInitialMinBid
			newDefaultSlotSetBid.SlotSet = auxNewDefaultSlotSetBid.SlotSet.Int64()
			auctionEvents.NewDefaultSlotSetBid = append(auctionEvents.NewDefaultSlotSetBid, newDefaultSlotSetBid)
		case logNewForge:
			var newForge AuctionEventNewForge
			newForge.Forger = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
			newForge.CurrentSlot = new(big.Int).SetBytes(vLog.Topics[2][:]).Int64()
			auctionEvents.NewForge = append(auctionEvents.NewForge, newForge)
		case logHEZClaimed:
			var HEZClaimed AuctionEventHEZClaimed
			if err := c.contractAbi.Unpack(&HEZClaimed, "HEZClaimed", vLog.Data); err != nil {
				return nil, nil, err
			}
			HEZClaimed.Owner = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
			auctionEvents.HEZClaimed = append(auctionEvents.HEZClaimed, HEZClaimed)
		}
	}
	return &auctionEvents, &blockHash, nil
}