Struct phronesis_runtime::Runtime

pub struct Runtime;

Implementations

impl Runtime

pub(crate) fn metadata_ir() -> MetadataIR

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<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, RuntimeCall, EthereumSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, <<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32> for Runtime

fn account_nonce(account: AccountId) -> Nonce

Get current account nonce of given AccountId.

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

fn slot_duration() -> SlotDuration

Returns the slot duration for Aura.

fn authorities() -> Vec<AuraId>

Return the current set of authorities.

impl BlockBuilderV6<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, RuntimeCall, EthereumSignature, (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 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 FullIdentification = Exposure<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, u128>

Full identification of the validator.

type FullIdentificationOf = ExposureOf<Runtime>

A conversion from validator ID to full identification.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type StateRoot = IntermediateStateRoot<Runtime>

How Ethereum state root is calculated.

type PostLogContent = PostBlockAndTxnHashes

What’s included in the PostLog.

type ExtraDataLength = ConstU32<64>

The maximum length of the extra data in the Executed event.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Currency = Pallet<Runtime>

The currency trait.

type BasicDeposit = BasicDeposit

The amount held on deposit for a registered identity

type FieldDeposit = FieldDeposit

The amount held on deposit per additional field for a registered identity.

type SubAccountDeposit = SubAccountDeposit

The amount held on deposit for a registered subaccount. This should account for the fact that one storage item’s value will increase by the size of an account ID, and there will be another trie item whose value is the size of an account ID plus 32 bytes.

type MaxSubAccounts = ConstU32<60>

The maximum number of sub-accounts allowed per identified account.

type MaxAdditionalFields = ConstU32<60>

Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O required to access an identity, but can be pretty high.

type MaxRegistrars = ConstU32<15>

Maxmimum number of registrars allowed in the system. Needed to bound the complexity of, e.g., updating judgements.

type Slashed = Pallet<Runtime>

What to do with slashed funds.

type ForceOrigin = EnsureRoot<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin which may forcibly set or remove a name. Root can always do this.

type RegistrarOrigin = EnsureRoot<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin which may add or remove registrars. Root can always do this.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The ubiquitous event type.

type Balance = u128

The type for recording an account’s balance.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type DustRemoval = ()

Handler for the unbalanced reduction when removing a dust account.

type ExistentialDeposit = ConstU128<EXISTENTIAL_DEPOSIT>

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 ReserveIdentifier = [u8; 8]

The ID type for reserves.

type RuntimeHoldReason = RuntimeHoldReason

The overarching hold reason.

type FreezeIdentifier = ()

The ID type for freezes.

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 MaxHolds = ()

The maximum number of holds that can exist on an account at any time.

type MaxFreezes = ()

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

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

type BanHandler = Pallet<Runtime>

Something that handles bans

type EraInfoProvider = Pallet<Runtime>

Something that provides information about era.

type ValidatorProvider = Pallet<Runtime>

Something that provides information about validator.

type ValidatorRewardsHandler = Pallet<Runtime>

Something that handles addition of rewards for validators.

type ValidatorExtractor = Pallet<Runtime>

Something that handles removal of the validators

type FinalityCommitteeManager = Pallet<Runtime>

type SessionPeriod = SessionPeriod

Nr of blocks in the session.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

type AuthorityId = Public

The identifier type for an authority.

type MaxAuthorities = ConstU32<100000>

The maximum number of authorities that the pallet can hold.

type SessionPeriod = SessionPeriod

type MaxSplits = ConstU32<3>

type DisabledValidators = ()

A way to check whether a given validator is disabled and should not be authoring blocks. Blocks authored by a disabled validator will lead to a panic as part of this module’s initialization.

type AllowMultipleBlocksPerSlot = ConstBool<false>

Whether to allow block authors to create multiple blocks per slot.

impl Config for Runtime

type Moment = u64

A timestamp: milliseconds since the unix epoch.

type OnTimestampSet = Pallet<Runtime>

Something which can be notified when the timestamp is set. Set this to () if not needed.

type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>

The minimum period between blocks. Beware that this is different to the expected period that the block production apparatus provides. Your chosen consensus system will generally work with this to determine a sensible block time. e.g. For Aura, it will be double this period on default settings.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type FindAuthor = FindAccountFromAuthorIndex<Runtime, Pallet<Runtime>>

Find the author of a block.

type EventHandler = (Pallet<Runtime>,)

An event handler for authored blocks.

impl Config for Runtime

type MinGasPriceBoundDivisor = GasPriceBoundDivisor

Bound divisor for min gas price.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The ubiquitous event type.

type BaseCallFilter = Everything

The basic call filter to use in dispatchable.

type BlockWeights = BlockWeights

Block & extrinsics weights: base values and limits.

type BlockLength = BlockLength

The maximum length of a block (in bytes).

type RuntimeOrigin = RuntimeOrigin

The ubiquitous origin type.

type RuntimeCall = RuntimeCall

The aggregated dispatch type that is available for extrinsics.

type Hash = H256

The type for hashing blocks and tries.

type Hashing = BlakeTwo256

The hashing algorithm used.

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

The identifier used to distinguish between accounts.

type Lookup = IdentityLookup<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>

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

type BlockHashCount = BlockHashCount

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

type DbWeight = RocksDbWeight

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 AccountData = AccountData<u128>

The data to be stored in an account.

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 SystemWeightInfo = SubstrateWeight<Runtime>

Weight information for the extrinsics of this pallet.

type SS58Prefix = SS58Prefix

This is used as an identifier of the chain. 42 is the generic substrate prefix.

type OnSetCode = ()

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

type Nonce = u32

This stores the number of previous transactions associated with a sender account.

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

The Block type used by the runtime. This is used by construct_runtime to retrieve the extrinsics or other block specific data as needed.

type MaxConsumers = ConstU32<16>

The maximum number of consumers allowed on a single account.

impl Config for Runtime

type Currency = Pallet<Runtime>

The staking balance.

type CurrencyBalance = u128

Just the Currency::Balance type; we have this item to allow us to constrain it to From<u64>.

type UnixTime = Pallet<Runtime>

Time used for computing era duration.

type CurrencyToVote = U128CurrencyToVote

Convert a balance into a number used for election calculation. This must fit into a u64 but is allowed to be sensibly lossy. The u64 is used to communicate with the [frame_election_provider_support] crate which accepts u64 numbers and does operations in 128. Consequently, the backward convert is used convert the u128s from sp-elections back to a [BalanceOf].

type ElectionProvider = Pallet<Runtime>

Something that provides the election functionality.

type GenesisElectionProvider = Pallet<Runtime>

Something that provides the election functionality at genesis.

type NominationsQuota = FixedNominationsQuota<MAX_NOMINATIONS>

Something that defines the maximum number of nominations per nominator.

type HistoryDepth = ConstU32<100>

Number of eras to keep in history.

type RewardRemainder = Pallet<Runtime>

Tokens have been minted and are unused for validator-reward. See Era payout.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Slash = Pallet<Runtime>

Handler for the unbalanced reduction when slashing a staker.

type Reward = ()

Handler for the unbalanced increment when rewarding a staker. NOTE: in most cases, the implementation of OnUnbalanced should modify the total issuance.

type SessionsPerEra = SessionsPerEra

Number of sessions per era.

type BondingDuration = BondingDuration

Number of eras that staked funds must remain bonded for.

type SlashDeferDuration = SlashDeferDuration

Number of eras that slashes are deferred by, after computation.

type AdminOrigin = EnsureRoot<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin which can manage less critical staking parameters that does not require root.

type SessionInterface = Runtime

Interface for interacting with a session pallet.

type EraPayout = ConvertCurve<RewardCurve>

The payout for validators and the system for the current era. See Era payout.

type NextNewSession = Pallet<Runtime>

Something that can estimate the next session change, accurately or as a best effort guess.

type MaxNominatorRewardedPerValidator = ConstU32<100>

The maximum number of nominators rewarded for each validator.

type OffendingValidatorsThreshold = OffendngValidatorsThreshold

The fraction of the validator set that is safe to be offending. After the threshold is reached a new era will be forced.

type VoterList = UseNominatorsAndValidatorsMap<Runtime>

Something that provides a best-effort sorted list of voters aka electing nominators, used for NPoS election.

type TargetList = UseValidatorsMap<Runtime>

WIP: This is a noop as of now, the actual business logic that’s described below is going to be introduced in a follow-up PR.

type MaxUnlockingChunks = ConstU32<16>

The maximum number of unlocking chunks a [StakingLedger] can have. Effectively determines how many unique eras a staker may be unbonding in.

type EventListeners = ()

Something that listens to staking updates and performs actions based on the data it receives.

type BenchmarkingConfig = StakingBenchmarkingConfig

Some parameters of the benchmarking.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type ValidatorId = <Runtime as Config>::AccountId

A stable ID for a validator.

type ValidatorIdOf = IdentityValidator

A conversion from account ID to validator ID.

type ShouldEndSession = PeriodicSessions<SessionPeriod, Offset>

Indicator for when to end the session.

type NextSessionRotation = PeriodicSessions<SessionPeriod, Offset>

Something that can predict the next session rotation. This should typically come from the same logical unit that provides [ShouldEndSession], yet, it gives a best effort estimate. It is helpful to implement [EstimateNextNewSession].

type SessionManager = Pallet<Runtime>

Handler for managing new session.

type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders

Handler when a session has changed.

type Keys = SessionKeys

The keys.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Currency = Pallet<Runtime>

The staking balance.

type ApproveOrigin = EnsureSignedBy<TreasuryGovernance, <<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin from which approvals must come.

type RejectOrigin = EnsureSignedBy<TreasuryGovernance, <<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin from which rejections must come.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type OnSlash = ()

Handler for the unbalanced decrease when slashing for a rejected proposal or bounty.

type ProposalBond = ProposalBond

Fraction of a proposal’s value that should be bonded in order to place the proposal. An accepted proposal gets these back. A rejected proposal does not.

type ProposalBondMinimum = ProposalBondMinimum

Minimum amount of funds that should be placed in a deposit for making a proposal.

type ProposalBondMaximum = ()

Maximum amount of funds that should be placed in a deposit for making a proposal.

type SpendPeriod = SpendPeriod

Period between successive spends.

type Burn = Burn

Percentage of spare funds (if any) that are burnt per spend period.

type PalletId = TreasuryPalletId

The treasury’s pallet id, used for deriving its sovereign account ID.

type BurnDestination = ()

Handler for the unbalanced decrease when treasury funds are burned.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

type SpendFunds = ()

Runtime hooks to external pallet using treasury to compute spend funds.

type MaxApprovals = ConstU32<100>

The maximum number of approvals that can wait in the spending queue.

type SpendOrigin = EnsureWithSuccess<EnsureRoot<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>, <<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, MaxBalance>

The origin required for approving spends from the treasury outside of the proposal process. The Success value is the maximum amount that this origin is allowed to spend at a time.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type OnChargeTransaction = CurrencyAdapter<Pallet<Runtime>, DealWithFees<Runtime>>

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 mulitplier for Operational extrinsics to compute “virtual tip” to boost their priority

type WeightToFee = ConstantMultiplier<u128, ConstU128<{ phronesis::WEIGHT_FEE }>>

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

type LengthToFee = LengthToFee

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

type FeeMultiplierUpdate = TargetedFeeAdjustment<Runtime, TargetBlockFullness, AdjustmentVariable, MinimumMultiplier, MaximumMultiplier>

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

impl Config for Runtime

type FeeCalculator = TransactionPaymentGasPrice

Calculator for current gas price.

type GasWeightMapping = FixedGasWeightMapping<Runtime>

Maps Ethereum gas to Substrate weight.

type WeightPerGas = WeightPerGas

Weight corresponding to a gas unit.

type BlockHashMapping = EthereumBlockHashMapping<Runtime>

Block number to block hash.

type CallOrigin = EnsureAddressRoot<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Allow the origin to call on behalf of given address.

type WithdrawOrigin = EnsureAddressNever<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Allow the origin to withdraw on behalf of given address.

type AddressMapping = IdentityAddressMapping

Mapping from address to account id.

type Currency = Pallet<Runtime>

Currency type for withdraw and balance storage.

type RuntimeEvent = RuntimeEvent

The overarching event type.

type PrecompilesType = FrontierPrecompiles<Runtime>

Precompiles associated with this EVM engine.

type PrecompilesValue = PrecompilesValue

type ChainId = ConstU64<4477>

Chain ID of EVM.

type BlockGasLimit = BlockGasLimit

The block gas limit. Can be a simple constant, or an adjustment algorithm in another pallet.

type Runner = Runner<Runtime>

EVM execution runner.

type OnChargeTransaction = OnChargeEVMTransaction<DealWithFees<Runtime>>

To handle fee deduction for EVM transactions. An example is this pallet being used by pallet_ethereum where the chain implementing pallet_ethereum should be able to configure what happens to the fees Similar to OnChargeTransaction of pallet_transaction_payment

type OnCreate = ()

Called on create calls, used to record owner

type FindAuthor = PhronFindAuthor<FindAccountFromAuthorIndex<Runtime, Pallet<Runtime>>>

Find author for the current block.

type GasLimitPovSizeRatio = GasLimitPovSizeRatio

Gas limit Pov size ratio.

type Timestamp = Pallet<Runtime>

Get the timestamp for the current block.

type WeightInfo = SubstrateWeight<Runtime>

Weight information for extrinsics in this pallet.

fn config() -> &'static Config

EVM config used in the module.

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

The overarching event type.

type Currency = Pallet<Runtime>

The currency trait.

type ReservationFee = ConstU128<1000>

Reservation fee.

type Slashed = ()

What to do with slashed funds.

type ForceOrigin = EnsureRoot<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The origin which may forcibly set or remove a name. Root can always do this.

type MinLength = ConstU32<5>

The minimum length a name may be.

type MaxLength = ConstU32<40>

The maximum length a name may be.

impl Config for Runtime

type AuthorityId = Public

type RuntimeEvent = RuntimeEvent

type SessionInfoProvider = SessionInfoImpl

type SessionManager = SessionAndEraManager<Pallet<Runtime>, Pallet<Runtime>, NoteHistoricalRoot<Runtime, Pallet<Runtime>>, Runtime>

type NextSessionAuthorityProvider = Pallet<Runtime>

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 DataProvider = Pallet<Runtime>

Something that provides data for elections.

type ValidatorProvider = Pallet<Runtime>

type MaxWinners = MaxWinners

The maximum number of winners that can be elected by this ElectionProvider implementation.

type BannedValidators = Pallet<Runtime>

impl Config for Runtime

type RuntimeEvent = RuntimeEvent

type Threshold = BaseFeeThreshold

Lower and upper bounds for increasing / decreasing BaseFeePerGas.

type DefaultBaseFeePerGas = DefaultBaseFeePerGas

type DefaultElasticity = DefaultElasticity

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

fn convert_transaction(transaction: Transaction) -> <Block as Block>::Extrinsic

impl CoreV4<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, RuntimeCall, EthereumSignature, (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)

Initialize a block with the given header.

impl<LocalCall> CreateSignedTransaction<LocalCall> for Runtime

where RuntimeCall: From<LocalCall>,

fn create_transaction<C: AppCrypto<Self::Public, Self::Signature>>( call: RuntimeCall, public: <Signature as Verify>::Signer, account: AccountId, index: Index ) -> Option<(RuntimeCall, <UncheckedExtrinsic as Extrinsic>::SignaturePayload)>

Attempt to create signed extrinsic data that encodes call from given account.

impl Debug for Runtime

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

Formats the value using the given formatter.

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

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

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

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

fn chain_id() -> u64

Returns runtime defined pallet_evm::ChainId.

fn account_basic(address: H160) -> Account

Returns pallet_evm::Accounts by address.

fn gas_price() -> U256

Returns FixedGasPrice::min_gas_price

fn account_code_at(address: H160) -> Vec<u8>

For a given account address, returns pallet_evm::AccountCodes.

fn author() -> H160

Returns the converted FindAuthor::find_author authority id.

fn storage_at(address: H160, index: U256) -> H256

For a given account address and index, returns pallet_evm::AccountStorages.

fn call( from: H160, to: H160, data: Vec<u8>, value: U256, gas_limit: U256, max_fee_per_gas: Option<U256>, max_priority_fee_per_gas: Option<U256>, nonce: Option<U256>, estimate: bool, access_list: Option<Vec<(H160, Vec<H256>)>> ) -> Result<CallInfo, DispatchError>

fn create( from: H160, data: Vec<u8>, value: U256, gas_limit: U256, max_fee_per_gas: Option<U256>, max_priority_fee_per_gas: Option<U256>, nonce: Option<U256>, estimate: bool, access_list: Option<Vec<(H160, Vec<H256>)>> ) -> Result<CreateInfo, DispatchError>

fn current_transaction_statuses() -> Option<Vec<TransactionStatus>>

Return the current transaction status.

fn current_block() -> Option<Block>

Return the current block.

fn current_receipts() -> Option<Vec<Receipt>>

Return the current receipt.

fn current_all( ) -> (Option<Block>, Option<Vec<Receipt>>, Option<Vec<TransactionStatus>>)

fn extrinsic_filter(xts: Vec<<Block as Block>::Extrinsic>) -> Vec<Transaction>

Receives a Vec<OpaqueExtrinsic> and filters all the ethereum transactions.

fn elasticity() -> Option<Permill>

Return the elasticity multiplier.

fn gas_limit_multiplier_support()

Used to determine if gas limit multiplier for non-transactional calls (eth_call/estimateGas) is supported.

fn pending_block( xts: Vec<<Block as Block>::Extrinsic> ) -> (Option<Block>, Option<Vec<TransactionStatus>>)

Return the pending block.

impl GetRuntimeBlockType for Runtime

type RuntimeBlock = <Runtime as Config>::Block

The RuntimeBlock type.

impl MetadataV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, RuntimeCall, EthereumSignature, (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 OffchainWorkerApiV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, RuntimeCall, EthereumSignature, (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 PartialEq for Runtime

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

This method tests for self and other values to be equal, and is used by ==.

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

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

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

fn millisecs_per_block() -> u64

fn session_period() -> u32

fn authorities() -> Vec<PhronId>

fn next_session_authorities() -> Result<Vec<PhronId>, PhronApiError>

fn authority_data() -> SessionAuthorityData

fn next_session_authority_data() -> Result<SessionAuthorityData, PhronApiError>

fn finality_version() -> FinalityVersion

fn next_session_finality_version() -> FinalityVersion

fn next_session_aura_authorities() -> Vec<AuraId>

fn key_owner(key: PhronId) -> Option<AccountId>

Returns owner (AccountId) corresponding to an AuthorityId (in some contexts referenced also as aleph_key - consensus engine’s part of session keys) in the current session of AlephBFT (finalisation committee).

impl<C> SendTransactionTypes<C> for Runtime

where RuntimeCall: From<C>,

type Extrinsic = UncheckedExtrinsic<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, RuntimeCall, EthereumSignature, (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<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, RuntimeCall, EthereumSignature, (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 SigningTypes for Runtime

type Public = <EthereumSignature as Verify>::Signer

A public key that is capable of identifying AccountIds.

type Signature = EthereumSignature

A matching Signature type.

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

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

Validate the transaction.

impl TransactionPaymentApiV4<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, RuntimeCall, EthereumSignature, (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 TransactionPaymentCallApiV3<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<EthereumSignature as Verify>::Signer as IdentifyAccount>::AccountId, RuntimeCall, EthereumSignature, (CheckNonZeroSender<Runtime>, CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>)>>, u128, RuntimeCall> for Runtime

fn query_call_info(call: RuntimeCall, len: u32) -> RuntimeDispatchInfo<Balance>

Query information of a dispatch class, weight, and fee of a given encoded Call.

fn query_call_fee_details(call: RuntimeCall, len: u32) -> FeeDetails<Balance>

Query fee details of a given encoded Call.

fn query_weight_to_fee(weight: Weight) -> Balance

Query the output of the current WeightToFee given some input.

fn query_length_to_fee(length: u32) -> Balance

Query the output of the current LengthToFee given some input.

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