Struct Runtime

pub struct Runtime;

Implementations

impl Runtime

pub fn metadata() -> RuntimeMetadataPrefixed

pub fn metadata_at_version(version: u32) -> Option<OpaqueMetadata>

pub fn metadata_versions() -> Vec<u32>

Trait Implementations

impl AccountNonceApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32> for Runtime

fn account_nonce(account: AccountId) -> Nonce

Get current account nonce of given AccountId.

impl BlockBuilderV6<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn apply_extrinsic( extrinsic: <Block as BlockT>::Extrinsic, ) -> ApplyExtrinsicResult

Apply the given extrinsic.

fn finalize_block() -> <Block as BlockT>::Header

Finish the current block.

fn inherent_extrinsics(data: InherentData) -> Vec<<Block as BlockT>::Extrinsic>

Generate inherent extrinsics. The inherent data will vary from chain to chain.

fn check_inherents(block: Block, data: InherentData) -> CheckInherentsResult

Check that the inherents are valid. The inherent data will vary from chain to chain.

impl BlockSlot<Runtime> for BlockSlot

fn future_slot(block_number: BlockNumber) -> Option<Slot>

fn slot_produced_after(to_check: Slot) -> Option<BlockNumber>

impl BundleProducerElectionApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, u128> for Runtime

fn bundle_producer_election_params( domain_id: DomainId, ) -> Option<BundleProducerElectionParams<Balance>>

fn operator(operator_id: OperatorId) -> Option<(OperatorPublicKey, Balance)>

impl CallerTrait<<Runtime as Config>::AccountId> for OriginCaller

fn into_system(self) -> Option<RawOrigin<<Runtime as Config>::AccountId>>

Extract the signer from the message if it is a Signed origin.

fn as_system_ref(&self) -> Option<&RawOrigin<<Runtime as Config>::AccountId>>

Extract a reference to the system-level RawOrigin if it is that.

fn as_signed(&self) -> Option<&AccountId>

Extract the signer from it if a system Signed origin, None otherwise.

fn is_root(&self) -> bool

Returns true if self is a system Root origin, None otherwise.

fn is_none(&self) -> bool

Returns true if self is a system None origin, None otherwise.

impl Clone for Runtime

fn clone(&self) -> Runtime

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Config for Runtime

type BaseCallFilter = Everything

The basic call filter to use in dispatchable.

type BlockWeights = SubspaceBlockWeights

Block & extrinsics weights: base values and limits.

type BlockLength = SubspaceBlockLength

The maximum length of a block (in bytes).

type AccountId = <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId

The identifier used to distinguish between accounts.

type RuntimeCall = RuntimeCall

The aggregated dispatch type that is available for extrinsics.

type RuntimeTask = RuntimeTask

The aggregated RuntimeTask type.

type Lookup = AccountIdLookup<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>

The lookup mechanism to get account ID from whatever is passed in dispatchers.

type Nonce = u32

The type for storing how many extrinsics an account has signed.

type Hash = H256

The type for hashing blocks and tries.

type Hashing = BlakeTwo256

The hashing algorithm used.

type Block = Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>

The block type.

type RuntimeEvent = RuntimeEvent

The ubiquitous event type.

type RuntimeOrigin = RuntimeOrigin

The ubiquitous origin type.

type BlockHashCount = BlockHashCount

Maximum number of block number to block hash mappings to keep (oldest pruned first).

type DbWeight = ParityDbWeight

The weight of database operations that the runtime can invoke.

type Version = Version

Version of the runtime.

type PalletInfo = PalletInfo

Converts a module to the index of the module in construct_runtime!.

This type is being generated by construct_runtime!.

type OnNewAccount = ()

What to do if a new account is created.

type OnKilledAccount = ()

What to do if an account is fully reaped from the system.

type AccountData = AccountData<u128>

The data to be stored in an account.

type SystemWeightInfo = ()

Weight information for the extrinsics of this pallet.

type SS58Prefix = ConstU16<6094>

This is used as an identifier of the chain.

type OnSetCode = ()

The set code logic, just the default since we’re not a parachain.

type SingleBlockMigrations = ()

All migrations that should run in the next runtime upgrade.

type MultiBlockMigrator = ()

The migrator that is used to run Multi-Block-Migrations.

type PreInherents = ()

A callback that executes in every block directly before all inherents were applied.

type PostInherents = ()

A callback that executes in every block directly after all inherents were applied.

