Struct substrate_test_client::client::Client

pub struct Client<B, E, Block, RA> where
    Block: Block,  { /* fields omitted */ }

Substrate Client

Implementations

impl<B, E, Block, RA> Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>,
    <Block as Block>::Header: Clone, 

pub fn new(
    backend: Arc<B>,
    executor: E,
    build_genesis_storage: &dyn BuildStorage,
    fork_blocks: Option<Vec<(<<Block as Block>::Header as Header>::Number, <Block as Block>::Hash), Global>>,
    bad_blocks: Option<HashSet<<Block as Block>::Hash, RandomState>>,
    execution_extensions: ExecutionExtensions<Block>,
    prometheus_registry: Option<Registry>,
    telemetry: Option<TelemetryHandle>,
    config: ClientConfig<Block>
) -> Result<Client<B, E, Block, RA>, Error>

Creates new Substrate Client with given blockchain and code executor.

pub fn import_notification_sinks(
    &self
) -> &Mutex<RawMutex, Vec<TracingUnboundedSender<BlockImportNotification<Block>>, Global>>

returns a reference to the block import notification sinks useful for test environments.

pub fn finality_notification_sinks(
    &self
) -> &Mutex<RawMutex, Vec<TracingUnboundedSender<FinalityNotification<Block>>, Global>>

returns a reference to the finality notification sinks useful for test environments.

pub fn state_at(
    &self,
    block: &BlockId<Block>
) -> Result<<B as Backend<Block>>::State, Error>

Get a reference to the state at a given block.

pub fn code_at(&self, id: &BlockId<Block>) -> Result<Vec<u8, Global>, Error>

Get the code at a given block.

pub fn runtime_version_at(
    &self,
    id: &BlockId<Block>
) -> Result<RuntimeVersion, Error>

Get the RuntimeVersion at a given block.

pub fn header_proof_with_cht_size(
    &self,
    id: &BlockId<Block>,
    cht_size: <<Block as Block>::Header as Header>::Number
) -> Result<(<Block as Block>::Header, StorageProof), Error>

Reads given header and generates CHT-based header proof for CHT of given size.

pub fn key_changes_proof_with_cht_size(
    &self,
    first: <Block as Block>::Hash,
    last: <Block as Block>::Hash,
    min: <Block as Block>::Hash,
    max: <Block as Block>::Hash,
    storage_key: Option<&PrefixedStorageKey>,
    key: &StorageKey,
    cht_size: <<Block as Block>::Header as Header>::Number
) -> Result<ChangesProof<<Block as Block>::Header>, Error>

Does the same work as key_changes_proof, but assumes that CHTs are of passed size.

pub fn revert(
    &self,
    n: <<Block as Block>::Header as Header>::Number
) -> Result<<<Block as Block>::Header as Header>::Number, Error>

Attempts to revert the chain by n blocks guaranteeing that no block is reverted past the last finalized block. Returns the number of blocks that were successfully reverted.

pub fn unsafe_revert(
    &mut self,
    n: <<Block as Block>::Header as Header>::Number,
    blacklist: bool
) -> Result<<<Block as Block>::Header as Header>::Number, Error>

Attempts to revert the chain by n blocks disregarding finality. This method will revert any finalized blocks as requested and can potentially leave the node in an inconsistent state. Other modules in the system that persist data and that rely on finality (e.g. consensus parts) will be unaffected by the revert. Use this method with caution and making sure that no other data needs to be reverted for consistency aside from the block data. If blacklist is set to true, will also blacklist reverted blocks from finalizing again. The blacklist is reset upon client restart.

Returns the number of blocks that were successfully reverted.

pub fn chain_info(&self) -> Info<Block>

Get blockchain info.

pub fn block_status(&self, id: &BlockId<Block>) -> Result<BlockStatus, Error>

Get block status.

