Struct governance_os_runtime::RuntimeApiImpl[−][src]

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

Implements all runtime apis for the client side.

Trait Implementations

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, [src]

`fn AccountNonceApi_account_nonce_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<AccountId>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<Index>, RuntimeApiImplCall::Error>`[src]

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

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

`impl<Block: BlockT, C: CallApiAt<Block>> ApiErrorExt for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,` [src]

`type Error = C::Error`

Error type used by the runtime apis.

`impl<Block: BlockT, C: CallApiAt<Block>> ApiExt<Block> for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,` [src]

`type StateBackend = C::StateBackend`

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

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

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

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

`fn record_proof(&mut self)`[src]

`fn extract_proof(&mut self) -> Option<StorageProof>`[src]

`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,` [src]

`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,` [src]

`fn AuraApi_slot_duration_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<u64>, RuntimeApiImplCall::Error>`[src]

`fn AuraApi_authorities_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<Vec<AuraId>>, RuntimeApiImplCall::Error>`[src]

`pub fn slot_duration( &self, __runtime_api_at_param__: &BlockId<Block> ) -> Result<u64, Self::Error>`[src]

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

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

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

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, [src]

`fn BlockBuilder_apply_extrinsic_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK>, context: ExecutionContext, params: Option<<SR_API_BLOCK__ as BlockT>::Extrinsic>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<ApplyExtrinsicResult>, RuntimeApiImplCall::Error>`[src]

`fn BlockBuilder_finalize_block_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<<__SR_API_BLOCK__ as BlockT>::Header>, RuntimeApiImplCall::Error>`[src]

`fn BlockBuilder_inherent_extrinsics_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<InherentData>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<Vec<<__SR_API_BLOCK__ as BlockT>::Extrinsic>>, RuntimeApiImplCall::Error>`[src]

`fn BlockBuilder_check_inherents_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK>, context: ExecutionContext, params: Option<(SR_API_BLOCK__, InherentData)>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<CheckInherentsResult>, RuntimeApiImplCall::Error>`[src]

`fn BlockBuilder_random_seed_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<<__SR_API_BLOCK__ as BlockT>::Hash>, RuntimeApiImplCall::Error>`[src]

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

`pub 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>`[src]

`pub fn finalize_block( &self, __runtime_api_at_param__: &BlockId<Block> ) -> Result<<Block as Block>::Header, Self::Error>`[src]

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

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

`pub 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>`[src]

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

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

`pub fn random_seed( &self, __runtime_api_at_param__: &BlockId<Block> ) -> Result<<Block as Block>::Hash, Self::Error>`[src]

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

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, [src]

`fn Core_version_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<RuntimeVersion>, RuntimeApiImplCall::Error>`[src]

`fn Core_execute_block_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK>, context: ExecutionContext, params: Option<SR_API_BLOCK__>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<()>, RuntimeApiImplCall::Error>`[src]

`fn Core_initialize_block_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK>, context: ExecutionContext, params: Option<&<SR_API_BLOCK__ as BlockT>::Header>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<()>, RuntimeApiImplCall::Error>`[src]

`pub fn version( &self, __runtime_api_at_param__: &BlockId<Block> ) -> Result<RuntimeVersion, Self::Error>`[src]

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

`pub fn version_before_version_3( &self, __runtime_api_at_param__: &BlockId<Block> ) -> Result<OldRuntimeVersion, Self::Error>`[src]

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

`pub fn execute_block( &self, __runtime_api_at_param__: &BlockId<Block>, block: Block ) -> Result<(), Self::Error>`[src]

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

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

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

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, [src]

`fn GrandpaApi_grandpa_authorities_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<GrandpaAuthorityList>, RuntimeApiImplCall::Error>`[src]

`fn GrandpaApi_submit_report_equivocation_unsigned_extrinsic_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK>, context: ExecutionContext, params: Option<(EquivocationProof<<SR_API_BLOCK as BlockT>::Hash, NumberFor<SR_API_BLOCK__>>, OpaqueKeyOwnershipProof)>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<Option<()>>, RuntimeApiImplCall::Error>`[src]

`fn GrandpaApi_generate_key_ownership_proof_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<(SetId, GrandpaId)>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<Option<OpaqueKeyOwnershipProof>>, RuntimeApiImplCall::Error>`[src]

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

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