type PostTransactions = ()

A callback that executes in every block directly after all transactions were applied.

type MaxConsumers = ConstU32<16>

The maximum number of consumers allowed on a single account.

impl Config for Runtime

type WeightInfo = SubstrateWeight<Runtime>

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

Event type for this pallet.

type SelfChainId = SelfChainId

Gets the chain_id of the current execution environment.

type SelfEndpointId = TransporterEndpointId

Gets the endpoint_id of this pallet in a given execution environment.

type Currency = Pallet<Runtime>

Currency used by this pallet.

type Sender = Pallet<Runtime>

Sender used to transfer funds.

type AccountIdConverter = AccountIdConverter

MultiAccountID <> T::AccountId converter.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

type DomainHash = H256

Domain block hash type.

type DomainHeader = Header<u32, BlakeTwo256>

The domain header type.

type ConfirmationDepthK = ConfirmationDepthK

Same with pallet_subspace::Config::ConfirmationDepthK.

type DomainRuntimeUpgradeDelay = DomainRuntimeUpgradeDelay

Delay before a domain runtime is upgraded.

type Currency = Pallet<Runtime>

Currency type used by the domains for staking and other currency related stuff.

type HoldIdentifier = HoldIdentifierWrapper

A variation of the Identifier used for holding the funds used for staking and domains.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type InitialDomainTxRange = InitialDomainTxRange

Initial domain tx range value.

type DomainTxRangeAdjustmentInterval = DomainTxRangeAdjustmentInterval

Domain tx range is adjusted after every DomainTxRangeAdjustmentInterval blocks.

type MinOperatorStake = MinOperatorStake

Minimum operator stake required to become operator of a domain.

type MaxDomainBlockSize = MaxDomainBlockSize

The maximum block size limit for all domain.

type MaxDomainBlockWeight = MaxDomainBlockWeight

The maximum block weight limit for all domain.

type DomainInstantiationDeposit = DomainInstantiationDeposit

The amount of fund to be locked up for the domain instance creator.

type MaxDomainNameLength = MaxDomainNameLength

The maximum domain name length limit for all domain.

type Share = u128

Type representing the shares in the staking protocol.

type BlockTreePruningDepth = BlockTreePruningDepth

The block tree pruning depth.

type ConsensusSlotProbability = SlotProbability

Consensus chain slot probability.

type StakeWithdrawalLockingPeriod = StakeWithdrawalLockingPeriod

Minimum number of blocks after which any finalized withdrawals are released to nominators.

type StakeEpochDuration = StakeEpochDuration

Domain epoch transition interval

type TreasuryAccount = TreasuryAccount

Treasury account.

type MaxPendingStakingOperation = MaxPendingStakingOperation

The maximum number of pending staking operation that can perform upon epoch transition.

type Randomness = Pallet<Runtime>

Randomness source.

type MinNominatorStake = MinNominatorStake

Minimum nominator stake required to nominate and operator.

type PalletId = DomainsPalletId

The pallet-domains’s pallet id.

type StorageFee = Pallet<Runtime>

Storage fee interface used to deal with bundle storage fee

type BlockSlot = BlockSlot

The block slot

type BundleLongevity = BundleLongevity

How many block a bundle should still consider as valid after produced

type DomainsTransfersTracker = Pallet<Runtime>

Transfers tracker.

type MaxInitialDomainAccounts = MaxInitialDomainAccounts

Upper limit for total initial accounts domains

type MinInitialDomainAccountBalance = MinInitialDomainAccountBalance

Minimum balance for each initial domain account

type DomainBundleSubmitted = Pallet<Runtime>

Post hook to notify accepted domain bundles in previous block.

type OnDomainInstantiated = Pallet<Runtime>

A hook to call after a domain is instantiated

type Balance = u128

type MmrHash = <<Runtime as Config>::Hashing as Hash>::Output

Hash type of MMR

type MmrProofVerifier = MmrProofVerifier

MMR proof verifier

type FraudProofStorageKeyProvider = StorageKeyProvider

Fraud proof storage key provider

type OnChainRewards = OnChainRewards

Hook to handle chain rewards.

type WithdrawalLimit = WithdrawalLimit

The max number of withdrawals per nominator that may exist at any time, once this limit is reached, the nominator need to unlock the withdrawal before requesting new withdrawal.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

pallet-rewards events

type Currency = Pallet<Runtime>

type AvgBlockspaceUsageNumBlocks = AvgBlockspaceUsageNumBlocks

