Struct anagolay_runtime::RuntimeApiImpl

source · [−]

pub struct RuntimeApiImpl<Block: BlockT, C: CallApiAt<Block> + 'static> where
    C::StateBackend: StateBackend<HashFor<Block>>,  { /* private fields */ }

Expand description

Implements all runtime apis for the client side.

Trait Implementations

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> AccountNonceApi<SR_API_BLOCK, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 AccountId: UnwindSafe + RefUnwindSafe,
 Index: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn account_nonce(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 account: AccountId
) -> Result<Index, Self::Error>

Get current account nonce of given AccountId.

source

fn account_nonce_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 account: AccountId
) -> Result<Index, Self::Error>

Get current account nonce of given AccountId.

source

impl<Block: BlockT, C: CallApiAt<Block>> ApiErrorExt for RuntimeApiImpl<Block, C> where
C::StateBackend: StateBackend<HashFor<Block>>,

type Error = C::Error

Error type used by the runtime apis.

source

impl<Block: BlockT, C: CallApiAt<Block>> ApiExt<Block> for RuntimeApiImpl<Block, C> where
C::StateBackend: StateBackend<HashFor<Block>>,

type StateBackend = C::StateBackend

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

source

fn execute_in_transaction<F: FnOnce(&Self) -> TransactionOutcome<R>, R>(
 &self,
 call: F
) -> R where
 Self: Sized,

Execute the given closure inside a new transaction. Read more

source

fn has_api<A: RuntimeApiInfo + ?Sized>(
 &self,
 at: &BlockId<Block>
) -> Result<bool, C::Error> 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: &BlockId<Block>,
 pred: P
) -> Result<bool, C::Error> where
 Self: Sized,

Check if the given api is implemented and the version passes a predicate.

source

fn record_proof(&mut self)

Start recording all accessed trie nodes for generating proofs.

source

fn extract_proof(&mut self) -> Option<StorageProof>

Extract the recorded proof. Read more

source

fn into_storage_changes(
 &self,
 backend: &Self::StateBackend,
 changes_trie_state: Option<&ChangesTrieState<'_, HashFor<Block>, NumberFor<Block>>>,
 parent_hash: Block::Hash
) -> Result<StorageChanges<Self::StateBackend, Block>, String> where
 Self: Sized,

Convert the api object into the storage changes that were done while executing runtime api functions. Read more

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> AuraApi<SR_API_BLOCK, Public> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 u64: UnwindSafe + RefUnwindSafe,
 Vec<AuraId>: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn slot_duration(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<u64, Self::Error>

Return the slot duration in seconds for Aura. Currently, only the value provided by this type at genesis will be used. Read more

source

fn slot_duration_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext
) -> Result<u64, Self::Error>

Return the slot duration in seconds for Aura. Currently, only the value provided by this type at genesis will be used. Read more

source

fn authorities(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<Vec<AuthorityId, Global>, Self::Error>

source

fn authorities_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext
) -> Result<Vec<AuthorityId, Global>, Self::Error>

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> Benchmark<SR_API_BLOCK> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 BenchmarkConfig: UnwindSafe + RefUnwindSafe,
 Result<Vec<BenchmarkBatch>, RuntimeString>: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn dispatch_benchmark(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 config: BenchmarkConfig
) -> Result<Result<Vec<BenchmarkBatch, Global>, RuntimeString>, Self::Error>

Dispatch the given benchmark.

source

fn dispatch_benchmark_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 config: BenchmarkConfig
) -> Result<Result<Vec<BenchmarkBatch, Global>, RuntimeString>, Self::Error>

Dispatch the given benchmark.

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> BlockBuilder<SR_API_BLOCK> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 <SR_API_BLOCK as BlockT>::Extrinsic: UnwindSafe + RefUnwindSafe,
 ApplyExtrinsicResult: UnwindSafe + RefUnwindSafe,
 <SR_API_BLOCK as BlockT>::Header: UnwindSafe + RefUnwindSafe,
 InherentData: UnwindSafe + RefUnwindSafe,
 Vec<<SR_API_BLOCK as BlockT>::Extrinsic>: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK: UnwindSafe + RefUnwindSafe,
 InherentData: UnwindSafe + RefUnwindSafe,
 CheckInherentsResult: UnwindSafe + RefUnwindSafe,
 <SR_API_BLOCK as BlockT>::Hash: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn apply_extrinsic(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 extrinsic: <Block as Block>::Extrinsic
) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, Self::Error>

