Struct StatelessRuntime

pub struct StatelessRuntime<CBlock, Block, Executor> { /* private fields */ }

Stateless runtime api based on the runtime code and partial state if provided.

NOTE:

• This is only supposed to be used when no domain client available, i.e., when the caller does not own the entire domain state.
• This perfectly fits the runtime APIs that are purely stateless, but it’s also usable for the stateful APIs. If some states are used inside a runtime api, these states must be provided and set before dispatching otherwise StatelessRuntime may give invalid output.

Implementations

impl<CBlock, Block, Executor> StatelessRuntime<CBlock, Block, Executor>

where CBlock: BlockT, Block: BlockT, Executor: CodeExecutor + RuntimeVersionOf,

pub fn new(executor: Arc<Executor>, runtime_code: Cow<'static, [u8]>) -> Self

Create a new instance of StatelessRuntime with empty storage.

pub fn set_storage(&mut self, storage: Storage)

Set the storage.

Inject the state necessary for calling stateful runtime APIs.

pub fn set_extension_factory( &mut self, extension_factory: Box<dyn ExtensionsFactory<Block>>, )

Set the extensions.

Inject the necessary extensions for Domain.

pub fn outbox_storage_key( &self, message_key: MessageKey, ) -> Result<Vec<u8>, ApiError>

pub fn inbox_response_storage_key( &self, message_key: MessageKey, ) -> Result<Vec<u8>, ApiError>

pub fn channel_storage_key( &self, chain_id: ChainId, channel_id: ChannelId, ) -> Result<Vec<u8>, ApiError>

pub fn extract_signer( &self, extrinsics: Vec<Block::Extrinsic>, ) -> Result<ExtractSignerResult<Block>, ApiError>

pub fn construct_set_code_extrinsic( &self, runtime_code: Vec<u8>, ) -> Result<Vec<u8>, ApiError>

pub fn construct_timestamp_extrinsic( &self, moment: Moment, ) -> Result<Block::Extrinsic, ApiError>

pub fn construct_consensus_chain_byte_fee_extrinsic( &self, consensus_chain_byte_fee: Balance, ) -> Result<Block::Extrinsic, ApiError>

pub fn construct_domain_update_chain_allowlist_extrinsic( &self, updates: DomainAllowlistUpdates, ) -> Result<Block::Extrinsic, ApiError>

pub fn is_inherent_extrinsic( &self, extrinsic: &Block::Extrinsic, ) -> Result<bool, ApiError>

pub fn is_xdm_mmr_proof_valid( &self, extrinsic: &Block::Extrinsic, ) -> Result<Option<bool>, ApiError>

pub fn extract_xdm_mmr_proof( &self, extrinsic: &Block::Extrinsic, ) -> Result<Option<Vec<u8>>, ApiError>

pub fn decode_extrinsic( &self, opaque_extrinsic: OpaqueExtrinsic, ) -> Result<Result<Block::Extrinsic, DecodeExtrinsicError>, ApiError>

pub fn is_within_tx_range( &self, extrinsic: &Block::Extrinsic, bundle_vrf_hash: &U256, tx_range: &U256, ) -> Result<bool, ApiError>

pub fn check_extrinsics_and_do_pre_dispatch( &self, uxts: Vec<Block::Extrinsic>, block_number: NumberFor<Block>, block_hash: Block::Hash, ) -> Result<Result<(), CheckExtrinsicsValidityError>, ApiError>

This is stateful runtime api call and require setting of storage keys.

pub fn transfers_storage_key(&self) -> Result<Vec<u8>, ApiError>

pub fn block_fees_storage_key(&self) -> Result<Vec<u8>, ApiError>

pub fn extrinsic_weight( &self, extrinsic: &Block::Extrinsic, ) -> Result<Weight, ApiError>

pub fn is_valid_sudo_call(&self, extrinsic: Vec<u8>) -> Result<bool, ApiError>

pub fn construct_domain_sudo_extrinsic( &self, inner_call: Vec<u8>, ) -> Result<Block::Extrinsic, ApiError>

Trait Implementations

impl<CBlock, Block, Executor> Core<Block> for StatelessRuntime<CBlock, Block, Executor>

where CBlock: BlockT, Block: BlockT, Executor: CodeExecutor + RuntimeVersionOf,

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

Returns the version of the runtime.

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

Execute the given block.

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

👎Deprecated

Initialize a block with the given header.

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

Initialize a block with the given header and return the runtime executive mode.

impl<CBlock, Block, Executor> DomainCoreApi<Block> for StatelessRuntime<CBlock, Block, Executor>

where CBlock: BlockT, Block: BlockT, Executor: CodeExecutor + RuntimeVersionOf,

fn extract_signer( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsics: Vec<<Block as Block>::Extrinsic>, ) -> Result<Vec<(Option<Vec<u8>>, <Block as Block>::Extrinsic)>, ApiError>

Extracts the optional signer per extrinsic.

fn is_within_tx_range( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsic: &<Block as Block>::Extrinsic, bundle_vrf_hash: &U256, tx_range: &U256, ) -> Result<bool, ApiError>

fn intermediate_roots( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Vec<[u8; 32]>, ApiError>

Returns the intermediate storage roots in an encoded form.

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

Returns the storage root after initializing the block.

fn apply_extrinsic_with_post_state_root( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsic: <Block as Block>::Extrinsic, ) -> Result<Vec<u8>, ApiError>

Returns the storage root after applying the extrinsic.

fn construct_set_code_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, code: Vec<u8>, ) -> Result<Vec<u8>, ApiError>

Returns an encoded extrinsic aiming to upgrade the runtime using given code.

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

Returns an encoded extrinsic to set timestamp.

fn construct_consensus_chain_byte_fee_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, consensus_chain_byte_fee: u128, ) -> Result<<Block as Block>::Extrinsic, ApiError>

