Struct ChainApi 

pub struct ChainApi { /* private fields */ }

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

Implementations

impl ChainApi

pub fn new(client: Client) -> Self

Creates a helper for low-level 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.

• error: overrides whether transport errors are retried (defaults to the client’s global flag).
• none: when Some(true), RPCs returning None (e.g., missing storage) will also be retried.

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

Fetches a block hash for the given height when available.

Returns

• Ok(Some(H256)) when the chain knows about the requested height.
• Ok(None) when the block does not exist (and retry_on_none is false).
• 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.

Returns

• Ok(Some(AvailHeader)) when the header exists.
• Ok(None) when the header is missing (and retry_on_none is false).
• 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 when you need the old format.

Return semantics match ChainApi::block_hash regarding retries and None handling.

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.

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.

Errors

Returns Err(Error) when the account identifier is invalid 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.

Errors mirror ChainApi::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.

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(None) when the node does not recognise the hash and retry_on_none is false.

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

Returns the latest block info, either best or finalized.

This is a thin wrapper over system_latest_block_info with retry support.

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

Quick snapshot of both the best and finalized heads.

Mirrors system_latest_chain_info, exposing height/hash pairs for head and finalized.

pub async fn submit(&self, tx: &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 sign_payload<'a>( &self, signer: &Keypair, tx_payload: ExtrinsicPayload<'a>, ) -> GenericExtrinsic<'a>

Signs an already prepared payload with the provided keypair.

pub async fn sign_call<'a>( &self, signer: &Keypair, tx_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 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.

Retries according to the helper’s configuration before surfacing Err(RpcError).

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 system_fetch_extrinsics( &self, block_id: impl Into<HashStringNumber>, opts: ExtrinsicOpts, ) -> Result<Vec<ExtrinsicInfo>, Error>

Collects 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 async fn grandpa_block_justification( &self, at: u32, ) -> Result<Option<GrandpaJustification>, RpcError>

Fetches a binary 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 grandpa_block_justification_json( &self, at: u32, ) -> Result<Option<GrandpaJustification>, RpcError>

Fetches a JSON GRANDPA justification for the given block number.

Return semantics mirror ChainApi::grandpa_block_justification, but the payload is parsed from JSON.

pub async fn runtime_api_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 transaction_payment_query_info( &self, extrinsic: Vec<u8>, at: Option<H256>, ) -> Result<RuntimeDispatchInfo, RpcError>

Estimates fees for a signed extrinsic.

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

Breaks down the fee details for a signed extrinsic.

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

Estimates fees for an unsigned call payload.

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

Breaks down the fee details for an unsigned call payload.

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.