Struct subsocial_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> PostsApi<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>>, Vec<PostId>: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u16: UnwindSafe + RefUnwindSafe, Vec<FlatPost<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, Vec<FlatPostKind>: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u16: UnwindSafe + RefUnwindSafe, Vec<FlatPost<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, SpaceId: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u16: UnwindSafe + RefUnwindSafe, Vec<FlatPost<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, SpaceId: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u16: UnwindSafe + RefUnwindSafe, Vec<FlatPost<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, PostId: UnwindSafe + RefUnwindSafe, Vec<PostId>: UnwindSafe + RefUnwindSafe, Vec<PostId>: UnwindSafe + RefUnwindSafe, BTreeMap<PostId, Vec<PostId>>: UnwindSafe + RefUnwindSafe, PostId: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u16: UnwindSafe + RefUnwindSafe, Vec<FlatPost<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, Vec<PostId>: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u16: UnwindSafe + RefUnwindSafe, RepliesByPostId<AccountId, BlockNumber>: UnwindSafe + RefUnwindSafe, SpaceId: UnwindSafe + RefUnwindSafe, Vec<PostId>: UnwindSafe + RefUnwindSafe, SpaceId: UnwindSafe + RefUnwindSafe, Vec<PostId>: UnwindSafe + RefUnwindSafe, PostId: UnwindSafe + RefUnwindSafe, AccountId: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u16: UnwindSafe + RefUnwindSafe, Vec<FlatPost<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe, [src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`pub fn get_posts_by_ids( &self, __runtime_api_at_param__: &BlockId<Block>, post_ids: Vec<u64, Global>, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_posts_by_ids_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, post_ids: Vec<u64, Global>, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_public_posts( &self, __runtime_api_at_param__: &BlockId<Block>, kind_filter: Vec<FlatPostKind, Global>, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_public_posts_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, kind_filter: Vec<FlatPostKind, Global>, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_public_posts_by_space_id( &self, __runtime_api_at_param__: &BlockId<Block>, space_id: u64, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_public_posts_by_space_id_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, space_id: u64, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_unlisted_posts_by_space_id( &self, __runtime_api_at_param__: &BlockId<Block>, space_id: u64, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_unlisted_posts_by_space_id_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, space_id: u64, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

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

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

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

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

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

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

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

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

`pub fn get_replies_by_parent_id( &self, __runtime_api_at_param__: &BlockId<Block>, parent_id: u64, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_replies_by_parent_id_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, parent_id: u64, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_replies_by_parent_ids( &self, __runtime_api_at_param__: &BlockId<Block>, parent_ids: Vec<u64, Global>, offset: u64, limit: u16 ) -> Result<BTreeMap<u64, Vec<FlatPost<AccountId, BlockNumber>, Global>>, Self::Error>`[src]

`pub fn get_replies_by_parent_ids_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, parent_ids: Vec<u64, Global>, offset: u64, limit: u16 ) -> Result<BTreeMap<u64, Vec<FlatPost<AccountId, BlockNumber>, Global>>, Self::Error>`[src]

`pub fn get_feed( &self, __runtime_api_at_param__: &BlockId<Block>, account: AccountId, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_feed_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, account: AccountId, offset: u64, limit: u16 ) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>`[src]

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> ProfileFollowsApi<SR_API_BLOCK, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>, AccountId: UnwindSafe + RefUnwindSafe, Vec<AccountId>: UnwindSafe + RefUnwindSafe, Vec<AccountId>: UnwindSafe + RefUnwindSafe, SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe, [src]

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

`pub fn filter_followed_accounts( &self, __runtime_api_at_param__: &BlockId<Block>, account: AccountId, maybe_following: Vec<AccountId, Global> ) -> Result<Vec<AccountId, Global>, Self::Error>`[src]

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

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> ProfilesApi<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>>, Vec<AccountId>: UnwindSafe + RefUnwindSafe, Vec<FlatSocialAccount<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe, [src]

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

`pub fn get_social_accounts_by_ids( &self, __runtime_api_at_param__: &BlockId<Block>, account_ids: Vec<AccountId, Global> ) -> Result<Vec<FlatSocialAccount<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_social_accounts_by_ids_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, account_ids: Vec<AccountId, Global> ) -> Result<Vec<FlatSocialAccount<AccountId, BlockNumber>, Global>, Self::Error>`[src]

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> ReactionsApi<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>>, Vec<ReactionId>: UnwindSafe + RefUnwindSafe, Vec<FlatReaction<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, PostId: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, Vec<FlatReaction<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, Vec<PostId>: UnwindSafe + RefUnwindSafe, AccountId: UnwindSafe + RefUnwindSafe, BTreeMap<PostId, ReactionKind>: UnwindSafe + RefUnwindSafe, SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe, [src]

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

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

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

`pub fn get_reactions_by_ids( &self, __runtime_api_at_param__: &BlockId<Block>, reaction_ids: Vec<u64, Global> ) -> Result<Vec<FlatReaction<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_reactions_by_ids_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, reaction_ids: Vec<u64, Global> ) -> Result<Vec<FlatReaction<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_reactions_by_post_id( &self, __runtime_api_at_param__: &BlockId<Block>, post_id: u64, limit: u64, offset: u64 ) -> Result<Vec<FlatReaction<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_reactions_by_post_id_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, post_id: u64, limit: u64, offset: u64 ) -> Result<Vec<FlatReaction<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_reaction_kinds_by_post_ids_and_reactor( &self, __runtime_api_at_param__: &BlockId<Block>, post_ids: Vec<u64, Global>, reactor: AccountId ) -> Result<BTreeMap<u64, ReactionKind>, Self::Error>`[src]

`pub fn get_reaction_kinds_by_post_ids_and_reactor_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, post_ids: Vec<u64, Global>, reactor: AccountId ) -> Result<BTreeMap<u64, ReactionKind>, Self::Error>`[src]

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> RolesApi<SR_API_BLOCK, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>, AccountId: UnwindSafe + RefUnwindSafe, SpaceId: UnwindSafe + RefUnwindSafe, Vec<SpacePermission>: UnwindSafe + RefUnwindSafe, SpaceId: UnwindSafe + RefUnwindSafe, Vec<AccountId>: UnwindSafe + RefUnwindSafe, AccountId: UnwindSafe + RefUnwindSafe, Vec<SpaceId>: UnwindSafe + RefUnwindSafe, SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe, [src]

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

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

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

`pub fn get_space_permissions_by_account( &self, __runtime_api_at_param__: &BlockId<Block>, account: AccountId, space_id: u64 ) -> Result<Vec<SpacePermission, Global>, Self::Error>`[src]

`pub fn get_space_permissions_by_account_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, account: AccountId, space_id: u64 ) -> Result<Vec<SpacePermission, Global>, Self::Error>`[src]

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

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

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

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

`impl<Block: BlockT, C: CallApiAt<Block>> Send for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,` [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> SpaceFollowsApi<SR_API_BLOCK, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId> for RuntimeApiImpl<SR_API_BLOCK, RuntimeApiImplCall> where RuntimeApiImplCall::StateBackend: StateBackend<HashFor<SR_API_BLOCK>>, AccountId: UnwindSafe + RefUnwindSafe, Vec<SpaceId>: UnwindSafe + RefUnwindSafe, AccountId: UnwindSafe + RefUnwindSafe, Vec<SpaceId>: UnwindSafe + RefUnwindSafe, Vec<SpaceId>: UnwindSafe + RefUnwindSafe, SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe, [src]

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

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

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

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

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

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

impl<__SR_API_BLOCK: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<SR_API_BLOCK> + 'static> SpacesApi<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>>, u64: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, Vec<FlatSpace<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, Vec<SpaceId>: UnwindSafe + RefUnwindSafe, Vec<FlatSpace<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, Vec<FlatSpace<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, u64: UnwindSafe + RefUnwindSafe, Vec<FlatSpace<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, Vec<u8>: UnwindSafe + RefUnwindSafe, Option<SpaceId>: UnwindSafe + RefUnwindSafe, Vec<u8>: UnwindSafe + RefUnwindSafe, Option<FlatSpace<AccountId, BlockNumber>>: UnwindSafe + RefUnwindSafe, AccountId: UnwindSafe + RefUnwindSafe, Vec<SpaceId>: UnwindSafe + RefUnwindSafe, AccountId: UnwindSafe + RefUnwindSafe, Vec<SpaceId>: UnwindSafe + RefUnwindSafe, SpaceId: UnwindSafe + RefUnwindSafe, SR_API_BLOCK__::Header: UnwindSafe + RefUnwindSafe, [src]

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

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

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

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

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

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

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

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

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

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

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

`pub fn get_spaces( &self, __runtime_api_at_param__: &BlockId<Block>, start_id: u64, limit: u64 ) -> Result<Vec<FlatSpace<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_spaces_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, start_id: u64, limit: u64 ) -> Result<Vec<FlatSpace<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_spaces_by_ids( &self, __runtime_api_at_param__: &BlockId<Block>, space_ids: Vec<u64, Global> ) -> Result<Vec<FlatSpace<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_spaces_by_ids_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, space_ids: Vec<u64, Global> ) -> Result<Vec<FlatSpace<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_public_spaces( &self, __runtime_api_at_param__: &BlockId<Block>, start_id: u64, limit: u64 ) -> Result<Vec<FlatSpace<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_public_spaces_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, start_id: u64, limit: u64 ) -> Result<Vec<FlatSpace<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_unlisted_spaces( &self, __runtime_api_at_param__: &BlockId<Block>, start_id: u64, limit: u64 ) -> Result<Vec<FlatSpace<AccountId, BlockNumber>, Global>, Self::Error>`[src]

`pub fn get_unlisted_spaces_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, start_id: u64, limit: u64 ) -> Result<Vec<FlatSpace<AccountId, BlockNumber>, Global>, Self::Error>`[src]

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

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

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

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

`pub fn get_space_by_handle( &self, __runtime_api_at_param__: &BlockId<Block>, handle: Vec<u8, Global> ) -> Result<Option<FlatSpace<AccountId, BlockNumber>>, Self::Error>`[src]

`pub fn get_space_by_handle_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, handle: Vec<u8, Global> ) -> Result<Option<FlatSpace<AccountId, BlockNumber>>, Self::Error>`[src]

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

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

`impl<Block: BlockT, C: CallApiAt<Block>> Sync for RuntimeApiImpl<Block, C> where C::StateBackend: StateBackend<HashFor<Block>>,` [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__::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]

`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]

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> Pointable for T`[src]

`pub const ALIGN: usize`[src]

`type Init = T`

The type for initializers.

`pub unsafe fn init(init: <T as Pointable>::Init) -> usize`[src]

`pub unsafe fn deref<'a>(ptr: usize) -> &'a T`[src]

`pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T`[src]

`pub unsafe fn drop(ptr: usize)`[src]

`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]

Struct subsocial_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 PostsApi_get_posts_by_ids_runtime_api_impl( &self, at: &BlockId<__SR_API_BLOCK__>, context: ExecutionContext, params: Option<(Vec<PostId>, u64, u16)>, params_encoded: Vec<u8>) -> Result<NativeOrEncoded<Vec<FlatPost<AccountId, BlockNumber>>>, RuntimeApiImplCall::Error>[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn get_posts_by_ids( &self, __runtime_api_at_param__: &BlockId<Block>, post_ids: Vec<u64, Global>, offset: u64, limit: u16) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>[src]

pub fn get_posts_by_ids_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, post_ids: Vec<u64, Global>, offset: u64, limit: u16) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>[src]

pub fn get_public_posts( &self, __runtime_api_at_param__: &BlockId<Block>, kind_filter: Vec<FlatPostKind, Global>, offset: u64, limit: u16) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>[src]

pub fn get_public_posts_with_context( &self, __runtime_api_at_param__: &BlockId<Block>, context: ExecutionContext, kind_filter: Vec<FlatPostKind, Global>, offset: u64, limit: u16) -> Result<Vec<FlatPost<AccountId, BlockNumber>, Global>, Self::Error>[src]