Returns an encoded extrinsic to set domain transaction byte fee.

fn construct_domain_update_chain_allowlist_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, updates: DomainAllowlistUpdates, ) -> Result<<Block as Block>::Extrinsic, ApiError>

Returns an extrinsic to update chain allowlist.

fn is_inherent_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsic: &<Block as Block>::Extrinsic, ) -> Result<bool, ApiError>

Returns true if the extrinsic is an inherent extrinsic.

fn check_extrinsics_and_do_pre_dispatch( &self, __runtime_api_at_param__: <Block as Block>::Hash, uxts: Vec<<Block as Block>::Extrinsic>, block_number: <<Block as Block>::Header as Header>::Number, block_hash: <Block as Block>::Hash, ) -> Result<Result<(), CheckExtrinsicsValidityError>, ApiError>

Checks the validity of array of extrinsics + pre_dispatch returning failure on first extrinsic that fails runtime call. IMPORTANT: Change CHECK_EXTRINSICS_AND_DO_PRE_DISPATCH_METHOD_NAME constant when this method name is changed

fn decode_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, opaque_extrinsic: OpaqueExtrinsic, ) -> Result<Result<<Block as Block>::Extrinsic, DecodeExtrinsicError>, ApiError>

Decodes the domain specific extrinsic from the opaque extrinsic.

fn extrinsic_era( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsic: &<Block as Block>::Extrinsic, ) -> Result<Option<Era>, ApiError>

Returns extrinsic Era if present.

fn extrinsic_weight( &self, __runtime_api_at_param__: <Block as Block>::Hash, ext: &<Block as Block>::Extrinsic, ) -> Result<Weight, ApiError>

Returns the extrinsic weight.

