reth_rpc_eth_api::core

Trait EthApiServer

Source 
pub trait EthApiServer<T: RpcObject, B: RpcObject, R: RpcObject, H: RpcObject>:
    Sized
    + Send
    + Sync
    + 'static {

Show 51 methods    // Required methods
    fn protocol_version<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<U64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn syncing(&self) -> RpcResult<SyncStatus>;
    fn author<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Address>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn accounts(&self) -> RpcResult<Vec<Address>>;
    fn block_number(&self) -> RpcResult<U256>;
    fn chain_id<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn block_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
        full: bool,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<B>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn block_by_number<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
        full: bool,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<B>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn block_transaction_count_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U256>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn block_transaction_count_by_number<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U256>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn block_uncles_count_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U256>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn block_uncles_count_by_number<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U256>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn block_receipts<'life0, 'async_trait>(
        &'life0 self,
        block_id: BlockId,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<Vec<R>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn uncle_by_block_hash_and_index<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<B>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn uncle_by_block_number_and_index<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<B>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn raw_transaction_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<Bytes>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn transaction_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<T>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn raw_transaction_by_block_hash_and_index<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<Bytes>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn transaction_by_block_hash_and_index<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<T>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn raw_transaction_by_block_number_and_index<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<Bytes>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn transaction_by_block_number_and_index<'life0, 'async_trait>(
        &'life0 self,
        number: BlockNumberOrTag,
        index: Index,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<T>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn transaction_by_sender_and_nonce<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        nonce: U64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<T>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn transaction_receipt<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<R>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn balance<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn storage_at<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        index: JsonStorageKey,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<B256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn transaction_count<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_code<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn header_by_number<'life0, 'async_trait>(
        &'life0 self,
        hash: BlockNumberOrTag,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<H>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn header_by_hash<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<H>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn simulate_v1<'life0, 'async_trait>(
        &'life0 self,
        opts: SimulatePayload,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<SimulatedBlock<B>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn call<'life0, 'async_trait>(
        &'life0 self,
        request: TransactionRequest,
        block_number: Option<BlockId>,
        state_overrides: Option<StateOverride>,
        block_overrides: Option<Box<BlockOverrides>>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn call_many<'life0, 'async_trait>(
        &'life0 self,
        bundle: Bundle,
        state_context: Option<StateContext>,
        state_override: Option<StateOverride>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<EthCallResponse>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_access_list<'life0, 'async_trait>(
        &'life0 self,
        request: TransactionRequest,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<AccessListResult>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn estimate_gas<'life0, 'async_trait>(
        &'life0 self,
        request: TransactionRequest,
        block_number: Option<BlockId>,
        state_override: Option<StateOverride>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn gas_price<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_account<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        block: BlockId,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<Account>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn max_priority_fee_per_gas<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn blob_base_fee<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn fee_history<'life0, 'async_trait>(
        &'life0 self,
        block_count: U64,
        newest_block: BlockNumberOrTag,
        reward_percentiles: Option<Vec<f64>>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<FeeHistory>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn is_mining<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn hashrate<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_work<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Work>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn submit_hashrate<'life0, 'async_trait>(
        &'life0 self,
        hashrate: U256,
        id: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn submit_work<'life0, 'async_trait>(
        &'life0 self,
        nonce: B64,
        pow_hash: B256,
        mix_digest: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn send_transaction<'life0, 'async_trait>(
        &'life0 self,
        request: TransactionRequest,
    ) -> Pin<Box<dyn Future<Output = RpcResult<B256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn send_raw_transaction<'life0, 'async_trait>(
        &'life0 self,
        bytes: Bytes,
    ) -> Pin<Box<dyn Future<Output = RpcResult<B256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sign<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        message: Bytes,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sign_transaction<'life0, 'async_trait>(
        &'life0 self,
        transaction: TransactionRequest,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sign_typed_data<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        data: TypedData,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_proof<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
        keys: Vec<JsonStorageKey>,
        block_number: Option<BlockId>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<EIP1186AccountProofResponse>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided method
    fn into_rpc(self) -> RpcModule<Self>
       where T: Send + Sync + 'static + Clone + Serialize,
             B: Send + Sync + 'static + Clone + Serialize,
             R: Send + Sync + 'static + Clone + Serialize,
             H: Send + Sync + 'static + Clone + Serialize { ... }

}
Expand description

Server trait implementation for the EthApi RPC API.

Required Methods§

Source

fn protocol_version<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<U64>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the protocol version encoded as a string.

Source

fn syncing(&self) -> RpcResult<SyncStatus>

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

Source

fn author<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<Address>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the client coinbase address.

Source

fn accounts(&self) -> RpcResult<Vec<Address>>

Returns a list of addresses owned by client.

Source

fn block_number(&self) -> RpcResult<U256>

Returns the number of most recent block.

Source

fn chain_id<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U64>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the chain ID of the current network.

Source

fn block_by_hash<'life0, 'async_trait>( &'life0 self, hash: B256, full: bool, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<B>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns information about a block by hash.

Source

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

Returns information about a block by number.

Source

fn block_transaction_count_by_hash<'life0, 'async_trait>( &'life0 self, hash: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U256>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn block_transaction_count_by_number<'life0, 'async_trait>( &'life0 self, number: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U256>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn block_uncles_count_by_hash<'life0, 'async_trait>( &'life0 self, hash: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U256>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn block_uncles_count_by_number<'life0, 'async_trait>( &'life0 self, number: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<U256>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

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

Returns all transaction receipts for a given block.

Source

fn uncle_by_block_hash_and_index<'life0, 'async_trait>( &'life0 self, hash: B256, index: Index, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<B>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns an uncle block of the given block and index.

Source

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

Returns an uncle block of the given block and index.

Source

fn raw_transaction_by_hash<'life0, 'async_trait>( &'life0 self, hash: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<Bytes>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: '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.

Source

fn transaction_by_hash<'life0, 'async_trait>( &'life0 self, hash: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<T>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the information about a transaction requested by transaction hash.

Source

fn raw_transaction_by_block_hash_and_index<'life0, 'async_trait>( &'life0 self, hash: B256, index: Index, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<Bytes>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn transaction_by_block_hash_and_index<'life0, 'async_trait>( &'life0 self, hash: B256, index: Index, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<T>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

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

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

Source

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

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

Source

fn transaction_by_sender_and_nonce<'life0, 'async_trait>( &'life0 self, address: Address, nonce: U64, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<T>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns information about a transaction by sender and nonce.

Source

fn transaction_receipt<'life0, 'async_trait>( &'life0 self, hash: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<R>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the receipt of a transaction by transaction hash.

Source

fn balance<'life0, 'async_trait>( &'life0 self, address: Address, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the balance of the account of given address.

Source

fn storage_at<'life0, 'async_trait>( &'life0 self, address: Address, index: JsonStorageKey, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = RpcResult<B256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the value from a storage position at a given address

Source

fn transaction_count<'life0, 'async_trait>( &'life0 self, address: Address, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

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

Returns code at a given address at given block number.

Source

fn header_by_number<'life0, 'async_trait>( &'life0 self, hash: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<H>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the block’s header at given number.

Source

fn header_by_hash<'life0, 'async_trait>( &'life0 self, hash: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<H>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the block’s header at given hash.

Source

fn simulate_v1<'life0, 'async_trait>( &'life0 self, opts: SimulatePayload, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<SimulatedBlock<B>>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: '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.

Source

fn call<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, block_number: Option<BlockId>, state_overrides: Option<StateOverride>, block_overrides: Option<Box<BlockOverrides>>, ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn call_many<'life0, 'async_trait>( &'life0 self, bundle: Bundle, state_context: Option<StateContext>, state_override: Option<StateOverride>, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<EthCallResponse>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn create_access_list<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = RpcResult<AccessListResult>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: '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.

Source

fn estimate_gas<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, block_number: Option<BlockId>, state_override: Option<StateOverride>, ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn gas_price<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns the current price per gas in wei.

Source

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

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

Source

fn max_priority_fee_per_gas<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn blob_base_fee<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn fee_history<'life0, 'async_trait>( &'life0 self, block_count: U64, newest_block: BlockNumberOrTag, reward_percentiles: Option<Vec<f64>>, ) -> Pin<Box<dyn Future<Output = RpcResult<FeeHistory>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: '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.

Source

fn is_mining<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Returns whether the client is actively mining new blocks.

Source

fn hashrate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<U256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn get_work<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<Work>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn submit_hashrate<'life0, 'async_trait>( &'life0 self, hashrate: U256, id: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: '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.

Source

fn submit_work<'life0, 'async_trait>( &'life0 self, nonce: B64, pow_hash: B256, mix_digest: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Used for submitting a proof-of-work solution.

Source

fn send_transaction<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, ) -> Pin<Box<dyn Future<Output = RpcResult<B256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

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

Source

fn send_raw_transaction<'life0, 'async_trait>( &'life0 self, bytes: Bytes, ) -> Pin<Box<dyn Future<Output = RpcResult<B256>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Sends signed transaction, returning its hash.

Source

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

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

  • len(message) + message))).
Source

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

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

Source

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

Signs data via EIP-712.

Source

fn get_proof<'life0, 'async_trait>( &'life0 self, address: Address, keys: Vec<JsonStorageKey>, block_number: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = RpcResult<EIP1186AccountProofResponse>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: '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.

Provided Methods§

Source

fn into_rpc(self) -> RpcModule<Self>
where T: Send + Sync + 'static + Clone + Serialize, B: Send + Sync + 'static + Clone + Serialize, R: Send + Sync + 'static + Clone + Serialize, H: Send + Sync + 'static + Clone + Serialize,

Collects all the methods and subscriptions defined in the trait and adds them into a single RpcModule.

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§

Source§

impl<T> EthApiServer<<<T as EthApiTypes>::NetworkTypes as Network>::TransactionResponse, Block<<<T as EthApiTypes>::NetworkTypes as Network>::TransactionResponse, <<T as EthApiTypes>::NetworkTypes as Network>::HeaderResponse>, <<T as EthApiTypes>::NetworkTypes as Network>::ReceiptResponse, <<T as EthApiTypes>::NetworkTypes as Network>::HeaderResponse> for T
where T: FullEthApi, ErrorObject<'static>: From<T::Error>,