Add ethclient full skeleton

eth/auction.go

@@ -0,0 +1,380 @@
+package eth
+
+import (
+	"math/big"
+
+	ethCommon "github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// AuctionConstants are the constants of the Rollup Smart Contract
+type AuctionConstants struct {
+	// Blocks to wait before starting with the first slot
+	DelayGenesis uint16
+	// 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
+	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
+}
+
+// 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
+	MinBidEpoch [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]uint8
+	// Minimum outbid (percentage) over the previous one to consider it valid
+	Outbidding uint8
+	// 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 uint8
+}
+
+// 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]uint8
+}
+
+// AuctionEventNewCoordinator is an event of the Auction Smart Contract
+type AuctionEventNewCoordinator struct {
+	ForgerAddress     ethCommon.Address
+	WithdrawalAddress ethCommon.Address
+	URL               string
+}
+
+// AuctionEventCoordinatorUpdated is an event of the Auction Smart Contract
+type AuctionEventCoordinatorUpdated struct {
+	ForgerAddress     ethCommon.Address
+	WithdrawalAddress ethCommon.Address
+	URL               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
+}
+
+// AuctionEventNewMinBidEpoch is an event of the Auction Smart Contract
+type AuctionEventNewMinBidEpoch struct {
+	SlotEpoch        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
+	NewMinBidEpoch        []AuctionEventNewMinBidEpoch
+	NewForge              []AuctionEventNewForge
+	HEZClaimed            []AuctionEventHEZClaimed
+}
+
+// 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 uint8) (*types.Transaction, error)
+	AuctionGetOutbidding() (uint8, error)
+	AuctionSetAllocationRatio(newAllocationRatio [3]uint8) (*types.Transaction, error)
+	AuctionGetAllocationRatio() ([3]uint8, error)
+	AuctionSetDonationAddress(newDonationAddress ethCommon.Address) (*types.Transaction, error)
+	AuctionGetDonationAddress() (*ethCommon.Address, error)
+	AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address) (*types.Transaction, error)
+	AuctionGetBootCoordinator() (*ethCommon.Address, error)
+	AuctionChangeEpochMinBid(slotEpoch 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)
+	AuctionGetMinBidEpoch(epoch uint8) (*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, slotEpoch [6]bool,
+		maxBid, closedMinBid, budget *big.Int, forger ethCommon.Address) (*types.Transaction, error)
+
+	// Forge
+	AuctionCanForge(forger ethCommon.Address) (bool, error)
+	// AuctionForge(forger ethCommon.Address) (bool, error) // Only called from another smart contract
+
+	// Fees
+	AuctionClaimHEZ() (*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 {
+}
+
+// AuctionSetSlotDeadline is the interface to call the smart contract function
+func (c *AuctionClient) AuctionSetSlotDeadline(newDeadline uint8) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionGetSlotDeadline is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetSlotDeadline() (uint8, error) {
+	return 0, errTODO
+}
+
+// AuctionSetOpenAuctionSlots is the interface to call the smart contract function
+func (c *AuctionClient) AuctionSetOpenAuctionSlots(newOpenAuctionSlots uint16) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionGetOpenAuctionSlots is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetOpenAuctionSlots() (uint16, error) {
+	return 0, errTODO
+}
+
+// AuctionSetClosedAuctionSlots is the interface to call the smart contract function
+func (c *AuctionClient) AuctionSetClosedAuctionSlots(newClosedAuctionSlots uint16) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionGetClosedAuctionSlots is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetClosedAuctionSlots() (uint16, error) {
+	return 0, errTODO
+}
+
+// AuctionSetOutbidding is the interface to call the smart contract function
+func (c *AuctionClient) AuctionSetOutbidding(newOutbidding uint8) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionGetOutbidding is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetOutbidding() (uint8, error) {
+	return 0, errTODO
+}
+
+// AuctionSetAllocationRatio is the interface to call the smart contract function
+func (c *AuctionClient) AuctionSetAllocationRatio(newAllocationRatio [3]uint8) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionGetAllocationRatio is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetAllocationRatio() ([3]uint8, error) {
+	return [3]uint8{}, errTODO
+}
+
+// AuctionSetDonationAddress is the interface to call the smart contract function
+func (c *AuctionClient) AuctionSetDonationAddress(newDonationAddress ethCommon.Address) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionGetDonationAddress is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetDonationAddress() (*ethCommon.Address, error) {
+	return nil, errTODO
+}
+
+// AuctionSetBootCoordinator is the interface to call the smart contract function
+func (c *AuctionClient) AuctionSetBootCoordinator(newBootCoordinator ethCommon.Address) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionGetBootCoordinator is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetBootCoordinator() (*ethCommon.Address, error) {
+	return nil, errTODO
+}
+
+// AuctionChangeEpochMinBid is the interface to call the smart contract function
+func (c *AuctionClient) AuctionChangeEpochMinBid(slotEpoch int64, newInitialMinBid *big.Int) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionRegisterCoordinator is the interface to call the smart contract function
+func (c *AuctionClient) AuctionRegisterCoordinator(forgerAddress ethCommon.Address, URL string) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionIsRegisteredCoordinator is the interface to call the smart contract function
+func (c *AuctionClient) AuctionIsRegisteredCoordinator(forgerAddress ethCommon.Address) (bool, error) {
+	return false, errTODO
+}
+
+// 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) {
+	return nil, errTODO
+}
+
+// AuctionGetCurrentSlotNumber is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetCurrentSlotNumber() (int64, error) {
+	return 0, errTODO
+}
+
+// AuctionGetMinBidBySlot is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetMinBidBySlot(slot int64) (*big.Int, error) {
+	return nil, errTODO
+}
+
+// AuctionGetMinBidEpoch is the interface to call the smart contract function
+func (c *AuctionClient) AuctionGetMinBidEpoch(epoch uint8) (*big.Int, error) {
+	return nil, errTODO
+}
+
+// AuctionTokensReceived is the interface to call the smart contract function
+// func (c *AuctionClient) AuctionTokensReceived(operator, from, to ethCommon.Address, amount *big.Int, userData, operatorData []byte) error {
+// 	return errTODO
+// }
+
+// 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) {
+	return nil, errTODO
+}
+
+// AuctionMultiBid is the interface to call the smart contract function
+func (c *AuctionClient) AuctionMultiBid(startingSlot int64, endingSlot int64, slotEpoch [6]bool, maxBid, closedMinBid, budget *big.Int, forger ethCommon.Address) (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionCanForge is the interface to call the smart contract function
+func (c *AuctionClient) AuctionCanForge(forger ethCommon.Address) (bool, error) {
+	return false, errTODO
+}
+
+// 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() (*types.Transaction, error) {
+	return nil, errTODO
+}
+
+// AuctionConstants returns the Constants of the Auction Smart Contract
+func (c *AuctionClient) AuctionConstants() (*AuctionConstants, error) {
+	return nil, errTODO
+}
+
+// AuctionEventsByBlock returns the events in a block that happened in the Auction Smart Contract
+func (c *AuctionClient) AuctionEventsByBlock(blockNum int64) (*AuctionEvents, *ethCommon.Hash, error) {
+	return nil, nil, errTODO
+}