README
Documentation
¶
Index ¶
- Constants
- Variables
- func Do[T any](ctx context.Context, maxAttempts int, strategy Strategy, op func() (T, error)) (T, error)
- func GweiToWei(gwei float64) (*big.Int, error)
- type CLIConfig
- type Config
- type DefaultFlagValues
- type ETHBackend
- type FailedPermanentlyError
- type FixedStrategy
- type SendState
- type SignerFactory
- type SignerFn
- type SimpleTxManager
- type Strategy
- type TxCandidate
- type TxManager
Constants ¶
const ( // PriceBump geth requires a minimum fee bump of 10% for regular tx resubmission. PriceBump int64 = 10 )
Variables ¶
var ( //nolint:gochecknoglobals // should be configurable DefaultSenderFlagValues = DefaultFlagValues{ NumConfirmations: uint64(1), SafeAbortNonceTooLowCount: uint64(3), FeeLimitMultiplier: uint64(5), FeeLimitThresholdGwei: 100.0, ResubmissionTimeout: 48 * time.Second, NetworkTimeout: 10 * time.Second, TxSendTimeout: 0 * time.Second, TxNotInMempoolTimeout: 2 * time.Minute, } )
var (
ErrClosed = errors.New("transaction manager is closed")
)
Functions ¶
Types ¶
type CLIConfig ¶
type CLIConfig struct {
ChainID uint64
NumConfirmations uint64
SafeAbortNonceTooLowCount uint64
FeeLimitMultiplier uint64
FeeLimitThresholdGwei float64
MinBaseFeeGwei float64
MinTipCapGwei float64
ResubmissionTimeout time.Duration
ReceiptQueryInterval time.Duration
NetworkTimeout time.Duration
TxSendTimeout time.Duration
TxNotInMempoolTimeout time.Duration
}
func NewCLIConfig ¶
func NewCLIConfig(chainID uint64, interval time.Duration, defaults DefaultFlagValues) CLIConfig
type Config ¶
type Config struct {
Backend ETHBackend
// ResubmissionTimeout is the interval at which, if no previously
// published transaction has been mined, the new tx with a bumped gas
// price will be published. Only one publication at MaxGasPrice will be
// attempted.
ResubmissionTimeout time.Duration
// The multiplier applied to fee suggestions to put a hard limit on fee increases.
FeeLimitMultiplier uint64
// Minimum threshold (in Wei) at which the FeeLimitMultiplier takes effect.
// On low-fee networks, like test networks, this allows for arbitrary fee bumps
// below this threshold.
FeeLimitThreshold *big.Int
// Minimum base fee (in Wei) to assume when determining tx fees.
MinBaseFee *big.Int
// Minimum tip cap (in Wei) to enforce when determining tx fees.
MinTipCap *big.Int
// ChainID is the chain ID of the L1 chain.
ChainID *big.Int
// TxSendTimeout is how long to wait for sending a transaction.
// By default, it is unbounded. If set, this is recommended to be at least 20 minutes.
TxSendTimeout time.Duration
// TxNotInMempoolTimeout is how long to wait before aborting a transaction doSend if the transaction does not
// make it to the mempool. If the tx is in the mempool, TxSendTimeout is used instead.
TxNotInMempoolTimeout time.Duration
// NetworkTimeout is the allowed duration for a single network request.
// This is intended to be used for network requests that can be replayed.
// todo(lazar): this should be handled by eth client
NetworkTimeout time.Duration
// RequireQueryInterval is the interval at which the tx manager will
// query the backend to check for confirmations after a tx at a
// specific gas price has been published.
ReceiptQueryInterval time.Duration
// NumConfirmations specifies how many blocks are need to consider a
// transaction confirmed.
NumConfirmations uint64
// SafeAbortNonceTooLowCount specifies how many ErrNonceTooLow observations
// are required to give up on a tx at a particular nonce without receiving
// confirmation.
SafeAbortNonceTooLowCount uint64
// Signer is used to sign transactions when the gas price is increased.
Signer SignerFn
From common.Address
}
Config houses parameters for altering the behavior of a SimpleTxManager.
type DefaultFlagValues ¶
type ETHBackend ¶ added in v0.1.0
type ETHBackend interface {
// BlockNumber returns the most recent block number.
BlockNumber(ctx context.Context) (uint64, error)
// CallContract executes an eth_call against the provided contract.
CallContract(ctx context.Context, msg ethereum.CallMsg, blockNumber *big.Int) ([]byte, error)
// TransactionReceipt queries the backend for a receipt associated with
// txHash. If lookup does not fail, but the transaction is not found,
// nil should be returned for both values.
TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
// SendTransaction submits a signed transaction to L1.
SendTransaction(ctx context.Context, tx *types.Transaction) error
// These functions are used to estimate what the base fee & priority fee should be set to.
// TODO(CLI-3318): Maybe need a generic interface to support different RPC providers
HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
SuggestGasTipCap(ctx context.Context) (*big.Int, error)
// NonceAt returns the account nonce of the given account.
// The block number can be nil, in which case the nonce is taken from the latest known block.
NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error)
// PendingNonceAt returns the pending nonce.
PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
// EstimateGas returns an estimate of the amount of gas needed to execute the given
// transaction against the current pending block.
EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error)
// Close the underlying eth connection
Close()
}
ETHBackend is the set of methods that the transaction manager uses to resubmit gas & determine when transactions are included on L1.
type FailedPermanentlyError ¶ added in v0.1.0
type FailedPermanentlyError struct {
LastErr error
// contains filtered or unexported fields
}
FailedPermanentlyError is an error raised by Do when the underlying Operation has been retried maxAttempts times.
func (*FailedPermanentlyError) Error ¶ added in v0.1.0
func (e *FailedPermanentlyError) Error() string
func (*FailedPermanentlyError) Unwrap ¶ added in v0.1.0
func (e *FailedPermanentlyError) Unwrap() error
type FixedStrategy ¶ added in v0.1.0
type SendState ¶
type SendState struct {
// contains filtered or unexported fields
}
SendState tracks information about the publication state of a given txn. In this context, a txn may correspond to multiple different txn hashes due to varying gas prices, though we treat them all as the same logical txn. This struct is primarily used to determine whether the txmgr should abort a given txn.
func NewSendState ¶
NewSendState creates a new doSend state.
func NewSendStateWithNow ¶
func NewSendStateWithNow(nonceTooLowCount uint64, timeout time.Duration, now func() time.Time) *SendState
NewSendStateWithNow creates a new doSend state with the provided clock.
func (*SendState) IsWaitingForConfirmation ¶
IsWaitingForConfirmation returns true if we have at least one confirmation on one of our txs.
func (*SendState) ProcessSendError ¶
ProcessSendError should be invoked with the error returned for each publication. It is safe to call this method with nil or arbitrary errors.
func (*SendState) ShouldAbortImmediately ¶
ShouldAbortImmediately returns true if the txmgr should give up on trying a given txn with the target nonce. This occurs when the set of errors recorded indicates that no further progress can be made on this transaction.
func (*SendState) TxMined ¶
TxMined records that the txn with txnHash has been mined and is await confirmation. It is safe to call this function multiple times.
func (*SendState) TxNotMined ¶
TxNotMined records that the txn with txnHash has not been mined or has been reorg'd out. It is safe to call this function multiple times.
type SignerFactory ¶
SignerFactory creates a SignerFn that is bound to a specific chainID.
type SignerFn ¶
type SignerFn func(context.Context, common.Address, *types.Transaction) (*types.Transaction, error)
SignerFn is a generic transaction signing function. It may be a remote signer so it takes a context. It also takes the address that should be used to sign the transaction with.
type SimpleTxManager ¶ added in v0.1.0
type SimpleTxManager struct {
// contains filtered or unexported fields
}
SimpleTxManager is a implementation of TxManager that performs linear fee bumping of a tx until it confirms.
func NewSimpleTxManagerFromConfig ¶ added in v0.1.0
func NewSimpleTxManagerFromConfig(chainName string, conf Config) (*SimpleTxManager, error)
NewSimpleTxManagerFromConfig initializes a new SimpleTxManager with the passed Config.
func (*SimpleTxManager) BlockNumber ¶ added in v0.1.0
func (m *SimpleTxManager) BlockNumber(ctx context.Context) (uint64, error)
func (*SimpleTxManager) Close ¶ added in v0.1.0
func (m *SimpleTxManager) Close()
Close closes the underlying connection, and sets the closed flag. once closed, the tx manager will refuse to doSend any new transactions, and may abandon pending ones.
func (*SimpleTxManager) From ¶ added in v0.1.0
func (m *SimpleTxManager) From() common.Address
func (*SimpleTxManager) Send ¶ added in v0.1.0
func (m *SimpleTxManager) Send(ctx context.Context, candidate TxCandidate) (*types.Transaction, *types.Receipt, error)
Send is used to publish a transaction with incrementally higher gas prices until the transaction eventually confirms. This method blocks until an invocation of sendTx returns (called with differing gas prices). The method may be canceled using the passed context.
The transaction manager handles all signing. If and only if the gas limit is 0, the transaction manager will do a gas estimation.
NOTE: Send can be called concurrently, the nonce will be managed internally.
type Strategy ¶ added in v0.1.0
type Strategy interface {
// Duration returns how long to wait for a given retry attempt.
Duration(attempt int) time.Duration
}
Strategy is used to calculate how long a particular Operation should wait between attempts.
type TxCandidate ¶
type TxCandidate struct {
// TxData is the transaction calldata to be used in the constructed tx.
TxData []byte
// To is the recipient of the constructed tx. Nil means contract creation.
To *common.Address
// GasLimit is the gas limit to be used in the constructed tx.
GasLimit uint64
// Value is the value to be used in the constructed tx.
Value *big.Int
}
TxCandidate is a transaction candidate that can be submitted to ask the TxManager to construct a transaction with gas price bounds.
type TxManager ¶
type TxManager interface {
// Send is used to create & doSend a transaction. It will handle increasing
// the gas price & ensuring that the transaction remains in the transaction pool.
// It can be stopped by canceling the provided context; however, the transaction
// may be included on L1 even if the context is canceled.
//
// NOTE: Send can be called concurrently, the nonce will be managed internally.
Send(ctx context.Context, candidate TxCandidate) (*types.Transaction, *types.Receipt, error)
// From returns the sending address associated with the instance of the transaction manager.
// It is static for a single instance of a TxManager.
From() common.Address
// BlockNumber returns the most recent block number from the underlying network.
BlockNumber(ctx context.Context) (uint64, error)
// Close the underlying connection
Close()
}
TxManager is an interface that allows callers to reliably publish txs, bumping the gas price if needed, and obtain the receipt of the resulting tx.
Source Files