Struct gtest_runtime::RuntimeApiImpl

source ·

pub struct RuntimeApiImpl<Block: BlockT, C: CallApiAt<Block> + 'static> {
    pub(crate) call: &'static C,
    pub(crate) transaction_depth: RefCell<u16>,
    pub(crate) changes: RefCell<OverlayedChanges<HashingFor<Block>>>,
    pub(crate) recorder: Option<ProofRecorder<Block>>,
    pub(crate) call_context: CallContext,
    pub(crate) extensions: RefCell<Extensions>,
    pub(crate) extensions_generated_for: RefCell<Option<Block::Hash>>,
}

Expand description

Implements all runtime apis for the client side.

Fields§

§call: &'static C§transaction_depth: RefCell<u16>§changes: RefCell<OverlayedChanges<HashingFor<Block>>>§recorder: Option<ProofRecorder<Block>>§call_context: CallContext§extensions: RefCell<Extensions>§extensions_generated_for: RefCell<Option<Block::Hash>>

Struct gtest_runtime::RuntimeApiImpl

Fields§

Implementations§

impl<Block: BlockT, C: CallApiAt<Block>> RuntimeApiImpl<Block, C>

pub(crate) fn commit_or_rollback_transaction(&self, commit: bool)

pub(crate) fn start_transaction(&self)

Trait Implementations§

fn account_nonce( &self, __runtime_api_at_param__: <Block as Block>::Hash, account: AccountId ) -> Result<Nonce, ApiError>

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

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

fn has_api<A: RuntimeApiInfo + ?Sized>( &self, at: <Block as BlockT>::Hash ) -> Result<bool, ApiError>where Self: Sized,

fn has_api_with<A: RuntimeApiInfo + ?Sized, P: Fn(u32) -> bool>( &self, at: <Block as BlockT>::Hash, pred: P ) -> Result<bool, ApiError>where Self: Sized,

fn api_version<A: RuntimeApiInfo + ?Sized>( &self, at: <Block as BlockT>::Hash ) -> Result<Option<u32>, ApiError>where Self: Sized,

fn record_proof(&mut self)

fn proof_recorder(&self) -> Option<ProofRecorder<Block>>

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

fn into_storage_changes<B: StateBackend<HashingFor<Block>>>( &self, backend: &B, parent_hash: Block::Hash ) -> Result<StorageChanges<Block>, String>where Self: Sized,

fn set_call_context(&mut self, call_context: CallContext)

fn register_extension<E: Extension>(&mut self, extension: E)