Number of blocks over which to compute average blockspace usage

type TransactionByteFee = TransactionByteFee

Cost of one byte of blockspace

type MaxRewardPoints = ConstU32<20>

Max number of reward points

type ProposerTaxOnVotes = ProposerTaxOnVotes

Tax of the proposer on vote rewards

type RewardsEnabled = Pallet<Runtime>

Determine whether rewards are enabled or not

type FindBlockRewardAddress = Pallet<Runtime>

Reward address of block producer

type FindVotingRewardAddresses = Pallet<Runtime>

Reward addresses of all receivers of voting rewards

type WeightInfo = ()

type OnReward = ()

impl Config for Runtime

const INDEXING_PREFIX: &'static [u8] = mmr::INDEXING_PREFIX

Prefix for elements stored in the Off-chain DB via Indexing API.

type Hashing = Keccak256

A hasher type for MMR.

type LeafData = Pallet<Runtime>

Data stored in the leaf nodes.

type OnNewRoot = Pallet<Runtime>

A hook to act on the new MMR root.

type BlockHashProvider = BlockHashProvider

Block hash provider for a given block number.

type WeightInfo = ()

Weights for this pallet.

impl Config for Runtime

type MmrRootHash = <<Runtime as Config>::Hashing as Hash>::Output

type MmrRootHashCount = MmrRootHashCount

The number of mmr root hashes to store in the runtime. It will be used to verify mmr proof statelessly and the number of roots stored here represents the number of blocks for which the mmr proof is valid since it is generated. After that the mmr proof will be expired and the prover needs to re-generate the proof.

impl Config for Runtime

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type BlockAuthoringDelay = BlockAuthoringDelay

Number of slots between slot arrival and when corresponding block can be produced.

type PotEntropyInjectionInterval = PotEntropyInjectionInterval

Interval, in blocks, between blockchain entropy injection into proof of time chain.

type PotEntropyInjectionLookbackDepth = PotEntropyInjectionLookbackDepth

Interval, in entropy injection intervals, where to take entropy for injection from.

type PotEntropyInjectionDelay = PotEntropyInjectionDelay

Delay after block, in slots, when entropy injection takes effect.

type EraDuration = EraDuration

The amount of time, in blocks, that each era should last. NOTE: Currently it is not possible to change the era duration after the chain has started. Attempting to do so will brick block production.

type InitialSolutionRange = ConstU64<INITIAL_SOLUTION_RANGE>

Initial solution range used for challenges during the very first era.

type SlotProbability = SlotProbability

How often in slots slots (on average, not counting collisions) will have a block.

type ConfirmationDepthK = ConfirmationDepthK

Depth K after which a block enters the recorded history (a global constant, as opposed to the client-dependent transaction confirmation depth k).

type RecentSegments = RecentSegments

Number of latest archived segments that are considered “recent history”.

type RecentHistoryFraction = RecentHistoryFraction

Fraction of pieces from the “recent history” (recent_segments) in each sector.

type MinSectorLifetime = MinSectorLifetime

Minimum lifetime of a plotted sector, measured in archived segment.

type ExpectedVotesPerBlock = ExpectedVotesPerBlock

Number of votes expected per block.

type MaxPiecesInSector = ConstU16<{ MAX_PIECES_IN_SECTOR }>

How many pieces one sector is supposed to contain (max)

type ShouldAdjustSolutionRange = ShouldAdjustSolutionRange

type EraChangeTrigger = NormalEraChange

Subspace requires some logic to be triggered on every block to query for whether an era has ended and to perform the transition to the next era.

type BlockSlotCount = BlockSlotCount

Maximum number of block number to block slot mappings to keep (oldest pruned first).

type WeightInfo = ()

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Moment = u64

A timestamp: milliseconds since the unix epoch.

type OnTimestampSet = ()

Something which can be notified (e.g. another pallet) when the timestamp is set.

type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>

The minimum period between blocks.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Balance = u128

The type for recording an account’s balance.

type RuntimeEvent = RuntimeEvent

The ubiquitous event type.

type RuntimeFreezeReason = RuntimeFreezeReason

The overarching freeze reason.

type MaxLocks = ConstU32<50>

The maximum number of locks that should exist on an account. Not strictly enforced, but used for weight estimation.

type MaxReserves = ()

The maximum number of named reserves that can exist on an account.

type ReserveIdentifier = [u8; 8]

