Struct ForkRpcClient 

pub struct ForkRpcClient { /* private fields */ }

RPC client wrapper for fork operations.

Wraps subxt’s LegacyRpcMethods to provide a focused API for fetching state from live Polkadot-SDK chains. See the module-level documentation for why this wrapper exists rather than using LegacyRpcMethods directly.

Example

use pop_fork::ForkRpcClient;

let client = ForkRpcClient::connect(&"wss://rpc.polkadot.io".parse()?).await?;
let block_hash = client.finalized_head().await?;
let metadata = client.metadata(block_hash).await?;
let storage_value = client.storage(&key, block_hash).await?;

Implementations

impl ForkRpcClient

pub async fn connect(endpoint: &Url) -> Result<Self, RpcClientError>

Connect to a live Polkadot-SDK chain.

Arguments

• endpoint - WebSocket URL of the chain’s RPC endpoint (e.g., wss://rpc.polkadot.io)

Example

let client = ForkRpcClient::connect(&"wss://rpc.polkadot.io".parse()?).await?;

pub async fn reconnect(&self) -> Result<(), RpcClientError>

Reconnect to the upstream RPC endpoint.

Creates a fresh WebSocket connection, replacing the existing one. All clones of this client share the connection, so reconnecting affects all of them.

Serialized via reconnect_lock: only one task performs the actual reconnection. Other concurrent callers wait for the lock, then verify the connection is alive before attempting another reconnect (avoiding the thundering herd problem).

pub fn endpoint(&self) -> &Url

Get the endpoint URL this client is connected to.

pub async fn finalized_head(&self) -> Result<H256, RpcClientError>

Get the latest finalized block hash.

This is typically the starting point for forking - we fork from the latest finalized state to ensure consistency.

pub async fn header( &self, hash: H256, ) -> Result<<SubstrateConfig as Config>::Header, RpcClientError>

Get block header by hash.

Returns the header for the specified block, which contains the parent hash, state root, extrinsics root, and digest.

pub async fn block_hash_at( &self, block_number: u32, ) -> Result<Option<H256>, RpcClientError>

Get a block hash by its number.

Arguments

• block_number - The block number to query

Returns

• Ok(Some(hash)) - Block exists with this hash
• Ok(None) - Block number doesn’t exist yet
• Err(_) - RPC error

pub async fn block_by_number( &self, block_number: u32, ) -> Result<Option<(H256, Block<SubstrateConfig>)>, RpcClientError>

Get full block data by block number.

This method first fetches the block hash for the given block number using chain_getBlockHash, then fetches the full block data using chain_getBlock.

Arguments

• block_number - The block number to query

Returns

• Ok(Some((hash, block))) - Block exists with hash and data
• Ok(None) - Block number doesn’t exist yet
• Err(_) - RPC error

pub async fn block_by_hash( &self, block_hash: H256, ) -> Result<Option<Block<SubstrateConfig>>, RpcClientError>

Get full block data by block hash.

Arguments

• block_hash - The block hash to query

Returns

• Ok(Some(block)) - Block exists
• Ok(None) - Block hash not found
• Err(_) - RPC error

pub async fn storage( &self, key: &[u8], at: H256, ) -> Result<Option<Vec<u8>>, RpcClientError>

Get a single storage value at a specific block.

Arguments

• key - The storage key (raw bytes)
• at - The block hash to query state at

Returns

• Ok(Some(value)) - Storage exists with value
• Ok(None) - Storage key doesn’t exist (empty)
• Err(_) - RPC error

pub async fn storage_batch( &self, keys: &[&[u8]], at: H256, ) -> Result<Vec<Option<Vec<u8>>>, RpcClientError>

Get multiple storage values in a single batch request.

More efficient than multiple individual storage() calls when fetching many keys at once.

Arguments

• keys - Slice of storage keys to fetch
• at - The block hash to query state at

Returns

A vector of optional values, in the same order as the input keys.

pub async fn storage_keys_paged( &self, prefix: &[u8], count: u32, start_key: Option<&[u8]>, at: H256, ) -> Result<Vec<Vec<u8>>, RpcClientError>

Get storage keys matching a prefix, with pagination.

Useful for iterating over map storage items.

Arguments

• prefix - The storage key prefix to match
• count - Maximum number of keys to return
• start_key - Optional key to start from (for pagination)
• at - The block hash to query state at

pub async fn metadata(&self, at: H256) -> Result<Metadata, RpcClientError>

Get runtime metadata at a specific block.

Attempts to fetch and decode metadata via state_getMetadata. If decoding fails (e.g., due to type registry inconsistencies in the chain’s metadata), falls back to requesting specific metadata versions via Metadata_metadata_at_version runtime API (latest down to V14).

pub async fn runtime_code(&self, at: H256) -> Result<Vec<u8>, RpcClientError>

Get the runtime WASM code at a specific block.

This fetches the :code storage key which contains the runtime WASM blob.

pub async fn system_chain(&self) -> Result<String, RpcClientError>

Get the chain name from system properties.

pub async fn state_call( &self, function: &str, call_parameters: &[u8], at: Option<H256>, ) -> Result<Vec<u8>, RpcClientError>

Execute a runtime API call via state_call on the upstream chain.

This is useful for proxying computationally expensive runtime calls (like metadata generation) to the upstream node, which has a JIT-compiled runtime and handles them much faster than the local WASM interpreter.

pub async fn system_properties( &self, ) -> Result<SystemProperties, RpcClientError>

Get system properties (token decimals, symbols, etc.).

Trait Implementations

impl Clone for ForkRpcClient

fn clone(&self) -> ForkRpcClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ForkRpcClient

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

Formats the value using the given formatter.