Struct Chain 

pub struct Chain { /* private fields */ }

Low-level RPC surface with fine-grained retry controls.

Implementations

impl Chain

pub fn new(client: Client) -> Self

Creates a chain helper bound to the given client.

Arguments

• client - Client used for all subsequent RPC calls.

pub fn retry_on(self, error: Option<bool>, none: Option<bool>) -> Self

Lets you decide if upcoming calls retry on errors or missing data.

Arguments

• error - Overrides whether transport errors are retried (defaults to the client’s global flag).
• none - When Some(true), RPCs returning None (for example, missing storage) will also be retried.

Returns

Returns the helper with updated retry configuration.

pub async fn block_hash( &self, block_height: Option<u32>, ) -> Result<Option<H256>, RpcError>

Fetches a block hash for the given height when available.

Arguments

• block_height - Optional block number to resolve; None queries the best block.

Returns

• Ok(Some(H256)) when the chain knows about the requested height.
• Ok(None) when the block does not exist
• Err(RpcError) when the underlying RPC call fails.

pub async fn block_header( &self, at: Option<impl Into<HashStringNumber>>, ) -> Result<Option<AvailHeader>, Error>

Grabs a block header by hash or height.

Arguments

• at - Optional hash or height identifying the target block; None queries the best block.

Returns

• Ok(Some(AvailHeader)) when the header exists.
• Ok(None) when the header is missing
• Err(Error) when conversions or RPC calls fail.

pub async fn legacy_block( &self, at: Option<H256>, ) -> Result<Option<LegacyBlock>, RpcError>

Retrieves the full legacy block

Arguments

• at - Optional block hash; None queries the best block.

Returns

• Ok(Some(LegacyBlock)) when the block exists.
• Ok(None) when the block is missing
• Err(Error) when RPC calls fail.

pub async fn block_nonce( &self, account_id: impl Into<AccountIdLike>, at: impl Into<HashStringNumber>, ) -> Result<u32, Error>

Looks up an account nonce at a particular block.

Arguments

• account_id - Account identifier convertible into AccountIdLike.
• at - Block reference (hash, height, or string) describing where to query the nonce.

Returns

Returns the account nonce observed at the specified block.

Errors

Returns Err(Error) when the account id cannot be parsed or the RPC call fails.

pub async fn account_nonce( &self, account_id: impl Into<AccountIdLike>, ) -> Result<u32, Error>

Returns the latest account nonce as seen by the node.

Arguments

• account_id - Account identifier convertible into AccountIdLike.

Returns

Returns the latest account nonce reported by the node.

Errors

Returns Err(Error) when the account id cannot be parsed or the RPC call fails.

pub async fn account_balance( &self, account_id: impl Into<AccountIdLike>, at: impl Into<HashStringNumber>, ) -> Result<AccountData, Error>

Reports the free balance for an account at a specific block.

Arguments

• account_id - Account identifier convertible into AccountIdLike.
• at - Block reference describing where to query balances.

Returns

Returns AccountData for the requested account at the chosen block.

Errors mirror Chain::account_info.

pub async fn account_info( &self, account_id: impl Into<AccountIdLike>, at: impl Into<HashStringNumber>, ) -> Result<AccountInfo, Error>

Fetches the full account record (nonce, balances, …) at a given block.

Arguments

• account_id - Account identifier convertible into AccountIdLike.
• at - Block reference describing where to query the account.

Returns

Returns AccountInfo containing balances, consumers, and nonce data.

Errors

Returns Err(Error) when the account identifier or block id cannot be converted, the block is missing, or the RPC call fails.

pub async fn block_state( &self, block_id: impl Into<HashStringNumber>, ) -> Result<BlockState, Error>

Tells you if a block is pending, finalized, or missing.

Returns

Distinguishes between BlockState::Included, BlockState::Finalized, BlockState::Discarded, and BlockState::DoesNotExist, depending on chain state.

Errors

Returns Err(Error) if the supplied identifier cannot be converted or RPC calls fail.

pub async fn block_height( &self, at: impl Into<HashString>, ) -> Result<Option<u32>, Error>

Converts a block hash into its block height when possible.

Returns

• Ok(Some(u32)) when the block height exists.
• Ok(None) when the block height is missing
• Err(Error) when RPC calls fail.

pub async fn block_info( &self, use_best_block: bool, ) -> Result<BlockInfo, RpcError>

