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 create_default_config( &self, __runtime_api_at_param__: <Block as Block>::Hash ) -> Result<Vec<u8>, ApiError>

fn build_config( &self, __runtime_api_at_param__: <Block as Block>::Hash, json: Vec<u8> ) -> Result<Result<(), 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> !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> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,

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>,

fn conv<T>(self) -> T
where Self: Into<T>,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

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

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>,

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

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

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>,