transactions

Documentation

Index

• Variables
• type AddrLocker
  • func (l *AddrLocker) LockAddr(address types.Address)
  • func (l *AddrLocker) UnlockAddr(address types.Address)
• type ErrBadNonce
  • func (e *ErrBadNonce) Error() string
• type GasCalculator
• type PendingNonceProvider
• type SendTxArgs
  • func (args SendTxArgs) GetInput() types.HexBytes
  • func (args SendTxArgs) IsDynamicFeeTx() bool
  • func (args SendTxArgs) ToTransactOpts(signerFn bind.SignerFn) *bind.TransactOpts
  • func (args SendTxArgs) Valid() bool
• type Transactor
  • func NewTransactor() *Transactor
  • func (t *Transactor) HashTransaction(args SendTxArgs) (validatedArgs SendTxArgs, hash types.Hash, err error)
  • func (t *Transactor) SendTransaction(sendArgs SendTxArgs, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error)
  • func (t *Transactor) SendTransactionWithSignature(args SendTxArgs, sig []byte) (hash types.Hash, err error)
  • func (t *Transactor) SetNetworkID(networkID uint64)
  • func (t *Transactor) SetRPC(rpcClient *rpc.Client, timeout time.Duration)

Variables

var (
	// ErrInvalidSendTxArgs is returned when the structure of SendTxArgs is ambigious.
	ErrInvalidSendTxArgs = errors.New("transaction arguments are invalid")
	// ErrUnexpectedArgs is returned when args are of unexpected length.
	ErrUnexpectedArgs = errors.New("unexpected args")
	//ErrInvalidTxSender is returned when selected account is different than From field.
	ErrInvalidTxSender = errors.New("transaction can only be send by its creator")
	//ErrAccountDoesntExist is sent when provided sub-account is not stored in database.
	ErrAccountDoesntExist = errors.New("account doesn't exist")
)

var ErrInvalidSignatureSize = errors.New("signature size must be 65")

ErrInvalidSignatureSize is returned if a signature is not 65 bytes to avoid panic from go-ethereum

Types

type AddrLocker

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

AddrLocker provides locks for addresses

func (*AddrLocker) LockAddr

func (l *AddrLocker) LockAddr(address types.Address)

LockAddr locks an account's mutex. This is used to prevent another tx getting the same nonce until the lock is released. The mutex prevents the (an identical nonce) from being read again during the time that the first transaction is being signed.

func (*AddrLocker) UnlockAddr

func (l *AddrLocker) UnlockAddr(address types.Address)

UnlockAddr unlocks the mutex of the given account.

type ErrBadNonce

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

func (*ErrBadNonce) Error

func (e *ErrBadNonce) Error() string

type GasCalculator

type GasCalculator interface {
	ethereum.GasEstimator
	ethereum.GasPricer
}

GasCalculator provides methods for estimating and pricing gas.

type PendingNonceProvider

type PendingNonceProvider interface {
	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
}

PendingNonceProvider provides information about nonces.

type SendTxArgs

type SendTxArgs struct {
	From                 types.Address   `json:"from"`
	To                   *types.Address  `json:"to"`
	Gas                  *hexutil.Uint64 `json:"gas"`
	GasPrice             *hexutil.Big    `json:"gasPrice"`
	Value                *hexutil.Big    `json:"value"`
	Nonce                *hexutil.Uint64 `json:"nonce"`
	MaxFeePerGas         *hexutil.Big    `json:"maxFeePerGas"`
	MaxPriorityFeePerGas *hexutil.Big    `json:"maxPriorityFeePerGas"`
	// We keep both "input" and "data" for backward compatibility.
	// "input" is a preferred field.
	// see `vendor/github.com/ethereum/go-ethereum/internal/ethapi/api.go:1107`
	Input types.HexBytes `json:"input"`
	Data  types.HexBytes `json:"data"`
}

SendTxArgs represents the arguments to submit a new transaction into the transaction pool. This struct is based on go-ethereum's type in internal/ethapi/api.go, but we have freedom over the exact layout of this struct.

func (SendTxArgs) GetInput

func (args SendTxArgs) GetInput() types.HexBytes

GetInput returns either Input or Data field's value dependent on what is filled.

func (SendTxArgs) IsDynamicFeeTx

func (args SendTxArgs) IsDynamicFeeTx() bool

IsDynamicFeeTx checks whether dynamic fee parameters are set for the tx

func (SendTxArgs) ToTransactOpts

func (args SendTxArgs) ToTransactOpts(signerFn bind.SignerFn) *bind.TransactOpts

func (SendTxArgs) Valid

func (args SendTxArgs) Valid() bool

Valid checks whether this structure is filled in correctly.

type Transactor

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

Transactor validates, signs transactions. It uses upstream to propagate transactions to the Ethereum network.

func NewTransactor

func NewTransactor() *Transactor

NewTransactor returns a new Manager.

func (*Transactor) HashTransaction

func (t *Transactor) HashTransaction(args SendTxArgs) (validatedArgs SendTxArgs, hash types.Hash, err error)

func (*Transactor) SendTransaction

func (t *Transactor) SendTransaction(sendArgs SendTxArgs, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error)

SendTransaction is an implementation of eth_sendTransaction. It queues the tx to the sign queue.

func (*Transactor) SendTransactionWithSignature

func (t *Transactor) SendTransactionWithSignature(args SendTxArgs, sig []byte) (hash types.Hash, err error)

SendTransactionWithSignature receive a transaction and a signature, serialize them together and propage it to the network. It's different from eth_sendRawTransaction because it receives a signature and not a serialized transaction with signature. Since the transactions is already signed, we assume it was validated and used the right nonce.

func (*Transactor) SetNetworkID

func (t *Transactor) SetNetworkID(networkID uint64)

SetNetworkID selects a correct network.

func (*Transactor) SetRPC

func (t *Transactor) SetRPC(rpcClient *rpc.Client, timeout time.Duration)

SetRPC sets RPC params, a client and a timeout