Returns the latest block info, either best or finalized.

pub async fn block_info_from( &self, block_id: impl Into<HashStringNumber>, ) -> Result<BlockInfo, Error>

Fetches block metadata for the provided block identifier.

Arguments

• block_id - Hash, height, or string representation of the target block.

Returns

Returns BlockInfo describing the block, or an error if the lookup fails.

pub async fn block_author( &self, block_id: impl Into<HashStringNumber>, ) -> Result<AccountId, Error>

Determines the author of the specified block.

Arguments

• block_id - Hash, height, or string representation of the target block.

Returns

Returns the account id of the block author or an error if it cannot be determined.

pub async fn block_event_count( &self, block_id: impl Into<HashStringNumber>, ) -> Result<usize, Error>

Counts the events emitted by the specified block.

Arguments

• block_id - Identifier describing which block to inspect.

Returns

Returns the number of events as usize, or an error if the count cannot be fetched.

pub async fn block_weight( &self, block_id: impl Into<HashStringNumber>, ) -> Result<PerDispatchClassWeight, Error>

Retrieves the dispatch-class weight totals for the specified block.

Arguments

• block_id - Identifier describing which block to inspect.

Returns

Returns the per-dispatch-class weight totals or an error if unavailable.

pub async fn chain_info(&self) -> Result<ChainInfo, RpcError>

Quick snapshot of both the best and finalized heads.

pub async fn build_payload<'a>( &self, account_id: &AccountId, call: &'a ExtrinsicCall, options: Options, ) -> Result<ExtrinsicPayload<'a>, Error>

Builds an unsigned extrinsic payload for the provided account and call.

Arguments

• account_id - Account that will sign the payload.
• call - Runtime call to encode inside the payload.
• options - Transaction options used to refine mortality, nonce, and fees.

Returns

Returns the constructed payload or an error if option refinement fails.

pub async fn build_extrinsic_from_call<'a>( &self, signer: &Keypair, call: &'a ExtrinsicCall, options: Options, ) -> Result<GenericExtrinsic<'a>, Error>

Builds a payload from a call and signs it with sensible defaults.

Errors

Returns Err(Error) when option refinement fails (e.g., fetching account info) or signing fails.

