Struct cumulus_relay_chain_rpc_interface::RelayChainRpcClient

pub struct RelayChainRpcClient { /* private fields */ }

Client that maps RPC methods and deserializes results

Implementations

impl RelayChainRpcClient

pub async fn call_remote_runtime_function_encoded( &self, method_name: &str, hash: RelayHash, payload: &[u8], ) -> RelayChainResult<Bytes>

Same as call_remote_runtime_function but work on encoded data

pub async fn call_remote_runtime_function<R: Decode>( &self, method_name: &str, hash: RelayHash, payload: Option<impl Encode>, ) -> RelayChainResult<R>

Call a call to state_call rpc method.

pub async fn babe_api_current_epoch( &self, at: RelayHash, ) -> Result<Epoch, RelayChainError>

Returns information regarding the current epoch.

pub async fn parachain_host_on_chain_votes( &self, at: RelayHash, ) -> Result<Option<ScrapedOnChainVotes<RelayHash>>, RelayChainError>

Scrape dispute relevant from on-chain, backing votes and resolved disputes.

pub async fn parachain_host_pvfs_require_precheck( &self, at: RelayHash, ) -> Result<Vec<ValidationCodeHash>, RelayChainError>

Returns code hashes of PVFs that require pre-checking by validators in the active set.

pub async fn parachain_host_submit_pvf_check_statement( &self, at: RelayHash, stmt: PvfCheckStatement, signature: ValidatorSignature, ) -> Result<(), RelayChainError>

Submits a PVF pre-checking statement into the transaction pool.

pub async fn system_health(&self) -> Result<Health, RelayChainError>

Get system health information

pub async fn state_get_read_proof( &self, storage_keys: Vec<StorageKey>, at: Option<RelayHash>, ) -> Result<ReadProof<RelayHash>, RelayChainError>

Get read proof for storage_keys

pub async fn state_get_storage( &self, storage_key: StorageKey, at: Option<RelayHash>, ) -> Result<Option<StorageData>, RelayChainError>

Retrieve storage item at storage_key

pub async fn chain_get_head( &self, at: Option<u64>, ) -> Result<RelayHash, RelayChainError>

Get hash of the n-th block in the canon chain.

By default returns latest block hash.

pub async fn parachain_host_validator_groups( &self, at: RelayHash, ) -> Result<(Vec<Vec<ValidatorIndex>>, GroupRotationInfo), RelayChainError>

Returns the validator groups and rotation info localized based on the hypothetical child of a block whose state this is invoked on. Note that now in the GroupRotationInfo should be the successor of the number of the block.

pub async fn parachain_host_candidate_events( &self, at: RelayHash, ) -> Result<Vec<CandidateEvent>, RelayChainError>

Get a vector of events concerning candidates that occurred within a block.

pub async fn parachain_host_check_validation_outputs( &self, at: RelayHash, para_id: ParaId, outputs: CandidateCommitments, ) -> Result<bool, RelayChainError>

Checks if the given validation outputs pass the acceptance criteria.

pub async fn parachain_host_assumed_validation_data( &self, at: RelayHash, para_id: ParaId, expected_hash: RelayHash, ) -> Result<Option<(PersistedValidationData, ValidationCodeHash)>, RelayChainError>

Returns the persisted validation data for the given ParaId along with the corresponding validation code hash. Instead of accepting assumption about the para, matches the validation data hash against an expected one and yields None if they’re not equal.

pub async fn chain_get_finalized_head( &self, ) -> Result<RelayHash, RelayChainError>

Get hash of last finalized block.

pub async fn chain_get_block_hash( &self, block_number: Option<BlockNumber>, ) -> Result<Option<RelayHash>, RelayChainError>

Get hash of n-th block.

pub async fn parachain_host_persisted_validation_data( &self, at: RelayHash, para_id: ParaId, occupied_core_assumption: OccupiedCoreAssumption, ) -> Result<Option<PersistedValidationData>, RelayChainError>

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

Returns None if either the para is not registered or the assumption is Freed and the para already occupies a core.

pub async fn parachain_host_validation_code_by_hash( &self, at: RelayHash, validation_code_hash: ValidationCodeHash, ) -> Result<Option<ValidationCode>, RelayChainError>

Get the validation code from its hash.

pub async fn parachain_host_availability_cores( &self, at: RelayHash, ) -> Result<Vec<CoreState<RelayHash, BlockNumber>>, RelayChainError>

Yields information on all availability cores as relevant to the child block. Cores are either free or occupied. Free cores can have paras assigned to them.

pub async fn runtime_version( &self, at: RelayHash, ) -> Result<RuntimeVersion, RelayChainError>

Get runtime version

pub async fn parachain_host_disputes( &self, at: RelayHash, ) -> Result<Vec<(SessionIndex, CandidateHash, DisputeState<BlockNumber>)>, RelayChainError>

Returns all onchain disputes.

pub async fn parachain_host_unapplied_slashes( &self, at: RelayHash, ) -> Result<Vec<(SessionIndex, CandidateHash, PendingSlashes)>, RelayChainError>

Returns a list of validators that lost a past session dispute and need to be slashed.

This is a staging method! Do not use on production runtimes!

