Struct cumulus_relay_chain_rpc_interface::RelayChainRpcInterface

pub struct RelayChainRpcInterface { /* private fields */ }

RelayChainRpcInterface is used to interact with a full node that is running locally in the same process.

Implementations

impl RelayChainRpcInterface

pub fn new(rpc_client: RelayChainRpcClient) -> Self

Trait Implementations

impl Clone for RelayChainRpcInterface

fn clone(&self) -> RelayChainRpcInterface

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl RelayChainInterface for RelayChainRpcInterface

fn wait_for_block<'life0, 'async_trait>(
    &'life0 self,
    wait_for_hash: PHash
) -> Pin<Box<dyn Future<Output = RelayChainResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Wait for a given relay chain block

The hash of the block to wait for is passed. We wait for the block to arrive or return after a timeout.

Implementation:

1. Register a listener to all new blocks.
2. Check if the block is already in chain. If yes, succeed early.
3. Wait for the block to be imported via subscription.
4. If timeout is reached, we return an error.

fn retrieve_dmq_contents<'life0, 'async_trait>(
    &'life0 self,
    para_id: ParaId,
    relay_parent: PHash
) -> Pin<Box<dyn Future<Output = RelayChainResult<Vec<InboundDownwardMessage>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Returns the whole contents of the downward message queue for the parachain we are collating for.

fn retrieve_all_inbound_hrmp_channel_contents<'life0, 'async_trait>(
    &'life0 self,
    para_id: ParaId,
    relay_parent: PHash
) -> Pin<Box<dyn Future<Output = RelayChainResult<BTreeMap<ParaId, Vec<InboundHrmpMessage>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Returns channels contents for each inbound HRMP channel addressed to the parachain we are collating for.

fn persisted_validation_data<'life0, 'async_trait>(
    &'life0 self,
    hash: PHash,
    para_id: ParaId,
    occupied_core_assumption: OccupiedCoreAssumption
) -> Pin<Box<dyn Future<Output = RelayChainResult<Option<PersistedValidationData>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Yields the persisted validation data for the given ParaId along with an assumption that should be used if the para currently occupies a core.

fn candidate_pending_availability<'life0, 'async_trait>(
    &'life0 self,
    hash: PHash,
    para_id: ParaId
) -> Pin<Box<dyn Future<Output = RelayChainResult<Option<CommittedCandidateReceipt>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Get the receipt of a candidate pending availability. This returns Some for any paras assigned to occupied cores in availability_cores and None otherwise.

fn session_index_for_child<'life0, 'async_trait>(
    &'life0 self,
    hash: PHash
) -> Pin<Box<dyn Future<Output = RelayChainResult<SessionIndex>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Returns the session index expected at a child of the block.

fn validators<'life0, 'async_trait>(
    &'life0 self,
    block_id: PHash
) -> Pin<Box<dyn Future<Output = RelayChainResult<Vec<ValidatorId>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Fetch a vector of current validators.

fn import_notification_stream<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = RelayChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Get a stream of import block notifications.

fn finality_notification_stream<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = RelayChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Get a stream of finality notifications.

fn best_block_hash<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = RelayChainResult<PHash>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Get the hash of the current best block.

fn is_major_syncing<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = RelayChainResult<bool>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Whether the synchronization service is undergoing major sync. Returns true if so.

fn overseer_handle(&self) -> RelayChainResult<Option<Handle>>

Get a handle to the overseer.

fn get_storage_by_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    relay_parent: PHash,
    key: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = RelayChainResult<Option<StorageValue>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Fetch a storage item by key.

fn prove_read<'life0, 'life1, 'async_trait>(
    &'life0 self,
    relay_parent: PHash,
    relevant_keys: &'life1 Vec<Vec<u8>>
) -> Pin<Box<dyn Future<Output = RelayChainResult<StorageProof>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Generate a storage read proof.

fn new_best_notification_stream<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = RelayChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Get a stream of new best block notifications.