Struct ApiServer 

pub struct ApiServer {

    eth_rpc_client: Client,
    req_receiver: Receiver<ApiRequest>,
    backend: BackendWithOverlay,
    logging_manager: LoggingManager,
    client: Arc<Client>,
    mining_engine: Arc<MiningEngine>,
    wallet: DevSigner,
    block_provider: SubxtBlockInfoProvider,
    revert_manager: RevertManager,
    impersonation_manager: ImpersonationManager,
    tx_pool: Arc<TransactionPoolHandle>,
    instance_id: B256,
    filters: Filters,
}

Fields

eth_rpc_client: Client

req_receiver: Receiver<ApiRequest>

backend: BackendWithOverlay

logging_manager: LoggingManager

client: Arc<Client>

mining_engine: Arc<MiningEngine>

wallet: DevSigner

block_provider: SubxtBlockInfoProvider

revert_manager: RevertManager

impersonation_manager: ImpersonationManager

tx_pool: Arc<TransactionPoolHandle>

instance_id: B256

filters: Filters

Tracks all active filters

Implementations

impl ApiServer

pub async fn new( substrate_service: Service, req_receiver: Receiver<ApiRequest>, logging_manager: LoggingManager, revert_manager: RevertManager, impersonation_manager: ImpersonationManager, signers: Vec<Keypair>, filters: Filters, revive_rpc_block_limit: Option<usize>, ) -> Result<Self>

pub async fn run(self)

pub async fn execute(&mut self, req: EthRequest) -> ResponseResult

fn set_logging(&self, enabled: bool) -> Result<()>

async fn mine(&self, blocks: Option<U256>, interval: Option<U256>) -> Result<()>

fn set_interval_mining(&self, interval: u64) -> Result<()>

fn get_interval_mining(&self) -> Result<Option<u64>>

fn get_auto_mine(&self) -> Result<bool>

fn set_auto_mine(&self, enabled: bool) -> Result<()>

async fn evm_mine( &self, mine: Option<AnvilCoreParams<Option<MineOptions>>>, ) -> Result<String>

async fn evm_mine_detailed( &self, mine: Option<AnvilCoreParams<Option<MineOptions>>>, ) -> Result<Vec<Block>>

fn set_block_timestamp_interval(&self, time: u64) -> Result<()>

fn remove_block_timestamp_interval(&self) -> Result<bool>

fn set_next_block_timestamp(&self, time: U256) -> Result<()>

fn increase_time(&self, time: U256) -> Result<i64>

fn set_time(&self, timestamp: U256) -> Result<u64>

fn impersonate_account(&mut self, addr: H160) -> Result<()>

fn auto_impersonate_account(&mut self, enable: bool) -> Result<()>

fn stop_impersonating_account(&mut self, addr: &H160) -> Result<()>

fn chain_id(&self, at: Hash) -> u64

fn eth_chain_id(&self) -> Result<U64>

fn network_id(&self) -> Result<u64>

fn net_listening(&self) -> Result<bool>

fn syncing(&self) -> Result<bool>

async fn transaction_receipt( &self, tx_hash: B256, ) -> Result<Option<ReceiptInfo>>

async fn get_balance( &self, addr: Address, block: Option<BlockId>, ) -> Result<U256>

async fn get_storage_at( &self, addr: Address, slot: U256, block: Option<BlockId>, ) -> Result<B256>

async fn get_code( &self, address: Address, block: Option<BlockId>, ) -> Result<Bytes>

async fn get_block_by_hash( &self, block_hash: B256, hydrated_transactions: bool, ) -> Result<Option<Block>>

Returns the EVM block with the given ethereum hash.

async fn estimate_gas( &self, request: WithOtherFields<TransactionRequest>, block: Option<BlockId>, ) -> Result<U256>

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

async fn gas_price(&self) -> Result<U256>

async fn get_transaction_count( &self, address: H160, block: Option<BlockId>, ) -> Result<U256>

async fn send_raw_transaction(&self, transaction: Bytes) -> Result<H256>

pub async fn send_raw_transaction_sync(&self, tx: Bytes) -> Result<ReceiptInfo>

async fn send_transaction( &self, transaction_req: WithOtherFields<TransactionRequest>, unsigned_tx: bool, ) -> Result<H256>

async fn send_transaction_sync( &self, request: WithOtherFields<TransactionRequest>, ) -> Result<ReceiptInfo>

async fn get_block_by_number( &self, block_number: BlockNumberOrTag, hydrated_transactions: bool, ) -> Result<Option<Block>>

pub(crate) async fn snapshot(&mut self) -> Result<U256>

pub(crate) async fn revert(&mut self, id: U256) -> Result<bool>

pub(crate) async fn reset(&mut self, forking: Option<Forking>) -> Result<()>

Reset to genesis if no forking information is set.

TODO: currently the forking information is not consider at the RPC level, but it will need to be considered once forking feature is functional.

pub(crate) async fn rollback(&mut self, depth: Option<u64>) -> Result<()>

async fn anvil_node_info(&self) -> Result<NodeInfo>

async fn anvil_metadata(&self) -> Result<AnvilMetadata>

async fn get_block_transaction_count_by_hash( &self, block_hash: B256, ) -> Result<Option<U256>>

async fn get_block_transaction_count_by_number( &self, block_number: BlockNumberOrTag, ) -> Result<Option<U256>>

async fn get_transaction_by_block_hash_and_index( &self, block_hash: B256, transaction_index: U256, ) -> Result<Option<TransactionInfo>>