The ID type for reserves.

type DustRemoval = ()

Handler for the unbalanced reduction when removing a dust account.

type ExistentialDeposit = ConstU128<{ 500 * SHANNON }>

The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!

type AccountStore = Pallet<Runtime>

The means of storing the balances of an account.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type FreezeIdentifier = ()

The ID type for freezes.

type MaxFreezes = ()

The maximum number of individual freeze locks that can exist on an account at any time.

type RuntimeHoldReason = HoldIdentifierWrapper

The overarching hold reason.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

pallet-transaction-fees events

type MinReplicationFactor = ConstU16<MIN_REPLICATION_FACTOR>

Minimum desired number of replicas of the blockchain to be stored by the network, impacts storage fees.

type CreditSupply = CreditSupply

How many credits there is in circulation.

type TotalSpacePledged = TotalSpacePledged

How much space there is on the network.

type BlockchainHistorySize = BlockchainHistorySize

How big is the history of the blockchain in archived state (thus includes erasure coding, but not replication).

type Currency = Pallet<Runtime>

type FindBlockRewardAddress = Pallet<Runtime>

type DynamicCostOfStorage = ConstBool<false>

Whether dynamic cost of storage should be used

type WeightInfo = SubstrateWeight<Runtime>

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type OnChargeTransaction = OnChargeTransaction

Handler for withdrawing, refunding and depositing the transaction fee. Transaction fees are withdrawn before the transaction is executed. After the transaction was executed the transaction weight can be adjusted, depending on the used resources by the transaction. If the transaction weight is lower than expected, parts of the transaction fee might be refunded. In the end the fees can be deposited.

type OperationalFeeMultiplier = ConstU8<5>

A fee multiplier for Operational extrinsics to compute “virtual tip” to boost their priority

type WeightToFee = ConstantMultiplier<u128, TransactionWeightFee>

Convert a weight value into a deductible fee based on the currency type.

type LengthToFee = ConstantMultiplier<u128, TransactionByteFee>

Convert a length value into a deductible fee based on the currency type.

type FeeMultiplierUpdate = ()

Update the multiplier of the next block, based on the previous block’s weight.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

The overarching call type.

type PalletsOrigin = OriginCaller

The caller origin, overarching type of all pallets origins.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type RuntimeCall = RuntimeCall

A sudo-able call.

type WeightInfo = SubstrateWeight<Runtime>

Type representing the weight of this pallet

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

type SelfChainId = SelfChainId

Gets the chain_id that is treated as src_chain_id for outgoing messages.

type Currency = Pallet<Runtime>

Currency type pallet uses for fees and deposits.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type WeightToFee = ConstantMultiplier<u128, TransactionWeightFee>

Weight to fee conversion.

type OnXDMRewards = OnXDMRewards

Handle XDM rewards.

type MmrHash = <<Runtime as Config>::Hashing as Hash>::Output

Hash type of MMR

type MmrProofVerifier = MmrProofVerifier

MMR proof verifier

type StorageKeys = StorageKeys

Storage key provider.

type DomainOwner = Pallet<Runtime>

Domain owner provider.

type HoldIdentifier = HoldIdentifierWrapper

A variation of the Identifier used for holding the funds used for Messenger

type ChannelReserveFee = ChannelReserveFee

Channel reserve fee to open a channel.

type ChannelInitReservePortion = ChannelInitReservePortion

Portion of Channel reserve taken by the protocol if the channel is in init state and is requested to be closed.

type DomainRegistration = DomainRegistration

Type to check if a given domain is registered on Consensus chain.

type ChannelFeeModel = ChannelFeeModel

Channels fee model

fn get_endpoint_handler( endpoint: &Endpoint, ) -> Option<Box<dyn EndpointHandlerT<MessageId>>>

function to fetch endpoint response handler by Endpoint.

impl CoreV5<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn version() -> RuntimeVersion

Returns the version of the runtime.

fn execute_block(block: Block)

Execute the given block.

fn initialize_block( header: &<Block as BlockT>::Header, ) -> ExtrinsicInclusionMode

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

impl Debug for Runtime

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DomainsApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, Header<u32, BlakeTwo256>> for Runtime

fn submit_bundle_unsigned( opaque_bundle: OpaqueBundle<NumberFor<Block>, <Block as BlockT>::Hash, DomainHeader, Balance>, )

Submits the transaction bundle via an unsigned extrinsic.