`pub 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>`[src]

`pub 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>`[src]

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

`pub 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>`[src]

`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,` [src]

`fn Metadata_metadata_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<OpaqueMetadata>, RuntimeApiImplCall::Error>`[src]

`pub fn metadata( &self, __runtime_api_at_param__: &BlockId<Block> ) -> Result<OpaqueMetadata, Self::Error>`[src]

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

`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,` [src]

`fn OffchainWorkerApi_offchain_worker_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK>, context: ExecutionContext, params: Option<&<SR_API_BLOCK__ as BlockT>::Header>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<()>, RuntimeApiImplCall::Error>`[src]

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

`pub 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>`[src]

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

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

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, [src]

`fn SessionKeys_generate_session_keys_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<Option<Vec<u8>>>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<Vec<u8>>, RuntimeApiImplCall::Error>`[src]

`fn SessionKeys_decode_session_keys_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<Vec<u8>>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<Option<Vec<(Vec<u8>, KeyTypeId)>>>, RuntimeApiImplCall::Error>`[src]

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

`pub 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>`[src]

`pub 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>`[src]

`pub 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>`[src]

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, [src]

`fn TaggedTransactionQueue_validate_transaction_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK>, context: ExecutionContext, params: Option<(TransactionSource, <SR_API_BLOCK__ as BlockT>::Extrinsic)>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<TransactionValidity>, RuntimeApiImplCall::Error>`[src]

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

`pub 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>`[src]

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

`pub 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>`[src]

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, [src]

`fn TransactionPaymentApi_query_info_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK>, context: ExecutionContext, params: Option<(<SR_API_BLOCK__ as BlockT>::Extrinsic, u32)>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<RuntimeDispatchInfo<Balance>>, RuntimeApiImplCall::Error>`[src]

`fn TransactionPaymentApi_query_fee_details_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK>, context: ExecutionContext, params: Option<(<SR_API_BLOCK__ as BlockT>::Extrinsic, u32)>, params_encoded: Vec<u8> ) -> Result<NativeOrEncoded<FeeDetails<Balance>>, RuntimeApiImplCall::Error>`[src]

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

`pub 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>`[src]

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

`pub 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>`[src]

`impl<Block: BlockT, C: CallApiAt<Block>> Send for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,` [src]

`impl<Block: BlockT, C: CallApiAt<Block>> Sync for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,` [src]

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

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> CheckedConversion for T`[src]

`pub fn checked_from<T>(t: T) -> Option<Self> where Self: TryFrom<T>,` [src]

`pub fn checked_into<T>(self) -> Option<T> where Self: TryInto<T>,` [src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T> Instrument for T`[src]

`pub fn instrument(self, span: Span) -> Instrumented<Self>`[src]

`pub fn in_current_span(self) -> Instrumented<Self>`[src]

`impl<T> Instrument for T`[src]

`pub fn instrument(self, span: Span) -> Instrumented<Self>`[src]