Apply the given extrinsic. Read more

source

fn apply_extrinsic_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 extrinsic: <Block as Block>::Extrinsic
) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, Self::Error>

Apply the given extrinsic. Read more

source

fn finalize_block(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<<Block as Block>::Header, Self::Error>

Finish the current block.

source

fn finalize_block_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext
) -> Result<<Block as Block>::Header, Self::Error>

Finish the current block.

source

fn inherent_extrinsics(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 inherent: InherentData
) -> Result<Vec<<Block as Block>::Extrinsic, Global>, Self::Error>

Generate inherent extrinsics. The inherent data will vary from chain to chain.

source

fn inherent_extrinsics_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 inherent: InherentData
) -> Result<Vec<<Block as Block>::Extrinsic, Global>, Self::Error>

Generate inherent extrinsics. The inherent data will vary from chain to chain.

source

fn check_inherents(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 block: Block,
 data: InherentData
) -> Result<CheckInherentsResult, Self::Error>

Check that the inherents are valid. The inherent data will vary from chain to chain.

source

fn check_inherents_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 block: Block,
 data: InherentData
) -> Result<CheckInherentsResult, Self::Error>

Check that the inherents are valid. The inherent data will vary from chain to chain.

source

fn random_seed(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<<Block as Block>::Hash, Self::Error>

Generate a random seed.

source

fn random_seed_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext
) -> Result<<Block as Block>::Hash, Self::Error>

Generate a random seed.

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> Core<SR_API_BLOCK> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 RuntimeVersion: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK: UnwindSafe + RefUnwindSafe,
 <SR_API_BLOCK as BlockT>::Header: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn version(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<RuntimeVersion, Self::Error>

Returns the version of the runtime.

source

fn version_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext
) -> Result<RuntimeVersion, Self::Error>

Returns the version of the runtime.

source

fn version_before_version_3(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<OldRuntimeVersion, Self::Error>

👎 Deprecated

Returns the version of the runtime.

source

fn version_before_version_3_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext
) -> Result<OldRuntimeVersion, Self::Error>

👎 Deprecated

Returns the version of the runtime.

source

fn execute_block(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 block: Block
) -> Result<(), Self::Error>

Execute the given block.

source

fn execute_block_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 block: Block
) -> Result<(), Self::Error>

Execute the given block.

source

fn initialize_block(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 header: &<Block as Block>::Header
) -> Result<(), Self::Error>

Initialize a block with the given header.

source

fn initialize_block_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 header: &<Block as Block>::Header
) -> Result<(), Self::Error>

Initialize a block with the given header.

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> GrandpaApi<SR_API_BLOCK> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 GrandpaAuthorityList: UnwindSafe + RefUnwindSafe,
 EquivocationProof<<SR_API_BLOCK as BlockT>::Hash, NumberFor<SR_API_BLOCK>>: UnwindSafe + RefUnwindSafe,
 OpaqueKeyOwnershipProof: UnwindSafe + RefUnwindSafe,
 Option<()>: UnwindSafe + RefUnwindSafe,
 SetId: UnwindSafe + RefUnwindSafe,
 GrandpaId: UnwindSafe + RefUnwindSafe,
 Option<OpaqueKeyOwnershipProof>: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn grandpa_authorities(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<Vec<(Public, u64 ), Global>, Self::Error>

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 grandpa_authorities_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext
) -> Result<Vec<(Public, u64 ), Global>, Self::Error>

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__: &BlockId<Block>,
 equivocation_proof: EquivocationProof<<Block as Block>::Hash, <<Block as Block>::Header as Header>::Number>,
 key_owner_proof: OpaqueKeyOwnershipProof
) -> Result<Option<()>, Self::Error>

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