pub fn header(
    &self,
    id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Header>, Error>

Get block header by id.

pub fn body(
    &self,
    id: &BlockId<Block>
) -> Result<Option<Vec<<Block as Block>::Extrinsic, Global>>, Error>

Get block body by id.

pub fn uncles(
    &self,
    target_hash: <Block as Block>::Hash,
    max_generation: <<Block as Block>::Header as Header>::Number
) -> Result<Vec<<Block as Block>::Hash, Global>, Error>

Gets the uncles of the block with target_hash going back max_generation ancestors.

Trait Implementations

impl<'_, B, E, Block, RA> AuxStore for &'_ Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>,
    Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
    <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>, 

pub fn insert_aux<'a, 'b, 'c, I, D>(
    &self,
    insert: I,
    delete: D
) -> Result<(), Error> where
    'b: 'a,
    'c: 'a,
    I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
    D: IntoIterator<Item = &'a &'b [u8]>, 

Insert auxiliary data into key-value store.

pub fn get_aux(&self, key: &[u8]) -> Result<Option<Vec<u8, Global>>, Error>

Query auxiliary data from key-value store.

impl<B, E, Block, RA> AuxStore for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>,
    Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
    <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>, 

pub fn insert_aux<'a, 'b, 'c, I, D>(
    &self,
    insert: I,
    delete: D
) -> Result<(), Error> where
    'b: 'a,
    'c: 'a,
    I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
    D: IntoIterator<Item = &'a &'b [u8]>, 

Insert auxiliary data into key-value store.

pub fn get_aux(&self, key: &[u8]) -> Result<Option<Vec<u8, Global>>, Error>

Query auxiliary data from key-value store.

impl<B, E, Block, RA> BlockBackend<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

pub fn block_body(
    &self,
    id: &BlockId<Block>
) -> Result<Option<Vec<<Block as Block>::Extrinsic, Global>>, Error>

Get block body by ID. Returns None if the body is not stored.

pub fn block(
    &self,
    id: &BlockId<Block>
) -> Result<Option<SignedBlock<Block>>, Error>

Get full block by id.

pub fn block_status(&self, id: &BlockId<Block>) -> Result<BlockStatus, Error>

Get block status.

pub fn justifications(
    &self,
    id: &BlockId<Block>
) -> Result<Option<Justifications>, Error>

Get block justifications for the block with the given id.

pub fn block_hash(
    &self,
    number: <<Block as Block>::Header as Header>::Number
) -> Result<Option<<Block as Block>::Hash>, Error>

Get block hash by number.

pub fn indexed_transaction(
    &self,
    hash: &<Block as Block>::Hash
) -> Result<Option<Vec<u8, Global>>, Error>

Get single indexed transaction by content hash.

pub fn has_indexed_transaction(
    &self,
    hash: &<Block as Block>::Hash
) -> Result<bool, Error>

Check if transaction index exists.

pub fn block_indexed_body(
    &self,
    id: &BlockId<Block>
) -> Result<Option<Vec<Vec<u8, Global>, Global>>, Error>

Get all indexed transactions for a block, including renewed transactions.

impl<B, E, Block, RA> BlockBuilderProvider<B, Block, Client<B, E, Block, RA>> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block> + Send + Sync + 'static,
    B: Backend<Block> + Send + Sync + 'static,
    Client<B, E, Block, RA>: HeaderBackend<Block>,
    Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
    <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: ApiExt<Block>,
    <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: BlockBuilder<Block>,
    <<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend == <B as Backend<Block>>::State, 

pub fn new_block_at<R>(
    &self,
    parent: &BlockId<Block>,
    inherent_digests: Digest<<<Block as Block>::Header as Header>::Hash>,
    record_proof: R
) -> Result<BlockBuilder<'_, Block, Client<B, E, Block, RA>, B>, Error> where
    R: Into<RecordProof>, 

Create a new block, built on top of parent.

pub fn new_block(
    &self,
    inherent_digests: Digest<<<Block as Block>::Header as Header>::Hash>
) -> Result<BlockBuilder<'_, Block, Client<B, E, Block, RA>, B>, Error>

Create a new block, built on the head of the chain.

impl<B, E, Block, RA> BlockIdTo<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block> + Send + Sync,
    B: Backend<Block>,
    RA: Send + Sync, 

type Error = Error

The error type that will be returned by the functions.