`pub fn in_current_span(self) -> Instrumented<Self>`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> IsType<T> for T`[src]

`pub fn from_ref(t: &T) -> &T`[src]

`pub fn into_ref(&self) -> &T`[src]

`pub fn from_mut(t: &mut T) -> &mut T`[src]

`pub fn into_mut(&mut self) -> &mut T`[src]

`impl<T, Outer> IsWrappedBy<Outer> for T where T: From<Outer>, Outer: AsRef<T> + AsMut<T> + From<T>,` [src]

`pub fn from_ref(outer: &Outer) -> &T`[src]

Get a reference to the inner from the outer.

`pub fn from_mut(outer: &mut Outer) -> &mut T`[src]

Get a mutable reference to the inner from the outer.

`impl<T> Same<T> for T`[src]

`type Output = T`

Should always be Self

`impl<T> SaturatedConversion for T`[src]

`pub fn saturated_from<T>(t: T) -> Self where Self: UniqueSaturatedFrom<T>,` [src]

`pub fn saturated_into<T>(self) -> T where Self: UniqueSaturatedInto<T>,` [src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

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

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

`impl<S, T> UncheckedInto<T> for S where T: UncheckedFrom<S>,` [src]

`pub fn unchecked_into(self) -> T`[src]

`impl<T, S> UniqueSaturatedInto<T> for S where T: Bounded, S: TryInto<T>,` [src]

`pub fn unique_saturated_into(self) -> T`[src]

`impl<V, T> VZip<V> for T where V: MultiLane<T>,` [src]

`pub fn vzip(self) -> V`[src]

`impl<T> WithSubscriber for T`[src]

`pub fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where S: Into<Dispatch>,` [src]

`pub fn with_current_subscriber(self) -> WithDispatch<Self>`[src]

Struct governance_os_runtime::RuntimeApiImpl⎘[−][src]

Trait Implementations

fn AccountNonceApi_account_nonce_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<AccountId>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<Index>, RuntimeApiImplCall::Error>[src]

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

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

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

type Error = C::Error

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

type StateBackend = C::StateBackend

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

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

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

fn record_proof(&mut self)[src]

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

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, [src]

fn AuraApi_slot_duration_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<u64>, RuntimeApiImplCall::Error>[src]

fn AuraApi_authorities_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<Vec<AuraId>>, RuntimeApiImplCall::Error>[src]

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

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

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

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

fn BlockBuilder_apply_extrinsic_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<<__SR_API_BLOCK__ as BlockT>::Extrinsic>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<ApplyExtrinsicResult>, RuntimeApiImplCall::Error>[src]

fn BlockBuilder_finalize_block_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<<__SR_API_BLOCK__ as BlockT>::Header>, RuntimeApiImplCall::Error>[src]

fn BlockBuilder_inherent_extrinsics_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<InherentData>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<Vec<<__SR_API_BLOCK__ as BlockT>::Extrinsic>>, RuntimeApiImplCall::Error>[src]

fn BlockBuilder_check_inherents_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<(__SR_API_BLOCK__, InherentData)>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<CheckInherentsResult>, RuntimeApiImplCall::Error>[src]

fn BlockBuilder_random_seed_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<<__SR_API_BLOCK__ as BlockT>::Hash>, RuntimeApiImplCall::Error>[src]

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

pub 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>[src]

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

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

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

pub 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>[src]

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

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

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

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

fn Core_version_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<RuntimeVersion>, RuntimeApiImplCall::Error>[src]

fn Core_execute_block_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<__SR_API_BLOCK__>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<()>, RuntimeApiImplCall::Error>[src]

fn Core_initialize_block_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<&<__SR_API_BLOCK__ as BlockT>::Header>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<()>, RuntimeApiImplCall::Error>[src]

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

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

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

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

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

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

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

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

fn GrandpaApi_grandpa_authorities_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<GrandpaAuthorityList>, RuntimeApiImplCall::Error>[src]

fn GrandpaApi_generate_key_ownership_proof_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<(SetId, GrandpaId)>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<Option<OpaqueKeyOwnershipProof>>, RuntimeApiImplCall::Error>[src]

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

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

pub 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>[src]

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

pub 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>[src]

fn Metadata_metadata_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<()>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<OpaqueMetadata>, RuntimeApiImplCall::Error>[src]

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

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

fn OffchainWorkerApi_offchain_worker_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<&<__SR_API_BLOCK__ as BlockT>::Header>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<()>, RuntimeApiImplCall::Error>[src]

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

pub 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>[src]

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

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

fn SessionKeys_generate_session_keys_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<Option<Vec<u8>>>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<Vec<u8>>, RuntimeApiImplCall::Error>[src]

fn SessionKeys_decode_session_keys_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<Vec<u8>>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<Option<Vec<(Vec<u8>, KeyTypeId)>>>, RuntimeApiImplCall::Error>[src]

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

pub 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>[src]

pub 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>[src]

pub 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>[src]

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

pub 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>[src]

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

pub 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>[src]

fn TransactionPaymentApi_query_info_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<(<__SR_API_BLOCK__ as BlockT>::Extrinsic, u32)>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<RuntimeDispatchInfo<Balance>>, RuntimeApiImplCall::Error>[src]

fn TransactionPaymentApi_query_fee_details_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<(<__SR_API_BLOCK__ as BlockT>::Extrinsic, u32)>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<FeeDetails<Balance>>, RuntimeApiImplCall::Error>[src]

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

pub 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>[src]

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

pub 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>[src]

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

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