source

fn submit_report_equivocation_unsigned_extrinsic_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 equivocation_proof: EquivocationProof<<Block as Block>::Hash, <<Block as Block>::Header as Header>::Number>,
 key_owner_proof: OpaqueKeyOwnershipProof
) -> Result<Option<()>, Self::Error>

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

source

fn generate_key_ownership_proof(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 set_id: u64,
 authority_id: Public
) -> Result<Option<OpaqueKeyOwnershipProof>, Self::Error>

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

source

fn generate_key_ownership_proof_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 set_id: u64,
 authority_id: Public
) -> Result<Option<OpaqueKeyOwnershipProof>, Self::Error>

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

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> Metadata<SR_API_BLOCK> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 OpaqueMetadata: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn metadata(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<OpaqueMetadata, Self::Error>

Returns the metadata of a runtime.

source

fn metadata_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext
) -> Result<OpaqueMetadata, Self::Error>

Returns the metadata of a runtime.

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> OffchainWorkerApi<SR_API_BLOCK> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 <SR_API_BLOCK as BlockT>::Header: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn offchain_worker_before_version_2(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 number: <<Block as Block>::Header as Header>::Number
) -> Result<(), Self::Error>

👎 Deprecated

Starts the off-chain task for given block number.

source

fn offchain_worker_before_version_2_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 number: <<Block as Block>::Header as Header>::Number
) -> Result<(), Self::Error>

👎 Deprecated

Starts the off-chain task for given block number.

source

fn offchain_worker(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 header: &<Block as Block>::Header
) -> Result<(), Self::Error>

Starts the off-chain task for given block header.

source

fn offchain_worker_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 header: &<Block as Block>::Header
) -> Result<(), Self::Error>

Starts the off-chain task for given block header.

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> SessionKeys<SR_API_BLOCK> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 Option<Vec<u8>>: UnwindSafe + RefUnwindSafe,
 Vec<u8>: UnwindSafe + RefUnwindSafe,
 Vec<u8>: UnwindSafe + RefUnwindSafe,
 Option<Vec<(Vec<u8>, KeyTypeId )>>: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn generate_session_keys(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 seed: Option<Vec<u8, Global>>
) -> Result<Vec<u8, Global>, Self::Error>

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

fn generate_session_keys_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 seed: Option<Vec<u8, Global>>
) -> Result<Vec<u8, Global>, Self::Error>

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

fn decode_session_keys(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 encoded: Vec<u8, Global>
) -> Result<Option<Vec<(Vec<u8, Global>, KeyTypeId ), Global>>, Self::Error>

Decode the given public session keys. Read more

source

fn decode_session_keys_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 encoded: Vec<u8, Global>
) -> Result<Option<Vec<(Vec<u8, Global>, KeyTypeId ), Global>>, Self::Error>

Decode the given public session keys. Read more

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> TaggedTransactionQueue<SR_API_BLOCK> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 TransactionSource: UnwindSafe + RefUnwindSafe,
 <SR_API_BLOCK as BlockT>::Extrinsic: UnwindSafe + RefUnwindSafe,
 TransactionValidity: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn validate_transaction_before_version_2(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 tx: <Block as Block>::Extrinsic
) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

👎 Deprecated

Validate the transaction.

source

fn validate_transaction_before_version_2_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 tx: <Block as Block>::Extrinsic
) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

👎 Deprecated

Validate the transaction.

source

fn validate_transaction(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 source: TransactionSource,
 tx: <Block as Block>::Extrinsic
) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

Validate the transaction. Read more

source

fn validate_transaction_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 source: TransactionSource,
 tx: <Block as Block>::Extrinsic
) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

Validate the transaction. Read more

source

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> TransactionPaymentApi<SR_API_BLOCK, u128> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where
 RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>,
 <SR_API_BLOCK as BlockT>::Extrinsic: UnwindSafe + RefUnwindSafe,
 u32: UnwindSafe + RefUnwindSafe,
 RuntimeDispatchInfo<Balance>: UnwindSafe + RefUnwindSafe,
 <SR_API_BLOCK as BlockT>::Extrinsic: UnwindSafe + RefUnwindSafe,
 u32: UnwindSafe + RefUnwindSafe,
 FeeDetails<Balance>: UnwindSafe + RefUnwindSafe,
 SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe,

