Struct rococo_runtime::RuntimeApiImpl
source · pub struct RuntimeApiImpl<Block: BlockT, C: CallApiAt<Block> + 'static> { /* private fields */ }
Expand description
Implements all runtime apis for the client side.
Trait Implementations§
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> AccountNonceApi<__SrApiBlock__, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> AccountNonceApi<__SrApiBlock__, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§impl<Block: BlockT, C: CallApiAt<Block>> ApiExt<Block> for RuntimeApiImpl<Block, C>
impl<Block: BlockT, C: CallApiAt<Block>> ApiExt<Block> for RuntimeApiImpl<Block, C>
source§fn execute_in_transaction<F: FnOnce(&Self) -> TransactionOutcome<R>, R>(
&self,
call: F,
) -> Rwhere
Self: Sized,
fn execute_in_transaction<F: FnOnce(&Self) -> TransactionOutcome<R>, R>(
&self,
call: F,
) -> Rwhere
Self: Sized,
Execute the given closure inside a new transaction. Read more
source§fn has_api<A: RuntimeApiInfo + ?Sized>(
&self,
at: <Block as BlockT>::Hash,
) -> Result<bool, ApiError>where
Self: Sized,
fn has_api<A: RuntimeApiInfo + ?Sized>(
&self,
at: <Block as BlockT>::Hash,
) -> Result<bool, ApiError>where
Self: Sized,
Checks if the given api is implemented and versions match.
source§fn has_api_with<A: RuntimeApiInfo + ?Sized, P: Fn(u32) -> bool>(
&self,
at: <Block as BlockT>::Hash,
pred: P,
) -> Result<bool, ApiError>where
Self: Sized,
fn has_api_with<A: RuntimeApiInfo + ?Sized, P: Fn(u32) -> bool>(
&self,
at: <Block as BlockT>::Hash,
pred: P,
) -> Result<bool, ApiError>where
Self: Sized,
Check if the given api is implemented and the version passes a predicate.
source§fn api_version<A: RuntimeApiInfo + ?Sized>(
&self,
at: <Block as BlockT>::Hash,
) -> Result<Option<u32>, ApiError>where
Self: Sized,
fn api_version<A: RuntimeApiInfo + ?Sized>(
&self,
at: <Block as BlockT>::Hash,
) -> Result<Option<u32>, ApiError>where
Self: Sized,
Returns the version of the given api.
source§fn record_proof(&mut self)
fn record_proof(&mut self)
Start recording all accessed trie nodes for generating proofs.
source§fn proof_recorder(&self) -> Option<ProofRecorder<Block>>
fn proof_recorder(&self) -> Option<ProofRecorder<Block>>
Returns the current active proof recorder.
source§fn extract_proof(&mut self) -> Option<StorageProof>
fn extract_proof(&mut self) -> Option<StorageProof>
Extract the recorded proof. Read more
source§fn into_storage_changes<B: StateBackend<HashingFor<Block>>>(
&self,
backend: &B,
parent_hash: Block::Hash,
) -> Result<StorageChanges<Block>, String>where
Self: Sized,
fn into_storage_changes<B: StateBackend<HashingFor<Block>>>(
&self,
backend: &B,
parent_hash: Block::Hash,
) -> Result<StorageChanges<Block>, String>where
Self: Sized,
Convert the api object into the storage changes that were done while executing runtime
api functions. Read more
source§fn set_call_context(&mut self, call_context: CallContext)
fn set_call_context(&mut self, call_context: CallContext)
Set the
CallContext
to be used by the runtime api calls done by this instance.source§fn register_extension<E: Extension>(&mut self, extension: E)
fn register_extension<E: Extension>(&mut self, extension: E)
Register an
Extension
that will be accessible while executing a runtime api call.source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> AuthorityDiscoveryApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> AuthorityDiscoveryApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
Retrieve authority identifiers of the current and next authority set.
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> BabeApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> BabeApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn configuration(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<BabeConfiguration, ApiError>
fn configuration( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<BabeConfiguration, ApiError>
Return the configuration for BABE.
source§fn configuration_before_version_2(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<BabeConfigurationV1, ApiError>
fn configuration_before_version_2( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<BabeConfigurationV1, ApiError>
👎Deprecated
Return the configuration for BABE. Version 1.
source§fn current_epoch_start(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Slot, ApiError>
fn current_epoch_start( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Slot, ApiError>
Returns the slot that started the current epoch.
source§fn current_epoch(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Epoch, ApiError>
fn current_epoch( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Epoch, ApiError>
Returns information regarding the current epoch.
source§fn next_epoch(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Epoch, ApiError>
fn next_epoch( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Epoch, ApiError>
Returns information regarding the next epoch (which was already
previously announced).
source§fn generate_key_ownership_proof(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
slot: Slot,
authority_id: Public,
) -> Result<Option<OpaqueKeyOwnershipProof>, ApiError>
fn generate_key_ownership_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, slot: Slot, authority_id: Public, ) -> Result<Option<OpaqueKeyOwnershipProof>, ApiError>
Generates a proof of key ownership for the given authority in the
current epoch. An example usage of this module is coupled with the
session historical module to prove that a given authority key is
tied to a given staking identity during a specific session. Proofs
of key ownership are necessary for submitting equivocation reports.
NOTE: even though the API takes a
slot
as parameter the current
implementations ignores this parameter and instead relies on this
method being called at the correct block height, i.e. any point at
which the epoch for the given slot is live on-chain. Future
implementations will instead use indexed data through an offchain
worker, not requiring older states to be available.source§fn submit_report_equivocation_unsigned_extrinsic(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
equivocation_proof: EquivocationProof<<Block as Block>::Header, Public>,
key_owner_proof: OpaqueKeyOwnershipProof,
) -> Result<Option<()>, ApiError>
fn submit_report_equivocation_unsigned_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, equivocation_proof: EquivocationProof<<Block as Block>::Header, Public>, key_owner_proof: OpaqueKeyOwnershipProof, ) -> Result<Option<()>, ApiError>
Submits an unsigned extrinsic to report an equivocation. The caller
must provide the equivocation proof and a key ownership proof
(should be obtained using
generate_key_ownership_proof
). The
extrinsic will be unsigned and should only be accepted for local
authorship (not to be broadcast to the network). This method returns
None
when creation of the extrinsic fails, e.g. if equivocation
reporting is disabled for the given runtime (i.e. this method is
hardcoded to return None
). Only useful in an offchain context.source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> BeefyApi<__SrApiBlock__, Public> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> BeefyApi<__SrApiBlock__, Public> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn beefy_genesis(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, ApiError>
fn beefy_genesis( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Option<<<Block as Block>::Header as Header>::Number>, ApiError>
Return the block number where BEEFY consensus is enabled/started
source§fn validator_set(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Option<ValidatorSet<AuthorityId>>, ApiError>
fn validator_set( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Option<ValidatorSet<AuthorityId>>, ApiError>
Return the current active BEEFY validator set
source§fn submit_report_double_voting_unsigned_extrinsic(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
equivocation_proof: DoubleVotingProof<<<Block as Block>::Header as Header>::Number, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>,
key_owner_proof: OpaqueValue,
) -> Result<Option<()>, ApiError>
fn submit_report_double_voting_unsigned_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, equivocation_proof: DoubleVotingProof<<<Block as Block>::Header as Header>::Number, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>, key_owner_proof: OpaqueValue, ) -> Result<Option<()>, ApiError>
Submits an unsigned extrinsic to report a double voting equivocation. The caller
must provide the double voting proof and a key ownership proof
(should be obtained using
generate_key_ownership_proof
). The
extrinsic will be unsigned and should only be accepted for local
authorship (not to be broadcast to the network). This method returns
None
when creation of the extrinsic fails, e.g. if equivocation
reporting is disabled for the given runtime (i.e. this method is
hardcoded to return None
). Only useful in an offchain context.source§fn submit_report_fork_voting_unsigned_extrinsic(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
equivocation_proof: ForkVotingProof<<Block as Block>::Header, AuthorityId, OpaqueValue>,
key_owner_proof: OpaqueValue,
) -> Result<Option<()>, ApiError>
fn submit_report_fork_voting_unsigned_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, equivocation_proof: ForkVotingProof<<Block as Block>::Header, AuthorityId, OpaqueValue>, key_owner_proof: OpaqueValue, ) -> Result<Option<()>, ApiError>
Submits an unsigned extrinsic to report a fork voting equivocation. The caller
must provide the fork voting proof (the ancestry proof should be obtained using
generate_ancestry_proof
) and a key ownership proof (should be obtained using
generate_key_ownership_proof
). The extrinsic will be unsigned and should only
be accepted for local authorship (not to be broadcast to the network). This method
returns None
when creation of the extrinsic fails, e.g. if equivocation
reporting is disabled for the given runtime (i.e. this method is
hardcoded to return None
). Only useful in an offchain context.source§fn submit_report_future_block_voting_unsigned_extrinsic(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
equivocation_proof: FutureBlockVotingProof<<<Block as Block>::Header as Header>::Number, AuthorityId>,
key_owner_proof: OpaqueValue,
) -> Result<Option<()>, ApiError>
fn submit_report_future_block_voting_unsigned_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, equivocation_proof: FutureBlockVotingProof<<<Block as Block>::Header as Header>::Number, AuthorityId>, key_owner_proof: OpaqueValue, ) -> Result<Option<()>, ApiError>
Submits an unsigned extrinsic to report a future block voting equivocation. The caller
must provide the future block voting proof and a key ownership proof
(should be obtained using
generate_key_ownership_proof
).
The extrinsic will be unsigned and should only be accepted for local
authorship (not to be broadcast to the network). This method returns
None
when creation of the extrinsic fails, e.g. if equivocation
reporting is disabled for the given runtime (i.e. this method is
hardcoded to return None
). Only useful in an offchain context.source§fn generate_key_ownership_proof(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
set_id: u64,
authority_id: AuthorityId,
) -> Result<Option<OpaqueValue>, ApiError>
fn generate_key_ownership_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, set_id: u64, authority_id: AuthorityId, ) -> Result<Option<OpaqueValue>, ApiError>
Generates a proof of key ownership for the given authority in the
given set. An example usage of this module is coupled with the
session historical module to prove that a given authority key is
tied to a given staking identity during a specific session. Proofs
of key ownership are necessary for submitting equivocation reports.
NOTE: even though the API takes a
set_id
as parameter the current
implementations ignores this parameter and instead relies on this
method being called at the correct block height, i.e. any point at
which the given set id is live on-chain. Future implementations will
instead use indexed data through an offchain worker, not requiring
older states to be available.source§fn generate_ancestry_proof(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
prev_block_number: <<Block as Block>::Header as Header>::Number,
best_known_block_number: Option<<<Block as Block>::Header as Header>::Number>,
) -> Result<Option<OpaqueValue>, ApiError>
fn generate_ancestry_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, prev_block_number: <<Block as Block>::Header as Header>::Number, best_known_block_number: Option<<<Block as Block>::Header as Header>::Number>, ) -> Result<Option<OpaqueValue>, ApiError>
Generates a proof that the
prev_block_number
is part of the canonical chain at
best_known_block_number
.source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> BeefyMmrApi<__SrApiBlock__, H256> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> BeefyMmrApi<__SrApiBlock__, H256> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
Return the currently active BEEFY authority set proof.
Return the next/queued BEEFY authority set proof.
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> Benchmark<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> Benchmark<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn benchmark_metadata(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
extra: bool,
) -> Result<(Vec<BenchmarkList>, Vec<StorageInfo>), ApiError>
fn benchmark_metadata( &self, __runtime_api_at_param__: <Block as Block>::Hash, extra: bool, ) -> Result<(Vec<BenchmarkList>, Vec<StorageInfo>), ApiError>
Get the benchmark metadata available for this runtime. Read more
source§fn dispatch_benchmark(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
config: BenchmarkConfig,
) -> Result<Result<Vec<BenchmarkBatch>, String>, ApiError>
fn dispatch_benchmark( &self, __runtime_api_at_param__: <Block as Block>::Hash, config: BenchmarkConfig, ) -> Result<Result<Vec<BenchmarkBatch>, String>, ApiError>
Dispatch the given benchmark.
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> BlockBuilder<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> BlockBuilder<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn apply_extrinsic(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
extrinsic: <Block as Block>::Extrinsic,
) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, ApiError>
fn apply_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsic: <Block as Block>::Extrinsic, ) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, ApiError>
Apply the given extrinsic. Read more
source§fn apply_extrinsic_before_version_6(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
extrinsic: <Block as Block>::Extrinsic,
) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, ApiError>
fn apply_extrinsic_before_version_6( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsic: <Block as Block>::Extrinsic, ) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, ApiError>
👎Deprecated
source§fn finalize_block(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<<Block as Block>::Header, ApiError>
fn finalize_block( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<<Block as Block>::Header, ApiError>
Finish the current block.
source§fn inherent_extrinsics(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
inherent: InherentData,
) -> Result<Vec<<Block as Block>::Extrinsic>, ApiError>
fn inherent_extrinsics( &self, __runtime_api_at_param__: <Block as Block>::Hash, inherent: InherentData, ) -> Result<Vec<<Block as Block>::Extrinsic>, ApiError>
Generate inherent extrinsics. The inherent data will vary from chain to chain.
source§fn check_inherents(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
block: Block,
data: InherentData,
) -> Result<CheckInherentsResult, ApiError>
fn check_inherents( &self, __runtime_api_at_param__: <Block as Block>::Hash, block: Block, data: InherentData, ) -> Result<CheckInherentsResult, ApiError>
Check that the inherents are valid. The inherent data will vary from chain to chain.
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> Core<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> Core<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn version(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<RuntimeVersion, ApiError>
fn version( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<RuntimeVersion, ApiError>
Returns the version of the runtime.
source§fn execute_block(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
block: Block,
) -> Result<(), ApiError>
fn execute_block( &self, __runtime_api_at_param__: <Block as Block>::Hash, block: Block, ) -> Result<(), ApiError>
Execute the given block.
source§fn initialize_block_before_version_5(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
header: &<Block as Block>::Header,
) -> Result<(), ApiError>
fn initialize_block_before_version_5( &self, __runtime_api_at_param__: <Block as Block>::Hash, header: &<Block as Block>::Header, ) -> Result<(), ApiError>
👎Deprecated
Initialize a block with the given header.
source§fn initialize_block(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
header: &<Block as Block>::Header,
) -> Result<ExtrinsicInclusionMode, ApiError>
fn initialize_block( &self, __runtime_api_at_param__: <Block as Block>::Hash, header: &<Block as Block>::Header, ) -> Result<ExtrinsicInclusionMode, ApiError>
Initialize a block with the given header and return the runtime executive mode.
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> DryRunApi<__SrApiBlock__, RuntimeCall, RuntimeEvent, OriginCaller> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> DryRunApi<__SrApiBlock__, RuntimeCall, RuntimeEvent, OriginCaller> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn dry_run_call(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
origin: OriginCaller,
call: Call,
) -> Result<Result<CallDryRunEffects<Event>, Error>, ApiError>
fn dry_run_call( &self, __runtime_api_at_param__: <Block as Block>::Hash, origin: OriginCaller, call: Call, ) -> Result<Result<CallDryRunEffects<Event>, Error>, ApiError>
Dry run call.
source§fn dry_run_xcm(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
origin_location: VersionedLocation,
xcm: VersionedXcm<Call>,
) -> Result<Result<XcmDryRunEffects<Event>, Error>, ApiError>
fn dry_run_xcm( &self, __runtime_api_at_param__: <Block as Block>::Hash, origin_location: VersionedLocation, xcm: VersionedXcm<Call>, ) -> Result<Result<XcmDryRunEffects<Event>, Error>, ApiError>
Dry run XCM program
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> GenesisBuilder<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> GenesisBuilder<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn build_state(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
json: Vec<u8>,
) -> Result<Result<(), String>, ApiError>
fn build_state( &self, __runtime_api_at_param__: <Block as Block>::Hash, json: Vec<u8>, ) -> Result<Result<(), String>, ApiError>
Build
RuntimeGenesisConfig
from a JSON blob not using any defaults and store it in the
storage. Read moresource§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> GrandpaApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> GrandpaApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
Get the current GRANDPA authorities and weights. This should not change except
for when changes are scheduled and the corresponding delay has passed. Read more
source§fn submit_report_equivocation_unsigned_extrinsic(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
equivocation_proof: EquivocationProof<<Block as Block>::Hash, <<Block as Block>::Header as Header>::Number>,
key_owner_proof: OpaqueValue,
) -> Result<Option<()>, ApiError>
fn submit_report_equivocation_unsigned_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, equivocation_proof: EquivocationProof<<Block as Block>::Hash, <<Block as Block>::Header as Header>::Number>, key_owner_proof: OpaqueValue, ) -> Result<Option<()>, ApiError>
Submits an unsigned extrinsic to report an equivocation. The caller
must provide the equivocation proof and a key ownership proof
(should be obtained using
generate_key_ownership_proof
). The
extrinsic will be unsigned and should only be accepted for local
authorship (not to be broadcast to the network). This method returns
None
when creation of the extrinsic fails, e.g. if equivocation
reporting is disabled for the given runtime (i.e. this method is
hardcoded to return None
). Only useful in an offchain context.source§fn generate_key_ownership_proof(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
set_id: u64,
authority_id: Public,
) -> Result<Option<OpaqueValue>, ApiError>
fn generate_key_ownership_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, set_id: u64, authority_id: Public, ) -> Result<Option<OpaqueValue>, ApiError>
Generates a proof of key ownership for the given authority in the
given set. An example usage of this module is coupled with the
session historical module to prove that a given authority key is
tied to a given staking identity during a specific session. Proofs
of key ownership are necessary for submitting equivocation reports.
NOTE: even though the API takes a
set_id
as parameter the current
implementations ignore this parameter and instead rely on this
method being called at the correct block height, i.e. any point at
which the given set id is live on-chain. Future implementations will
instead use indexed data through an offchain worker, not requiring
older states to be available.source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> LocationToAccountApi<__SrApiBlock__, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> LocationToAccountApi<__SrApiBlock__, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn convert_location(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
location: VersionedLocation,
) -> Result<Result<AccountId, Error>, ApiError>
fn convert_location( &self, __runtime_api_at_param__: <Block as Block>::Hash, location: VersionedLocation, ) -> Result<Result<AccountId, Error>, ApiError>
Converts
Location
to AccountId
.source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> Metadata<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> Metadata<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn metadata(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<OpaqueMetadata, ApiError>
fn metadata( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<OpaqueMetadata, ApiError>
Returns the metadata of a runtime.
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> MmrApi<__SrApiBlock__, <<Runtime as Config>::Hashing as Hash>::Output, u32> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> MmrApi<__SrApiBlock__, <<Runtime as Config>::Hashing as Hash>::Output, u32> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn mmr_root(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Result<Hash, Error>, ApiError>
fn mmr_root( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Result<Hash, Error>, ApiError>
Return the on-chain MMR root hash.
source§fn mmr_leaf_count(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Result<u64, Error>, ApiError>
fn mmr_leaf_count( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Result<u64, Error>, ApiError>
Return the number of MMR blocks in the chain.
source§fn generate_proof(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
block_numbers: Vec<BlockNumber>,
best_known_block_number: Option<BlockNumber>,
) -> Result<Result<(Vec<EncodableOpaqueLeaf>, LeafProof<Hash>), Error>, ApiError>
fn generate_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, block_numbers: Vec<BlockNumber>, best_known_block_number: Option<BlockNumber>, ) -> Result<Result<(Vec<EncodableOpaqueLeaf>, LeafProof<Hash>), Error>, ApiError>
Generate MMR proof for a series of block numbers. If
best_known_block_number = Some(n)
,
use historical MMR state at given block height n
. Else, use current MMR state.source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> OffchainWorkerApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> OffchainWorkerApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> ParachainHost<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> ParachainHost<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn validators(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Vec<Public>, ApiError>
fn validators( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Vec<Public>, ApiError>
Get the current validators.
source§fn validator_groups(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<(Vec<Vec<ValidatorIndex>>, GroupRotationInfo), ApiError>
fn validator_groups( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<(Vec<Vec<ValidatorIndex>>, GroupRotationInfo), ApiError>
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.source§fn availability_cores(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Vec<CoreState>, ApiError>
fn availability_cores( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Vec<CoreState>, ApiError>
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.
source§fn persisted_validation_data(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
para_id: Id,
assumption: OccupiedCoreAssumption,
) -> Result<Option<PersistedValidationData>, ApiError>
fn persisted_validation_data( &self, __runtime_api_at_param__: <Block as Block>::Hash, para_id: Id, assumption: OccupiedCoreAssumption, ) -> Result<Option<PersistedValidationData>, ApiError>
Yields the persisted validation data for the given
ParaId
along with an assumption that
should be used if the para currently occupies a core. Read moresource§fn assumed_validation_data(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
para_id: Id,
expected_persisted_validation_data_hash: H256,
) -> Result<Option<(PersistedValidationData, ValidationCodeHash)>, ApiError>
fn assumed_validation_data( &self, __runtime_api_at_param__: <Block as Block>::Hash, para_id: Id, expected_persisted_validation_data_hash: H256, ) -> Result<Option<(PersistedValidationData, ValidationCodeHash)>, ApiError>
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.source§fn check_validation_outputs(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
para_id: Id,
outputs: CandidateCommitments,
) -> Result<bool, ApiError>
fn check_validation_outputs( &self, __runtime_api_at_param__: <Block as Block>::Hash, para_id: Id, outputs: CandidateCommitments, ) -> Result<bool, ApiError>
Checks if the given validation outputs pass the acceptance criteria.
source§fn session_index_for_child(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<u32, ApiError>
fn session_index_for_child( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<u32, ApiError>
Returns the session index expected at a child of the block. Read more
source§fn validation_code(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
para_id: Id,
assumption: OccupiedCoreAssumption,
) -> Result<Option<ValidationCode>, ApiError>
fn validation_code( &self, __runtime_api_at_param__: <Block as Block>::Hash, para_id: Id, assumption: OccupiedCoreAssumption, ) -> Result<Option<ValidationCode>, ApiError>
Fetch the validation code used by a para, making the given
OccupiedCoreAssumption
. Read moresource§fn candidate_pending_availability(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
para_id: Id,
) -> Result<Option<CommittedCandidateReceiptV2>, ApiError>
fn candidate_pending_availability( &self, __runtime_api_at_param__: <Block as Block>::Hash, para_id: Id, ) -> Result<Option<CommittedCandidateReceiptV2>, ApiError>
Get the receipt of a candidate pending availability. This returns
Some
for any paras
assigned to occupied cores in availability_cores
and None
otherwise.source§fn candidate_events(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Vec<CandidateEvent>, ApiError>
fn candidate_events( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Vec<CandidateEvent>, ApiError>
Get a vector of events concerning candidates that occurred within a block.
source§fn dmq_contents(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
recipient: Id,
) -> Result<Vec<InboundDownwardMessage>, ApiError>
fn dmq_contents( &self, __runtime_api_at_param__: <Block as Block>::Hash, recipient: Id, ) -> Result<Vec<InboundDownwardMessage>, ApiError>
Get all the pending inbound messages in the downward message queue for a para.
source§fn inbound_hrmp_channels_contents(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
recipient: Id,
) -> Result<BTreeMap<Id, Vec<InboundHrmpMessage>>, ApiError>
fn inbound_hrmp_channels_contents( &self, __runtime_api_at_param__: <Block as Block>::Hash, recipient: Id, ) -> Result<BTreeMap<Id, Vec<InboundHrmpMessage>>, ApiError>
Get the contents of all channels addressed to the given recipient. Channels that have no
messages in them are also included.
source§fn validation_code_by_hash(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
hash: ValidationCodeHash,
) -> Result<Option<ValidationCode>, ApiError>
fn validation_code_by_hash( &self, __runtime_api_at_param__: <Block as Block>::Hash, hash: ValidationCodeHash, ) -> Result<Option<ValidationCode>, ApiError>
Get the validation code from its hash.
source§fn on_chain_votes(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Option<ScrapedOnChainVotes>, ApiError>
fn on_chain_votes( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Option<ScrapedOnChainVotes>, ApiError>
Scrape dispute relevant from on-chain, backing votes and resolved disputes.
source§fn session_info(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
index: u32,
) -> Result<Option<SessionInfo>, ApiError>
fn session_info( &self, __runtime_api_at_param__: <Block as Block>::Hash, index: u32, ) -> Result<Option<SessionInfo>, ApiError>
Get the session info for the given session, if stored. Read more
source§fn submit_pvf_check_statement(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
stmt: PvfCheckStatement,
signature: Signature,
) -> Result<(), ApiError>
fn submit_pvf_check_statement( &self, __runtime_api_at_param__: <Block as Block>::Hash, stmt: PvfCheckStatement, signature: Signature, ) -> Result<(), ApiError>
Submits a PVF pre-checking statement into the transaction pool. Read more
source§fn pvfs_require_precheck(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Vec<ValidationCodeHash>, ApiError>
fn pvfs_require_precheck( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Vec<ValidationCodeHash>, ApiError>
Returns code hashes of PVFs that require pre-checking by validators in the active set. Read more
source§fn validation_code_hash(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
para_id: Id,
assumption: OccupiedCoreAssumption,
) -> Result<Option<ValidationCodeHash>, ApiError>
fn validation_code_hash( &self, __runtime_api_at_param__: <Block as Block>::Hash, para_id: Id, assumption: OccupiedCoreAssumption, ) -> Result<Option<ValidationCodeHash>, ApiError>
Fetch the hash of the validation code used by a para, making the given
OccupiedCoreAssumption
. Read moresource§fn disputes(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Vec<(u32, CandidateHash, DisputeState)>, ApiError>
fn disputes( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Vec<(u32, CandidateHash, DisputeState)>, ApiError>
Returns all onchain disputes.
source§fn session_executor_params(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
session_index: u32,
) -> Result<Option<ExecutorParams>, ApiError>
fn session_executor_params( &self, __runtime_api_at_param__: <Block as Block>::Hash, session_index: u32, ) -> Result<Option<ExecutorParams>, ApiError>
Returns execution parameters for the session.
source§fn unapplied_slashes(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Vec<(u32, CandidateHash, PendingSlashes)>, ApiError>
fn unapplied_slashes( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Vec<(u32, CandidateHash, PendingSlashes)>, ApiError>
Returns a list of validators that lost a past session dispute and need to be slashed.
NOTE: This function is only available since parachain host version 5.
source§fn key_ownership_proof(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
validator_id: Public,
) -> Result<Option<OpaqueKeyOwnershipProof>, ApiError>
fn key_ownership_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, validator_id: Public, ) -> Result<Option<OpaqueKeyOwnershipProof>, ApiError>
Returns a merkle proof of a validator session key.
NOTE: This function is only available since parachain host version 5.
source§fn submit_report_dispute_lost(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
dispute_proof: DisputeProof,
key_ownership_proof: OpaqueKeyOwnershipProof,
) -> Result<Option<()>, ApiError>
fn submit_report_dispute_lost( &self, __runtime_api_at_param__: <Block as Block>::Hash, dispute_proof: DisputeProof, key_ownership_proof: OpaqueKeyOwnershipProof, ) -> Result<Option<()>, ApiError>
Submit an unsigned extrinsic to slash validators who lost a dispute about
a candidate of a past session.
NOTE: This function is only available since parachain host version 5.
source§fn minimum_backing_votes(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<u32, ApiError>
fn minimum_backing_votes( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<u32, ApiError>
Get the minimum number of backing votes for a parachain candidate.
This is a staging method! Do not use on production runtimes!
source§fn para_backing_state(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
__runtime_api_generated_name_0__: Id,
) -> Result<Option<BackingState>, ApiError>
fn para_backing_state( &self, __runtime_api_at_param__: <Block as Block>::Hash, __runtime_api_generated_name_0__: Id, ) -> Result<Option<BackingState>, ApiError>
Returns the state of parachain backing for a given para.
source§fn async_backing_params(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<AsyncBackingParams, ApiError>
fn async_backing_params( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<AsyncBackingParams, ApiError>
Returns candidate’s acceptance limitations for asynchronous backing for a relay parent.
source§fn disabled_validators(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<Vec<ValidatorIndex>, ApiError>
fn disabled_validators( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Vec<ValidatorIndex>, ApiError>
Returns a list of all disabled validators at the given block.
source§fn node_features(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<BitVec<u8>, ApiError>
fn node_features( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<BitVec<u8>, ApiError>
Get node features.
This is a staging method! Do not use on production runtimes!
source§fn approval_voting_params(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<ApprovalVotingParams, ApiError>
fn approval_voting_params( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<ApprovalVotingParams, ApiError>
Approval voting configuration parameters
source§fn claim_queue(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
) -> Result<BTreeMap<CoreIndex, VecDeque<Id>>, ApiError>
fn claim_queue( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<BTreeMap<CoreIndex, VecDeque<Id>>, ApiError>
Claim queue
source§fn candidates_pending_availability(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
para_id: Id,
) -> Result<Vec<CommittedCandidateReceiptV2>, ApiError>
fn candidates_pending_availability( &self, __runtime_api_at_param__: <Block as Block>::Hash, para_id: Id, ) -> Result<Vec<CommittedCandidateReceiptV2>, ApiError>
Elastic scaling support
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> SessionKeys<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> SessionKeys<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn generate_session_keys(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
seed: Option<Vec<u8>>,
) -> Result<Vec<u8>, ApiError>
fn generate_session_keys( &self, __runtime_api_at_param__: <Block as Block>::Hash, seed: Option<Vec<u8>>, ) -> Result<Vec<u8>, ApiError>
Generate a set of session keys with optionally using the given seed.
The keys should be stored within the keystore exposed via runtime
externalities. Read more
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> TaggedTransactionQueue<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> TaggedTransactionQueue<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn validate_transaction_before_version_2(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
tx: <Block as Block>::Extrinsic,
) -> Result<Result<ValidTransaction, TransactionValidityError>, ApiError>
fn validate_transaction_before_version_2( &self, __runtime_api_at_param__: <Block as Block>::Hash, tx: <Block as Block>::Extrinsic, ) -> Result<Result<ValidTransaction, TransactionValidityError>, ApiError>
👎Deprecated
Validate the transaction.
source§fn validate_transaction_before_version_3(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
source: TransactionSource,
tx: <Block as Block>::Extrinsic,
) -> Result<Result<ValidTransaction, TransactionValidityError>, ApiError>
fn validate_transaction_before_version_3( &self, __runtime_api_at_param__: <Block as Block>::Hash, source: TransactionSource, tx: <Block as Block>::Extrinsic, ) -> Result<Result<ValidTransaction, TransactionValidityError>, ApiError>
👎Deprecated
Validate the transaction.
source§fn validate_transaction(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
source: TransactionSource,
tx: <Block as Block>::Extrinsic,
block_hash: <Block as Block>::Hash,
) -> Result<Result<ValidTransaction, TransactionValidityError>, ApiError>
fn validate_transaction( &self, __runtime_api_at_param__: <Block as Block>::Hash, source: TransactionSource, tx: <Block as Block>::Extrinsic, block_hash: <Block as Block>::Hash, ) -> Result<Result<ValidTransaction, TransactionValidityError>, ApiError>
Validate the transaction. Read more
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> TransactionPaymentApi<__SrApiBlock__, u128> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> TransactionPaymentApi<__SrApiBlock__, u128> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
fn query_info( &self, __runtime_api_at_param__: <Block as Block>::Hash, uxt: <Block as Block>::Extrinsic, len: u32, ) -> Result<RuntimeDispatchInfo<Balance>, ApiError>
fn query_fee_details( &self, __runtime_api_at_param__: <Block as Block>::Hash, uxt: <Block as Block>::Extrinsic, len: u32, ) -> Result<FeeDetails<Balance>, ApiError>
fn query_weight_to_fee( &self, __runtime_api_at_param__: <Block as Block>::Hash, weight: Weight, ) -> Result<Balance, ApiError>
fn query_length_to_fee( &self, __runtime_api_at_param__: <Block as Block>::Hash, length: u32, ) -> Result<Balance, ApiError>
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> TrustedQueryApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> TrustedQueryApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn is_trusted_reserve(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
asset: VersionedAsset,
location: VersionedLocation,
) -> Result<Result<bool, Error>, ApiError>
fn is_trusted_reserve( &self, __runtime_api_at_param__: <Block as Block>::Hash, asset: VersionedAsset, location: VersionedLocation, ) -> Result<Result<bool, Error>, ApiError>
Returns if the location is a trusted reserve for the asset. Read more
source§fn is_trusted_teleporter(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
asset: VersionedAsset,
location: VersionedLocation,
) -> Result<Result<bool, Error>, ApiError>
fn is_trusted_teleporter( &self, __runtime_api_at_param__: <Block as Block>::Hash, asset: VersionedAsset, location: VersionedLocation, ) -> Result<Result<bool, Error>, ApiError>
Returns if the asset can be teleported to the location. Read more
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> TryRuntime<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> TryRuntime<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> XcmPaymentApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
impl<__SrApiBlock__: BlockT, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> XcmPaymentApi<__SrApiBlock__> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>where
RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>,
&'static RuntimeApiImplCall: Send,
source§fn query_acceptable_payment_assets(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
xcm_version: u32,
) -> Result<Result<Vec<VersionedAssetId>, Error>, ApiError>
fn query_acceptable_payment_assets( &self, __runtime_api_at_param__: <Block as Block>::Hash, xcm_version: u32, ) -> Result<Result<Vec<VersionedAssetId>, Error>, ApiError>
Returns a list of acceptable payment assets. Read more
source§fn query_xcm_weight(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
message: VersionedXcm<()>,
) -> Result<Result<Weight, Error>, ApiError>
fn query_xcm_weight( &self, __runtime_api_at_param__: <Block as Block>::Hash, message: VersionedXcm<()>, ) -> Result<Result<Weight, Error>, ApiError>
Returns a weight needed to execute a XCM. Read more
source§fn query_weight_to_asset_fee(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
weight: Weight,
asset: VersionedAssetId,
) -> Result<Result<u128, Error>, ApiError>
fn query_weight_to_asset_fee( &self, __runtime_api_at_param__: <Block as Block>::Hash, weight: Weight, asset: VersionedAssetId, ) -> Result<Result<u128, Error>, ApiError>
Converts a weight into a fee for the specified
AssetId
. Read moresource§fn query_delivery_fees(
&self,
__runtime_api_at_param__: <Block as Block>::Hash,
destination: VersionedLocation,
message: VersionedXcm<()>,
) -> Result<Result<VersionedAssets, Error>, ApiError>
fn query_delivery_fees( &self, __runtime_api_at_param__: <Block as Block>::Hash, destination: VersionedLocation, message: VersionedXcm<()>, ) -> Result<Result<VersionedAssets, Error>, ApiError>
Get delivery fees for sending a specific
message
to a destination
.
These always come in a specific asset, defined by the chain. Read moreAuto Trait Implementations§
impl<Block, C> !Freeze for RuntimeApiImpl<Block, C>
impl<Block, C> !RefUnwindSafe for RuntimeApiImpl<Block, C>
impl<Block, C> Send for RuntimeApiImpl<Block, C>where
C: Sync,
impl<Block, C> !Sync for RuntimeApiImpl<Block, C>
impl<Block, C> Unpin for RuntimeApiImpl<Block, C>
impl<Block, C> !UnwindSafe for RuntimeApiImpl<Block, C>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CheckedConversion for T
impl<T> CheckedConversion for T
§impl<T> Conv for T
impl<T> Conv for T
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
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,
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,
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,
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,
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,
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,
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,
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,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
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 moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
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§impl<Src, Dest> IntoTuple<Dest> for Srcwhere
Dest: FromTuple<Src>,
impl<Src, Dest> IntoTuple<Dest> for Srcwhere
Dest: FromTuple<Src>,
fn into_tuple(self) -> Dest
source§impl<T, Outer> IsWrappedBy<Outer> for T
impl<T, Outer> IsWrappedBy<Outer> for T
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
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) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
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) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
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
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
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
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
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
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
Borrows
self
, then passes self.deref()
into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<T> SaturatedConversion for T
impl<T> SaturatedConversion for T
source§fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
source§fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,
fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,
Consume self to return an equivalent value of
T
. Read more§impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
§fn to_subset(&self) -> Option<SS>
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
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
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
fn from_subset(element: &SS) -> SP
The inclusion map: converts
self
to the equivalent element of its superset.§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Immutable access to the
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
Mutable access to the
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
Immutable access to the
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
Mutable access to the
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Immutable access to the
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Mutable access to the
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
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
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
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
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
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
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
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
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
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
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
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
Calls
.tap_deref()
only in debug builds, and is erased in release
builds.§impl<T> TryConv for T
impl<T> TryConv for T
source§impl<T, U> TryIntoKey<U> for Twhere
U: TryFromKey<T>,
impl<T, U> TryIntoKey<U> for Twhere
U: TryFromKey<T>,
type Error = <U as TryFromKey<T>>::Error
fn try_into_key(self) -> Result<U, <U as TryFromKey<T>>::Error>
source§impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
source§fn unchecked_into(self) -> T
fn unchecked_into(self) -> T
The counterpart to
unchecked_from
.source§impl<T, S> UniqueSaturatedInto<T> for S
impl<T, S> UniqueSaturatedInto<T> for S
source§fn unique_saturated_into(self) -> T
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of
T
.