evm

package
v0.0.0-...-6fdbc3c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 23, 2022 License: MIT Imports: 19 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// GasLimit is the default gas limit used to send transactions
	GasLimit = uint64(300000)
)
View Source 
const ProviderABI = "[]"

ProviderABI is the input ABI used to generate the binding from.

View Source 
const ProvidersABI = "" /* 1625-byte string literal not displayed */

ProvidersABI is the input ABI used to generate the binding from.

View Source 
const UnorderedSetABI = "[]"

UnorderedSetABI is the input ABI used to generate the binding from.

Variables

View Source 
var (
	// ErrChainID is thrown on an invalid ETH chain ID
	ErrChainID = errors.New("invalid chain id")

	// ErrClientState is thrown on an invalid client state
	ErrClientState = errors.New("invalid client state")
)
View Source 
var ProviderBin = "" /* 334-byte string literal not displayed */

ProviderBin is the compiled bytecode used for deploying new contracts.

View Source 
var (
	// ProvidersAddr is a temporary placeholder for the contract address
	ProvidersAddr = common.HexToAddress(os.Getenv("PROVIDERS"))
)
View Source 
var ProvidersBin = "" /* 7362-byte string literal not displayed */

ProvidersBin is the compiled bytecode used for deploying new contracts.

View Source 
var UnorderedSetBin = "" /* 334-byte string literal not displayed */

UnorderedSetBin is the compiled bytecode used for deploying new contracts.

Functions

This section is empty.

Types

type Client 

type Client struct {
	// ID is the chain ID
	ID *big.Int

	// Account is the eth account used for signing transactions
	Account *evm.Account

	// URI is a valid endpoint
	URI *url.URL

	// Connection is a WebSocket connection to an Ethereum node
	RPC *rpc.Client

	// Client is an Ethereum client
	Client *ethclient.Client

	// Context is the client's calling context
	Ctx ctx.Context

	// Alive is true if the node is connected
	Alive bool

	// Providers smart contract instance
	Providers *Providers
}

Client wraps a connection to an evm compatible node

func NewClient 

func NewClient(chainID int64, uri string) (*Client, error)

NewClient returns an empty evm client

func (*Client) Close 

func (c *Client) Close() error

Close terminates an existing RPC connection

func (*Client) Join 

func (c *Client) Join(pubkey []byte, netAddr []byte) error

Join submits a tx to join the provider network

func (*Client) Open 

func (c *Client) Open() error

Open connects to an eth client

func (*Client) Peers 

func (c *Client) Peers() ([]node.Peer, error)

Peers queries the provider network for a list of peers

func (*Client) ProviderManager 

func (c *Client) ProviderManager(p chan node.Peer) error

ProviderManager subscribes to join/exit events

func (*Client) Run 

func (c *Client) Run(p chan node.Peer) (err error)

Run is the client's main blocking tx loop

type Provider 

type Provider struct {
	ProviderCaller     // Read-only binding to the contract
	ProviderTransactor // Write-only binding to the contract
	ProviderFilterer   // Log filterer for contract events
}

Provider is an auto generated Go binding around an Ethereum contract.

func DeployProvider 

func DeployProvider(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Provider, error)

DeployProvider deploys a new Ethereum contract, binding an instance of Provider to it.

func NewProvider 

func NewProvider(address common.Address, backend bind.ContractBackend) (*Provider, error)

NewProvider creates a new instance of Provider, bound to a specific deployed contract.

type ProviderCaller 

type ProviderCaller struct {
	// contains filtered or unexported fields
}

ProviderCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewProviderCaller 

func NewProviderCaller(address common.Address, caller bind.ContractCaller) (*ProviderCaller, error)

NewProviderCaller creates a new read-only instance of Provider, bound to a specific deployed contract.

type ProviderCallerRaw 

type ProviderCallerRaw struct {
	Contract *ProviderCaller // Generic read-only contract binding to access the raw methods on
}

ProviderCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ProviderCallerRaw) Call 

