Documentation ¶
Index ¶
- Variables
- func FindSingleEvent(abi *abi.ABI, receipt *types.Receipt, contractAddress common.Address, ...) error
- func IsSynced(ctx context.Context, backend Backend, maxDelay time.Duration) (bool, error)
- func ParseABIUnchecked(json string) abi.ABI
- func ParseEvent(a *abi.ABI, eventName string, c interface{}, e types.Log) error
- func WaitBlock(ctx context.Context, backend Backend, pollingInterval time.Duration, ...) (*types.Block, error)
- func WaitSynced(ctx context.Context, backend Backend, maxDelay time.Duration) error
- type Backend
- type Matcher
- type Monitor
- type Service
- type StoredTransaction
- type TxRequest
Constants ¶
This section is empty.
Variables ¶
var ( ErrEventNotFound = errors.New("event not found") ErrNoTopic = errors.New("no topic") )
var ( ErrTransactionNotFound = errors.New("transaction not found") ErrTransactionPending = errors.New("transaction in pending status") ErrTransactionSenderInvalid = errors.New("invalid transaction sender") ErrBlockHashMismatch = errors.New("block hash mismatch") ErrOverlayMismatch = errors.New("overlay mismatch") )
var ( // ErrTransactionReverted denotes that the sent transaction has been // reverted. ErrTransactionReverted = errors.New("transaction reverted") ErrUnknownTransaction = errors.New("unknown transaction") ErrAlreadyImported = errors.New("already imported") )
var ErrMonitorClosed = errors.New("monitor closed")
var ErrTransactionCancelled = errors.New("transaction cancelled")
Functions ¶
func FindSingleEvent ¶
func FindSingleEvent(abi *abi.ABI, receipt *types.Receipt, contractAddress common.Address, event abi.Event, out interface{}) error
FindSingleEvent will find the first event of the given kind.
func IsSynced ¶
IsSynced will check if we are synced with the given blockchain backend. This is true if the current wall clock is after the block time of last block with the given maxDelay as the maximum duration we can be behind the block time.
func ParseABIUnchecked ¶
ParseABIUnchecked will parse a valid json abi. Only use this with string constants known to be correct.
func ParseEvent ¶
ParseEvent will parse the specified abi event from the given log
Types ¶
type Backend ¶
type Backend interface { bind.ContractBackend TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) TransactionByHash(ctx context.Context, hash common.Hash) (tx *types.Transaction, isPending bool, err error) BlockNumber(ctx context.Context) (uint64, error) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) BalanceAt(ctx context.Context, address common.Address, block *big.Int) (*big.Int, error) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) }
Backend is the minimum of blockchain backend functions we need.
type Monitor ¶
type Monitor interface { io.Closer // WatchTransaction watches the transaction until either there is 1 confirmation or a competing transaction with cancellationDepth confirmations. WatchTransaction(txHash common.Hash, nonce uint64) (<-chan types.Receipt, <-chan error, error) }
Monitor is a nonce-based watcher for transaction confirmations. Instead of watching transactions individually, the senders nonce is monitored and transactions are checked based on this. The idea is that if the nonce is still lower than that of a pending transaction, there is no point in actually checking the transaction for a receipt. At the same time if the nonce was already used and this was a few blocks ago we can reasonably assume that it will never confirm.
type Service ¶
type Service interface { io.Closer // Send creates a transaction based on the request and sends it. Send(ctx context.Context, request *TxRequest) (txHash common.Hash, err error) // Call simulate a transaction based on the request. Call(ctx context.Context, request *TxRequest) (result []byte, err error) // WaitForReceipt waits until either the transaction with the given hash has been mined or the context is cancelled. // This is only valid for transaction sent by this service. WaitForReceipt(ctx context.Context, txHash common.Hash) (receipt *types.Receipt, err error) // WatchSentTransaction start watching the given transaction. // This wraps the monitors watch function by loading the correct nonce from the store. // This is only valid for transaction sent by this service. WatchSentTransaction(txHash common.Hash) (<-chan types.Receipt, <-chan error, error) // StoredTransaction retrieves the stored information for the transaction StoredTransaction(txHash common.Hash) (*StoredTransaction, error) // PendingTransactions retrieves the list of all pending transaction hashes PendingTransactions() ([]common.Hash, error) // Resend resends a previously sent transaction // This operation can be useful if for some reason the transaction vanished from the eth networks pending pool ResendTransaction(txHash common.Hash) error }
Service is the service to send transactions. It takes care of gas price, gas limit and nonce management.
type StoredTransaction ¶ added in v1.0.0
type StoredTransaction struct { To *common.Address // recipient of the transaction Data []byte // transaction data GasPrice *big.Int // used gas price GasLimit uint64 // used gas limit Value *big.Int // amount of wei to send Nonce uint64 // used nonce Created int64 // creation timestamp Description string // description }
type TxRequest ¶
type TxRequest struct { To *common.Address // recipient of the transaction Data []byte // transaction data GasPrice *big.Int // gas price or nil if suggested gas price should be used GasLimit uint64 // gas limit or 0 if it should be estimated Value *big.Int // amount of wei to send Description string // optional description }
TxRequest describes a request for a transaction that can be executed.