source

fn query_info(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 uxt: <Block as Block>::Extrinsic,
 len: u32
) -> Result<RuntimeDispatchInfo<Balance>, Self::Error>

source

fn query_info_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 uxt: <Block as Block>::Extrinsic,
 len: u32
) -> Result<RuntimeDispatchInfo<Balance>, Self::Error>

source

fn query_fee_details(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 uxt: <Block as Block>::Extrinsic,
 len: u32
) -> Result<FeeDetails<Balance>, Self::Error>

source

fn query_fee_details_with_context(
 &self,
 __runtime_api_at_param__: &BlockId<Block>,
 context: ExecutionContext,
 uxt: <Block as Block>::Extrinsic,
 len: u32
) -> Result<FeeDetails<Balance>, Self::Error>

source

impl<Block: BlockT, C: CallApiAt<Block>> Send for RuntimeApiImpl<Block, C> where
C::StateBackend: StateBackend<HashFor<Block>>,

source

impl<Block: BlockT, C: CallApiAt<Block>> Sync for RuntimeApiImpl<Block, C> where
C::StateBackend: StateBackend<HashFor<Block>>,

Auto Trait Implementations

impl<Block, C> !RefUnwindSafe for RuntimeApiImpl<Block, C>

impl<Block, C> Unpin for RuntimeApiImpl<Block, C> where
 <Block as Block>::Hash: Unpin,
 <<Block as Block>::Header as Header>::Hashing: Unpin,
 <<Block as Block>::Header as Header>::Number: Unpin,
 <<C as CallApiAt<Block>>::StateBackend as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction: Unpin,

impl<Block, C> !UnwindSafe for RuntimeApiImpl<Block, C>

Blanket Implementations

source

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

source

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

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

const: unstable · source

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

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

const: unstable · source

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

Mutably borrows from an owned value. 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

source

impl<T> From<T> for T

const: unstable · source

pub fn from(t: T) -> T

Returns the argument unchanged.

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> 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 for T where
U: From<T>,

const: unstable · source

pub 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> IsType<T> for T

source

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

Cast reference.

source

pub fn into_ref(&self) -> &T

Cast reference.

source

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

Cast mutable reference.

source

pub 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

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

Get a reference to the inner from the outer.

source

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

Get a mutable reference to the inner from the outer.

source

impl<T> Same<T> 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<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,

source

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

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

source

pub fn is_in_subset(&self) -> bool

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

source

pub fn to_subset_unchecked(&self) -> SS

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

source

pub fn from_subset(element: &SS) -> SP

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

source

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

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

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

Performs the conversion.

source

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

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

source

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

source

pub 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

pub fn unique_saturated_into(self) -> T

Consume self to return an equivalent value of 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

Struct anagolay_runtime::RuntimeApiImpl

Trait Implementations

fn account_nonce( &self, __runtime_api_at_param__: &BlockId<Block>, account: AccountId) -> Result<Index, Self::Error>

fn account_nonce_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, account: AccountId) -> Result<Index, Self::Error>

impl<Block: BlockT, C: CallApiAt<Block>> ApiErrorExt for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,

type Error = C::Error

impl<Block: BlockT, C: CallApiAt<Block>> ApiExt<Block> for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,

type StateBackend = C::StateBackend

fn execute_in_transaction<F: FnOnce(&Self) -> TransactionOutcome<R>, R>( &self, call: F) -> R where Self: Sized,

fn has_api<A: RuntimeApiInfo + ?Sized>( &self, at: &BlockId<Block>) -> Result<bool, C::Error> where Self: Sized,

fn has_api_with<A: RuntimeApiInfo + ?Sized, P: Fn(u32) -> bool>( &self, at: &BlockId<Block>, pred: P) -> Result<bool, C::Error> where Self: Sized,

fn record_proof(&mut self)