fn submit_receipt_unsigned( singleton_receipt: SealedSingletonReceipt<NumberFor<Block>, <Block as BlockT>::Hash, DomainHeader, Balance>, )

fn extract_successful_bundles( domain_id: DomainId, extrinsics: Vec<<Block as BlockT>::Extrinsic>, ) -> OpaqueBundles<Block, DomainHeader, Balance>

Extract the bundles stored successfully from the given extrinsics.

fn extrinsics_shuffling_seed() -> Randomness

Generates a randomness seed for extrinsics shuffling.

fn domain_runtime_code(domain_id: DomainId) -> Option<Vec<u8>>

Returns the WASM bundle for given domain_id.

fn runtime_id(domain_id: DomainId) -> Option<RuntimeId>

Returns the runtime id for given domain_id.

fn domain_instance_data( domain_id: DomainId, ) -> Option<(DomainInstanceData, NumberFor<Block>)>

Returns the domain instance data for given domain_id.

fn timestamp() -> Moment

Returns the current timestamp at given height.

fn domain_tx_range(_: DomainId) -> U256

Returns the current Tx range for the given domain Id.

fn genesis_state_root(domain_id: DomainId) -> Option<H256>

Return the genesis state root if not pruned

fn head_receipt_number(domain_id: DomainId) -> DomainNumber

Returns the best execution chain number.

fn oldest_unconfirmed_receipt_number( domain_id: DomainId, ) -> Option<DomainNumber>

Returns the block number of oldest unconfirmed execution receipt.

fn domain_bundle_limit(domain_id: DomainId) -> Option<DomainBundleLimit>

Returns the domain bundle limit of the given domain.

fn non_empty_er_exists(domain_id: DomainId) -> bool

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

fn domain_best_number(domain_id: DomainId) -> Option<DomainNumber>

Returns the current best number of the domain.

fn execution_receipt( receipt_hash: DomainHash, ) -> Option<ExecutionReceiptFor<DomainHeader, Block, Balance>>

Returns the execution receipt

fn domain_operators( domain_id: DomainId, ) -> Option<(BTreeMap<OperatorId, Balance>, Vec<OperatorId>)>

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

fn operator_id_by_signing_key( signing_key: OperatorPublicKey, ) -> Option<OperatorId>

Get operator id by signing key

fn receipt_hash( domain_id: DomainId, domain_number: DomainNumber, ) -> Option<DomainHash>

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

fn consensus_chain_byte_fee() -> Balance

Return the consensus chain byte fee that will used to charge the domain transaction for consensus chain storage fee

fn latest_confirmed_domain_block( domain_id: DomainId, ) -> Option<(DomainNumber, DomainHash)>

Returns the latest confirmed domain block number and hash

fn is_bad_er_pending_to_prune( domain_id: DomainId, receipt_hash: DomainHash, ) -> bool

Return if the receipt is exist and pending to prune

fn storage_fund_account_balance(operator_id: OperatorId) -> Balance

Return the balance of the storage fund account

fn is_domain_runtime_upgraded_since( domain_id: DomainId, at: NumberFor<Block>, ) -> Option<bool>

Return if the domain runtime code is upgraded since at

fn domain_sudo_call(domain_id: DomainId) -> Option<Vec<u8>>

Return domain sudo call.

fn last_confirmed_domain_block_receipt( domain_id: DomainId, ) -> Option<ExecutionReceiptFor<DomainHeader, Block, Balance>>

Return last confirmed domain block execution receipt.

impl EnsureInherentsAreFirst<<Runtime as Config>::Block> for Runtime

fn ensure_inherents_are_first( block: &<Runtime as Config>::Block, ) -> Result<u32, u32>

Ensure the position of inherent is correct, i.e. they are before non-inherents.

impl FraudProofApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, Header<u32, BlakeTwo256>> for Runtime

fn submit_fraud_proof_unsigned( fraud_proof: FraudProof<NumberFor<Block>, <Block as BlockT>::Hash, DomainHeader, H256>, )

Submit the fraud proof via an unsigned extrinsic.

fn fraud_proof_storage_key( req: FraudProofStorageKeyRequest<NumberFor<Block>>, ) -> Vec<u8>

Reture the storage key used in fraud proof

impl GenesisBuilderV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn build_state(config: Vec<u8>) -> Result

Build RuntimeGenesisConfig from a JSON blob not using any defaults and store it in the storage.

fn get_preset(id: &Option<PresetId>) -> Option<Vec<u8>>