pub async fn submit(&self, ext: &GenericExtrinsic<'_>) -> Result<H256, RpcError>

Submits a signed extrinsic and gives you the transaction hash.

Errors

Returns Err(RpcError) when the node rejects the extrinsic or the RPC transport fails.

pub async fn submit_raw(&self, ext: &[u8]) -> Result<H256, RpcError>

Submits a signed extrinsic and gives you the transaction hash.

Errors

Returns Err(RpcError) when the node rejects the extrinsic or the RPC transport fails.

pub async fn sign_and_submit_payload( &self, signer: &Keypair, tx_payload: ExtrinsicPayload<'_>, ) -> Result<H256, RpcError>

Signs the payload and submits it in one step.

pub async fn sign_and_submit_call( &self, signer: &Keypair, tx_call: &ExtrinsicCall, options: Options, ) -> Result<SubmittedTransaction, Error>

Signs a call, submits it, and hands back a tracker you can poll.

Returns

• Ok(SubmittedTransaction) containing the transaction hash and refined options for later receipt queries.
• Err(Error) when option refinement, signing, or submission fails.

pub async fn state_call( &self, method: &str, data: &[u8], at: Option<H256>, ) -> Result<String, RpcError>

Runs a state_call and returns the raw response string.

pub async fn state_get_metadata( &self, at: Option<H256>, ) -> Result<Vec<u8>, RpcError>

Downloads runtime metadata as bytes.

pub async fn state_get_storage( &self, key: &str, at: Option<H256>, ) -> Result<Option<Vec<u8>>, RpcError>

Reads a storage entry, returning the raw bytes if present.

pub async fn state_get_keys_paged( &self, prefix: Option<&str>, count: u32, start_key: Option<&str>, at: Option<H256>, ) -> Result<Vec<String>, RpcError>

Lists storage keys under a prefix, one page at a time.

pub async fn rpc_raw_call<T: DeserializeOwned>( &self, method: &str, params: RpcParams, ) -> Result<T, RpcError>

Performs a raw RPC invocation against the connected node and deserializes the response.

pub async fn runtime_api_raw_call<T: Decode>( &self, method: &str, data: &[u8], at: Option<H256>, ) -> Result<T, RpcError>

Calls into the runtime API and decodes the answer for you.

pub async fn grandpa_block_justification( &self, at: u32, ) -> Result<Option<GrandpaJustification>, RpcError>

Fetches GRANDPA justification for the given block number.

Returns

• Ok(Some(GrandpaJustification)) when a justification is present.
• Ok(None) when the runtime returns no justification.
• Err(RpcError) if decoding the response or the RPC call fails.

pub async fn transaction_payment_query_info( &self, extrinsic: Vec<u8>, at: Option<H256>, ) -> Result<RuntimeDispatchInfo, RpcError>

Queries the runtime for fee information about an encoded extrinsic.

Arguments

• extrinsic - SCALE-encoded extrinsic bytes.
• at - Optional block hash to query against.

Returns

Returns dispatch info describing the estimated fee and weight.

pub async fn transaction_payment_query_fee_details( &self, extrinsic: Vec<u8>, at: Option<H256>, ) -> Result<FeeDetails, RpcError>

Retrieves detailed fee breakdown for an encoded extrinsic.

Arguments

• extrinsic - SCALE-encoded extrinsic bytes.
• at - Optional block hash to query against.

Returns

Returns fee components such as inclusion and tip fees.

pub async fn transaction_payment_query_call_info( &self, call: Vec<u8>, at: Option<H256>, ) -> Result<RuntimeDispatchInfo, RpcError>

Queries the runtime for fee information about an encoded call.

Arguments

• call - SCALE-encoded call bytes.
• at - Optional block hash to query against.

Returns

Returns dispatch info describing the estimated fee and weight.

pub async fn transaction_payment_query_call_fee_details( &self, call: Vec<u8>, at: Option<H256>, ) -> Result<FeeDetails, RpcError>

Retrieves detailed fee components for an encoded call.

Arguments

• call - SCALE-encoded call bytes.
• at - Optional block hash to query against.

Returns

Returns the fee breakdown for executing the call.

pub async fn kate_block_length( &self, at: Option<H256>, ) -> Result<BlockLength, RpcError>

Retrieves the KATE block layout metadata (rows, cols, chunk size) for the block at at.

Errors

Returns Err(RpcError) when the KATE RPC call fails; respects the helper’s retry policy.

pub async fn kate_query_data_proof( &self, transaction_index: u32, at: Option<H256>, ) -> Result<ProofResponse, RpcError>

Produces the KATE data proof (and optional addressed message) for the given extrinsic index.

Errors

Returns Err(RpcError) when the proof cannot be fetched or deserialised; obeys the retry setting.

pub async fn kate_query_proof( &self, cells: Vec<Cell>, at: Option<H256>, ) -> Result<Vec<GDataProof>, RpcError>

Fetches individual KATE proofs for the provided list of cells.

Errors

Bubbles Err(RpcError) if the RPC call fails; retries follow the configured policy.

pub async fn kate_query_rows( &self, rows: Vec<u32>, at: Option<H256>, ) -> Result<Vec<GRow>, RpcError>

Returns KATE row data for the requested row indices (up to the chain-imposed limit).

Errors

Propagates Err(RpcError) when the row query fails; adheres to the retry preference.

pub async fn kate_query_multi_proof( &self, cells: Vec<Cell>, at: Option<H256>, ) -> Result<Vec<(GMultiProof, GCellBlock)>, RpcError>

Requests multi-proofs for the supplied KATE cells, paired with the corresponding cell block metadata.

Errors

Returns Err(RpcError) when the RPC transport or decoding fails; follows the retry configuration.

pub async fn system_fetch_extrinsics( &self, block_id: impl Into<HashStringNumber>, opts: ExtrinsicOpts, ) -> Result<Vec<ExtrinsicInfo>, Error>

Fetches extrinsics from a block using the provided filters.

Errors

Returns Err(Error) when the block id cannot be decoded or the RPC request fails.

pub async fn system_fetch_events( &self, at: impl Into<HashStringNumber>, opts: EventOpts, ) -> Result<Vec<BlockPhaseEvent>, Error>

Pulls events for a block with optional filtering.

Errors

Returns Err(Error) when the block id cannot be resolved or the RPC call fails.

pub fn should_retry_on_error(&self) -> bool

Reports whether RPC helpers should retry after encountering errors.