async fn get_transaction_by_block_number_and_index( &self, block: BlockNumberOrTag, transaction_index: U256, ) -> Result<Option<TransactionInfo>>

async fn get_transaction_by_hash( &self, transaction_hash: B256, ) -> Result<Option<TransactionInfo>>

async fn fee_history( &self, block_count: U256, newest_block: BlockNumberOrTag, reward_percentiles: Option<Vec<f64>>, ) -> Result<FeeHistoryResult>

async fn max_priority_fee_per_gas(&self) -> Result<U256>

pub fn accounts(&self) -> Result<Vec<H160>>

async fn get_logs(&self, filter: Filter) -> Result<FilterResults>

fn set_chain_id(&self, chain_id: u64) -> Result<()>

fn set_balance(&self, address: Address, value: U256) -> Result<()>

fn set_nonce(&self, address: Address, value: U256) -> Result<()>

fn set_storage_at(&self, address: Address, key: U256, value: B256) -> Result<()>

fn set_code(&self, address: Address, bytes: Bytes) -> Result<()>

fn set_immutable_storage_at( &self, address: Address, immutables: Vec<Bytes>, ) -> Result<()>

async fn sign( &self, address: Address, content: impl AsRef<[u8]>, ) -> Result<String>

fn sign_typed_data(&self, _address: Address, _data: Value) -> Result<String>

fn sign_typed_data_v3(&self, _address: Address, _data: Value) -> Result<String>

async fn sign_transaction( &self, tx: WithOtherFields<TransactionRequest>, ) -> Result<TransactionSigned>

async fn sign_typed_data_v4( &self, address: Address, data: TypedData, ) -> Result<String>

async fn get_account( &self, address: Address, block_number: Option<BlockId>, ) -> Result<TrieAccount>

async fn get_account_info( &self, address: Address, block_number: Option<BlockId>, ) -> Result<AccountInfo>

async fn new_block_filter(&self) -> Result<String>

Creates a filter to notify about new blocks

async fn uninstall_filter(&self, id: &str) -> Result<bool>

Remove filter

async fn get_filter_changes(&self, id: &str) -> ResponseResult

Polls a filter and returns all events that happened since the last poll.

async fn new_pending_transactions_filter(&self) -> Result<String>

async fn new_filter(&self, filter: Filter) -> Result<String>

async fn get_filter_logs(&self, id: &str) -> Result<Vec<Log>>

async fn update_block_provider_on_revert( &self, info: &Info<OpaqueBlock>, ) -> Result<()>

async fn update_time_on_revert(&self, best_hash: Hash) -> Result<()>

async fn on_revert_update(&self, revert_info: RevertInfo) -> Result<()>

async fn maybe_get_block_hash_for_tag( &self, block_id: Option<BlockId>, ) -> Result<Option<H256>>

async fn get_block_hash_for_tag( &self, block_id: Option<BlockId>, ) -> Result<H256>

Returns the substrate block hash for a given block id.

fn get_account_id(&self, block: Hash, address: Address) -> Result<AccountId>

fn construct_balance_with_dust( &self, block: Hash, value: U256, ) -> Result<(Balance, u32)>

fn latest_block(&self) -> H256

async fn get_block_by_substrate_hash( &self, block_hash: H256, ) -> Result<Option<Block>>

Returns the EVM block for a given substrate block hash.

fn set_frame_system_balance( &self, latest_block: H256, account_id: AccountId, balance: Balance, ) -> Result<()>

async fn txpool_status(&self) -> Result<TxpoolStatus>

Returns transaction pool status

async fn txpool_inspect(&self) -> Result<TxpoolInspect>

Returns a summary of all transactions in the pool

async fn txpool_content(&self) -> Result<TxpoolContent<TxpoolTransactionInfo>>

Returns full transaction details for all transactions in the pool

async fn anvil_drop_all_transactions(&self) -> Result<()>

Drop all transactions from pool

async fn anvil_drop_transaction(&self, eth_hash: B256) -> Result<Option<B256>>

Drop a specific transaction from the pool by its ETH hash

async fn anvil_remove_pool_transactions(&self, address: Address) -> Result<()>

Remove all transactions from a specific sender address

async fn debug_trace_transaction( &self, tx_hash: B256, geth_tracer_options: GethDebugTracingOptions, ) -> Result<GethTrace>

async fn debug_trace_call( &self, request: WithOtherFields<TransactionRequest>, block_number: Option<BlockId>, geth_tracer_options: GethDebugTracingCallOptions, ) -> Result<GethTrace>

async fn debug_trace_block_by_number( &self, block_number: BlockNumberOrTag, geth_tracer_options: GethDebugTracingOptions, ) -> Result<Vec<TraceResult>>

async fn trace_transaction( &self, tx_hash: B256, ) -> Result<Vec<LocalizedTransactionTrace>>

async fn trace_block( &self, block_number: BlockNumberOrTag, ) -> Result<Vec<LocalizedTransactionTrace>>

async fn wait_for_receipt( &self, hash: B256, receiver: Receiver<H256>, ) -> Result<ReceiptInfo>

async fn wait_for_hash( &self, receiver: Option<Receiver<H256>>, awaited_hash: H256, ) -> Result<()>

fn new_block_notifications(&self) -> Result<Receiver<H256>>

async fn log_mined_block(&self, block_hash: H256) -> Result<()>

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: 656 bytes