Returns a JSON blob representation of the built-in RuntimeGenesisConfig identified by id.

fn preset_names() -> Vec<PresetId>

Returns a list of identifiers for available builtin RuntimeGenesisConfig presets.

impl GetRuntimeBlockType for Runtime

type RuntimeBlock = <Runtime as Config>::Block

The RuntimeBlock type.

impl HoldIdentifier<Runtime> for HoldIdentifierWrapper

fn staking_staked() -> Self

fn domain_instantiation_id() -> Self

fn storage_fund_withdrawal() -> Self

impl HoldIdentifier<Runtime> for HoldIdentifierWrapper

fn messenger_channel() -> Self

impl IsInherent<<<Runtime as Config>::Block as Block>::Extrinsic> for Runtime

fn is_inherent(ext: &<<Runtime as Config>::Block as Block>::Extrinsic) -> bool

Whether this extrinsic is an inherent.

impl MessengerApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, u32, <Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>> as Block>::Hash> for Runtime

fn is_xdm_mmr_proof_valid( extrinsic: &<Block as BlockT>::Extrinsic, ) -> Option<bool>

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

fn extract_xdm_mmr_proof( ext: &<Block as BlockT>::Extrinsic, ) -> Option<ConsensusChainMmrLeafProof<BlockNumber, <Block as BlockT>::Hash, H256>>

fn confirmed_domain_block_storage_key(domain_id: DomainId) -> Vec<u8>

Returns the confirmed domain block storage for given domain.

fn outbox_storage_key(message_key: MessageKey) -> Vec<u8>

Returns storage key for outbox for a given message_id.

fn inbox_response_storage_key(message_key: MessageKey) -> Vec<u8>

Returns storage key for inbox response for a given message_id.

fn domain_chains_allowlist_update( domain_id: DomainId, ) -> Option<DomainAllowlistUpdates>

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

impl MetadataV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn metadata() -> OpaqueMetadata

Returns the metadata of a runtime.

fn metadata_at_version(version: u32) -> Option<OpaqueMetadata>

Returns the metadata at a given version.

fn metadata_versions() -> Vec<u32>

Returns the supported metadata versions.

impl<__SrApiBlock__: BlockT + UnwindSafe + RefUnwindSafe, RuntimeApiImplCall: CallApiAt<__SrApiBlock__> + 'static> MmrApi<__SrApiBlock__, <<Runtime as Config>::Hashing as Hash>::Output, u32> for RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall>

where RuntimeApiImplCall::StateBackend: StateBackend<HashingFor<__SrApiBlock__>>, &'static RuntimeApiImplCall: Send, Result<<<Runtime as Config>::Hashing as Hash>::Output, Error>: UnwindSafe + RefUnwindSafe, Result<LeafIndex, Error>: UnwindSafe + RefUnwindSafe, Vec<BlockNumber>: UnwindSafe + RefUnwindSafe, Option<BlockNumber>: UnwindSafe + RefUnwindSafe, Result<(Vec<EncodableOpaqueLeaf>, LeafProof<<<Runtime as Config>::Hashing as Hash>::Output>), Error>: UnwindSafe + RefUnwindSafe, Vec<EncodableOpaqueLeaf>: UnwindSafe + RefUnwindSafe, LeafProof<<<Runtime as Config>::Hashing as Hash>::Output>: UnwindSafe + RefUnwindSafe, Result<(), Error>: UnwindSafe + RefUnwindSafe, <<Runtime as Config>::Hashing as Hash>::Output: UnwindSafe + RefUnwindSafe, __SrApiBlock__::Header: UnwindSafe + RefUnwindSafe,

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

Return the on-chain MMR root hash.

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

Return the number of MMR blocks in the chain.

fn generate_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, block_numbers: Vec<BlockNumber>, best_known_block_number: Option<BlockNumber>, ) -> Result<Result<(Vec<EncodableOpaqueLeaf>, LeafProof<Hash>), Error>, ApiError>

Generate MMR proof for a series of block numbers. If best_known_block_number = Some(n), use historical MMR state at given block height n. Else, use current MMR state.

fn verify_proof( &self, __runtime_api_at_param__: <Block as Block>::Hash, leaves: Vec<EncodableOpaqueLeaf>, proof: LeafProof<Hash>, ) -> Result<Result<(), Error>, ApiError>

Verify MMR proof against on-chain MMR for a batch of leaves.

