Struct ClientFork

pub struct ClientFork {
    pub storage: Arc<RwLock<ForkedStorage>>,
    pub config: Arc<RwLock<ClientForkConfig>>,
    pub database: Arc<RwLock<Box<dyn Db>>>,
}

Represents a fork of a remote client

This type contains a subset of the EthApi functions but will exclusively fetch the requested data from the remote client, if it wasn’t already fetched.

Fields

storage: Arc<RwLock<ForkedStorage>>

Contains the cached data

config: Arc<RwLock<ClientForkConfig>>

contains the info how the fork is configured

database: Arc<RwLock<Box<dyn Db>>>

This also holds a handle to the underlying database

Implementations

impl ClientFork

pub fn new( config: ClientForkConfig, database: Arc<AsyncRwLock<Box<dyn Db>>>, ) -> Self

Creates a new instance of the fork

pub async fn reset( &self, url: Option<String>, block_number: impl Into<BlockId>, ) -> Result<(), BlockchainError>

Reset the fork to a fresh forked state, and optionally update the fork config

pub fn clear_cached_storage(&self)

Removes all data cached from previous responses

pub fn predates_fork(&self, block: u64) -> bool

Returns true whether the block predates the fork

pub fn predates_fork_inclusive(&self, block: u64) -> bool

Returns true whether the block predates the fork or is the same block as the fork

pub fn timestamp(&self) -> u64

pub fn block_number(&self) -> u64

pub fn transaction_hash(&self) -> Option<B256>

Returns the transaction hash we forked off of, if any.

pub fn total_difficulty(&self) -> U256

pub fn base_fee(&self) -> Option<u128>

pub fn block_hash(&self) -> B256

pub fn eth_rpc_url(&self) -> String

pub fn chain_id(&self) -> u64

fn provider(&self) -> Arc<RetryProvider>

fn storage_read(&self) -> RwLockReadGuard<'_, RawRwLock, ForkedStorage>

fn storage_write(&self) -> RwLockWriteGuard<'_, RawRwLock, ForkedStorage>

pub async fn fee_history( &self, block_count: u64, newest_block: BlockNumber, reward_percentiles: &[f64], ) -> Result<FeeHistory, TransportError>

Returns the fee history eth_feeHistory

pub async fn get_proof( &self, address: Address, keys: Vec<B256>, block_number: Option<BlockId>, ) -> Result<EIP1186AccountProofResponse, TransportError>

Sends eth_getProof

pub async fn call( &self, request: &WithOtherFields<TransactionRequest>, block: Option<BlockNumber>, ) -> Result<Bytes, TransportError>

Sends eth_call

pub async fn simulate_v1( &self, request: &SimulatePayload, block: Option<BlockNumber>, ) -> Result<Vec<SimulatedBlock<AnyRpcBlock>>, TransportError>

Sends eth_simulateV1

pub async fn estimate_gas( &self, request: &WithOtherFields<TransactionRequest>, block: Option<BlockNumber>, ) -> Result<u128, TransportError>

Sends eth_estimateGas

pub async fn create_access_list( &self, request: &WithOtherFields<TransactionRequest>, block: Option<BlockNumber>, ) -> Result<AccessListResult, TransportError>

Sends eth_createAccessList

pub async fn storage_at( &self, address: Address, index: U256, number: Option<BlockNumber>, ) -> Result<StorageValue, TransportError>

pub async fn logs(&self, filter: &Filter) -> Result<Vec<Log>, TransportError>

pub async fn get_code( &self, address: Address, blocknumber: u64, ) -> Result<Bytes, TransportError>

pub async fn get_balance( &self, address: Address, blocknumber: u64, ) -> Result<U256, TransportError>

pub async fn get_nonce( &self, address: Address, block: u64, ) -> Result<u64, TransportError>

pub async fn get_account( &self, address: Address, blocknumber: u64, ) -> Result<Account, TransportError>

pub async fn transaction_by_block_number_and_index( &self, number: u64, index: usize, ) -> Result<Option<AnyRpcTransaction>, TransportError>

pub async fn transaction_by_block_hash_and_index( &self, hash: B256, index: usize, ) -> Result<Option<AnyRpcTransaction>, TransportError>

pub async fn transaction_by_hash( &self, hash: B256, ) -> Result<Option<AnyRpcTransaction>, TransportError>

pub async fn trace_transaction( &self, hash: B256, ) -> Result<Vec<Trace>, TransportError>

pub async fn debug_trace_transaction( &self, hash: B256, opts: GethDebugTracingOptions, ) -> Result<GethTrace, TransportError>

pub async fn trace_block( &self, number: u64, ) -> Result<Vec<Trace>, TransportError>

pub async fn transaction_receipt( &self, hash: B256, ) -> Result<Option<ReceiptResponse>, BlockchainError>

pub async fn block_receipts( &self, number: u64, ) -> Result<Option<Vec<ReceiptResponse>>, BlockchainError>

pub async fn block_by_hash( &self, hash: B256, ) -> Result<Option<AnyRpcBlock>, TransportError>

pub async fn block_by_hash_full( &self, hash: B256, ) -> Result<Option<AnyRpcBlock>, TransportError>

pub async fn block_by_number( &self, block_number: u64, ) -> Result<Option<AnyRpcBlock>, TransportError>

pub async fn block_by_number_full( &self, block_number: u64, ) -> Result<Option<AnyRpcBlock>, TransportError>

async fn fetch_full_block( &self, block_id: impl Into<BlockId>, ) -> Result<Option<AnyRpcBlock>, TransportError>

pub async fn uncle_by_block_hash_and_index( &self, hash: B256, index: usize, ) -> Result<Option<AnyRpcBlock>, TransportError>

pub async fn uncle_by_block_number_and_index( &self, number: u64, index: usize, ) -> Result<Option<AnyRpcBlock>, TransportError>

async fn uncles_by_block_and_index( &self, block: AnyRpcBlock, index: usize, ) -> Result<Option<AnyRpcBlock>, TransportError>

fn convert_to_full_block(&self, block: AnyRpcBlock) -> AnyRpcBlock

Converts a block of hashes into a full block

Trait Implementations

impl Clone for ClientFork

fn clone(&self) -> ClientFork

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ClientFork

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes