Trait EthTransactions 

pub trait EthTransactions: LoadTransaction
where
    Self::Provider: BlockReaderIdExt,
{
    // Required methods
    fn signers(
        &self,
    ) -> &RwLock<RawRwLock, Vec<Box<dyn EthSigner<<Self::Provider as TransactionsProvider>::Transaction, <Self::NetworkTypes as RpcTypes>::TransactionRequest>>>>;
    fn send_raw_transaction(
        &self,
        tx: Bytes,
    ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send;

    // Provided methods
    fn send_raw_transaction_sync(
        &self,
        tx: Bytes,
    ) -> impl Future<Output = Result<<Self::NetworkTypes as RpcTypes>::Receipt, Self::Error>> + Send
       where Self: LoadReceipt + 'static { ... }
    fn transaction_by_hash(
        &self,
        hash: FixedBytes<32>,
    ) -> impl Future<Output = Result<Option<TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>>, Self::Error>> + Send { ... }
    fn transactions_by_block(
        &self,
        block: FixedBytes<32>,
    ) -> impl Future<Output = Result<Option<Vec<<Self::Provider as TransactionsProvider>::Transaction>>, Self::Error>> + Send { ... }
    fn raw_transaction_by_hash(
        &self,
        hash: FixedBytes<32>,
    ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + Send { ... }
    fn historical_transaction_by_hash_at(
        &self,
        hash: FixedBytes<32>,
    ) -> impl Future<Output = Result<Option<(TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>, FixedBytes<32>)>, Self::Error>> + Send { ... }
    fn transaction_receipt(
        &self,
        hash: FixedBytes<32>,
    ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::Receipt>, Self::Error>> + Send
       where Self: LoadReceipt + 'static { ... }
    fn load_transaction_and_receipt(
        &self,
        hash: FixedBytes<32>,
    ) -> impl Future<Output = Result<Option<(<Self::Provider as TransactionsProvider>::Transaction, TransactionMeta, <Self::Provider as ReceiptProvider>::Receipt)>, Self::Error>> + Send
       where Self: 'static { ... }
    fn transaction_by_block_and_tx_index(
        &self,
        block_id: BlockId,
        index: usize,
    ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::TransactionResponse>, Self::Error>> + Send
       where Self: LoadBlock { ... }
    fn get_transaction_by_sender_and_nonce(
        &self,
        sender: Address,
        nonce: u64,
        include_pending: bool,
    ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::TransactionResponse>, Self::Error>> + Send
       where Self: LoadBlock + LoadState { ... }
    fn raw_transaction_by_block_and_tx_index(
        &self,
        block_id: BlockId,
        index: usize,
    ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + Send
       where Self: LoadBlock { ... }
    fn send_transaction(
        &self,
        request: <Self::NetworkTypes as RpcTypes>::TransactionRequest,
    ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send
       where Self: EthApiSpec + LoadBlock + EstimateCall { ... }
    fn sign_request(
        &self,
        from: &Address,
        txn: <Self::NetworkTypes as RpcTypes>::TransactionRequest,
    ) -> impl Future<Output = Result<<Self::Provider as TransactionsProvider>::Transaction, Self::Error>> + Send { ... }
    fn sign(
        &self,
        account: Address,
        message: Bytes,
    ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send { ... }
    fn sign_transaction(
        &self,
        request: <Self::NetworkTypes as RpcTypes>::TransactionRequest,
    ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send { ... }
    fn sign_typed_data(
        &self,
        data: &TypedData,
        account: Address,
    ) -> Result<Bytes, Self::Error> { ... }
    fn find_signer(
        &self,
        account: &Address,
    ) -> Result<Box<dyn EthSigner<<Self::Provider as TransactionsProvider>::Transaction, <Self::NetworkTypes as RpcTypes>::TransactionRequest>>, Self::Error> { ... }
}

Transaction related functions for the EthApiServer trait in the eth_ namespace.

This includes utilities for transaction tracing, transacting and inspection.

Async functions that are spawned onto the BlockingTaskPool begin with spawn_

Calls

There are subtle differences between when transacting RpcTxReq:

The endpoints eth_call and eth_estimateGas and eth_createAccessList should always disable the base fee check in the CfgEnv.

The behaviour for tracing endpoints is not consistent across clients. Geth also disables the basefee check for tracing: https://github.com/ethereum/go-ethereum/blob/bc0b87ca196f92e5af49bd33cc190ef0ec32b197/eth/tracers/api.go#L955-L955 Erigon does not: https://github.com/ledgerwatch/erigon/blob/aefb97b07d1c4fd32a66097a24eddd8f6ccacae0/turbo/transactions/tracing.go#L209-L209

See also https://github.com/paradigmxyz/reth/issues/6240

This implementation follows the behaviour of Geth and disables the basefee check for tracing.

Required Methods

fn signers( &self, ) -> &RwLock<RawRwLock, Vec<Box<dyn EthSigner<<Self::Provider as TransactionsProvider>::Transaction, <Self::NetworkTypes as RpcTypes>::TransactionRequest>>>>

Returns a handle for signing data.

Signer access in default (L1) trait method implementations.

fn send_raw_transaction( &self, tx: Bytes, ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send

Decodes and recovers the transaction and submits it to the pool.

Returns the hash of the transaction.

Provided Methods

fn send_raw_transaction_sync( &self, tx: Bytes, ) -> impl Future<Output = Result<<Self::NetworkTypes as RpcTypes>::Receipt, Self::Error>> + Send

where Self: LoadReceipt + 'static,

Decodes and recovers the transaction and submits it to the pool.

And awaits the receipt.

fn transaction_by_hash( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>>, Self::Error>> + Send

Returns the transaction by hash.

Checks the pool and state.

Returns Ok(None) if no matching transaction was found.

fn transactions_by_block( &self, block: FixedBytes<32>, ) -> impl Future<Output = Result<Option<Vec<<Self::Provider as TransactionsProvider>::Transaction>>, Self::Error>> + Send

Get all transactions in the block with the given hash.

Returns None if block does not exist.

fn raw_transaction_by_hash( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + Send

Returns the EIP-2718 encoded transaction by hash.

If this is a pooled EIP-4844 transaction, the blob sidecar is included.

Checks the pool and state.

Returns Ok(None) if no matching transaction was found.

fn historical_transaction_by_hash_at( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<(TransactionSource<<Self::Provider as TransactionsProvider>::Transaction>, FixedBytes<32>)>, Self::Error>> + Send

Returns the historical transaction and the block it was mined in

fn transaction_receipt( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::Receipt>, Self::Error>> + Send

where Self: LoadReceipt + 'static,

Returns the transaction receipt for the given hash.

Returns None if the transaction does not exist or is pending Note: The tx receipt is not available for pending transactions.

fn load_transaction_and_receipt( &self, hash: FixedBytes<32>, ) -> impl Future<Output = Result<Option<(<Self::Provider as TransactionsProvider>::Transaction, TransactionMeta, <Self::Provider as ReceiptProvider>::Receipt)>, Self::Error>> + Send

where Self: 'static,

Helper method that loads a transaction and its receipt.

fn transaction_by_block_and_tx_index( &self, block_id: BlockId, index: usize, ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::TransactionResponse>, Self::Error>> + Send

where Self: LoadBlock,

Get transaction by BlockId and index of transaction within that block.

Returns Ok(None) if the block does not exist, or index is out of range.

fn get_transaction_by_sender_and_nonce( &self, sender: Address, nonce: u64, include_pending: bool, ) -> impl Future<Output = Result<Option<<Self::NetworkTypes as RpcTypes>::TransactionResponse>, Self::Error>> + Send

where Self: LoadBlock + LoadState,

Find a transaction by sender’s address and nonce.

fn raw_transaction_by_block_and_tx_index( &self, block_id: BlockId, index: usize, ) -> impl Future<Output = Result<Option<Bytes>, Self::Error>> + Send

where Self: LoadBlock,

Get transaction, as raw bytes, by BlockId and index of transaction within that block.

Returns Ok(None) if the block does not exist, or index is out of range.

fn send_transaction( &self, request: <Self::NetworkTypes as RpcTypes>::TransactionRequest, ) -> impl Future<Output = Result<FixedBytes<32>, Self::Error>> + Send

where Self: EthApiSpec + LoadBlock + EstimateCall,

Signs transaction with a matching signer, if any and submits the transaction to the pool. Returns the hash of the signed transaction.

fn sign_request( &self, from: &Address, txn: <Self::NetworkTypes as RpcTypes>::TransactionRequest, ) -> impl Future<Output = Result<<Self::Provider as TransactionsProvider>::Transaction, Self::Error>> + Send

Signs a transaction, with configured signers.

fn sign( &self, account: Address, message: Bytes, ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send

Signs given message. Returns the signature.

fn sign_transaction( &self, request: <Self::NetworkTypes as RpcTypes>::TransactionRequest, ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send

Signs a transaction request using the given account in request Returns the EIP-2718 encoded signed transaction.

fn sign_typed_data( &self, data: &TypedData, account: Address, ) -> Result<Bytes, Self::Error>

Encodes and signs the typed data according EIP-712. Payload must implement Eip712 trait.

fn find_signer( &self, account: &Address, ) -> Result<Box<dyn EthSigner<<Self::Provider as TransactionsProvider>::Transaction, <Self::NetworkTypes as RpcTypes>::TransactionRequest>>, Self::Error>

Returns the signer for the given account, if found in configured signers.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<N, Rpc> EthTransactions for EthApi<N, Rpc>

where N: RpcNodeCore, EthApiError: FromEvmError<<N as RpcNodeCore>::Evm>, Rpc: RpcConvert<Primitives = <N as RpcNodeCore>::Primitives, Error = EthApiError>,