fn verify_proof_stateless( &self, __runtime_api_at_param__: <Block as Block>::Hash, root: Hash, leaves: Vec<EncodableOpaqueLeaf>, proof: LeafProof<Hash>, ) -> Result<Result<(), Error>, ApiError>

Verify MMR proof against given root hash for a batch of leaves.

impl MmrApiV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, <<Runtime as Config>::Hashing as Hash>::Output, u32> for Runtime

fn mmr_root() -> Result<<<Runtime as Config>::Hashing as Hash>::Output, Error>

Return the on-chain MMR root hash.

fn mmr_leaf_count() -> Result<LeafIndex, Error>

Return the number of MMR blocks in the chain.

fn generate_proof( block_numbers: Vec<BlockNumber>, best_known_block_number: Option<BlockNumber>, ) -> Result<(Vec<EncodableOpaqueLeaf>, LeafProof<<<Runtime as Config>::Hashing as Hash>::Output>), Error>

Generate MMR proof for a series of block numbers. If best_known_block_number = Some(n), use historical MMR state at given block height n. Else, use current MMR state.

fn verify_proof( leaves: Vec<EncodableOpaqueLeaf>, proof: LeafProof<<<Runtime as Config>::Hashing as Hash>::Output>, ) -> Result<(), Error>

Verify MMR proof against on-chain MMR for a batch of leaves.

fn verify_proof_stateless( root: <<Runtime as Config>::Hashing as Hash>::Output, leaves: Vec<EncodableOpaqueLeaf>, proof: LeafProof<<<Runtime as Config>::Hashing as Hash>::Output>, ) -> Result<(), Error>

Verify MMR proof against given root hash for a batch of leaves.

impl MmrProofVerifier<<<Runtime as Config>::Hashing as Hash>::Output, <<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>> as Block>::Header as Header>::Number, H256> for MmrProofVerifier

fn verify_proof_and_extract_leaf( mmr_leaf_proof: ConsensusChainMmrLeafProof<NumberFor<Block>, Hash, <<Runtime as Config>::Hashing as Hash>::Output>, ) -> Option<<<Runtime as Config>::LeafData as LeafDataProvider>::LeafData>

Returns consensus state root if the given MMR proof is valid

fn verify_proof_stateless( mmr_root: <<Runtime as Config>::Hashing as Hash>::Output, mmr_leaf_proof: ConsensusChainMmrLeafProof<NumberFor<Block>, Hash, <<Runtime as Config>::Hashing as Hash>::Output>, ) -> Option<<<Runtime as Config>::LeafData as LeafDataProvider>::LeafData>

fn extract_leaf_without_verifying( mmr_leaf_proof: ConsensusChainMmrLeafProof<CBlockNumber, CBlockHash, MmrHash>, ) -> Option<MmrLeaf<CBlockNumber, CBlockHash>>

impl ObjectsApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn extract_block_object_mapping(block: Block) -> BlockObjectMapping

Extract block object mapping for a given block

impl OffchainWorkerApiV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn offchain_worker(header: &<Block as BlockT>::Header)

Starts the off-chain task for given block header.

impl OnChargeTransaction<Runtime> for OnChargeTransaction

type LiquidityInfo = Option<LiquidityInfo>

type Balance = u128

The underlying integer type in which fees are calculated.

fn withdraw_fee( who: &AccountId, call: &RuntimeCall, _info: &DispatchInfoOf<RuntimeCall>, fee: Self::Balance, tip: Self::Balance, ) -> Result<Self::LiquidityInfo, TransactionValidityError>

Before the transaction is executed the payment of the transaction fees need to be secured.

fn correct_and_deposit_fee( who: &AccountId, _dispatch_info: &DispatchInfoOf<RuntimeCall>, _post_info: &PostDispatchInfoOf<RuntimeCall>, corrected_fee: Self::Balance, tip: Self::Balance, liquidity_info: Self::LiquidityInfo, ) -> Result<(), TransactionValidityError>

After the transaction was executed the actual fee can be calculated. This function should refund any overpaid fees and optionally deposit the corrected amount.

impl OnchainStateApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u128> for Runtime

fn free_balance(account_id: AccountId) -> Balance

Api to get the free balance of the given account

fn get_open_channel_for_chain(dst_chain_id: ChainId) -> Option<ChannelId>

Returns the last open channel for a given domain.

