Documentation ¶
Overview ¶
Package bind generates Ethereum contract Go bindings.
Detailed usage document and tutorial available on the go-ethereum Wiki page: https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts
(c) 2019-2022, Ava Labs, Inc. All rights reserved. See the file LICENSE for licensing terms.
Index ¶
- Variables
- func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, ...) (string, error)
- func WaitDeployed(ctx context.Context, b DeployBackend, tx *types.Transaction) (common.Address, error)
- func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*types.Receipt, error)
- type AcceptedContractCaller
- type BoundContract
- func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method string, params ...interface{}) error
- func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error)
- func (c *BoundContract) RawTransact(opts *TransactOpts, calldata []byte) (*types.Transaction, error)
- func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error)
- func (c *BoundContract) Transfer(opts *TransactOpts) (*types.Transaction, error)
- func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log) error
- func (c *BoundContract) UnpackLogIntoMap(out map[string]interface{}, event string, log types.Log) error
- func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error)
- type CallOpts
- type ContractBackend
- type ContractCaller
- type ContractFilterer
- type ContractTransactor
- type DeployBackend
- type FilterOpts
- type Lang
- type MetaData
- type SignerFn
- type TransactOpts
- func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts
- func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error)deprecated
- func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) (*TransactOpts, error)
- func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOptsdeprecated
- func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error)
- func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error)deprecated
- func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.Int) (*TransactOpts, error)
- type WatchOpts
Constants ¶
This section is empty.
Variables ¶
var ( // ErrNoCode is returned by call and transact operations for which the requested // recipient contract to operate on does not exist in the state db or does not // have any code associated with it (i.e. suicided). ErrNoCode = errors.New("no contract code at given address") // ErrNoAcceptedState is raised when attempting to perform a accepted state action // on a backend that doesn't implement AcceptedContractCaller. ErrNoAcceptedState = errors.New("backend does not support accepted state") // ErrNoCodeAfterDeploy is returned by WaitDeployed if contract creation leaves // an empty contract behind. ErrNoCodeAfterDeploy = errors.New("no contract code after deployment") )
var ErrNoChainID = errors.New("no chain id specified")
ErrNoChainID is returned whenever the user failed to specify a chain id.
var ErrNotAuthorized = errors.New("not authorized to sign this account")
ErrNotAuthorized is returned when an account is not properly unlocked.
Functions ¶
func Bind ¶
func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string, isPrecompile bool) (string, error)
Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant to be used as is in client code, but rather as an intermediate struct which enforces compile time type safety and naming convention opposed to having to manually maintain hard coded strings that break on runtime.
func WaitDeployed ¶
func WaitDeployed(ctx context.Context, b DeployBackend, tx *types.Transaction) (common.Address, error)
WaitDeployed waits for a contract deployment transaction and returns the on-chain contract address when it is mined. It stops waiting when ctx is canceled.
func WaitMined ¶
func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*types.Receipt, error)
WaitMined waits for tx to be mined on the blockchain. It stops waiting when the context is canceled.
Types ¶
type AcceptedContractCaller ¶
type AcceptedContractCaller interface { // AcceptedCodeAt returns the code of the given account in the accepted state. AcceptedCodeAt(ctx context.Context, contract common.Address) ([]byte, error) // AcceptedCallContract executes an Ethereum contract call against the accepted state. AcceptedCallContract(ctx context.Context, call interfaces.CallMsg) ([]byte, error) }
AcceptedContractCaller defines methods to perform contract calls on the pending state. Call will try to discover this interface when access to the accepted state is requested. If the backend does not support the pending state, Call returns ErrNoAcceptedState.
type BoundContract ¶
type BoundContract struct {
// contains filtered or unexported fields
}
BoundContract is the base wrapper object that reflects a contract on the Ethereum network. It contains a collection of methods that are used by the higher level contract bindings to operate.
func DeployContract ¶
func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, params ...interface{}) (common.Address, *types.Transaction, *BoundContract, error)
DeployContract deploys a contract onto the Ethereum blockchain and binds the deployment address with a Go wrapper.
func NewBoundContract ¶
func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller, transactor ContractTransactor, filterer ContractFilterer) *BoundContract
NewBoundContract creates a low level contract interface through which calls and transactions may be made through.
func (*BoundContract) Call ¶
func (c *BoundContract) Call(opts *CallOpts, results *[]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 (*BoundContract) FilterLogs ¶
func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error)
FilterLogs filters contract logs for past blocks, returning the necessary channels to construct a strongly typed bound iterator on top of them.
func (*BoundContract) RawTransact ¶
func (c *BoundContract) RawTransact(opts *TransactOpts, calldata []byte) (*types.Transaction, error)
RawTransact initiates a transaction with the given raw calldata as the input. It's usually used to initiate transactions for invoking **Fallback** function.
func (*BoundContract) Transact ¶
func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error)
Transact invokes the (paid) contract method with params as input values.
func (*BoundContract) Transfer ¶
func (c *BoundContract) Transfer(opts *TransactOpts) (*types.Transaction, error)
Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.
func (*BoundContract) UnpackLog ¶
func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log) error
UnpackLog unpacks a retrieved log into the provided output structure.
func (*BoundContract) UnpackLogIntoMap ¶
func (c *BoundContract) UnpackLogIntoMap(out map[string]interface{}, event string, log types.Log) error
UnpackLogIntoMap unpacks a retrieved log into the provided map.
func (*BoundContract) WatchLogs ¶
func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error)
WatchLogs filters subscribes to contract logs for future blocks, returning a subscription object that can be used to tear down the watcher.
type CallOpts ¶
type CallOpts struct { Accepted bool // Whether to operate on the accepted state or the last known one From common.Address // Optional the sender address, otherwise the first account is used BlockNumber *big.Int // Optional the block number on which the call should be performed Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) }
CallOpts is the collection of options to fine tune a contract call request.
type ContractBackend ¶
type ContractBackend interface { ContractCaller ContractTransactor ContractFilterer }
ContractBackend defines the methods needed to work with contracts on a read-write basis.
type ContractCaller ¶
type ContractCaller interface { // CodeAt returns the code of the given account. This is needed to differentiate // between contract internal errors and the local chain being out of sync. CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) // CallContract executes an Ethereum contract call with the specified data as the // input. CallContract(ctx context.Context, call interfaces.CallMsg, blockNumber *big.Int) ([]byte, error) }
ContractCaller defines the methods needed to allow operating with a contract on a read only basis.
type ContractFilterer ¶
type ContractFilterer interface { // FilterLogs executes a log filter operation, blocking during execution and // returning all the results in one batch. // // TODO(karalabe): Deprecate when the subscription one can return past data too. FilterLogs(ctx context.Context, query interfaces.FilterQuery) ([]types.Log, error) // SubscribeFilterLogs creates a background log filtering operation, returning // a subscription immediately, which can be used to stream the found events. SubscribeFilterLogs(ctx context.Context, query interfaces.FilterQuery, ch chan<- types.Log) (interfaces.Subscription, error) }
ContractFilterer defines the methods needed to access log events using one-off queries or continuous event subscriptions.
type ContractTransactor ¶
type ContractTransactor interface { // HeaderByNumber returns a block header from the current canonical chain. If // number is nil, the latest known header is returned. HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) // AcceptedCodeAt returns the code of the given account in the accepted state. AcceptedCodeAt(ctx context.Context, account common.Address) ([]byte, error) // AcceptedNonceAt retrieves the current accepted nonce associated with an account. AcceptedNonceAt(ctx context.Context, account common.Address) (uint64, error) // SuggestGasPrice retrieves the currently suggested gas price to allow a timely // execution of a transaction. SuggestGasPrice(ctx context.Context) (*big.Int, error) // SuggestGasTipCap retrieves the currently suggested 1559 priority fee to allow // a timely execution of a transaction. SuggestGasTipCap(ctx context.Context) (*big.Int, error) // EstimateGas tries to estimate the gas needed to execute a specific // transaction based on the current pending state of the backend blockchain. // There is no guarantee that this is the true gas limit requirement as other // transactions may be added or removed by miners, but it should provide a basis // for setting a reasonable default. EstimateGas(ctx context.Context, call interfaces.CallMsg) (gas uint64, err error) // SendTransaction injects the transaction into the pending pool for execution. SendTransaction(ctx context.Context, tx *types.Transaction) error }
ContractTransactor defines the methods needed to allow operating with a contract on a write only basis. Besides the transacting method, the remainder are helpers used when the user does not provide some needed values, but rather leaves it up to the transactor to decide.
type DeployBackend ¶
type DeployBackend interface { TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) }
DeployBackend wraps the operations needed by WaitMined and WaitDeployed.
type FilterOpts ¶
type FilterOpts struct { Start uint64 // Start of the queried range End *uint64 // End of the range (nil = latest) Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) }
FilterOpts is the collection of options to fine tune filtering for events within a bound contract.
type MetaData ¶
type MetaData struct { Sigs map[string]string Bin string ABI string // contains filtered or unexported fields }
MetaData collects all metadata for a bound contract.
type SignerFn ¶
type SignerFn func(common.Address, *types.Transaction) (*types.Transaction, error)
SignerFn is a signer function callback when a contract requires a method to sign the transaction before submission.
type TransactOpts ¶
type TransactOpts struct { From common.Address // Ethereum account to send the transaction from Nonce *big.Int // Nonce to use for the transaction execution (nil = use pending state) Signer SignerFn // Method to use for signing the transaction (mandatory) Value *big.Int // Funds to transfer along the transaction (nil = 0 = no funds) GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle) GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle) GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate) Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) NoSend bool // Do all transact steps but do not send the transaction }
TransactOpts is the collection of authorization data required to create a valid Ethereum transaction.
func NewClefTransactor ¶
func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts
NewClefTransactor is a utility method to easily create a transaction signer with a clef backend.
func NewKeyStoreTransactor
deprecated
func NewKeyStoreTransactorWithChainID ¶
func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) (*TransactOpts, error)
NewKeyStoreTransactorWithChainID is a utility method to easily create a transaction signer from an decrypted key from a keystore.
func NewKeyedTransactor
deprecated
func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts
NewKeyedTransactor is a utility method to easily create a transaction signer from a single private key.
Deprecated: Use NewKeyedTransactorWithChainID instead.
func NewKeyedTransactorWithChainID ¶
func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error)
NewKeyedTransactorWithChainID is a utility method to easily create a transaction signer from a single private key.
func NewTransactor
deprecated
func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error)
NewTransactor is a utility method to easily create a transaction signer from an encrypted json key stream and the associated passphrase.
Deprecated: Use NewTransactorWithChainID instead.
func NewTransactorWithChainID ¶
func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.Int) (*TransactOpts, error)
NewTransactorWithChainID is a utility method to easily create a transaction signer from an encrypted json key stream and the associated passphrase.
type WatchOpts ¶
type WatchOpts struct { Start *uint64 // Start of the queried range (nil = latest) Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) }
WatchOpts is the collection of options to fine tune subscribing for events within a bound contract.
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
Package bind generates Ethereum contract Go bindings.
|
Package bind generates Ethereum contract Go bindings. |