pub type TFullClient<TBl, TRtApi, TExec> = Client<TFullBackend<TBl>, TFullCallExecutor<TBl, TExec>, TBl, TRtApi>;
Expand description
Full client type.
Aliased Type§
struct TFullClient<TBl, TRtApi, TExec> { /* private fields */ }
Implementations
Source§impl<B, E, Block, RA> Client<B, E, Block, RA>
impl<B, E, Block, RA> Client<B, E, Block, RA>
Sourcepub fn new<G>(
backend: Arc<B>,
executor: E,
spawn_handle: Box<dyn SpawnNamed>,
genesis_block_builder: G,
fork_blocks: ForkBlocks<Block>,
bad_blocks: BadBlocks<Block>,
prometheus_registry: Option<Registry>,
telemetry: Option<TelemetryHandle>,
config: ClientConfig<Block>,
) -> Result<Self>where
G: BuildGenesisBlock<Block, BlockImportOperation = <B as Backend<Block>>::BlockImportOperation>,
E: Clone,
B: 'static,
pub fn new<G>(
backend: Arc<B>,
executor: E,
spawn_handle: Box<dyn SpawnNamed>,
genesis_block_builder: G,
fork_blocks: ForkBlocks<Block>,
bad_blocks: BadBlocks<Block>,
prometheus_registry: Option<Registry>,
telemetry: Option<TelemetryHandle>,
config: ClientConfig<Block>,
) -> Result<Self>where
G: BuildGenesisBlock<Block, BlockImportOperation = <B as Backend<Block>>::BlockImportOperation>,
E: Clone,
B: 'static,
Creates new Substrate Client with given blockchain and code executor.
Sourcepub fn import_notification_sinks(
&self,
) -> &Mutex<Vec<TracingUnboundedSender<BlockImportNotification<Block>>>>
pub fn import_notification_sinks( &self, ) -> &Mutex<Vec<TracingUnboundedSender<BlockImportNotification<Block>>>>
returns a reference to the block import notification sinks useful for test environments.
Sourcepub fn finality_notification_sinks(
&self,
) -> &Mutex<Vec<TracingUnboundedSender<FinalityNotification<Block>>>>
pub fn finality_notification_sinks( &self, ) -> &Mutex<Vec<TracingUnboundedSender<FinalityNotification<Block>>>>
returns a reference to the finality notification sinks useful for test environments.
Sourcepub fn state_at(&self, hash: Block::Hash) -> Result<B::State>
pub fn state_at(&self, hash: Block::Hash) -> Result<B::State>
Get a reference to the state at a given block.
Sourcepub fn code_at(&self, hash: Block::Hash) -> Result<Vec<u8>>
pub fn code_at(&self, hash: Block::Hash) -> Result<Vec<u8>>
Get the code at a given block.
This takes any potential substitutes into account, but ignores overrides.
Sourcepub fn runtime_version_at(&self, hash: Block::Hash) -> Result<RuntimeVersion>
pub fn runtime_version_at(&self, hash: Block::Hash) -> Result<RuntimeVersion>
Get the RuntimeVersion at a given block.
Sourcepub fn revert(&self, n: NumberFor<Block>) -> Result<NumberFor<Block>>
pub fn revert(&self, n: NumberFor<Block>) -> Result<NumberFor<Block>>
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.
Sourcepub fn unsafe_revert(
&mut self,
n: NumberFor<Block>,
blacklist: bool,
) -> Result<NumberFor<Block>>
pub fn unsafe_revert( &mut self, n: NumberFor<Block>, blacklist: bool, ) -> Result<NumberFor<Block>>
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.
Sourcepub fn chain_info(&self) -> BlockchainInfo<Block>
pub fn chain_info(&self) -> BlockchainInfo<Block>
Get blockchain info.
Sourcepub fn block_status(&self, hash: Block::Hash) -> Result<BlockStatus>
pub fn block_status(&self, hash: Block::Hash) -> Result<BlockStatus>
Get block status.
Sourcepub fn header(
&self,
hash: Block::Hash,
) -> Result<Option<<Block as BlockT>::Header>>
pub fn header( &self, hash: Block::Hash, ) -> Result<Option<<Block as BlockT>::Header>>
Get block header by id.
Trait Implementations
Source§impl<B, E, Block, RA> AuxStore for Client<B, E, Block, RA>where
B: Backend<Block>,
E: CallExecutor<Block>,
Block: BlockT,
Self: ProvideRuntimeApi<Block>,
<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block>,
impl<B, E, Block, RA> AuxStore for Client<B, E, Block, RA>where
B: Backend<Block>,
E: CallExecutor<Block>,
Block: BlockT,
Self: ProvideRuntimeApi<Block>,
<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block>,
Source§fn insert_aux<'a, 'b: 'a, 'c: 'a, I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>, D: IntoIterator<Item = &'a &'b [u8]>>(
&self,
insert: I,
delete: D,
) -> Result<()>
fn insert_aux<'a, 'b: 'a, 'c: 'a, I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>, D: IntoIterator<Item = &'a &'b [u8]>>( &self, insert: I, delete: D, ) -> Result<()>
Insert auxiliary data into key-value store.
Source§impl<B, E, Block, RA> BlockBackend<Block> for Client<B, E, Block, RA>
impl<B, E, Block, RA> BlockBackend<Block> for Client<B, E, Block, RA>
Source§fn block_body(
&self,
hash: Block::Hash,
) -> Result<Option<Vec<<Block as BlockT>::Extrinsic>>>
fn block_body( &self, hash: Block::Hash, ) -> Result<Option<Vec<<Block as BlockT>::Extrinsic>>>
None
if the body is not stored.Source§fn block(&self, hash: Block::Hash) -> Result<Option<SignedBlock<Block>>>
fn block(&self, hash: Block::Hash) -> Result<Option<SignedBlock<Block>>>
Source§fn block_status(&self, hash: Block::Hash) -> Result<BlockStatus>
fn block_status(&self, hash: Block::Hash) -> Result<BlockStatus>
Source§fn justifications(&self, hash: Block::Hash) -> Result<Option<Justifications>>
fn justifications(&self, hash: Block::Hash) -> Result<Option<Justifications>>
Source§fn block_hash(&self, number: NumberFor<Block>) -> Result<Option<Block::Hash>>
fn block_hash(&self, number: NumberFor<Block>) -> Result<Option<Block::Hash>>
Source§fn indexed_transaction(&self, hash: Block::Hash) -> Result<Option<Vec<u8>>>
fn indexed_transaction(&self, hash: Block::Hash) -> Result<Option<Vec<u8>>>
Source§fn has_indexed_transaction(&self, hash: Block::Hash) -> Result<bool>
fn has_indexed_transaction(&self, hash: Block::Hash) -> Result<bool>
Source§fn block_indexed_body(&self, hash: Block::Hash) -> Result<Option<Vec<Vec<u8>>>>
fn block_indexed_body(&self, hash: Block::Hash) -> Result<Option<Vec<Vec<u8>>>>
Source§fn requires_full_sync(&self) -> bool
fn requires_full_sync(&self) -> bool
Source§impl<B, E, Block, RA> BlockIdTo<Block> for Client<B, E, Block, RA>
impl<B, E, Block, RA> BlockIdTo<Block> for Client<B, E, Block, RA>
Source§impl<B, E, Block, RA> BlockImport<Block> for Client<B, E, Block, RA>where
B: Backend<Block>,
E: CallExecutor<Block> + Send + Sync,
Block: BlockT,
Self: ProvideRuntimeApi<Block>,
<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block> + ApiExt<Block>,
RA: Sync + Send,
impl<B, E, Block, RA> BlockImport<Block> for Client<B, E, Block, RA>where
B: Backend<Block>,
E: CallExecutor<Block> + Send + Sync,
Block: BlockT,
Self: ProvideRuntimeApi<Block>,
<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block> + ApiExt<Block>,
RA: Sync + Send,
Source§fn check_block<'life0, 'async_trait>(
&'life0 self,
block: BlockCheckParams<Block>,
) -> Pin<Box<dyn Future<Output = Result<ImportResult, Self::Error>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn check_block<'life0, 'async_trait>(
&'life0 self,
block: BlockCheckParams<Block>,
) -> Pin<Box<dyn Future<Output = Result<ImportResult, Self::Error>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Source§fn import_block<'life0, 'async_trait>(
&'life0 self,
import_block: BlockImportParams<Block>,
) -> Pin<Box<dyn Future<Output = Result<ImportResult, Self::Error>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn import_block<'life0, 'async_trait>(
&'life0 self,
import_block: BlockImportParams<Block>,
) -> Pin<Box<dyn Future<Output = Result<ImportResult, Self::Error>> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
Source§impl<B, E, Block, RA> BlockchainEvents<Block> for Client<B, E, Block, RA>where
E: CallExecutor<Block>,
Block: BlockT,
impl<B, E, Block, RA> BlockchainEvents<Block> for Client<B, E, Block, RA>where
E: CallExecutor<Block>,
Block: BlockT,
Source§fn import_notification_stream(&self) -> ImportNotifications<Block>
fn import_notification_stream(&self) -> ImportNotifications<Block>
Get block import event stream.
Source§fn storage_changes_notification_stream(
&self,
filter_keys: Option<&[StorageKey]>,
child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>,
) -> Result<StorageEventStream<Block::Hash>>
fn storage_changes_notification_stream( &self, filter_keys: Option<&[StorageKey]>, child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>, ) -> Result<StorageEventStream<Block::Hash>>
Get storage changes event stream.
Source§fn every_import_notification_stream(&self) -> ImportNotifications<Block>
fn every_import_notification_stream(&self) -> ImportNotifications<Block>
Source§fn finality_notification_stream(&self) -> FinalityNotifications<Block>
fn finality_notification_stream(&self) -> FinalityNotifications<Block>
Source§impl<B, E, Block, RA> CallApiAt<Block> for Client<B, E, Block, RA>
impl<B, E, Block, RA> CallApiAt<Block> for Client<B, E, Block, RA>
Source§type StateBackend = <B as Backend<Block>>::State
type StateBackend = <B as Backend<Block>>::State
Source§fn call_api_at(
&self,
params: CallApiAtParams<'_, Block>,
) -> Result<Vec<u8>, ApiError>
fn call_api_at( &self, params: CallApiAtParams<'_, Block>, ) -> Result<Vec<u8>, ApiError>
Source§fn runtime_version_at(
&self,
hash: Block::Hash,
) -> Result<RuntimeVersion, ApiError>
fn runtime_version_at( &self, hash: Block::Hash, ) -> Result<RuntimeVersion, ApiError>
Source§fn state_at(&self, at: Block::Hash) -> Result<Self::StateBackend, ApiError>
fn state_at(&self, at: Block::Hash) -> Result<Self::StateBackend, ApiError>
at
the given block.Source§fn initialize_extensions(
&self,
at: Block::Hash,
extensions: &mut Extensions,
) -> Result<(), ApiError>
fn initialize_extensions( &self, at: Block::Hash, extensions: &mut Extensions, ) -> Result<(), ApiError>
extensions
for the given block at
by using the global extensions factory.Source§impl<BE, E, B, RA> Chain<B> for Client<BE, E, B, RA>
impl<BE, E, B, RA> Chain<B> for Client<BE, E, B, RA>
Source§fn block_status(
&self,
hash: B::Hash,
) -> Result<BlockStatus, Box<dyn Error + Send>>
fn block_status( &self, hash: B::Hash, ) -> Result<BlockStatus, Box<dyn Error + Send>>
Block::Hash
.Source§impl<B, E, Block, RA> ExecutorProvider<Block> for Client<B, E, Block, RA>
impl<B, E, Block, RA> ExecutorProvider<Block> for Client<B, E, Block, RA>
Source§impl<B, E, Block, RA> Finalizer<Block, B> for Client<B, E, Block, RA>
impl<B, E, Block, RA> Finalizer<Block, B> for Client<B, E, Block, RA>
Source§fn apply_finality(
&self,
operation: &mut ClientImportOperation<Block, B>,
hash: Block::Hash,
justification: Option<Justification>,
notify: bool,
) -> Result<()>
fn apply_finality( &self, operation: &mut ClientImportOperation<Block, B>, hash: Block::Hash, justification: Option<Justification>, notify: bool, ) -> Result<()>
Source§fn finalize_block(
&self,
hash: Block::Hash,
justification: Option<Justification>,
notify: bool,
) -> Result<()>
fn finalize_block( &self, hash: Block::Hash, justification: Option<Justification>, notify: bool, ) -> Result<()>
Source§impl<B, E, Block, RA> HeaderBackend<Block> for Client<B, E, Block, RA>
impl<B, E, Block, RA> HeaderBackend<Block> for Client<B, E, Block, RA>
Source§fn header(&self, hash: Block::Hash) -> Result<Option<Block::Header>>
fn header(&self, hash: Block::Hash) -> Result<Option<Block::Header>>
None
if block is not found.Source§fn number(
&self,
hash: Block::Hash,
) -> Result<Option<<<Block as BlockT>::Header as HeaderT>::Number>>
fn number( &self, hash: Block::Hash, ) -> Result<Option<<<Block as BlockT>::Header as HeaderT>::Number>>
None
if the header is not in the chain.Source§fn hash(&self, number: NumberFor<Block>) -> Result<Option<Block::Hash>>
fn hash(&self, number: NumberFor<Block>) -> Result<Option<Block::Hash>>
None
if the header is not in the chain.Source§fn block_hash_from_id(
&self,
id: &BlockId<Block>,
) -> Result<Option<<Block as Block>::Hash>, Error>
fn block_hash_from_id( &self, id: &BlockId<Block>, ) -> Result<Option<<Block as Block>::Hash>, Error>
Source§fn block_number_from_id(
&self,
id: &BlockId<Block>,
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
fn block_number_from_id( &self, id: &BlockId<Block>, ) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
Source§fn expect_header(
&self,
hash: <Block as Block>::Hash,
) -> Result<<Block as Block>::Header, Error>
fn expect_header( &self, hash: <Block as Block>::Hash, ) -> Result<<Block as Block>::Header, Error>
UnknownBlock
error if block is not found.Source§impl<B, E, Block, RA> HeaderMetadata<Block> for Client<B, E, Block, RA>
impl<B, E, Block, RA> HeaderMetadata<Block> for Client<B, E, Block, RA>
fn header_metadata( &self, hash: Block::Hash, ) -> Result<CachedHeaderMetadata<Block>, Self::Error>
fn insert_header_metadata( &self, hash: Block::Hash, metadata: CachedHeaderMetadata<Block>, )
fn remove_header_metadata(&self, hash: Block::Hash)
Source§impl<BE, E, B, RA> IndexedBody<B> for Client<BE, E, B, RA>
impl<BE, E, B, RA> IndexedBody<B> for Client<BE, E, B, RA>
Source§impl<B, E, Block, RA> LockImportRun<Block, B> for Client<B, E, Block, RA>
impl<B, E, Block, RA> LockImportRun<Block, B> for Client<B, E, Block, RA>
Source§fn lock_import_and_run<R, Err, F>(&self, f: F) -> Result<R, Err>
fn lock_import_and_run<R, Err, F>(&self, f: F) -> Result<R, Err>
Source§impl<B, E, Block, RA> PreCommitActions<Block> for Client<B, E, Block, RA>where
Block: BlockT,
impl<B, E, Block, RA> PreCommitActions<Block> for Client<B, E, Block, RA>where
Block: BlockT,
Source§fn register_import_action(&self, action: OnImportAction<Block>)
fn register_import_action(&self, action: OnImportAction<Block>)
Source§fn register_finality_action(&self, action: OnFinalityAction<Block>)
fn register_finality_action(&self, action: OnFinalityAction<Block>)
Source§impl<B, E, Block, RA> ProofProvider<Block> for Client<B, E, Block, RA>
impl<B, E, Block, RA> ProofProvider<Block> for Client<B, E, Block, RA>
Source§fn read_proof(
&self,
hash: Block::Hash,
keys: &mut dyn Iterator<Item = &[u8]>,
) -> Result<StorageProof>
fn read_proof( &self, hash: Block::Hash, keys: &mut dyn Iterator<Item = &[u8]>, ) -> Result<StorageProof>
Source§fn read_child_proof(
&self,
hash: Block::Hash,
child_info: &ChildInfo,
keys: &mut dyn Iterator<Item = &[u8]>,
) -> Result<StorageProof>
fn read_child_proof( &self, hash: Block::Hash, child_info: &ChildInfo, keys: &mut dyn Iterator<Item = &[u8]>, ) -> Result<StorageProof>
Source§fn execution_proof(
&self,
hash: Block::Hash,
method: &str,
call_data: &[u8],
) -> Result<(Vec<u8>, StorageProof)>
fn execution_proof( &self, hash: Block::Hash, method: &str, call_data: &[u8], ) -> Result<(Vec<u8>, StorageProof)>
Source§fn read_proof_collection(
&self,
hash: Block::Hash,
start_key: &[Vec<u8>],
size_limit: usize,
) -> Result<(CompactProof, u32)>
fn read_proof_collection( &self, hash: Block::Hash, start_key: &[Vec<u8>], size_limit: usize, ) -> Result<(CompactProof, u32)>
Hash
iterate over all storage values starting at start_keys
.
Last start_keys
element contains last accessed key value.
With multiple start_keys
, first start_keys
element is
the current storage key of of the last accessed child trie.
at last level the value to start at exclusively.
Proofs is build until size limit is reached and always include at
least one key following start_keys
.
Returns combined proof and the numbers of collected keys.Source§fn storage_collection(
&self,
hash: Block::Hash,
start_key: &[Vec<u8>],
size_limit: usize,
) -> Result<Vec<(KeyValueStorageLevel, bool)>>
fn storage_collection( &self, hash: Block::Hash, start_key: &[Vec<u8>], size_limit: usize, ) -> Result<Vec<(KeyValueStorageLevel, bool)>>
Hash
iterate over all storage values starting at start_key
.
Returns collected keys and values.
Returns the collected keys values content of the top trie followed by the
collected keys values of child tries.
Only child tries with their root part of the collected content or
related to start_key
are attached.
For each collected state a boolean indicates if state reach
end.Source§fn verify_range_proof(
&self,
root: Block::Hash,
proof: CompactProof,
start_key: &[Vec<u8>],
) -> Result<(KeyValueStates, usize)>
fn verify_range_proof( &self, root: Block::Hash, proof: CompactProof, start_key: &[Vec<u8>], ) -> Result<(KeyValueStates, usize)>
Source§impl<B, E, Block, RA> ProvideRuntimeApi<Block> for Client<B, E, Block, RA>where
B: Backend<Block>,
E: CallExecutor<Block, Backend = B> + Send + Sync,
Block: BlockT,
RA: ConstructRuntimeApi<Block, Self> + Send + Sync,
impl<B, E, Block, RA> ProvideRuntimeApi<Block> for Client<B, E, Block, RA>where
B: Backend<Block>,
E: CallExecutor<Block, Backend = B> + Send + Sync,
Block: BlockT,
RA: ConstructRuntimeApi<Block, Self> + Send + Sync,
Source§type Api = <RA as ConstructRuntimeApi<Block, Client<B, E, Block, RA>>>::RuntimeApi
type Api = <RA as ConstructRuntimeApi<Block, Client<B, E, Block, RA>>>::RuntimeApi
Source§fn runtime_api(&self) -> ApiRef<'_, Self::Api>
fn runtime_api(&self) -> ApiRef<'_, Self::Api>
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
.Source§impl<B, E, Block, RA> ProvideUncles<Block> for Client<B, E, Block, RA>
impl<B, E, Block, RA> ProvideUncles<Block> for Client<B, E, Block, RA>
Source§impl<B, E, Block, RA> StorageProvider<Block, B> for Client<B, E, Block, RA>
impl<B, E, Block, RA> StorageProvider<Block, B> for Client<B, E, Block, RA>
Source§fn storage_keys(
&self,
hash: <Block as BlockT>::Hash,
prefix: Option<&StorageKey>,
start_key: Option<&StorageKey>,
) -> Result<KeysIter<B::State, Block>>
fn storage_keys( &self, hash: <Block as BlockT>::Hash, prefix: Option<&StorageKey>, start_key: Option<&StorageKey>, ) -> Result<KeysIter<B::State, Block>>
Hash
and a key prefix, returns a KeysIter
iterates matching storage
keys in that block.Source§fn child_storage_keys(
&self,
hash: <Block as BlockT>::Hash,
child_info: ChildInfo,
prefix: Option<&StorageKey>,
start_key: Option<&StorageKey>,
) -> Result<KeysIter<B::State, Block>>
fn child_storage_keys( &self, hash: <Block as BlockT>::Hash, child_info: ChildInfo, prefix: Option<&StorageKey>, start_key: Option<&StorageKey>, ) -> Result<KeysIter<B::State, Block>>
Hash
and a key prefix
and a child storage key,
returns a KeysIter
that iterates matching storage keys in that block.Source§fn storage_pairs(
&self,
hash: <Block as BlockT>::Hash,
prefix: Option<&StorageKey>,
start_key: Option<&StorageKey>,
) -> Result<PairsIter<B::State, Block>>
fn storage_pairs( &self, hash: <Block as BlockT>::Hash, prefix: Option<&StorageKey>, start_key: Option<&StorageKey>, ) -> Result<PairsIter<B::State, Block>>
Hash
and a key prefix, returns an iterator over the storage keys and
values in that block.Source§fn storage(
&self,
hash: Block::Hash,
key: &StorageKey,
) -> Result<Option<StorageData>>
fn storage( &self, hash: Block::Hash, key: &StorageKey, ) -> Result<Option<StorageData>>
Hash
and a key, return the value under the key in that block.Source§fn storage_hash(
&self,
hash: <Block as BlockT>::Hash,
key: &StorageKey,
) -> Result<Option<Block::Hash>>
fn storage_hash( &self, hash: <Block as BlockT>::Hash, key: &StorageKey, ) -> Result<Option<Block::Hash>>
Hash
and a key, return the value under the hash in that block.Source§fn child_storage(
&self,
hash: <Block as BlockT>::Hash,
child_info: &ChildInfo,
key: &StorageKey,
) -> Result<Option<StorageData>>
fn child_storage( &self, hash: <Block as BlockT>::Hash, child_info: &ChildInfo, key: &StorageKey, ) -> Result<Option<StorageData>>
Hash
, a key and a child storage key, return the value under the key in
that block.Source§fn child_storage_hash(
&self,
hash: <Block as BlockT>::Hash,
child_info: &ChildInfo,
key: &StorageKey,
) -> Result<Option<Block::Hash>>
fn child_storage_hash( &self, hash: <Block as BlockT>::Hash, child_info: &ChildInfo, key: &StorageKey, ) -> Result<Option<Block::Hash>>
Hash
, a key and a child storage key, return the hash under the key in that
block.Source§fn closest_merkle_value(
&self,
hash: <Block as BlockT>::Hash,
key: &StorageKey,
) -> Result<Option<MerkleValue<<Block as BlockT>::Hash>>>
fn closest_merkle_value( &self, hash: <Block as BlockT>::Hash, key: &StorageKey, ) -> Result<Option<MerkleValue<<Block as BlockT>::Hash>>>
Hash
and a key, return the closest merkle value.Source§impl<B, E, Block, RA> UsageProvider<Block> for Client<B, E, Block, RA>
impl<B, E, Block, RA> UsageProvider<Block> for Client<B, E, Block, RA>
Source§fn usage_info(&self) -> ClientInfo<Block>
fn usage_info(&self) -> ClientInfo<Block>
Get usage info about current client.