Struct cumulus_relay_chain_inprocess_interface::RelayChainInProcessInterface

pub struct RelayChainInProcessInterface { /* private fields */ }

Provides an implementation of the [RelayChainInterface] using a local in-process relay chain node.

Implementations

impl RelayChainInProcessInterface

pub fn new( full_client: Arc<FullClient>, backend: Arc<FullBackend>, sync_oracle: Arc<dyn SyncOracle + Send + Sync>, overseer_handle: Handle, ) -> Self

Create a new instance of RelayChainInProcessInterface

Trait Implementations

impl Clone for RelayChainInProcessInterface

fn clone(&self) -> RelayChainInProcessInterface

Returns a copy of the value.

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

Performs copy-assignment from source.

impl RelayChainInterface for RelayChainInProcessInterface

fn wait_for_block<'life0, 'async_trait>( &'life0 self, 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 in an async way.

The caller needs to pass the hash of a block it waits for and the function will return when the block is available or an error occurred.

The waiting for the block is implemented as follows:

1. Get a read lock on the import lock from the backend.

2. Check if the block is already imported. If yes, return from the function.

3. If the block isn’t imported yet, add an import notification listener.

4. Poll the import notification listener until the block is imported or the timeout is fired.

The timeout is set to 6 seconds. This should be enough time to import the block in the current round and if not, the new round of the relay chain already started anyway.

fn version<'life0, 'async_trait>( &'life0 self, relay_parent: PHash, ) -> Pin<Box<dyn Future<Output = RelayChainResult<RuntimeVersion>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the runtime version of the relay chain.

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 header<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = RelayChainResult<Option<PHeader>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetch the block header of a given hash or height, if it exists.

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 validation_code_hash<'life0, 'async_trait>( &'life0 self, hash: PHash, para_id: ParaId, occupied_core_assumption: OccupiedCoreAssumption, ) -> Pin<Box<dyn Future<Output = RelayChainResult<Option<ValidationCodeHash>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the validation code hash for the given para_id using the given occupied_core_assumption.

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,

👎Deprecated: candidate_pending_availability only returns one candidate and is deprecated. Use candidates_pending_availability instead.

Get the receipt of the first candidate pending availability of this para_id. 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, hash: 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 finalized_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 finalized block.

fn call_runtime_api<'life0, 'life1, 'async_trait>( &'life0 self, method_name: &'static str, hash: PHash, payload: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = RelayChainResult<Vec<u8>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Call an arbitrary runtime api. The input and output are SCALE-encoded.

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

fn availability_cores<'life0, 'async_trait>( &'life0 self, relay_parent: PHash, ) -> Pin<Box<dyn Future<Output = RelayChainResult<Vec<CoreState<PHash, BlockNumber>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Yields information on all availability cores as relevant to the child block.

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

where Self: 'async_trait, 'life0: 'async_trait,

Get the receipts of all candidates pending availability for this para_id.

fn claim_queue<'life0, 'async_trait>( &'life0 self, hash: PHash, ) -> Pin<Box<dyn Future<Output = RelayChainResult<BTreeMap<CoreIndex, VecDeque<ParaId>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetch the claim queue.