pub fn to_hash(
    &self,
    block_id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>

Convert the given block_id to the corresponding block hash.

pub fn to_number(
    &self,
    block_id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>

Convert the given block_id to the corresponding block number.

impl<'impl0, B, E, Block, RA> BlockImport<Block> for &'impl0 Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block> + Send + Sync,
    B: Backend<Block>,
    RA: Sync + Send,
    Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
    <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
    <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: ApiExt<Block>,
    <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction: Send,
    <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction: 'static,
    <<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend == <B as Backend<Block>>::State, 

NOTE: only use this implementation when you are sure there are NO consensus-level BlockImport objects. Otherwise, importing blocks directly into the client would be bypassing important verification work.

pub fn import_block<'life0, 'async_trait>(
    &'life0 mut self,
    import_block: BlockImportParams<Block, <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction>,
    new_cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <&'impl0 Client<B, E, Block, RA> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    &'impl0 Client<B, E, Block, RA>: 'async_trait, 

Import a checked and validated block. If a justification is provided in BlockImportParams then finalized must be true.

NOTE: only use this implementation when there are NO consensus-level BlockImport objects. Otherwise, importing blocks directly into the client would be bypassing important verification work.

If you are not sure that there are no BlockImport objects provided by the consensus algorithm, don’t use this function.

pub fn check_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockCheckParams<Block>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <&'impl0 Client<B, E, Block, RA> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    &'impl0 Client<B, E, Block, RA>: 'async_trait, 

Check block preconditions.

type Error = Error

The error type.

type Transaction = <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction

The transaction type used by the backend.

impl<B, E, Block, RA> BlockImport<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block> + Send + Sync,
    B: Backend<Block>,
    RA: Sync + Send,
    Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
    <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
    <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: ApiExt<Block>,
    <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction: Send,
    <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction: 'static,
    <<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend == <B as Backend<Block>>::State, 

type Error = Error

The error type.

type Transaction = <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction

The transaction type used by the backend.

pub fn import_block<'life0, 'async_trait>(
    &'life0 mut self,
    import_block: BlockImportParams<Block, <Client<B, E, Block, RA> as BlockImport<Block>>::Transaction>,
    new_cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <Client<B, E, Block, RA> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    Client<B, E, Block, RA>: 'async_trait, 

Import a block.

pub fn check_block<'life0, 'async_trait>(
    &'life0 mut self,
    block: BlockCheckParams<Block>
) -> Pin<Box<dyn Future<Output = Result<ImportResult, <Client<B, E, Block, RA> as BlockImport<Block>>::Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    Client<B, E, Block, RA>: 'async_trait, 

Check block preconditions.

impl<B, E, Block, RA> BlockOf for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

type Type = Block

The type of the block.

impl<B, E, Block, RA> BlockchainEvents<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>, 

pub fn import_notification_stream(
    &self
) -> TracingUnboundedReceiver<BlockImportNotification<Block>>

Get block import event stream.

pub fn storage_changes_notification_stream(
    &self,
    filter_keys: Option<&[StorageKey]>,
    child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey, Global>>)]>
) -> Result<TracingUnboundedReceiver<(<Block as Block>::Hash, StorageChangeSet)>, Error>

Get storage changes event stream.

pub fn finality_notification_stream(
    &self
) -> TracingUnboundedReceiver<FinalityNotification<Block>>

Get a stream of finality notifications. Not guaranteed to be fired for every finalized block.

impl<B, E, Block, RA> CallApiAt<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block, Backend = B> + Send + Sync,
    B: Backend<Block>, 

type StateBackend = <B as Backend<Block>>::State

The state backend that is used to store the block states.

pub fn call_api_at<R, NC>(
    &self,
    params: CallApiAtParams<'a, Block, NC, <B as Backend<Block>>::State>
) -> Result<NativeOrEncoded<R>, ApiError> where
    R: Encode + Decode + PartialEq<R>,
    NC: FnOnce() -> Result<R, ApiError> + UnwindSafe, 

Calls the given api function with the given encoded arguments at the given block and returns the encoded result.

pub fn runtime_version_at(
    &self,
    at: &BlockId<Block>
) -> Result<RuntimeVersion, ApiError>

Returns the runtime version at the given block.

impl<BE, E, B, RA> Chain<B> for Client<BE, E, B, RA> where
    E: CallExecutor<B>,
    B: Block,
    BE: Backend<B>, 

pub fn block_status(
    &self,
    id: &BlockId<B>
) -> Result<BlockStatus, Box<dyn Error + Send + 'static, Global>>

Retrieve the status of the block denoted by the given BlockId.

impl<B, E, RA, Block: BlockT> ClientBlockImportExt<Block> for Client<B, E, Block, RA> where
    Self: BlockImport<Block, Error = ConsensusError>,
    RA: Send,
    B: Send + Sync,
    E: Send,
    <Self as BlockImport<Block>>::Transaction: Send, 

fn import<'life0, 'async_trait>(
    &'life0 mut self,
    origin: BlockOrigin,
    block: Block
) -> Pin<Box<dyn Future<Output = Result<(), ConsensusError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Import block to the chain. No finality.

fn import_as_best<'life0, 'async_trait>(
    &'life0 mut self,
    origin: BlockOrigin,
    block: Block
) -> Pin<Box<dyn Future<Output = Result<(), ConsensusError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Import a block and make it our best block if possible.

fn import_as_final<'life0, 'async_trait>(
    &'life0 mut self,
    origin: BlockOrigin,
    block: Block
) -> Pin<Box<dyn Future<Output = Result<(), ConsensusError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Import a block and finalize it.

fn import_justified<'life0, 'async_trait>(
    &'life0 mut self,
    origin: BlockOrigin,
    block: Block,
    justifications: Justifications
) -> Pin<Box<dyn Future<Output = Result<(), ConsensusError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Import block with justification(s), finalizes block.

impl<B, E, RA, Block> ClientExt<Block> for Client<B, E, Block, RA> where
    B: Backend<Block>,
    E: CallExecutor<Block> + 'static,
    Self: BlockImport<Block, Error = ConsensusError>,
    Block: BlockT, 

fn finalize_block(
    &self,
    id: BlockId<Block>,
    justification: Option<Justification>
) -> Result<()>

Finalize a block.

fn genesis_hash(&self) -> <Block as BlockT>::Hash

Returns hash of the genesis block.

impl<B, E, Block, RA> ExecutorProvider<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

type Executor = E

executor instance

pub fn executor(
    &self
) -> &<Client<B, E, Block, RA> as ExecutorProvider<Block>>::Executor

Get call executor reference.

pub fn execution_extensions(&self) -> &ExecutionExtensions<Block>

Get a reference to the execution extensions.

impl<B, E, Block, RA> Finalizer<Block, B> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

pub fn apply_finality(
    &self,
    operation: &mut ClientImportOperation<Block, B>,
    id: BlockId<Block>,
    justification: Option<([u8; 4], Vec<u8, Global>)>,
    notify: bool
) -> Result<(), Error>

Mark all blocks up to given as finalized in operation.

pub fn finalize_block(
    &self,
    id: BlockId<Block>,
    justification: Option<([u8; 4], Vec<u8, Global>)>,
    notify: bool
) -> Result<(), Error>

Finalize a block.

impl<'_, B, E, Block, RA> Finalizer<Block, B> for &'_ Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

pub fn apply_finality(
    &self,
    operation: &mut ClientImportOperation<Block, B>,
    id: BlockId<Block>,
    justification: Option<([u8; 4], Vec<u8, Global>)>,
    notify: bool
) -> Result<(), Error>

Mark all blocks up to given as finalized in operation.

pub fn finalize_block(
    &self,
    id: BlockId<Block>,
    justification: Option<([u8; 4], Vec<u8, Global>)>,
    notify: bool
) -> Result<(), Error>

Finalize a block.

impl<B, E, Block, RA> HeaderBackend<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block> + Send + Sync,
    B: Backend<Block>,
    RA: Send + Sync, 

pub fn header(
    &self,
    id: BlockId<Block>
) -> Result<Option<<Block as Block>::Header>, Error>

Get block header. Returns None if block is not found.

pub fn info(&self) -> Info<Block>

Get blockchain info.

pub fn status(&self, id: BlockId<Block>) -> Result<BlockStatus, Error>

Get block status.

pub fn number(
    &self,
    hash: <Block as Block>::Hash
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>

Get block number by hash. Returns None if the header is not in the chain.

pub fn hash(
    &self,
    number: <<Block as Block>::Header as Header>::Number
) -> Result<Option<<Block as Block>::Hash>, Error>

Get block hash by number. Returns None if the header is not in the chain.

fn block_hash_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>

Convert an arbitrary block ID into a block hash.

fn block_number_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>

Convert an arbitrary block ID into a block hash.

fn expect_header(
    &self,
    id: BlockId<Block>
) -> Result<<Block as Block>::Header, Error>

Get block header. Returns UnknownBlock error if block is not found.

fn expect_block_number_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<<<Block as Block>::Header as Header>::Number, Error>

Convert an arbitrary block ID into a block number. Returns UnknownBlock error if block is not found.

fn expect_block_hash_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<<Block as Block>::Hash, Error>

Convert an arbitrary block ID into a block hash. Returns UnknownBlock error if block is not found.

impl<'_, B, E, Block, RA> HeaderBackend<Block> for &'_ Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block> + Send + Sync,
    B: Backend<Block>,
    RA: Send + Sync, 

pub fn header(
    &self,
    id: BlockId<Block>
) -> Result<Option<<Block as Block>::Header>, Error>

Get block header. Returns None if block is not found.

pub fn info(&self) -> Info<Block>

Get blockchain info.

pub fn status(&self, id: BlockId<Block>) -> Result<BlockStatus, Error>

Get block status.

pub fn number(
    &self,
    hash: <Block as Block>::Hash
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>

Get block number by hash. Returns None if the header is not in the chain.

pub fn hash(
    &self,
    number: <<Block as Block>::Header as Header>::Number
) -> Result<Option<<Block as Block>::Hash>, Error>

Get block hash by number. Returns None if the header is not in the chain.

fn block_hash_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>

Convert an arbitrary block ID into a block hash.

fn block_number_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>

Convert an arbitrary block ID into a block hash.

fn expect_header(
    &self,
    id: BlockId<Block>
) -> Result<<Block as Block>::Header, Error>

Get block header. Returns UnknownBlock error if block is not found.

fn expect_block_number_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<<<Block as Block>::Header as Header>::Number, Error>

Convert an arbitrary block ID into a block number. Returns UnknownBlock error if block is not found.

fn expect_block_hash_from_id(
    &self,
    id: &BlockId<Block>
) -> Result<<Block as Block>::Hash, Error>

Convert an arbitrary block ID into a block hash. Returns UnknownBlock error if block is not found.

impl<B, E, Block, RA> HeaderMetadata<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

type Error = Error

Error used in case the header metadata is not found.

pub fn header_metadata(
    &self,
    hash: <Block as Block>::Hash
) -> Result<CachedHeaderMetadata<Block>, <Client<B, E, Block, RA> as HeaderMetadata<Block>>::Error>

pub fn insert_header_metadata(
    &self,
    hash: <Block as Block>::Hash,
    metadata: CachedHeaderMetadata<Block>
)

pub fn remove_header_metadata(&self, hash: <Block as Block>::Hash)

impl<BE, E, B, RA> IndexedBody<B> for Client<BE, E, B, RA> where
    E: CallExecutor<B>,
    B: Block,
    BE: Backend<B>, 

pub fn block_indexed_body(
    &self,
    number: <<B as Block>::Header as Header>::Number
) -> Result<Option<Vec<Vec<u8, Global>, Global>>, Error>

Get all indexed transactions for a block, including renewed transactions.

pub fn number(
    &self,
    hash: <B as Block>::Hash
) -> Result<Option<<<B as Block>::Header as Header>::Number>, Error>

Get block number for a block hash.

impl<B, E, Block, RA> LockImportRun<Block, B> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

pub fn lock_import_and_run<R, Err, F>(&self, f: F) -> Result<R, Err> where
    Err: From<Error>,
    F: FnOnce(&mut ClientImportOperation<Block, B>) -> Result<R, Err>, 

Lock the import lock, and run operations inside.

impl<'_, B, E, Block, RA> LockImportRun<Block, B> for &'_ Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

pub fn lock_import_and_run<R, Err, F>(&self, f: F) -> Result<R, Err> where
    Err: From<Error>,
    F: FnOnce(&mut ClientImportOperation<Block, B>) -> Result<R, Err>, 

Lock the import lock, and run operations inside.

impl<B, E, Block, RA> ProofProvider<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

pub fn read_proof(
    &self,
    id: &BlockId<Block>,
    keys: &mut dyn Iterator<Item = &[u8]>
) -> Result<StorageProof, Error>

Reads storage value at a given block + key, returning read proof.

pub fn read_child_proof(
    &self,
    id: &BlockId<Block>,
    child_info: &ChildInfo,
    keys: &mut dyn Iterator<Item = &[u8]>
) -> Result<StorageProof, Error>

Reads child storage value at a given block + storage_key + key, returning read proof.

pub fn execution_proof(
    &self,
    id: &BlockId<Block>,
    method: &str,
    call_data: &[u8]
) -> Result<(Vec<u8, Global>, StorageProof), Error>

Execute a call to a contract on top of state in a block of given hash AND returning execution proof.

pub fn header_proof(
    &self,
    id: &BlockId<Block>
) -> Result<(<Block as Block>::Header, StorageProof), Error>

Reads given header and generates CHT-based header proof.

pub fn key_changes_proof(
    &self,
    first: <Block as Block>::Hash,
    last: <Block as Block>::Hash,
    min: <Block as Block>::Hash,
    max: <Block as Block>::Hash,
    storage_key: Option<&PrefixedStorageKey>,
    key: &StorageKey
) -> Result<ChangesProof<<Block as Block>::Header>, Error>

Get proof for computation of (block, extrinsic) pairs where key has been changed at given blocks range. min is the hash of the first block, which changes trie root is known to the requester - when we’re using changes tries from ascendants of this block, we should provide proofs for changes tries roots max is the hash of the last block known to the requester - we can’t use changes tries from descendants of this block. Works only for runtimes that are supporting changes tries.

pub fn read_proof_collection(
    &self,
    id: &BlockId<Block>,
    start_key: &[u8],
    size_limit: usize
) -> Result<(StorageProof, u32), Error>

Given a BlockId iterate over all storage values starting at start_key exclusively, building proofs until size limit is reached. Returns combined proof and the number of collected keys.

pub fn storage_collection(
    &self,
    id: &BlockId<Block>,
    start_key: &[u8],
    size_limit: usize
) -> Result<Vec<(Vec<u8, Global>, Vec<u8, Global>), Global>, Error>

Given a BlockId iterate over all storage values starting at start_key. Returns collected keys and values.

pub fn verify_range_proof(
    &self,
    root: <Block as Block>::Hash,
    proof: StorageProof,
    start_key: &[u8]
) -> Result<(Vec<(Vec<u8, Global>, Vec<u8, Global>), Global>, bool), Error>

Verify read storage proof for a set of keys. Returns collected key-value pairs and a flag indicating if iteration is complete.

impl<B, E, Block, RA> ProvideCache<Block> for Client<B, E, Block, RA> where
    Block: Block,
    B: Backend<Block>, 

pub fn cache(&self) -> Option<Arc<dyn Cache<Block> + 'static>>

Returns data cache reference, if it is enabled on this backend.

impl<B, E, Block, RA> ProvideRuntimeApi<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block, Backend = B> + Send + Sync,
    B: Backend<Block>,
    RA: ConstructRuntimeApi<Block, Client<B, E, Block, RA>>, 

type Api = <RA as ConstructRuntimeApi<Block, Client<B, E, Block, RA>>>::RuntimeApi

The concrete type that provides the api.

pub fn runtime_api(
    &'a self
) -> ApiRef<'a, <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api>

Returns the runtime api. The returned instance will keep track of modifications to the storage. Any successful call to an api function, will commit its changes to an internal buffer. Otherwise, the modifications will be discarded. The modifications will not be applied to the storage, even on a commit.

impl<B, E, Block, RA> ProvideUncles<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

pub fn uncles(
    &self,
    target_hash: <Block as Block>::Hash,
    max_generation: <<Block as Block>::Header as Header>::Number
) -> Result<Vec<<Block as Block>::Header, Global>, Error>

Gets the uncles of the block with target_hash going back max_generation ancestors.

impl<B, E, Block, RA> StorageProvider<Block, B> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

pub fn storage_keys(
    &self,
    id: &BlockId<Block>,
    key_prefix: &StorageKey
) -> Result<Vec<StorageKey, Global>, Error>

Given a BlockId and a key prefix, return the matching storage keys in that block.

pub fn storage_pairs(
    &self,
    id: &BlockId<Block>,
    key_prefix: &StorageKey
) -> Result<Vec<(StorageKey, StorageData), Global>, Error>

Given a BlockId and a key prefix, return the matching child storage keys and values in that block.

pub fn storage_keys_iter(
    &self,
    id: &BlockId<Block>,
    prefix: Option<&'a StorageKey>,
    start_key: Option<&StorageKey>
) -> Result<KeyIterator<'a, <B as Backend<Block>>::State, Block>, Error>

Given a BlockId and a key prefix, return a KeyIterator iterates matching storage keys in that block.

pub fn child_storage_keys_iter(
    &self,
    id: &BlockId<Block>,
    child_info: ChildInfo,
    prefix: Option<&'a StorageKey>,
    start_key: Option<&StorageKey>
) -> Result<KeyIterator<'a, <B as Backend<Block>>::State, Block>, Error>

Given a BlockId and a key prefix and a child storage key, return a KeyIterator that iterates matching storage keys in that block.

pub fn storage(
    &self,
    id: &BlockId<Block>,
    key: &StorageKey
) -> Result<Option<StorageData>, Error>

Given a BlockId and a key, return the value under the key in that block.

pub fn storage_hash(
    &self,
    id: &BlockId<Block>,
    key: &StorageKey
) -> Result<Option<<Block as Block>::Hash>, Error>

Given a BlockId and a key, return the value under the hash in that block.

pub fn child_storage_keys(
    &self,
    id: &BlockId<Block>,
    child_info: &ChildInfo,
    key_prefix: &StorageKey
) -> Result<Vec<StorageKey, Global>, Error>

Given a BlockId, a key prefix, and a child storage key, return the matching child storage keys.

pub fn child_storage(
    &self,
    id: &BlockId<Block>,
    child_info: &ChildInfo,
    key: &StorageKey
) -> Result<Option<StorageData>, Error>

Given a BlockId, a key and a child storage key, return the value under the key in that block.

pub fn child_storage_hash(
    &self,
    id: &BlockId<Block>,
    child_info: &ChildInfo,
    key: &StorageKey
) -> Result<Option<<Block as Block>::Hash>, Error>

Given a BlockId, a key and a child storage key, return the hash under the key in that block.

pub fn max_key_changes_range(
    &self,
    first: <<Block as Block>::Header as Header>::Number,
    last: BlockId<Block>
) -> Result<Option<(<<Block as Block>::Header as Header>::Number, BlockId<Block>)>, Error>

Get longest range within [first; last] that is possible to use in key_changes and key_changes_proof calls. Range could be shortened from the beginning if some changes tries have been pruned. Returns Ok(None) if changes tries are not supported.

pub fn key_changes(
    &self,
    first: <<Block as Block>::Header as Header>::Number,
    last: BlockId<Block>,
    storage_key: Option<&PrefixedStorageKey>,
    key: &StorageKey
) -> Result<Vec<(<<Block as Block>::Header as Header>::Number, u32), Global>, Error>

Get pairs of (block, extrinsic) where key has been changed at given blocks range. Works only for runtimes that are supporting changes tries.

impl<B, E, Block, RA> UsageProvider<Block> for Client<B, E, Block, RA> where
    Block: Block,
    E: CallExecutor<Block>,
    B: Backend<Block>, 

pub fn usage_info(&self) -> ClientInfo<Block>

Get usage info about current client.