fn extract_proof(&mut self) -> Option<StorageProof>

fn into_storage_changes( &self, backend: &Self::StateBackend, changes_trie_state: Option<&ChangesTrieState<'_, HashFor<Block>, NumberFor<Block>>>, parent_hash: Block::Hash) -> Result<StorageChanges<Self::StateBackend, Block>, String> where Self: Sized,

fn slot_duration( &self, __runtime_api_at_param__: &BlockId<Block>) -> Result<u64, Self::Error>

fn slot_duration_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext) -> Result<u64, Self::Error>

fn authorities( &self, __runtime_api_at_param__: &BlockId<Block>) -> Result<Vec<AuthorityId, Global>, Self::Error>

fn authorities_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext) -> Result<Vec<AuthorityId, Global>, Self::Error>

fn dispatch_benchmark( &self, __runtime_api_at_param__: &BlockId<Block>, config: BenchmarkConfig) -> Result<Result<Vec<BenchmarkBatch, Global>, RuntimeString>, Self::Error>

fn dispatch_benchmark_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, config: BenchmarkConfig) -> Result<Result<Vec<BenchmarkBatch, Global>, RuntimeString>, Self::Error>

fn apply_extrinsic( &self, __runtime_api_at_param__: &BlockId<Block>, extrinsic: <Block as Block>::Extrinsic) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, Self::Error>

fn apply_extrinsic_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, extrinsic: <Block as Block>::Extrinsic) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, Self::Error>

fn finalize_block( &self, __runtime_api_at_param__: &BlockId<Block>) -> Result<<Block as Block>::Header, Self::Error>

fn finalize_block_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext) -> Result<<Block as Block>::Header, Self::Error>

fn inherent_extrinsics( &self, __runtime_api_at_param__: &BlockId<Block>, inherent: InherentData) -> Result<Vec<<Block as Block>::Extrinsic, Global>, Self::Error>

fn inherent_extrinsics_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, inherent: InherentData) -> Result<Vec<<Block as Block>::Extrinsic, Global>, Self::Error>

fn check_inherents( &self, __runtime_api_at_param__: &BlockId<Block>, block: Block, data: InherentData) -> Result<CheckInherentsResult, Self::Error>

fn check_inherents_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, block: Block, data: InherentData) -> Result<CheckInherentsResult, Self::Error>

fn random_seed( &self, __runtime_api_at_param__: &BlockId<Block>) -> Result<<Block as Block>::Hash, Self::Error>

fn random_seed_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext) -> Result<<Block as Block>::Hash, Self::Error>

fn version( &self, __runtime_api_at_param__: &BlockId<Block>) -> Result<RuntimeVersion, Self::Error>

fn version_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext) -> Result<RuntimeVersion, Self::Error>

fn version_before_version_3( &self, __runtime_api_at_param__: &BlockId<Block>) -> Result<OldRuntimeVersion, Self::Error>

fn version_before_version_3_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext) -> Result<OldRuntimeVersion, Self::Error>

fn execute_block( &self, __runtime_api_at_param__: &BlockId<Block>, block: Block) -> Result<(), Self::Error>

fn execute_block_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, block: Block) -> Result<(), Self::Error>

fn initialize_block( &self, __runtime_api_at_param__: &BlockId<Block>, header: &<Block as Block>::Header) -> Result<(), Self::Error>

fn initialize_block_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, header: &<Block as Block>::Header) -> Result<(), Self::Error>

fn grandpa_authorities( &self, __runtime_api_at_param__: &BlockId<Block>) -> Result<Vec<(Public, u64), Global>, Self::Error>

fn grandpa_authorities_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext) -> Result<Vec<(Public, u64), Global>, Self::Error>

fn submit_report_equivocation_unsigned_extrinsic( &self, __runtime_api_at_param__: &BlockId<Block>, equivocation_proof: EquivocationProof<<Block as Block>::Hash, <<Block as Block>::Header as Header>::Number>, key_owner_proof: OpaqueKeyOwnershipProof) -> Result<Option<()>, Self::Error>

