referrerpolicy=no-referrer-when-downgrade

Struct cumulus_test_client::client::Client

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

Substrate Client

Implementations§

§

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

pub fn new<G>( backend: Arc<B>, executor: E, spawn_handle: Box<dyn SpawnNamed>, genesis_block_builder: G, fork_blocks: Option<Vec<(<<Block as Block>::Header as Header>::Number, <Block as Block>::Hash)>>, bad_blocks: Option<HashSet<<Block as Block>::Hash>>, prometheus_registry: Option<Registry>, telemetry: Option<TelemetryHandle>, config: ClientConfig<Block>, ) -> Result<Client<B, E, Block, RA>, Error>
where G: BuildGenesisBlock<Block, BlockImportOperation = <B as Backend<Block>>::BlockImportOperation>, E: Clone, B: 'static,

Creates new Substrate Client with given blockchain and code executor.

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

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>>>>

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

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

Get a reference to the state at a given block.

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

Get the code at a given block.

This takes any potential substitutes into account, but ignores overrides.

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

Get the RuntimeVersion at a given block.

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, hash: <Block as Block>::Hash, ) -> Result<BlockStatus, Error>

Get block status.

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

Get block header by id.

pub fn body( &self, hash: <Block as Block>::Hash, ) -> Result<Option<Vec<<Block as Block>::Extrinsic>>, 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>, 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 B: Backend<Block>, E: CallExecutor<Block>, Block: Block, Client<B, E, Block, RA>: ProvideRuntimeApi<Block>, <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,

§

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. Read more
§

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

Query auxiliary data from key-value store.
§

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

§

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.

§

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

Query auxiliary data from key-value store.

§

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

§

fn block_body( &self, hash: <Block as Block>::Hash, ) -> Result<Option<Vec<<Block as Block>::Extrinsic>>, Error>

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

fn block( &self, hash: <Block as Block>::Hash, ) -> Result<Option<SignedBlock<Block>>, Error>

Get full block by hash.
§

fn block_status( &self, hash: <Block as Block>::Hash, ) -> Result<BlockStatus, Error>

Get block status by block hash.
§

fn justifications( &self, hash: <Block as Block>::Hash, ) -> Result<Option<Justifications>, Error>

Get block justifications for the block with the given hash.
§

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

Get block hash by number.
§

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

Get single indexed transaction by content hash. Read more
§

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

Check if transaction index exists.
§

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

Get all indexed transactions for a block, including renewed transactions. Read more
§

fn requires_full_sync(&self) -> bool

Tells whether the current client configuration requires full-sync mode.
§

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

§

type Error = Error

The error type that will be returned by the functions.
§

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.
§

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<B, E, Block, RA> BlockImport<Block> for &Client<B, E, Block, RA>
where B: Backend<Block>, E: CallExecutor<Block> + Send + Sync, Block: Block, Client<B, E, Block, RA>: ProvideRuntimeApi<Block>, <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block> + ApiExt<Block>, RA: Sync + Send,

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.

§

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

Import a checked and validated block.

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.

§

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

Check block preconditions.

§

type Error = Error

The error type.
§

impl<B, E, Block, RA> BlockImport<Block> for Client<B, E, Block, RA>
where B: Backend<Block>, E: CallExecutor<Block> + Send + Sync, Block: Block, Client<B, E, Block, RA>: ProvideRuntimeApi<Block>, <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block> + ApiExt<Block>, RA: Sync + Send,

§

type Error = Error

The error type.
§

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

Check block preconditions.
§

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

Import a block.
§

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

§

type Type = Block

The type of the block.
§

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

§

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

Get block import event stream.

§

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

Get storage changes event stream.

§

fn every_import_notification_stream( &self, ) -> TracingUnboundedReceiver<BlockImportNotification<Block>>

Get a stream of every imported block.
§

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 B: Backend<Block>, E: CallExecutor<Block, Backend = B> + Send + Sync, Block: Block, RA: Send + Sync,

§

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

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