fn verify_proof_and_extract_leaf( mmr_leaf_proof: ConsensusChainMmrLeafProof<NumberFor<Block>, <Block as BlockT>::Hash, H256>, ) -> Option<<<Runtime as Config>::LeafData as LeafDataProvider>::LeafData>

Verify the mmr proof statelessly and extract the state root.

impl PartialEq for Runtime

fn eq(&self, other: &Runtime) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RelayerApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, u32, u32, <Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>> as Block>::Hash> for Runtime

fn block_messages() -> BlockMessagesWithStorageKey

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( msg: CrossDomainMessage<NumberFor<Block>, <Block as BlockT>::Hash, <Block as BlockT>::Hash>, ) -> Option<<Block as BlockT>::Extrinsic>

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

fn inbox_response_message_unsigned( msg: CrossDomainMessage<NumberFor<Block>, <Block as BlockT>::Hash, <Block as BlockT>::Hash>, ) -> Option<<Block as BlockT>::Extrinsic>

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

fn should_relay_outbox_message(dst_chain_id: ChainId, msg_id: MessageId) -> bool

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

fn should_relay_inbox_message_response( dst_chain_id: ChainId, msg_id: MessageId, ) -> bool

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

fn updated_channels() -> BTreeSet<(ChainId, ChannelId)>

Returns the list of channels updated in the given block.

fn channel_storage_key(chain_id: ChainId, channel_id: ChannelId) -> Vec<u8>

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

impl<C> SendTransactionTypes<C> for Runtime

where RuntimeCall: From<C>,

type Extrinsic = UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>

The extrinsic type expected by the runtime.

type OverarchingCall = RuntimeCall

The runtime’s call type.

impl SessionKeysV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8>

Generate a set of session keys with optionally using the given seed. The keys should be stored within the keystore exposed via runtime externalities.

fn decode_session_keys(encoded: Vec<u8>) -> Option<Vec<(Vec<u8>, KeyTypeId)>>

Decode the given public session keys.

impl SubspaceApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, PublicKey> for Runtime

fn pot_parameters() -> PotParameters

Proof of time parameters

fn solution_ranges() -> SolutionRanges

Solution ranges.

fn submit_vote_extrinsic( signed_vote: SignedVote<NumberFor<Block>, <Block as BlockT>::Hash, PublicKey>, )

Submit farmer vote vote that is essentially a header with bigger solution range than acceptable for block authoring. Only useful in an offchain context.

fn history_size() -> HistorySize

Size of the blockchain history

fn max_pieces_in_sector() -> u16

How many pieces one sector is supposed to contain (max)

fn segment_commitment(segment_index: SegmentIndex) -> Option<SegmentCommitment>

Get the segment commitment of records for specified segment index

fn extract_segment_headers( ext: &<Block as BlockT>::Extrinsic, ) -> Option<Vec<SegmentHeader>>

Returns Vec<SegmentHeader> if a given extrinsic has them.

fn is_inherent(ext: &<Block as BlockT>::Extrinsic) -> bool

Checks if the extrinsic is an inherent.

fn root_plot_public_key() -> Option<PublicKey>

Returns root plot public key in case block authoring is restricted.

fn should_adjust_solution_range() -> bool

Whether solution range adjustment is enabled.

fn chain_constants() -> ChainConstants

Get Subspace blockchain constants

impl TaggedTransactionQueueV3<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>> for Runtime

fn validate_transaction( source: TransactionSource, tx: <Block as BlockT>::Extrinsic, block_hash: <Block as BlockT>::Hash, ) -> TransactionValidity

Validate the transaction.

impl TransactionPaymentApiV4<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<MultiAddress<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, ()>, RuntimeCall, MultiSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, u128> for Runtime

fn query_info( uxt: <Block as BlockT>::Extrinsic, len: u32, ) -> RuntimeDispatchInfo<Balance>

fn query_fee_details( uxt: <Block as BlockT>::Extrinsic, len: u32, ) -> FeeDetails<Balance>

fn query_weight_to_fee(weight: Weight) -> Balance

fn query_length_to_fee(length: u32) -> Balance

impl TypeInfo for Runtime

type Identity = Runtime

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl ValidateUnsigned for Runtime

type Call = RuntimeCall

The call to validate

fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError>

Validate the call right before dispatch.

fn validate_unsigned( source: TransactionSource, call: &Self::Call, ) -> TransactionValidity

Return the validity of the call

impl Copy for Runtime

impl Eq for Runtime

impl StructuralPartialEq for Runtime