fn generate_key_ownership_proof( &self, __runtime_api_at_param__: &BlockId<Block>, set_id: u64, authority_id: Public) -> Result<Option<OpaqueKeyOwnershipProof>, Self::Error>

fn generate_key_ownership_proof_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, set_id: u64, authority_id: Public) -> Result<Option<OpaqueKeyOwnershipProof>, Self::Error>

fn metadata( &self, __runtime_api_at_param__: &BlockId<Block>) -> Result<OpaqueMetadata, Self::Error>

fn metadata_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext) -> Result<OpaqueMetadata, Self::Error>

fn offchain_worker_before_version_2( &self, __runtime_api_at_param__: &BlockId<Block>, number: <<Block as Block>::Header as Header>::Number) -> Result<(), Self::Error>

fn offchain_worker_before_version_2_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, number: <<Block as Block>::Header as Header>::Number) -> Result<(), Self::Error>

fn offchain_worker( &self, __runtime_api_at_param__: &BlockId<Block>, header: &<Block as Block>::Header) -> Result<(), Self::Error>

fn offchain_worker_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, header: &<Block as Block>::Header) -> Result<(), Self::Error>

fn generate_session_keys( &self, __runtime_api_at_param__: &BlockId<Block>, seed: Option<Vec<u8, Global>>) -> Result<Vec<u8, Global>, Self::Error>

fn generate_session_keys_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, seed: Option<Vec<u8, Global>>) -> Result<Vec<u8, Global>, Self::Error>

fn decode_session_keys( &self, __runtime_api_at_param__: &BlockId<Block>, encoded: Vec<u8, Global>) -> Result<Option<Vec<(Vec<u8, Global>, KeyTypeId), Global>>, Self::Error>

fn decode_session_keys_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, encoded: Vec<u8, Global>) -> Result<Option<Vec<(Vec<u8, Global>, KeyTypeId), Global>>, Self::Error>

fn validate_transaction_before_version_2( &self, __runtime_api_at_param__: &BlockId<Block>, tx: <Block as Block>::Extrinsic) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

fn validate_transaction_before_version_2_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, tx: <Block as Block>::Extrinsic) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

fn validate_transaction( &self, __runtime_api_at_param__: &BlockId<Block>, source: TransactionSource, tx: <Block as Block>::Extrinsic) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

fn validate_transaction_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, source: TransactionSource, tx: <Block as Block>::Extrinsic) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

fn query_info( &self, __runtime_api_at_param__: &BlockId<Block>, uxt: <Block as Block>::Extrinsic, len: u32) -> Result<RuntimeDispatchInfo<Balance>, Self::Error>

fn query_info_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, uxt: <Block as Block>::Extrinsic, len: u32) -> Result<RuntimeDispatchInfo<Balance>, Self::Error>

fn query_fee_details( &self, __runtime_api_at_param__: &BlockId<Block>, uxt: <Block as Block>::Extrinsic, len: u32) -> Result<FeeDetails<Balance>, Self::Error>

fn query_fee_details_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, uxt: <Block as Block>::Extrinsic, len: u32) -> Result<FeeDetails<Balance>, Self::Error>

impl<Block: BlockT, C: CallApiAt<Block>> Send for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,

impl<Block: BlockT, C: CallApiAt<Block>> Sync for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,

Auto Trait Implementations

impl<Block, C> !RefUnwindSafe for RuntimeApiImpl<Block, C>

impl<Block, C> !UnwindSafe for RuntimeApiImpl<Block, C>

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

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

pub fn borrow(&self) -> &T

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

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

impl<T> CheckedConversion for T

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

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

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> Instrument for T

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

fn account_nonce(
&self,
__runtime_api_at_param__: &BlockId<Block>,
account: AccountId
) -> Result<Index, Self::Error>

fn account_nonce_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
account: AccountId
) -> Result<Index, Self::Error>

impl<Block: BlockT, C: CallApiAt<Block>> ApiErrorExt for RuntimeApiImpl<Block, C> where
C::StateBackend: StateBackend<HashFor<Block>>,