fn block_fees( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<BlockFees<u128>, ApiError>

The accumulated transaction fee of all transactions included in the block.

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

Returns the block digest.

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

Returns the consumed weight of the block.

fn transfers( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<Transfers<u128>, ApiError>

Returns the transfers for this domain in the block.

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

Returns the storage key for the Transfers on Domain.

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

Returns the storage key for the CollectedBlockFees on Domain.

impl<CBlock, Block, Executor> DomainSudoApi<Block> for StatelessRuntime<CBlock, Block, Executor>

where CBlock: BlockT, Block: BlockT, NumberFor<Block>: Codec, Executor: CodeExecutor + RuntimeVersionOf,

fn is_valid_sudo_call( &self, __runtime_api_at_param__: <Block as Block>::Hash, extrinsic: Vec<u8>, ) -> Result<bool, ApiError>

Returns true if the domain_sudo exists in the runtime and extrinsic is valid

fn construct_domain_sudo_extrinsic( &self, __runtime_api_at_param__: <Block as Block>::Hash, inner: Vec<u8>, ) -> Result<<Block as Block>::Extrinsic, ApiError>

Returns an encoded extrinsic for domain sudo call.

impl<CBlock, Block, Executor> FetchRuntimeCode for StatelessRuntime<CBlock, Block, Executor>

fn fetch_runtime_code(&self) -> Option<Cow<'static, [u8]>>

Fetch the runtime :code.

impl<CBlock, Block, Executor> MessengerApi<Block, <<CBlock as Block>::Header as Header>::Number, <CBlock as Block>::Hash> for StatelessRuntime<CBlock, Block, Executor>

where CBlock: BlockT, Block: BlockT, NumberFor<Block>: Codec, Executor: CodeExecutor + RuntimeVersionOf,

fn is_xdm_mmr_proof_valid( &self, __runtime_api_at_param__: <Block as Block>::Hash, ext: &<Block as Block>::Extrinsic, ) -> Result<Option<bool>, ApiError>

Returns Some(true) if valid XDM or Some(false) if not Returns None if this is not an XDM

fn extract_xdm_mmr_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, ext: &<Block as Block>::Extrinsic, ) -> Result<Option<ConsensusChainMmrLeafProof<CNumber, CHash, H256>>, ApiError>

fn confirmed_domain_block_storage_key( &self, __runtime_api_at_param__: <Block as Block>::Hash, domain_id: DomainId, ) -> Result<Vec<u8>, ApiError>

Returns the confirmed domain block storage for given domain.

fn outbox_storage_key( &self, __runtime_api_at_param__: <Block as Block>::Hash, message_key: (ChainId, U256, U256), ) -> Result<Vec<u8>, ApiError>

Returns storage key for outbox for a given message_id.

fn inbox_response_storage_key( &self, __runtime_api_at_param__: <Block as Block>::Hash, message_key: (ChainId, U256, U256), ) -> Result<Vec<u8>, ApiError>

Returns storage key for inbox response for a given message_id.

fn domain_chains_allowlist_update( &self, __runtime_api_at_param__: <Block as Block>::Hash, domain_id: DomainId, ) -> Result<Option<DomainAllowlistUpdates>, ApiError>

Returns any domain’s chains allowlist updates on consensus chain.

impl<CBlock, Block, Executor> RelayerApi<Block, <<Block as Block>::Header as Header>::Number, u32, [u8; 32]> for StatelessRuntime<CBlock, Block, Executor>

where CBlock: BlockT, Block: BlockT, NumberFor<Block>: Codec, Executor: CodeExecutor + RuntimeVersionOf,

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

Returns all the outbox and inbox responses to deliver. Storage key is used to generate the storage proof for the message.

fn outbox_message_unsigned( &self, __runtime_api_at_param__: <Block as Block>::Hash, msg: CrossDomainMessage<CNumber, CHash, H256>, ) -> Result<Option<<Block as Block>::Extrinsic>, ApiError>

Constructs an outbox message to the dst_chain as an unsigned extrinsic.

fn inbox_response_message_unsigned( &self, __runtime_api_at_param__: <Block as Block>::Hash, msg: CrossDomainMessage<CNumber, CHash, H256>, ) -> Result<Option<<Block as Block>::Extrinsic>, ApiError>

Constructs an inbox response message to the dst_chain as an unsigned extrinsic.

fn should_relay_outbox_message( &self, __runtime_api_at_param__: <Block as Block>::Hash, dst_chain_id: ChainId, msg_id: (U256, U256), ) -> Result<bool, ApiError>

Returns true if the outbox message is ready to be relayed to dst_chain.

fn should_relay_inbox_message_response( &self, __runtime_api_at_param__: <Block as Block>::Hash, dst_chain_id: ChainId, msg_id: (U256, U256), ) -> Result<bool, ApiError>

Returns true if the inbox message response is ready to be relayed to dst_chain.

fn updated_channels( &self, __runtime_api_at_param__: <Block as Block>::Hash, ) -> Result<BTreeSet<(ChainId, U256)>, ApiError>

Returns the list of channels updated in the given block.

fn channel_storage_key( &self, __runtime_api_at_param__: <Block as Block>::Hash, chain_id: ChainId, channel_id: U256, ) -> Result<Vec<u8>, ApiError>

Returns storage key for channels for given chain and channel id.