fn authorities( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<Vec<Public>, ApiError>

fn configuration( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<BabeConfiguration, ApiError>

fn configuration_before_version_2( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<BabeConfigurationV1, ApiError>

fn current_epoch_start( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<Slot, ApiError>

fn current_epoch( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<Epoch, ApiError>

fn next_epoch( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<Epoch, ApiError>

fn generate_key_ownership_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, slot: Slot, authority_id: Public ) -> Result<Option<OpaqueKeyOwnershipProof>, ApiError>

fn submit_report_equivocation_unsigned_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, equivocation_proof: EquivocationProof<<Block as Block>::Header, Public>, key_owner_proof: OpaqueKeyOwnershipProof ) -> Result<Option<()>, ApiError>

fn benchmark_metadata( &self, __runtime_api_at_param__: <Block as Block>::Hash, extra: bool ) -> Result<(Vec<BenchmarkList>, Vec<StorageInfo>), ApiError>

fn dispatch_benchmark( &self, __runtime_api_at_param__: <Block as Block>::Hash, config: BenchmarkConfig ) -> Result<Result<Vec<BenchmarkBatch>, RuntimeString>, ApiError>

fn apply_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsic: <Block as Block>::Extrinsic ) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, ApiError>

fn apply_extrinsic_before_version_6( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsic: <Block as Block>::Extrinsic ) -> Result<Result<Result<(), DispatchError>, TransactionValidityError>, ApiError>

fn finalize_block( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<<Block as Block>::Header, ApiError>

fn inherent_extrinsics( &self, __runtime_api_at_param__: <Block as Block>::Hash, inherent: InherentData ) -> Result<Vec<<Block as Block>::Extrinsic>, ApiError>

fn check_inherents( &self, __runtime_api_at_param__: <Block as Block>::Hash, block: Block, data: InherentData ) -> Result<CheckInherentsResult, ApiError>

fn version( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<RuntimeVersion, ApiError>

fn execute_block( &self, __runtime_api_at_param__: <Block as Block>::Hash, block: Block ) -> Result<(), ApiError>

fn initialize_block_before_version_5( &self, __runtime_api_at_param__: <Block as Block>::Hash, header: &<Block as Block>::Header ) -> Result<(), ApiError>

fn initialize_block( &self, __runtime_api_at_param__: <Block as Block>::Hash, header: &<Block as Block>::Header ) -> Result<ExtrinsicInclusionMode, ApiError>

fn build_state( &self, __runtime_api_at_param__: <Block as Block>::Hash, json: Vec<u8> ) -> Result<Result<(), RuntimeString>, ApiError>

fn get_preset( &self, __runtime_api_at_param__: <Block as Block>::Hash, id: &Option<RuntimeString> ) -> Result<Option<Vec<u8>>, ApiError>

fn preset_names( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<Vec<RuntimeString>, ApiError>

fn grandpa_authorities( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<Vec<(Public, u64)>, ApiError>

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

fn generate_key_ownership_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, set_id: u64, authority_id: Public ) -> Result<Option<OpaqueKeyOwnershipProof>, ApiError>

fn current_set_id( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<u64, ApiError>

fn metadata( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<OpaqueMetadata, ApiError>

fn metadata_at_version( &self, __runtime_api_at_param__: <Block as Block>::Hash, version: u32 ) -> Result<Option<OpaqueMetadata>, ApiError>

fn metadata_versions( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<Vec<u32>, ApiError>

fn offchain_worker_before_version_2( &self, __runtime_api_at_param__: <Block as Block>::Hash, number: <<Block as Block>::Header as Header>::Number ) -> Result<(), ApiError>

fn offchain_worker( &self, __runtime_api_at_param__: <Block as Block>::Hash, header: &<Block as Block>::Header ) -> Result<(), ApiError>

fn generate_session_keys( &self, __runtime_api_at_param__: <Block as Block>::Hash, seed: Option<Vec<u8>> ) -> Result<Vec<u8>, ApiError>

fn decode_session_keys( &self, __runtime_api_at_param__: <Block as Block>::Hash, encoded: Vec<u8> ) -> Result<Option<Vec<(Vec<u8>, KeyTypeId)>>, ApiError>

fn validate_transaction_before_version_2( &self, __runtime_api_at_param__: <Block as Block>::Hash, tx: <Block as Block>::Extrinsic ) -> Result<Result<ValidTransaction, TransactionValidityError>, ApiError>

fn validate_transaction_before_version_3( &self, __runtime_api_at_param__: <Block as Block>::Hash, source: TransactionSource, tx: <Block as Block>::Extrinsic ) -> Result<Result<ValidTransaction, TransactionValidityError>, ApiError>

fn validate_transaction( &self, __runtime_api_at_param__: <Block as Block>::Hash, source: TransactionSource, tx: <Block as Block>::Extrinsic, block_hash: <Block as Block>::Hash ) -> Result<Result<ValidTransaction, TransactionValidityError>, ApiError>

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

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

fn query_weight_to_fee( &self, __runtime_api_at_param__: <Block as Block>::Hash, weight: Weight ) -> Result<Balance, ApiError>

fn query_length_to_fee( &self, __runtime_api_at_param__: <Block as Block>::Hash, length: u32 ) -> Result<Balance, ApiError>

Auto Trait Implementations§

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

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

impl<Block, C> Send for RuntimeApiImpl<Block, C>where C: Sync,

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

impl<Block, C> Unpin for RuntimeApiImpl<Block, C>where <Block as Block>::Hash: Unpin, <<Block as Block>::Header as Header>::Hashing: Unpin,

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

Blanket Implementations§

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> CheckedConversion for T

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

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

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

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

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

fn has_api<A: RuntimeApiInfo + ?Sized>( &self, at: <Block as BlockT>::Hash ) -> Result<bool, ApiError>
where Self: Sized,

fn has_api_with<A: RuntimeApiInfo + ?Sized, P: Fn(u32) -> bool>( &self, at: <Block as BlockT>::Hash, pred: P ) -> Result<bool, ApiError>
where Self: Sized,

fn api_version<A: RuntimeApiInfo + ?Sized>( &self, at: <Block as BlockT>::Hash ) -> Result<Option<u32>, ApiError>
where Self: Sized,

fn into_storage_changes<B: StateBackend<HashingFor<Block>>>( &self, backend: &B, parent_hash: Block::Hash ) -> Result<StorageChanges<Block>, String>
where Self: Sized,

impl<Block, C> Send for RuntimeApiImpl<Block, C>
where C: Sync,

impl<Block, C> Unpin for RuntimeApiImpl<Block, C>
where <Block as Block>::Hash: Unpin, <<Block as Block>::Header as Header>::Hashing: Unpin,

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

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

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

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

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

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

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, U> IntoKey<U> for T
where U: FromKey<T>,

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

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

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

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

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

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

impl<T, U> TryIntoKey<U> for T
where U: TryFromKey<T>,

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

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

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