impl<Block: BlockT, C: CallApiAt<Block>> ApiExt<Block> for RuntimeApiImpl<Block, C> where
C::StateBackend: StateBackend<HashFor<Block>>,

fn execute_in_transaction<F: FnOnce(&Self) -> TransactionOutcome<R>, R>(
&self,
call: F
) -> R where
Self: Sized,

fn has_api<A: RuntimeApiInfo + ?Sized>(
&self,
at: &BlockId<Block>
) -> Result<bool, C::Error> where
Self: Sized,

fn has_api_with<A: RuntimeApiInfo + ?Sized, P: Fn(u32) -> bool>(
&self,
at: &BlockId<Block>,
pred: P
) -> Result<bool, C::Error> where
Self: Sized,

fn into_storage_changes(
&self,
backend: &Self::StateBackend,
changes_trie_state: Option<&ChangesTrieState<'_, HashFor<Block>, NumberFor<Block>>>,
parent_hash: Block::Hash
) -> Result<StorageChanges<Self::StateBackend, Block>, String> where
Self: Sized,

fn slot_duration(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<u64, Self::Error>

fn slot_duration_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext
) -> Result<u64, Self::Error>

fn authorities(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<Vec<AuthorityId, Global>, Self::Error>

fn authorities_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext
) -> Result<Vec<AuthorityId, Global>, Self::Error>

fn dispatch_benchmark(
&self,
__runtime_api_at_param__: &BlockId<Block>,
config: BenchmarkConfig
) -> Result<Result<Vec<BenchmarkBatch, Global>, RuntimeString>, Self::Error>

fn dispatch_benchmark_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
config: BenchmarkConfig
) -> Result<Result<Vec<BenchmarkBatch, Global>, RuntimeString>, Self::Error>

fn apply_extrinsic(
&self,
__runtime_api_at_param__: &BlockId<Block>,
extrinsic: <Block as Block>::Extrinsic
) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, Self::Error>

fn apply_extrinsic_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
extrinsic: <Block as Block>::Extrinsic
) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, Self::Error>

fn finalize_block(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<<Block as Block>::Header, Self::Error>

fn finalize_block_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext
) -> Result<<Block as Block>::Header, Self::Error>

fn inherent_extrinsics(
&self,
__runtime_api_at_param__: &BlockId<Block>,
inherent: InherentData
) -> Result<Vec<<Block as Block>::Extrinsic, Global>, Self::Error>

fn inherent_extrinsics_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
inherent: InherentData
) -> Result<Vec<<Block as Block>::Extrinsic, Global>, Self::Error>

fn check_inherents(
&self,
__runtime_api_at_param__: &BlockId<Block>,
block: Block,
data: InherentData
) -> Result<CheckInherentsResult, Self::Error>

fn check_inherents_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
block: Block,
data: InherentData
) -> Result<CheckInherentsResult, Self::Error>

fn random_seed(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<<Block as Block>::Hash, Self::Error>

fn random_seed_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext
) -> Result<<Block as Block>::Hash, Self::Error>

fn version(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<RuntimeVersion, Self::Error>

fn version_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext
) -> Result<RuntimeVersion, Self::Error>

fn version_before_version_3(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<OldRuntimeVersion, Self::Error>

fn version_before_version_3_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext
) -> Result<OldRuntimeVersion, Self::Error>

fn execute_block(
&self,
__runtime_api_at_param__: &BlockId<Block>,
block: Block
) -> Result<(), Self::Error>

fn execute_block_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
block: Block
) -> Result<(), Self::Error>

fn initialize_block(
&self,
__runtime_api_at_param__: &BlockId<Block>,
header: &<Block as Block>::Header
) -> Result<(), Self::Error>

fn initialize_block_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
header: &<Block as Block>::Header
) -> Result<(), Self::Error>

fn grandpa_authorities(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<Vec<(Public, u64 ), Global>, Self::Error>

fn grandpa_authorities_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext
) -> Result<Vec<(Public, u64 ), Global>, Self::Error>