pub async fn parachain_host_key_ownership_proof( &self, at: RelayHash, validator_id: ValidatorId, ) -> Result<Option<OpaqueKeyOwnershipProof>, RelayChainError>

Returns a merkle proof of a validator session key in a past session.

This is a staging method! Do not use on production runtimes!

pub async fn parachain_host_submit_report_dispute_lost( &self, at: RelayHash, dispute_proof: DisputeProof, key_ownership_proof: OpaqueKeyOwnershipProof, ) -> Result<Option<()>, RelayChainError>

Submits an unsigned extrinsic to slash validators who lost a dispute about a candidate of a past session.

This is a staging method! Do not use on production runtimes!

pub async fn authority_discovery_authorities( &self, at: RelayHash, ) -> Result<Vec<AuthorityId>, RelayChainError>

pub async fn parachain_host_validation_code( &self, at: RelayHash, para_id: ParaId, occupied_core_assumption: OccupiedCoreAssumption, ) -> Result<Option<ValidationCode>, RelayChainError>

Fetch the validation code used by a para, making the given OccupiedCoreAssumption.

Returns None if either the para is not registered or the assumption is Freed and the para already occupies a core.

pub async fn parachain_host_validation_code_hash( &self, at: RelayHash, para_id: ParaId, occupied_core_assumption: OccupiedCoreAssumption, ) -> Result<Option<ValidationCodeHash>, RelayChainError>

Fetch the hash of the validation code used by a para, making the given OccupiedCoreAssumption.

pub async fn parachain_host_session_info( &self, at: RelayHash, index: SessionIndex, ) -> Result<Option<SessionInfo>, RelayChainError>

Get the session info for the given session, if stored.

pub async fn parachain_host_session_executor_params( &self, at: RelayHash, session_index: SessionIndex, ) -> Result<Option<ExecutorParams>, RelayChainError>

Get the executor parameters for the given session, if stored

pub async fn chain_get_header( &self, hash: Option<RelayHash>, ) -> Result<Option<RelayHeader>, RelayChainError>

Get header at specified hash

pub async fn parachain_host_candidate_pending_availability( &self, at: RelayHash, para_id: ParaId, ) -> Result<Option<CommittedCandidateReceipt>, RelayChainError>

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

pub async fn parachain_host_session_index_for_child( &self, at: RelayHash, ) -> Result<SessionIndex, RelayChainError>

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

This can be used to instantiate a SigningContext.

pub async fn parachain_host_validators( &self, at: RelayHash, ) -> Result<Vec<ValidatorId>, RelayChainError>

Get the current validators.

pub async fn parachain_host_inbound_hrmp_channels_contents( &self, para_id: ParaId, at: RelayHash, ) -> Result<BTreeMap<ParaId, Vec<InboundHrmpMessage>>, RelayChainError>

Get the contents of all channels addressed to the given recipient. Channels that have no messages in them are also included.

pub async fn parachain_host_dmq_contents( &self, para_id: ParaId, at: RelayHash, ) -> Result<Vec<InboundDownwardMessage>, RelayChainError>

Get all the pending inbound messages in the downward message queue for a para.

pub async fn parachain_host_minimum_backing_votes( &self, at: RelayHash, _session_index: SessionIndex, ) -> Result<u32, RelayChainError>

Get the minimum number of backing votes for a candidate.

pub async fn parachain_host_node_features( &self, at: RelayHash, ) -> Result<NodeFeatures, RelayChainError>

pub async fn parachain_host_disabled_validators( &self, at: RelayHash, ) -> Result<Vec<ValidatorIndex>, RelayChainError>

pub async fn parachain_host_async_backing_params( &self, at: RelayHash, ) -> Result<AsyncBackingParams, RelayChainError>

pub async fn parachain_host_staging_approval_voting_params( &self, at: RelayHash, _session_index: SessionIndex, ) -> Result<ApprovalVotingParams, RelayChainError>

pub async fn parachain_host_para_backing_state( &self, at: RelayHash, para_id: ParaId, ) -> Result<Option<BackingState>, RelayChainError>

pub async fn parachain_host_claim_queue( &self, at: RelayHash, ) -> Result<BTreeMap<CoreIndex, VecDeque<ParaId>>, RelayChainError>

pub async fn parachain_host_candidates_pending_availability( &self, at: RelayHash, para_id: ParaId, ) -> Result<Vec<CommittedCandidateReceipt>, RelayChainError>

Get the receipt of all candidates pending availability.

pub async fn validation_code_hash( &self, at: RelayHash, para_id: ParaId, occupied_core_assumption: OccupiedCoreAssumption, ) -> Result<Option<ValidationCodeHash>, RelayChainError>

pub fn get_imported_heads_stream( &self, ) -> Result<Receiver<RelayHeader>, RelayChainError>

Get a stream of all imported relay chain headers

pub fn get_best_heads_stream( &self, ) -> Result<Receiver<RelayHeader>, RelayChainError>

Get a stream of new best relay chain headers

pub fn get_finalized_heads_stream( &self, ) -> Result<Receiver<RelayHeader>, RelayChainError>

Get a stream of finalized relay chain headers

Trait Implementations

impl Clone for RelayChainRpcClient

fn clone(&self) -> RelayChainRpcClient

Returns a copy of the value.

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

Performs copy-assignment from source.