func (_Provider *ProviderCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ProviderCallerSession 

type ProviderCallerSession struct {
	Contract *ProviderCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts   // Call options to use throughout this session
}

ProviderCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ProviderFilterer 

type ProviderFilterer struct {
	// contains filtered or unexported fields
}

ProviderFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewProviderFilterer 

func NewProviderFilterer(address common.Address, filterer bind.ContractFilterer) (*ProviderFilterer, error)

NewProviderFilterer creates a new log filterer instance of Provider, bound to a specific deployed contract.

type ProviderNode 

type ProviderNode struct {
	Pubkey  [32]byte
	NetAddr [32]byte
}

ProviderNode is an auto generated low-level Go binding around an user-defined struct.

type ProviderRaw 

type ProviderRaw struct {
	Contract *Provider // Generic contract binding to access the raw methods on
}

ProviderRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ProviderRaw) Call 

func (_Provider *ProviderRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ProviderRaw) Transact 

func (_Provider *ProviderRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ProviderRaw) Transfer 

func (_Provider *ProviderRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ProviderSession 

type ProviderSession struct {
	Contract     *Provider         // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ProviderSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type ProviderTransactor 

type ProviderTransactor struct {
	// contains filtered or unexported fields
}

ProviderTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewProviderTransactor 

func NewProviderTransactor(address common.Address, transactor bind.ContractTransactor) (*ProviderTransactor, error)

NewProviderTransactor creates a new write-only instance of Provider, bound to a specific deployed contract.

type ProviderTransactorRaw 

type ProviderTransactorRaw struct {
	Contract *ProviderTransactor // Generic write-only contract binding to access the raw methods on
}

ProviderTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ProviderTransactorRaw) Transact 

func (_Provider *ProviderTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ProviderTransactorRaw) Transfer 

func (_Provider *ProviderTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ProviderTransactorSession 

type ProviderTransactorSession struct {
	Contract     *ProviderTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

ProviderTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type Providers 

type Providers struct {
	ProvidersCaller     // Read-only binding to the contract
	ProvidersTransactor // Write-only binding to the contract
	ProvidersFilterer   // Log filterer for contract events
}

Providers is an auto generated Go binding around an Ethereum contract.

func DeployProviders 

func DeployProviders(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Providers, error)

DeployProviders deploys a new Ethereum contract, binding an instance of Providers to it.

func NewProviders 

func NewProviders(address common.Address, backend bind.ContractBackend) (*Providers, error)

NewProviders creates a new instance of Providers, bound to a specific deployed contract.

type ProvidersCaller 

type ProvidersCaller struct {
	// contains filtered or unexported fields
}

ProvidersCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewProvidersCaller 

func NewProvidersCaller(address common.Address, caller bind.ContractCaller) (*ProvidersCaller, error)

NewProvidersCaller creates a new read-only instance of Providers, bound to a specific deployed contract.

func (*ProvidersCaller) GetProviders 

func (_Providers *ProvidersCaller) GetProviders(opts *bind.CallOpts) ([]common.Address, error)

GetProviders is a free data retrieval call binding the contract method 0xedc922a9.

Solidity: function getProviders() view returns(address[])

func (*ProvidersCaller) Lookup 

func (_Providers *ProvidersCaller) Lookup(opts *bind.CallOpts, a common.Address) (ProviderNode, error)

Lookup is a free data retrieval call binding the contract method 0xd4b6b5da.

Solidity: function lookup(address a) view returns((bytes32,bytes32))

type ProvidersCallerRaw 

type ProvidersCallerRaw struct {
	Contract *ProvidersCaller // Generic read-only contract binding to access the raw methods on
}

ProvidersCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ProvidersCallerRaw) Call 

func (_Providers *ProvidersCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ProvidersCallerSession 

type ProvidersCallerSession struct {
	Contract *ProvidersCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts    // Call options to use throughout this session
}

ProvidersCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*ProvidersCallerSession) GetProviders 

func (_Providers *ProvidersCallerSession) GetProviders() ([]common.Address, error)

GetProviders is a free data retrieval call binding the contract method 0xedc922a9.

Solidity: function getProviders() view returns(address[])

func (*ProvidersCallerSession) Lookup 

func (_Providers *ProvidersCallerSession) Lookup(a common.Address) (ProviderNode, error)

Lookup is a free data retrieval call binding the contract method 0xd4b6b5da.

Solidity: function lookup(address a) view returns((bytes32,bytes32))

type ProvidersFilterer 

type ProvidersFilterer struct {
	// contains filtered or unexported fields
}

ProvidersFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewProvidersFilterer 

func NewProvidersFilterer(address common.Address, filterer bind.ContractFilterer) (*ProvidersFilterer, error)

NewProvidersFilterer creates a new log filterer instance of Providers, bound to a specific deployed contract.

func (*ProvidersFilterer) FilterProviderExit 

func (_Providers *ProvidersFilterer) FilterProviderExit(opts *bind.FilterOpts, p []common.Address, pubkey [][32]byte, netAddr [][32]byte) (*ProvidersProviderExitIterator, error)

FilterProviderExit is a free log retrieval operation binding the contract event 0xc72f425864663e90861a0510ca302816b37bb1f9ab5203223088f8a4a25fb558.

Solidity: event ProviderExit(address indexed p, bytes32 indexed pubkey, bytes32 indexed netAddr)

func (*ProvidersFilterer) FilterProviderJoin 

func (_Providers *ProvidersFilterer) FilterProviderJoin(opts *bind.FilterOpts, p []common.Address, pubkey [][32]byte, netAddr [][32]byte) (*ProvidersProviderJoinIterator, error)

FilterProviderJoin is a free log retrieval operation binding the contract event 0x15b88bb7d80477950c43dc4f6fd378c0dd62f99cffcc5f99f30dbd117c4f57ff.

Solidity: event ProviderJoin(address indexed p, bytes32 indexed pubkey, bytes32 indexed netAddr)

func (*ProvidersFilterer) ParseProviderExit 

func (_Providers *ProvidersFilterer) ParseProviderExit(log types.Log) (*ProvidersProviderExit, error)

ParseProviderExit is a log parse operation binding the contract event 0xc72f425864663e90861a0510ca302816b37bb1f9ab5203223088f8a4a25fb558.

Solidity: event ProviderExit(address indexed p, bytes32 indexed pubkey, bytes32 indexed netAddr)

func (*ProvidersFilterer) ParseProviderJoin 

func (_Providers *ProvidersFilterer) ParseProviderJoin(log types.Log) (*ProvidersProviderJoin, error)

ParseProviderJoin is a log parse operation binding the contract event 0x15b88bb7d80477950c43dc4f6fd378c0dd62f99cffcc5f99f30dbd117c4f57ff.

Solidity: event ProviderJoin(address indexed p, bytes32 indexed pubkey, bytes32 indexed netAddr)

func (*ProvidersFilterer) WatchProviderExit 

func (_Providers *ProvidersFilterer) WatchProviderExit(opts *bind.WatchOpts, sink chan<- *ProvidersProviderExit, p []common.Address, pubkey [][32]byte, netAddr [][32]byte) (event.Subscription, error)

WatchProviderExit is a free log subscription operation binding the contract event 0xc72f425864663e90861a0510ca302816b37bb1f9ab5203223088f8a4a25fb558.

Solidity: event ProviderExit(address indexed p, bytes32 indexed pubkey, bytes32 indexed netAddr)

func (*ProvidersFilterer) WatchProviderJoin 

func (_Providers *ProvidersFilterer) WatchProviderJoin(opts *bind.WatchOpts, sink chan<- *ProvidersProviderJoin, p []common.Address, pubkey [][32]byte, netAddr [][32]byte) (event.Subscription, error)

WatchProviderJoin is a free log subscription operation binding the contract event 0x15b88bb7d80477950c43dc4f6fd378c0dd62f99cffcc5f99f30dbd117c4f57ff.

Solidity: event ProviderJoin(address indexed p, bytes32 indexed pubkey, bytes32 indexed netAddr)

type ProvidersProviderExit 

type ProvidersProviderExit struct {
	P       common.Address
	Pubkey  [32]byte
	NetAddr [32]byte
	Raw     types.Log // Blockchain specific contextual infos
}

ProvidersProviderExit represents a ProviderExit event raised by the Providers contract.

type ProvidersProviderExitIterator 

type ProvidersProviderExitIterator struct {
	Event *ProvidersProviderExit // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ProvidersProviderExitIterator is returned from FilterProviderExit and is used to iterate over the raw logs and unpacked data for ProviderExit events raised by the Providers contract.

func (*ProvidersProviderExitIterator) Close 

func (it *ProvidersProviderExitIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ProvidersProviderExitIterator) Error 

func (it *ProvidersProviderExitIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ProvidersProviderExitIterator) Next 

func (it *ProvidersProviderExitIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ProvidersProviderJoin 

type ProvidersProviderJoin struct {
	P       common.Address
	Pubkey  [32]byte
	NetAddr [32]byte
	Raw     types.Log // Blockchain specific contextual infos
}

ProvidersProviderJoin represents a ProviderJoin event raised by the Providers contract.

type ProvidersProviderJoinIterator 

type ProvidersProviderJoinIterator struct {
	Event *ProvidersProviderJoin // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ProvidersProviderJoinIterator is returned from FilterProviderJoin and is used to iterate over the raw logs and unpacked data for ProviderJoin events raised by the Providers contract.

func (*ProvidersProviderJoinIterator) Close 

func (it *ProvidersProviderJoinIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ProvidersProviderJoinIterator) Error 

func (it *ProvidersProviderJoinIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ProvidersProviderJoinIterator) Next 

func (it *ProvidersProviderJoinIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ProvidersRaw 

type ProvidersRaw struct {
	Contract *Providers // Generic contract binding to access the raw methods on
}

ProvidersRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ProvidersRaw) Call 

func (_Providers *ProvidersRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ProvidersRaw) Transact 

func (_Providers *ProvidersRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ProvidersRaw) Transfer 

func (_Providers *ProvidersRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ProvidersSession 

type ProvidersSession struct {
	Contract     *Providers        // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ProvidersSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ProvidersSession) Exit 

func (_Providers *ProvidersSession) Exit() (*types.Transaction, error)

Exit is a paid mutator transaction binding the contract method 0xe9fad8ee.

Solidity: function exit() returns()

func (*ProvidersSession) GetProviders 

func (_Providers *ProvidersSession) GetProviders() ([]common.Address, error)

GetProviders is a free data retrieval call binding the contract method 0xedc922a9.

Solidity: function getProviders() view returns(address[])

func (*ProvidersSession) Join 

func (_Providers *ProvidersSession) Join(pubkey [32]byte, netAddr [32]byte) (*types.Transaction, error)

Join is a paid mutator transaction binding the contract method 0x5b419a65.

Solidity: function join(bytes32 pubkey, bytes32 netAddr) returns()

func (*ProvidersSession) Lookup 

func (_Providers *ProvidersSession) Lookup(a common.Address) (ProviderNode, error)

Lookup is a free data retrieval call binding the contract method 0xd4b6b5da.

Solidity: function lookup(address a) view returns((bytes32,bytes32))

type ProvidersTransactor 

type ProvidersTransactor struct {
	// contains filtered or unexported fields
}

ProvidersTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewProvidersTransactor 

func NewProvidersTransactor(address common.Address, transactor bind.ContractTransactor) (*ProvidersTransactor, error)

NewProvidersTransactor creates a new write-only instance of Providers, bound to a specific deployed contract.

func (*ProvidersTransactor) Exit 

func (_Providers *ProvidersTransactor) Exit(opts *bind.TransactOpts) (*types.Transaction, error)

Exit is a paid mutator transaction binding the contract method 0xe9fad8ee.

Solidity: function exit() returns()

func (*ProvidersTransactor) Join 

func (_Providers *ProvidersTransactor) Join(opts *bind.TransactOpts, pubkey [32]byte, netAddr [32]byte) (*types.Transaction, error)

Join is a paid mutator transaction binding the contract method 0x5b419a65.

Solidity: function join(bytes32 pubkey, bytes32 netAddr) returns()

type ProvidersTransactorRaw 

type ProvidersTransactorRaw struct {
	Contract *ProvidersTransactor // Generic write-only contract binding to access the raw methods on
}

ProvidersTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ProvidersTransactorRaw) Transact 

func (_Providers *ProvidersTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ProvidersTransactorRaw) Transfer 

func (_Providers *ProvidersTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ProvidersTransactorSession 

type ProvidersTransactorSession struct {
	Contract     *ProvidersTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
}

ProvidersTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*ProvidersTransactorSession) Exit 

func (_Providers *ProvidersTransactorSession) Exit() (*types.Transaction, error)

Exit is a paid mutator transaction binding the contract method 0xe9fad8ee.

Solidity: function exit() returns()

func (*ProvidersTransactorSession) Join 

func (_Providers *ProvidersTransactorSession) Join(pubkey [32]byte, netAddr [32]byte) (*types.Transaction, error)

Join is a paid mutator transaction binding the contract method 0x5b419a65.

Solidity: function join(bytes32 pubkey, bytes32 netAddr) returns()

type UnorderedSet 

type UnorderedSet struct {
	UnorderedSetCaller     // Read-only binding to the contract
	UnorderedSetTransactor // Write-only binding to the contract
	UnorderedSetFilterer   // Log filterer for contract events
}

UnorderedSet is an auto generated Go binding around an Ethereum contract.

func DeployUnorderedSet 

func DeployUnorderedSet(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *UnorderedSet, error)

DeployUnorderedSet deploys a new Ethereum contract, binding an instance of UnorderedSet to it.

func NewUnorderedSet 

func NewUnorderedSet(address common.Address, backend bind.ContractBackend) (*UnorderedSet, error)

NewUnorderedSet creates a new instance of UnorderedSet, bound to a specific deployed contract.

type UnorderedSetCaller 

type UnorderedSetCaller struct {
	// contains filtered or unexported fields
}

UnorderedSetCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewUnorderedSetCaller 

func NewUnorderedSetCaller(address common.Address, caller bind.ContractCaller) (*UnorderedSetCaller, error)

NewUnorderedSetCaller creates a new read-only instance of UnorderedSet, bound to a specific deployed contract.

type UnorderedSetCallerRaw 

type UnorderedSetCallerRaw struct {
	Contract *UnorderedSetCaller // Generic read-only contract binding to access the raw methods on
}

UnorderedSetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*UnorderedSetCallerRaw) Call 

func (_UnorderedSet *UnorderedSetCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type UnorderedSetCallerSession 

type UnorderedSetCallerSession struct {
	Contract *UnorderedSetCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts       // Call options to use throughout this session
}

UnorderedSetCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type UnorderedSetFilterer 

type UnorderedSetFilterer struct {
	// contains filtered or unexported fields
}

UnorderedSetFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewUnorderedSetFilterer 

func NewUnorderedSetFilterer(address common.Address, filterer bind.ContractFilterer) (*UnorderedSetFilterer, error)

NewUnorderedSetFilterer creates a new log filterer instance of UnorderedSet, bound to a specific deployed contract.

type UnorderedSetRaw 

type UnorderedSetRaw struct {
	Contract *UnorderedSet // Generic contract binding to access the raw methods on
}

UnorderedSetRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*UnorderedSetRaw) Call 

func (_UnorderedSet *UnorderedSetRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*UnorderedSetRaw) Transact 

func (_UnorderedSet *UnorderedSetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*UnorderedSetRaw) Transfer 

func (_UnorderedSet *UnorderedSetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type UnorderedSetSession 

type UnorderedSetSession struct {
	Contract     *UnorderedSet     // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

UnorderedSetSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type UnorderedSetTransactor 

type UnorderedSetTransactor struct {
	// contains filtered or unexported fields
}

UnorderedSetTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewUnorderedSetTransactor 

func NewUnorderedSetTransactor(address common.Address, transactor bind.ContractTransactor) (*UnorderedSetTransactor, error)

NewUnorderedSetTransactor creates a new write-only instance of UnorderedSet, bound to a specific deployed contract.

type UnorderedSetTransactorRaw 

type UnorderedSetTransactorRaw struct {
	Contract *UnorderedSetTransactor // Generic write-only contract binding to access the raw methods on
}

UnorderedSetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*UnorderedSetTransactorRaw) Transact 

func (_UnorderedSet *UnorderedSetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*UnorderedSetTransactorRaw) Transfer 

func (_UnorderedSet *UnorderedSetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type UnorderedSetTransactorSession 

type UnorderedSetTransactorSession struct {
	Contract     *UnorderedSetTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
}

UnorderedSetTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.