fn submit_report_equivocation_unsigned_extrinsic(
&self,
__runtime_api_at_param__: &BlockId<Block>,
equivocation_proof: EquivocationProof<<Block as Block>::Hash, <<Block as Block>::Header as Header>::Number>,
key_owner_proof: OpaqueKeyOwnershipProof
) -> Result<Option<()>, Self::Error>

fn generate_key_ownership_proof(
&self,
__runtime_api_at_param__: &BlockId<Block>,
set_id: u64,
authority_id: Public
) -> Result<Option<OpaqueKeyOwnershipProof>, Self::Error>

fn generate_key_ownership_proof_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
set_id: u64,
authority_id: Public
) -> Result<Option<OpaqueKeyOwnershipProof>, Self::Error>

fn metadata(
&self,
__runtime_api_at_param__: &BlockId<Block>
) -> Result<OpaqueMetadata, Self::Error>

fn metadata_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext
) -> Result<OpaqueMetadata, Self::Error>

fn offchain_worker_before_version_2(
&self,
__runtime_api_at_param__: &BlockId<Block>,
number: <<Block as Block>::Header as Header>::Number
) -> Result<(), Self::Error>

fn offchain_worker_before_version_2_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
number: <<Block as Block>::Header as Header>::Number
) -> Result<(), Self::Error>

fn offchain_worker(
&self,
__runtime_api_at_param__: &BlockId<Block>,
header: &<Block as Block>::Header
) -> Result<(), Self::Error>

fn offchain_worker_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
header: &<Block as Block>::Header
) -> Result<(), Self::Error>

fn generate_session_keys(
&self,
__runtime_api_at_param__: &BlockId<Block>,
seed: Option<Vec<u8, Global>>
) -> Result<Vec<u8, Global>, Self::Error>

fn generate_session_keys_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
seed: Option<Vec<u8, Global>>
) -> Result<Vec<u8, Global>, Self::Error>

fn decode_session_keys(
&self,
__runtime_api_at_param__: &BlockId<Block>,
encoded: Vec<u8, Global>
) -> Result<Option<Vec<(Vec<u8, Global>, KeyTypeId ), Global>>, Self::Error>

fn decode_session_keys_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
encoded: Vec<u8, Global>
) -> Result<Option<Vec<(Vec<u8, Global>, KeyTypeId ), Global>>, Self::Error>

fn validate_transaction_before_version_2(
&self,
__runtime_api_at_param__: &BlockId<Block>,
tx: <Block as Block>::Extrinsic
) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

fn validate_transaction_before_version_2_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
tx: <Block as Block>::Extrinsic
) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

fn validate_transaction(
&self,
__runtime_api_at_param__: &BlockId<Block>,
source: TransactionSource,
tx: <Block as Block>::Extrinsic
) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

fn validate_transaction_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
source: TransactionSource,
tx: <Block as Block>::Extrinsic
) -> Result<Result<ValidTransaction, TransactionValidityError>, Self::Error>

fn query_info(
&self,
__runtime_api_at_param__: &BlockId<Block>,
uxt: <Block as Block>::Extrinsic,
len: u32
) -> Result<RuntimeDispatchInfo<Balance>, Self::Error>

fn query_info_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
uxt: <Block as Block>::Extrinsic,
len: u32
) -> Result<RuntimeDispatchInfo<Balance>, Self::Error>

fn query_fee_details(
&self,
__runtime_api_at_param__: &BlockId<Block>,
uxt: <Block as Block>::Extrinsic,
len: u32
) -> Result<FeeDetails<Balance>, Self::Error>

fn query_fee_details_with_context(
&self,
__runtime_api_at_param__: &BlockId<Block>,
context: ExecutionContext,
uxt: <Block as Block>::Extrinsic,
len: u32
) -> Result<FeeDetails<Balance>, Self::Error>

impl<Block: BlockT, C: CallApiAt<Block>> Send for RuntimeApiImpl<Block, C> where
C::StateBackend: StateBackend<HashFor<Block>>,

impl<Block: BlockT, C: CallApiAt<Block>> Sync for RuntimeApiImpl<Block, C> where
C::StateBackend: StateBackend<HashFor<Block>>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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