Trait DomainsApi 

pub trait DomainsApi<Block: BlockT, DomainHeader: HeaderT>: Core<Block> {
    // Provided methods
    fn submit_bundle_unsigned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        opaque_bundle: OpaqueBundle<NumberFor<Block>, Block::Hash, DomainHeader, Balance>,
    ) -> Result<(), ApiError> { ... }
    fn submit_receipt_unsigned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        singleton_receipt: SealedSingletonReceipt<NumberFor<Block>, Block::Hash, DomainHeader, Balance>,
    ) -> Result<(), ApiError> { ... }
    fn extract_successful_bundles(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
        extrinsics: Vec<Block::Extrinsic>,
    ) -> Result<OpaqueBundles<Block, DomainHeader, Balance>, ApiError> { ... }
    fn extrinsics_shuffling_seed(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<Randomness, ApiError> { ... }
    fn domain_runtime_code(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<Vec<u8>>, ApiError> { ... }
    fn runtime_id(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<RuntimeId>, ApiError> { ... }
    fn runtime_upgrades(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<Vec<RuntimeId>, ApiError> { ... }
    fn domain_instance_data(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<(DomainInstanceData, NumberFor<Block>)>, ApiError> { ... }
    fn domain_timestamp(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<Moment, ApiError> { ... }
    fn consensus_transaction_byte_fee(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<Balance, ApiError> { ... }
    fn domain_tx_range(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<U256, ApiError> { ... }
    fn genesis_state_root(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<H256>, ApiError> { ... }
    fn head_receipt_number(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<HeaderNumberFor<DomainHeader>, ApiError> { ... }
    fn oldest_unconfirmed_receipt_number(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<HeaderNumberFor<DomainHeader>>, ApiError> { ... }
    fn domain_bundle_limit(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<DomainBundleLimit>, ApiError> { ... }
    fn non_empty_er_exists(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<bool, ApiError> { ... }
    fn domain_best_number(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<HeaderNumberFor<DomainHeader>>, ApiError> { ... }
    fn execution_receipt(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        receipt_hash: HeaderHashFor<DomainHeader>,
    ) -> Result<Option<ExecutionReceiptFor<DomainHeader, Block, Balance>>, ApiError> { ... }
    fn domain_operators(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<(BTreeMap<OperatorId, Balance>, Vec<OperatorId>)>, ApiError> { ... }
    fn receipt_hash(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
        domain_number: HeaderNumberFor<DomainHeader>,
    ) -> Result<Option<HeaderHashFor<DomainHeader>>, ApiError> { ... }
    fn latest_confirmed_domain_block(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<(HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>)>, ApiError> { ... }
    fn is_bad_er_pending_to_prune(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
        receipt_hash: HeaderHashFor<DomainHeader>,
    ) -> Result<bool, ApiError> { ... }
    fn storage_fund_account_balance(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        operator_id: OperatorId,
    ) -> Result<Balance, ApiError> { ... }
    fn is_domain_runtime_upgraded_since(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
        at: NumberFor<Block>,
    ) -> Result<Option<bool>, ApiError> { ... }
    fn domain_sudo_call(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<Vec<u8>>, ApiError> { ... }
    fn evm_domain_contract_creation_allowed_by_call(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<PermissionedActionAllowedBy<EthereumAccountId>>, ApiError> { ... }
    fn last_confirmed_domain_block_receipt(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<ExecutionReceiptFor<DomainHeader, Block, Balance>>, ApiError> { ... }
    fn current_bundle_and_execution_receipt_version(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<BundleAndExecutionReceiptVersion, ApiError> { ... }
    fn genesis_execution_receipt(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        domain_id: DomainId,
    ) -> Result<Option<ExecutionReceiptFor<DomainHeader, Block, Balance>>, ApiError> { ... }
    fn nominator_position(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        operator_id: OperatorId,
        nominator_account: AccountId32,
    ) -> Result<Option<NominatorPosition<Balance, HeaderNumberFor<DomainHeader>, Balance>>, ApiError> { ... }
    fn block_pruning_depth(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<NumberFor<Block>, ApiError> { ... }
}

APIs used to access the domains pallet.

Provided Methods

fn submit_bundle_unsigned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, opaque_bundle: OpaqueBundle<NumberFor<Block>, Block::Hash, DomainHeader, Balance>, ) -> Result<(), ApiError>

Submits the transaction bundle via an unsigned extrinsic.

fn submit_receipt_unsigned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, singleton_receipt: SealedSingletonReceipt<NumberFor<Block>, Block::Hash, DomainHeader, Balance>, ) -> Result<(), ApiError>

Submits a singleton receipt via an unsigned extrinsic.

fn extract_successful_bundles( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, extrinsics: Vec<Block::Extrinsic>, ) -> Result<OpaqueBundles<Block, DomainHeader, Balance>, ApiError>

Extracts the bundles successfully stored from the given extrinsics.

fn extrinsics_shuffling_seed( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<Randomness, ApiError>

Generates a randomness seed for extrinsics shuffling.

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

Returns the current WASM bundle for the given domain_id.

fn runtime_id( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<RuntimeId>, ApiError>

Returns the runtime id for the given domain_id.

fn runtime_upgrades( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<Vec<RuntimeId>, ApiError>

Returns the list of runtime upgrades in the current block.

fn domain_instance_data( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<(DomainInstanceData, NumberFor<Block>)>, ApiError>

Returns the domain instance data for the given domain_id.

fn domain_timestamp( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<Moment, ApiError>

Returns the current timestamp at the current height.

fn consensus_transaction_byte_fee( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<Balance, ApiError>

Returns the consensus transaction byte fee that will used to charge the domain transaction for consensus chain storage fees.

fn domain_tx_range( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<U256, ApiError>

Returns the current Tx range for the given domain Id.

fn genesis_state_root( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<H256>, ApiError>

Returns the genesis state root if not pruned.

fn head_receipt_number( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<HeaderNumberFor<DomainHeader>, ApiError>

Returns the best execution chain number.

fn oldest_unconfirmed_receipt_number( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<HeaderNumberFor<DomainHeader>>, ApiError>

Returns the block number of oldest unconfirmed execution receipt.

fn domain_bundle_limit( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<DomainBundleLimit>, ApiError>

Returns the domain bundle limit of the given domain.

fn non_empty_er_exists( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<bool, ApiError>

Returns true if there are any ERs in the challenge period with non empty extrinsics.

fn domain_best_number( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<HeaderNumberFor<DomainHeader>>, ApiError>

Returns the current best block number for the domain.

fn execution_receipt( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, receipt_hash: HeaderHashFor<DomainHeader>, ) -> Result<Option<ExecutionReceiptFor<DomainHeader, Block, Balance>>, ApiError>

Returns the execution receipt with the given hash.

fn domain_operators( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<(BTreeMap<OperatorId, Balance>, Vec<OperatorId>)>, ApiError>

Returns the current epoch and the next epoch operators of the given domain.

fn receipt_hash( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, domain_number: HeaderNumberFor<DomainHeader>, ) -> Result<Option<HeaderHashFor<DomainHeader>>, ApiError>

Returns the execution receipt hash of the given domain and domain block number.

fn latest_confirmed_domain_block( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<(HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>)>, ApiError>

Returns the latest confirmed domain block number and hash.

fn is_bad_er_pending_to_prune( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, receipt_hash: HeaderHashFor<DomainHeader>, ) -> Result<bool, ApiError>

Returns true if the receipt exists and is going to be pruned

fn storage_fund_account_balance( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, operator_id: OperatorId, ) -> Result<Balance, ApiError>

Returns the balance of the storage fund account.

fn is_domain_runtime_upgraded_since( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, at: NumberFor<Block>, ) -> Result<Option<bool>, ApiError>

Returns true if the given domain’s runtime code has been upgraded since at.

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

Returns the domain sudo call for the given domain, if any.

fn evm_domain_contract_creation_allowed_by_call( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<PermissionedActionAllowedBy<EthereumAccountId>>, ApiError>

Returns the “set contract creation allowed by” call for the given EVM domain, if any.

fn last_confirmed_domain_block_receipt( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<ExecutionReceiptFor<DomainHeader, Block, Balance>>, ApiError>

Returns the last confirmed domain block execution receipt.

fn current_bundle_and_execution_receipt_version( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<BundleAndExecutionReceiptVersion, ApiError>

Returns the current bundle version that is accepted by runtime.

fn genesis_execution_receipt( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, domain_id: DomainId, ) -> Result<Option<ExecutionReceiptFor<DomainHeader, Block, Balance>>, ApiError>

Returns genesis execution receipt for domains.

fn nominator_position( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, operator_id: OperatorId, nominator_account: AccountId32, ) -> Result<Option<NominatorPosition<Balance, HeaderNumberFor<DomainHeader>, Balance>>, ApiError>

Returns the complete nominator position for a given operator and account.

This calculates the total position including:

• Current stake value (converted from shares using current share price)
• Total storage fee deposits (known + pending)
• Pending deposits (not yet converted to shares)
• Pending withdrawals (with unlock timing)

fn block_pruning_depth( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<NumberFor<Block>, ApiError>

Returns the block pruning depth for domains Available from Api version 6.

Trait Implementations

impl<Block: BlockT, DomainHeader: HeaderT> RuntimeApiInfo for dyn DomainsApi<Block, DomainHeader>

const ID: [u8; 8]

The identifier of the runtime api.

const VERSION: u32 = 6u32

The version of the runtime api.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors