Trait EthApiClient

pub trait EthApiClient<T, B, R>: ClientT
where
    T: RpcObject + Send + Sync + 'static + DeserializeOwned,
    B: RpcObject + Send + Sync + 'static + DeserializeOwned,
    R: RpcObject + Send + Sync + 'static + DeserializeOwned,
{
    // Provided methods
    fn protocol_version<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Uint<64, 1>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn syncing<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<SyncStatus, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn author<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Address, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn accounts<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Address>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn block_number<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn chain_id<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<64, 1>>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn block_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
        full: bool,
    ) -> Pin<Box<dyn Future<Output = Result<Option<B>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn block_by_number<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
        full: bool,
    ) -> Pin<Box<dyn Future<Output = Result<Option<B>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn block_transaction_count_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<256, 4>>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn block_transaction_count_by_number<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<256, 4>>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn block_uncles_count_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<256, 4>>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn block_uncles_count_by_number<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<256, 4>>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn block_receipts<'life0, 'async_trait>(
        &'life0 self,
        block_id: BlockId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<R>>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn uncle_by_block_hash_and_index<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = Result<Option<B>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn uncle_by_block_number_and_index<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = Result<Option<B>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn raw_transaction_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Bytes>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn transaction_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn raw_transaction_by_block_hash_and_index<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Bytes>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn transaction_by_block_hash_and_index<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn raw_transaction_by_block_number_and_index<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Bytes>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn transaction_by_block_number_and_index<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn transaction_by_sender_and_nonce<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        nonce: Uint<64, 1>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn transaction_receipt<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<R>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn balance<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn storage_at<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        index: JsonStorageKey,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = Result<FixedBytes<32>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn transaction_count<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn get_code<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn header_by_number<'life0, 'async_trait>(
        &'life0 self,
        hash: BlockNumberOrTag,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Header>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn header_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: FixedBytes<32>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Header>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn simulate_v1<'life0, 'async_trait>(
        &'life0 self,
        opts: SimulatePayload,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<SimulatedBlock<B>>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn call<'life0, 'async_trait>(
        &'life0 self,
        request: TransactionRequest,
        block_number: Option<BlockId>,
        state_overrides: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>,
        block_overrides: Option<Box<BlockOverrides>>,
    ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn call_many<'life0, 'async_trait>(
        &'life0 self,
        bundle: Bundle,
        state_context: Option<StateContext>,
        state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<EthCallResponse>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn create_access_list<'life0, 'async_trait>(
        &'life0 self,
        request: TransactionRequest,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = Result<AccessListResult, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn estimate_gas<'life0, 'async_trait>(
        &'life0 self,
        request: TransactionRequest,
        block_number: Option<BlockId>,
        state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>,
    ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn gas_price<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn get_account<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        block: BlockId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Account>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn max_priority_fee_per_gas<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn blob_base_fee<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn fee_history<'life0, 'async_trait>(
        &'life0 self,
        block_count: Uint<64, 1>,
        newest_block: BlockNumberOrTag,
        reward_percentiles: Option<Vec<f64>>,
    ) -> Pin<Box<dyn Future<Output = Result<FeeHistory, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn is_mining<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn hashrate<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn get_work<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Work, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn submit_hashrate<'life0, 'async_trait>(
        &'life0 self,
        hashrate: Uint<256, 4>,
        id: FixedBytes<32>,
    ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn submit_work<'life0, 'async_trait>(
        &'life0 self,
        nonce: FixedBytes<8>,
        pow_hash: FixedBytes<32>,
        mix_digest: FixedBytes<32>,
    ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn send_transaction<'life0, 'async_trait>(
        &'life0 self,
        request: TransactionRequest,
    ) -> Pin<Box<dyn Future<Output = Result<FixedBytes<32>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn send_raw_transaction<'life0, 'async_trait>(
        &'life0 self,
        bytes: Bytes,
    ) -> Pin<Box<dyn Future<Output = Result<FixedBytes<32>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn sign<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        message: Bytes,
    ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn sign_transaction<'life0, 'async_trait>(
        &'life0 self,
        transaction: TransactionRequest,
    ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn sign_typed_data<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        data: TypedData,
    ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn get_proof<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        keys: Vec<JsonStorageKey>,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = Result<EIP1186AccountProofResponse, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
}

Available on crate feature client only.

Client implementation for the EthApi RPC API.

Provided Methods

fn protocol_version<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Uint<64, 1>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the protocol version encoded as a string.

fn syncing<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<SyncStatus, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns an object with data about the sync status or false.

fn author<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Address, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the client coinbase address.

fn accounts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Address>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns a list of addresses owned by client.

fn block_number<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the number of most recent block.

fn chain_id<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<64, 1>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the chain ID of the current network.

fn block_by_hash<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, full: bool, ) -> Pin<Box<dyn Future<Output = Result<Option<B>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns information about a block by hash.

fn block_by_number<'life0, 'async_trait>( &'life0 self, number: BlockNumberOrTag, full: bool, ) -> Pin<Box<dyn Future<Output = Result<Option<B>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns information about a block by number.

fn block_transaction_count_by_hash<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<256, 4>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the number of transactions in a block from a block matching the given block hash.

fn block_transaction_count_by_number<'life0, 'async_trait>( &'life0 self, number: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<256, 4>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the number of transactions in a block matching the given block number.

fn block_uncles_count_by_hash<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<256, 4>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the number of uncles in a block from a block matching the given block hash.

fn block_uncles_count_by_number<'life0, 'async_trait>( &'life0 self, number: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = Result<Option<Uint<256, 4>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the number of uncles in a block with given block number.

fn block_receipts<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<R>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns all transaction receipts for a given block.

fn uncle_by_block_hash_and_index<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, index: Index, ) -> Pin<Box<dyn Future<Output = Result<Option<B>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns an uncle block of the given block and index.

fn uncle_by_block_number_and_index<'life0, 'async_trait>( &'life0 self, number: BlockNumberOrTag, index: Index, ) -> Pin<Box<dyn Future<Output = Result<Option<B>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns an uncle block of the given block and index.

fn raw_transaction_by_hash<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<Option<Bytes>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the EIP-2718 encoded transaction if it exists.

If this is a EIP-4844 transaction that is in the pool it will include the sidecar.

fn transaction_by_hash<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the information about a transaction requested by transaction hash.

fn raw_transaction_by_block_hash_and_index<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, index: Index, ) -> Pin<Box<dyn Future<Output = Result<Option<Bytes>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns information about a raw transaction by block hash and transaction index position.

fn transaction_by_block_hash_and_index<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, index: Index, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns information about a transaction by block hash and transaction index position.

fn raw_transaction_by_block_number_and_index<'life0, 'async_trait>( &'life0 self, number: BlockNumberOrTag, index: Index, ) -> Pin<Box<dyn Future<Output = Result<Option<Bytes>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns information about a raw transaction by block number and transaction index position.

fn transaction_by_block_number_and_index<'life0, 'async_trait>( &'life0 self, number: BlockNumberOrTag, index: Index, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns information about a transaction by block number and transaction index position.

fn transaction_by_sender_and_nonce<'life0, 'async_trait>( &'life0 self, address: Address, nonce: Uint<64, 1>, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns information about a transaction by sender and nonce.

fn transaction_receipt<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<Option<R>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the receipt of a transaction by transaction hash.

fn balance<'life0, 'async_trait>( &'life0 self, address: Address, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the balance of the account of given address.

fn storage_at<'life0, 'async_trait>( &'life0 self, address: Address, index: JsonStorageKey, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = Result<FixedBytes<32>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the value from a storage position at a given address

fn transaction_count<'life0, 'async_trait>( &'life0 self, address: Address, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the number of transactions sent from an address at given block number.

fn get_code<'life0, 'async_trait>( &'life0 self, address: Address, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns code at a given address at given block number.

fn header_by_number<'life0, 'async_trait>( &'life0 self, hash: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = Result<Option<Header>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the block’s header at given number.

fn header_by_hash<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<Option<Header>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the block’s header at given hash.

fn simulate_v1<'life0, 'async_trait>( &'life0 self, opts: SimulatePayload, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = Result<Vec<SimulatedBlock<B>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

eth_simulateV1 executes an arbitrary number of transactions on top of the requested state. The transactions are packed into individual blocks. Overrides can be provided.

fn call<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, block_number: Option<BlockId>, state_overrides: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, block_overrides: Option<Box<BlockOverrides>>, ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Executes a new message call immediately without creating a transaction on the block chain.

fn call_many<'life0, 'async_trait>( &'life0 self, bundle: Bundle, state_context: Option<StateContext>, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<EthCallResponse>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Simulate arbitrary number of transactions at an arbitrary blockchain index, with the optionality of state overrides

fn create_access_list<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = Result<AccessListResult, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Generates an access list for a transaction.

This method creates an EIP2930 type accessList based on a given Transaction.

An access list contains all storage slots and addresses touched by the transaction, except for the sender account and the chain’s precompiles.

It returns list of addresses and storage keys used by the transaction, plus the gas consumed when the access list is added. That is, it gives you the list of addresses and storage keys that will be used by that transaction, plus the gas consumed if the access list is included. Like eth_estimateGas, this is an estimation; the list could change when the transaction is actually mined. Adding an accessList to your transaction does not necessary result in lower gas usage compared to a transaction without an access list.

fn estimate_gas<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, block_number: Option<BlockId>, state_override: Option<HashMap<Address, AccountOverride, FbBuildHasher<20>>>, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Generates and returns an estimate of how much gas is necessary to allow the transaction to complete.

fn gas_price<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the current price per gas in wei.

fn get_account<'life0, 'async_trait>( &'life0 self, address: Address, block: BlockId, ) -> Pin<Box<dyn Future<Output = Result<Option<Account>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the account details by specifying an address and a block number/tag

fn max_priority_fee_per_gas<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Introduced in EIP-1559, returns suggestion for the priority for dynamic fee transactions.

fn blob_base_fee<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Introduced in EIP-4844, returns the current blob base fee in wei.

fn fee_history<'life0, 'async_trait>( &'life0 self, block_count: Uint<64, 1>, newest_block: BlockNumberOrTag, reward_percentiles: Option<Vec<f64>>, ) -> Pin<Box<dyn Future<Output = Result<FeeHistory, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the Transaction fee history

Introduced in EIP-1559 for getting information on the appropriate priority fee to use.

Returns transaction base fee per gas and effective priority fee per gas for the requested/supported block range. The returned Fee history for the returned block range can be a subsection of the requested range if not all blocks are available.

fn is_mining<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns whether the client is actively mining new blocks.

fn hashrate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the number of hashes per second that the node is mining with.

fn get_work<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Work, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the hash of the current block, the seedHash, and the boundary condition to be met (“target”)

fn submit_hashrate<'life0, 'async_trait>( &'life0 self, hashrate: Uint<256, 4>, id: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Used for submitting mining hashrate.

Can be used for remote miners to submit their hash rate. It accepts the miner hash rate and an identifier which must be unique between nodes. Returns true if the block was successfully submitted, false otherwise.

fn submit_work<'life0, 'async_trait>( &'life0 self, nonce: FixedBytes<8>, pow_hash: FixedBytes<32>, mix_digest: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Used for submitting a proof-of-work solution.

fn send_transaction<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, ) -> Pin<Box<dyn Future<Output = Result<FixedBytes<32>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Sends transaction; will block waiting for signer to return the transaction hash.

fn send_raw_transaction<'life0, 'async_trait>( &'life0 self, bytes: Bytes, ) -> Pin<Box<dyn Future<Output = Result<FixedBytes<32>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Sends signed transaction, returning its hash.

fn sign<'life0, 'async_trait>( &'life0 self, address: Address, message: Bytes, ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns an Ethereum specific signature with: sign(keccak256(“\x19Ethereum Signed Message:\n”

• len(message) + message))).

fn sign_transaction<'life0, 'async_trait>( &'life0 self, transaction: TransactionRequest, ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Signs a transaction that can be submitted to the network at a later time using with sendRawTransaction.

fn sign_typed_data<'life0, 'async_trait>( &'life0 self, address: Address, data: TypedData, ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Signs data via EIP-712.

fn get_proof<'life0, 'async_trait>( &'life0 self, address: Address, keys: Vec<JsonStorageKey>, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = Result<EIP1186AccountProofResponse, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns the account and storage values of the specified account including the Merkle-proof. This call can be used to verify that the data you are pulling from is not tampered with.

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<TypeJsonRpseeInteral, T, B, R> EthApiClient<T, B, R> for TypeJsonRpseeInteral

where T: RpcObject + Send + Sync + 'static + DeserializeOwned, B: RpcObject + Send + Sync + 'static + DeserializeOwned, R: RpcObject + Send + Sync + 'static + DeserializeOwned, TypeJsonRpseeInteral: ClientT,