fn call_api_at( &self, params: CallApiAtParams<'_, Block>, ) -> Result<Vec<u8>, ApiError>

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

fn runtime_version_at( &self, hash: <Block as Block>::Hash, ) -> Result<RuntimeVersion, ApiError>

Returns the runtime version at the given block.
§

fn state_at( &self, at: <Block as Block>::Hash, ) -> Result<<Client<B, E, Block, RA> as CallApiAt<Block>>::StateBackend, ApiError>

Get the state at the given block.
§

fn initialize_extensions( &self, at: <Block as Block>::Hash, extensions: &mut Extensions, ) -> Result<(), ApiError>

Initialize the extensions for the given block at by using the global extensions factory.
§

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

§

fn block_status( &self, hash: <B as Block>::Hash, ) -> Result<BlockStatus, Box<dyn Error + Send>>

Retrieve the status of the block denoted by the given Block::Hash.
§

impl<B, E, RA, Block> ClientBlockImportExt<Block> for Client<B, E, Block, RA>
where Block: Block, Client<B, E, Block, RA>: BlockImport<Block, Error = Error>, RA: Send + Sync, B: Send + Sync, E: Send + Sync,

§

fn import<'life0, 'async_trait>( &'life0 self, origin: BlockOrigin, block: Block, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, Client<B, E, Block, RA>: 'async_trait,

Import block to the chain. No finality.
§

fn import_as_best<'life0, 'async_trait>( &'life0 self, origin: BlockOrigin, block: Block, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, Client<B, E, Block, RA>: 'async_trait,

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

fn import_as_final<'life0, 'async_trait>( &'life0 self, origin: BlockOrigin, block: Block, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, Client<B, E, Block, RA>: 'async_trait,

Import a block and finalize it.
§

fn import_justified<'life0, 'async_trait>( &'life0 self, origin: BlockOrigin, block: Block, justifications: Justifications, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, Client<B, E, Block, RA>: '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> + RuntimeVersionOf + 'static, Client<B, E, Block, RA>: BlockImport<Block, Error = Error>, Block: Block,

§

fn finalize_block( &self, hash: <Block as Block>::Hash, justification: Option<([u8; 4], Vec<u8>)>, ) -> Result<(), Error>

Finalize a block.
§

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

Returns hash of the genesis block.
§

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

§

type Executor = E

executor instance
§

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

Get call executor reference.
§

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 B: Backend<Block>, E: CallExecutor<Block>, Block: Block,

§

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

Mark all blocks up to given as finalized in operation. Read more
§

fn finalize_block( &self, hash: <Block as Block>::Hash, justification: Option<([u8; 4], Vec<u8>)>, notify: bool, ) -> Result<(), Error>

Finalize a block. Read more
§

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

§

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

Mark all blocks up to given as finalized in operation. Read more
§

fn finalize_block( &self, hash: <Block as Block>::Hash, justification: Option<([u8; 4], Vec<u8>)>, notify: bool, ) -> Result<(), Error>

Finalize a block. Read more
§

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

§

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

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

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

Get blockchain info.
§

fn status(&self, hash: <Block as Block>::Hash) -> Result<BlockStatus, Error>

Get block status.
§

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.
§

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.
source§

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.
source§

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.
source§

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

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

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.
source§

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 B: Backend<Block>, E: CallExecutor<Block> + Send + Sync, Block: Block, RA: Send + Sync,

§

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

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

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

Get blockchain info.
§

fn status(&self, hash: <Block as Block>::Hash) -> Result<BlockStatus, Error>

Get block status.
§

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.
§

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.
source§

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.
source§

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.
source§

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

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

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.
source§

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 B: Backend<Block>, E: CallExecutor<Block>, Block: Block,

§

type Error = Error

Error used in case the header metadata is not found.
§

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

§

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

§

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

§

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

§

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

Get all indexed transactions for a block, including renewed transactions. Read more
§

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, B: Backend<Block>, E: CallExecutor<Block>,

§

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

Lock the import lock, and run operations inside.
§

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

§

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

Lock the import lock, and run operations inside.
§

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

§

fn register_import_action( &self, action: Box<dyn Fn(&BlockImportNotification<Block>) -> Vec<(Vec<u8>, Option<Vec<u8>>)> + Send>, )

Actions to be performed on block import.
§

fn register_finality_action( &self, action: Box<dyn Fn(&FinalityNotification<Block>) -> Vec<(Vec<u8>, Option<Vec<u8>>)> + Send>, )

Actions to be performed on block finalization.
§

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

§

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

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

fn read_child_proof( &self, hash: <Block as Block>::Hash, 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.
§

fn execution_proof( &self, hash: <Block as Block>::Hash, method: &str, call_data: &[u8], ) -> Result<(Vec<u8>, StorageProof), Error>

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

fn read_proof_collection( &self, hash: <Block as Block>::Hash, start_key: &[Vec<u8>], size_limit: usize, ) -> Result<(CompactProof, u32), Error>

Given a 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.
§

fn storage_collection( &self, hash: <Block as Block>::Hash, start_key: &[Vec<u8>], size_limit: usize, ) -> Result<Vec<(KeyValueStorageLevel, bool)>, Error>

Given a 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.
§

fn verify_range_proof( &self, root: <Block as Block>::Hash, proof: CompactProof, start_key: &[Vec<u8>], ) -> Result<(KeyValueStates, usize), Error>

Verify read storage proof for a set of keys. Returns collected key-value pairs and a the nested state depth of current iteration or 0 if completed.
§

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: Block, RA: ConstructRuntimeApi<Block, Client<B, E, Block, RA>> + Send + Sync,

§

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

The concrete type that provides the api.
§

fn runtime_api( &self, ) -> ApiRef<'_, <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 B: Backend<Block>, E: CallExecutor<Block>, Block: Block,

§

fn uncles( &self, target_hash: <Block as Block>::Hash, max_generation: <<Block as Block>::Header as Header>::Number, ) -> Result<Vec<<Block as Block>::Header>, 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 B: Backend<Block>, E: CallExecutor<Block>, Block: Block,

§

fn storage_keys( &self, hash: <Block as Block>::Hash, prefix: Option<&StorageKey>, start_key: Option<&StorageKey>, ) -> Result<KeysIter<<B as Backend<Block>>::State, Block>, Error>

Given a block’s Hash and a key prefix, returns a KeysIter iterates matching storage keys in that block.
§

fn child_storage_keys( &self, hash: <Block as Block>::Hash, child_info: ChildInfo, prefix: Option<&StorageKey>, start_key: Option<&StorageKey>, ) -> Result<KeysIter<<B as Backend<Block>>::State, Block>, Error>

Given a block’s Hash and a key prefix and a child storage key, returns a KeysIter that iterates matching storage keys in that block.
§

fn storage_pairs( &self, hash: <Block as Block>::Hash, prefix: Option<&StorageKey>, start_key: Option<&StorageKey>, ) -> Result<PairsIter<<B as Backend<Block>>::State, Block>, Error>

Given a block’s Hash and a key prefix, returns an iterator over the storage keys and values in that block.
§

fn storage( &self, hash: <Block as Block>::Hash, key: &StorageKey, ) -> Result<Option<StorageData>, Error>

Given a block’s Hash and a key, return the value under the key in that block.
§

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

Given a block’s Hash and a key, return the value under the hash in that block.
§

fn child_storage( &self, hash: <Block as Block>::Hash, child_info: &ChildInfo, key: &StorageKey, ) -> Result<Option<StorageData>, Error>

Given a block’s Hash, a key and a child storage key, return the value under the key in that block.
§

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

Given a block’s Hash, a key and a child storage key, return the hash under the key in that block.
§

fn closest_merkle_value( &self, hash: <Block as Block>::Hash, key: &StorageKey, ) -> Result<Option<MerkleValue<<Block as Block>::Hash>>, Error>

Given a block’s Hash and a key, return the closest merkle value.
§

fn child_closest_merkle_value( &self, hash: <Block as Block>::Hash, child_info: &ChildInfo, key: &StorageKey, ) -> Result<Option<MerkleValue<<Block as Block>::Hash>>, Error>

Given a block’s Hash, a key and a child storage key, return the closest merkle value.
§

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

§

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

Get usage info about current client.

Auto Trait Implementations§

§

impl<B, E, Block, RA> !Freeze for Client<B, E, Block, RA>

§

impl<B, E, Block, RA> !RefUnwindSafe for Client<B, E, Block, RA>

§

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

§

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

§

impl<B, E, Block, RA> Unpin for Client<B, E, Block, RA>
where E: Unpin, RA: Unpin, <Block as Block>::Hash: Unpin, <<Block as Block>::Header as Header>::Number: Unpin,

§

impl<B, E, Block, RA> !UnwindSafe for Client<B, E, Block, RA>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> Any for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

§

fn type_name(&self) -> &'static str

§

impl<T> AnySync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

§

impl<C, B> BlockchainEventsExt<C, B> for C
where C: BlockchainEvents<B>, B: Block,

§

fn wait_for_blocks( &self, count: usize, ) -> Pin<Box<dyn Future<Output = ()> + Send>>

Wait for count blocks to be imported in the node and then exit. This function will not return if no blocks are ever created, thus you should restrict the maximum amount of time of the test execution.
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> ChainApiBackend for T
where T: HeaderBackend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>,

source§

fn header<'life0, 'async_trait>( &'life0 self, hash: H256, ) -> Pin<Box<dyn Future<Output = Result<Option<Header<u32, BlakeTwo256>>, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

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

source§

fn info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Info<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

Get blockchain info.

source§

fn number<'life0, 'async_trait>( &'life0 self, hash: H256, ) -> Pin<Box<dyn Future<Output = Result<Option<<Header<u32, BlakeTwo256> as Header>::Number>, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

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

source§

fn hash<'life0, 'async_trait>( &'life0 self, number: <<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic> as Block>::Header as Header>::Number, ) -> Pin<Box<dyn Future<Output = Result<Option<H256>, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

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

source§

impl<T> CheckedConversion for T

source§

fn checked_from<T>(t: T) -> Option<Self>
where Self: TryFrom<T>,

Convert from a value of T into an equivalent instance of Option<Self>. Read more
source§

fn checked_into<T>(self) -> Option<T>
where Self: TryInto<T>,

Consume self to return Some equivalent value of Option<T>. Read more
source§

impl<T> CheckedConversion for T

source§

fn checked_from<T>(t: T) -> Option<Self>
where Self: TryFrom<T>,

Convert from a value of T into an equivalent instance of Option<Self>. Read more
source§

fn checked_into<T>(self) -> Option<T>
where Self: TryInto<T>,

Consume self to return Some equivalent value of Option<T>. Read more
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
source§

impl<Block, T> ForkBackend<Block> for T
where Block: Block, T: HeaderMetadata<Block> + HeaderBackend<Block> + Send + Sync,

source§

fn expand_forks( &self, fork_heads: &[<Block as Block>::Hash], ) -> Result<BTreeSet<<Block as Block>::Hash>, Error>

Returns block hashes for provided fork heads. It skips the fork if when blocks are missing (e.g. warp-sync) and internal tree_route function fails. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<Block, T> HeaderProvider<Block> for T
where Block: Block, T: HeaderBackend<Block> + 'static,

§

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

Obtain the header for a hash.
§

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

Obtain the block number for a hash.
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<T, U> IntoKey<U> for T
where U: FromKey<T>,

source§

fn into_key(self) -> U

§

impl<Src, Dest> IntoTuple<Dest> for Src
where Dest: FromTuple<Src>,

§

fn into_tuple(self) -> Dest

source§

impl<T> IsType<T> for T

source§

fn from_ref(t: &T) -> &T

Cast reference.
source§

fn into_ref(&self) -> &T

Cast reference.
source§

fn from_mut(t: &mut T) -> &mut T

Cast mutable reference.
source§

fn into_mut(&mut self) -> &mut T

Cast mutable reference.
source§

impl<T, Outer> IsWrappedBy<Outer> for T
where Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

source§

fn from_ref(outer: &Outer) -> &T

Get a reference to the inner from the outer.

source§

fn from_mut(outer: &mut Outer) -> &mut T

Get a mutable reference to the inner from the outer.

source§

impl<T, Outer> IsWrappedBy<Outer> for T
where Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

source§

fn from_ref(outer: &Outer) -> &T

Get a reference to the inner from the outer.

source§

fn from_mut(outer: &mut Outer) -> &mut T

Get a mutable reference to the inner from the outer.

§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> SaturatedConversion for T

source§

fn saturated_from<T>(t: T) -> Self
where Self: UniqueSaturatedFrom<T>,

Convert from a value of T into an equivalent instance of Self. Read more
source§

fn saturated_into<T>(self) -> T
where Self: UniqueSaturatedInto<T>,

Consume self to return an equivalent value of T. Read more
source§

impl<T> SaturatedConversion for T

source§

fn saturated_from<T>(t: T) -> Self
where Self: UniqueSaturatedFrom<T>,

Convert from a value of T into an equivalent instance of Self. Read more
source§

fn saturated_into<T>(self) -> T
where Self: UniqueSaturatedInto<T>,

Consume self to return an equivalent value of T. Read more
§

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T, U> TryIntoKey<U> for T
where U: TryFromKey<T>,

§

type Error = <U as TryFromKey<T>>::Error

source§

fn try_into_key(self) -> Result<U, <U as TryFromKey<T>>::Error>

source§

impl<S, T> UncheckedInto<T> for S
where T: UncheckedFrom<S>,

source§

fn unchecked_into(self) -> T

The counterpart to unchecked_from.
source§

impl<S, T> UncheckedInto<T> for S
where T: UncheckedFrom<S>,

source§

fn unchecked_into(self) -> T

The counterpart to unchecked_from.
source§

impl<T, S> UniqueSaturatedInto<T> for S
where T: Bounded, S: TryInto<T>,

source§

fn unique_saturated_into(self) -> T

Consume self to return an equivalent value of T.
source§

impl<T, S> UniqueSaturatedInto<T> for S
where T: Bounded, S: TryInto<T>,

source§

fn unique_saturated_into(self) -> T

Consume self to return an equivalent value of T.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<B, BE, T> Client<B, BE> for T
where B: Block, BE: Backend<B>, T: BlockchainEvents<B> + HeaderBackend<B> + Finalizer<B, BE> + ProvideRuntimeApi<B> + Send + Sync,

source§

impl<Block, BE, T> ClientForGrandpa<Block, BE> for T
where BE: Backend<Block>, Block: Block, T: LockImportRun<Block, BE> + Finalizer<Block, BE> + AuxStore + HeaderMetadata<Block, Error = Error> + HeaderBackend<Block> + BlockchainEvents<Block> + ProvideRuntimeApi<Block> + ExecutorProvider<Block> + BlockImport<Block, Error = Error> + StorageProvider<Block, BE>,

§

impl<T> JsonSchemaMaybe for T

§

impl<T> MaybeSend for T
where T: Send,