// Copyright 2020 Parity Technologies (UK) Ltd. // This file is part of Polkadot. // Polkadot is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // Polkadot is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . //! The Rococo runtime for v1 parachains. #![cfg_attr(not(feature = "std"), no_std)] // `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256. #![recursion_limit = "256"] use pallet_transaction_payment::CurrencyAdapter; use sp_std::prelude::*; use sp_std::collections::btree_map::BTreeMap; use parity_scale_codec::Encode; use primitives::v1::{ AccountId, AccountIndex, Balance, BlockNumber, Hash, Nonce, Signature, Moment, GroupRotationInfo, CoreState, Id, ValidationCode, CandidateEvent, ValidatorId, ValidatorIndex, CommittedCandidateReceipt, OccupiedCoreAssumption, PersistedValidationData, InboundDownwardMessage, InboundHrmpMessage, SessionInfo as SessionInfoData, }; use runtime_common::{ SlowAdjustingFeeUpdate, impls::ToAuthor, BlockHashCount, BlockWeights, BlockLength, RocksDbWeight, }; use runtime_parachains::{ self, runtime_api_impl::v1 as runtime_api_impl, }; use frame_support::{ construct_runtime, parameter_types, traits::{Filter, KeyOwnerProofSystem, Randomness}, weights::Weight, }; use sp_runtime::{ create_runtime_str, generic, impl_opaque_keys, ApplyExtrinsicResult, KeyTypeId, Perbill, ModuleId, transaction_validity::{TransactionValidity, TransactionSource, TransactionPriority}, traits::{ BlakeTwo256, Block as BlockT, OpaqueKeys, AccountIdLookup, Extrinsic as ExtrinsicT, SaturatedConversion, Verify, }, }; use pallet_im_online::sr25519::AuthorityId as ImOnlineId; use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId; #[cfg(any(feature = "std", test))] use sp_version::NativeVersion; use sp_version::RuntimeVersion; use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo}; use pallet_grandpa::{AuthorityId as GrandpaId, fg_primitives}; use sp_core::OpaqueMetadata; use sp_staking::SessionIndex; use pallet_session::historical as session_historical; use frame_system::EnsureRoot; use runtime_common::{paras_sudo_wrapper, paras_registrar, xcm_sender, auctions, crowdloan, slots}; use runtime_parachains::origin as parachains_origin; use runtime_parachains::configuration as parachains_configuration; use runtime_parachains::shared as parachains_shared; use runtime_parachains::inclusion as parachains_inclusion; use runtime_parachains::inclusion_inherent as parachains_inclusion_inherent; use runtime_parachains::initializer as parachains_initializer; use runtime_parachains::session_info as parachains_session_info; use runtime_parachains::paras as parachains_paras; use runtime_parachains::dmp as parachains_dmp; use runtime_parachains::ump as parachains_ump; use runtime_parachains::hrmp as parachains_hrmp; use runtime_parachains::scheduler as parachains_scheduler; pub use pallet_balances::Call as BalancesCall; use polkadot_parachain::primitives::Id as ParaId; use xcm::v0::{MultiLocation, NetworkId}; use xcm_executor::traits::IsConcrete; use xcm_builder::{ AccountId32Aliases, ChildParachainConvertsVia, SovereignSignedViaLocation, CurrencyAdapter as XcmCurrencyAdapter, ChildParachainAsNative, SignedAccountId32AsNative, ChildSystemParachainAsSuperuser, LocationInverter, }; use constants::{time::*, currency::*, fee::*}; /// Constant values used within the runtime. pub mod constants; mod validator_manager; // Make the WASM binary available. #[cfg(feature = "std")] include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); /// Runtime version (Rococo). pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("rococo"), impl_name: create_runtime_str!("parity-rococo-v1-1"), authoring_version: 0, spec_version: 215, impl_version: 0, #[cfg(not(feature = "disable-runtime-api"))] apis: RUNTIME_API_VERSIONS, #[cfg(feature = "disable-runtime-api")] apis: sp_version::create_apis_vec![[]], transaction_version: 0, }; /// The BABE epoch configuration at genesis. pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration = babe_primitives::BabeEpochConfiguration { c: PRIMARY_PROBABILITY, allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots }; /// Native version. #[cfg(any(feature = "std", test))] pub fn native_version() -> NativeVersion { NativeVersion { runtime_version: VERSION, can_author_with: Default::default(), } } /// The address format for describing accounts. pub type Address = sp_runtime::MultiAddress; /// Block header type as expected by this runtime. pub type Header = generic::Header; /// Block type as expected by this runtime. pub type Block = generic::Block; /// A Block signed with a Justification pub type SignedBlock = generic::SignedBlock; /// BlockId type as expected by this runtime. pub type BlockId = generic::BlockId; /// The SignedExtension to the basic transaction logic. pub type SignedExtra = ( frame_system::CheckSpecVersion, frame_system::CheckTxVersion, frame_system::CheckGenesis, frame_system::CheckMortality, frame_system::CheckNonce, frame_system::CheckWeight, pallet_transaction_payment::ChargeTransactionPayment, ); /// Unchecked extrinsic type as expected by this runtime. pub type UncheckedExtrinsic = generic::UncheckedExtrinsic; /// Extrinsic type that has already been checked. pub type CheckedExtrinsic = generic::CheckedExtrinsic; /// Executive: handles dispatch to the various modules. pub type Executive = frame_executive::Executive, Runtime, AllPallets>; /// The payload being signed in transactions. pub type SignedPayload = generic::SignedPayload; impl_opaque_keys! { pub struct SessionKeys { pub grandpa: Grandpa, pub babe: Babe, pub im_online: ImOnline, pub para_validator: Initializer, pub para_assignment: SessionInfo, pub authority_discovery: AuthorityDiscovery, } } construct_runtime! { pub enum Runtime where Block = Block, NodeBlock = primitives::v1::Block, UncheckedExtrinsic = UncheckedExtrinsic { System: frame_system::{Pallet, Call, Storage, Config, Event}, // Must be before session. Babe: pallet_babe::{Pallet, Call, Storage, Config, ValidateUnsigned}, Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent}, Indices: pallet_indices::{Pallet, Call, Storage, Config, Event}, Balances: pallet_balances::{Pallet, Call, Storage, Config, Event}, TransactionPayment: pallet_transaction_payment::{Pallet, Storage}, // Consensus support. Authorship: pallet_authorship::{Pallet, Call, Storage}, Offences: pallet_offences::{Pallet, Call, Storage, Event}, Historical: session_historical::{Pallet}, Session: pallet_session::{Pallet, Call, Storage, Event, Config}, Grandpa: pallet_grandpa::{Pallet, Call, Storage, Config, Event, ValidateUnsigned}, ImOnline: pallet_im_online::{Pallet, Call, Storage, Event, ValidateUnsigned, Config}, AuthorityDiscovery: pallet_authority_discovery::{Pallet, Call, Config}, // Parachains modules. ParachainsOrigin: parachains_origin::{Pallet, Origin}, ParachainsConfiguration: parachains_configuration::{Pallet, Call, Storage, Config}, Shared: parachains_shared::{Pallet, Call, Storage}, Inclusion: parachains_inclusion::{Pallet, Call, Storage, Event}, InclusionInherent: parachains_inclusion_inherent::{Pallet, Call, Storage, Inherent}, Scheduler: parachains_scheduler::{Pallet, Call, Storage}, Paras: parachains_paras::{Pallet, Call, Storage}, Initializer: parachains_initializer::{Pallet, Call, Storage}, Dmp: parachains_dmp::{Pallet, Call, Storage}, Ump: parachains_ump::{Pallet, Call, Storage}, Hrmp: parachains_hrmp::{Pallet, Call, Storage, Event}, SessionInfo: parachains_session_info::{Pallet, Call, Storage}, // Parachain Onboarding Pallets Registrar: paras_registrar::{Pallet, Call, Storage, Event}, Auctions: auctions::{Pallet, Call, Storage, Event}, Crowdloan: crowdloan::{Pallet, Call, Storage, Event}, Slots: slots::{Pallet, Call, Storage, Event}, ParasSudoWrapper: paras_sudo_wrapper::{Pallet, Call}, // Sudo Sudo: pallet_sudo::{Pallet, Call, Storage, Event, Config}, // Validator Manager pallet. ValidatorManager: validator_manager::{Pallet, Call, Storage, Event}, } } pub struct BaseFilter; impl Filter for BaseFilter { fn filter(_call: &Call) -> bool { true } } parameter_types! { pub const Version: RuntimeVersion = VERSION; pub const SS58Prefix: u8 = 42; } impl frame_system::Config for Runtime { type BaseCallFilter = BaseFilter; type BlockWeights = BlockWeights; type BlockLength = BlockLength; type DbWeight = RocksDbWeight; type Origin = Origin; type Call = Call; type Index = Nonce; type BlockNumber = BlockNumber; type Hash = Hash; type Hashing = BlakeTwo256; type AccountId = AccountId; type Lookup = AccountIdLookup; type Header = generic::Header; type Event = Event; type BlockHashCount = BlockHashCount; type Version = Version; type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; type OnNewAccount = (); type OnKilledAccount = (); type SystemWeightInfo = (); type SS58Prefix = SS58Prefix; } parameter_types! { pub const ValidationUpgradeFrequency: BlockNumber = 2 * DAYS; pub const ValidationUpgradeDelay: BlockNumber = 8 * HOURS; pub const SlashPeriod: BlockNumber = 7 * DAYS; } /// Submits a transaction with the node's public and signature type. Adheres to the signed extension /// format of the chain. impl frame_system::offchain::CreateSignedTransaction for Runtime where Call: From, { fn create_transaction>( call: Call, public: ::Signer, account: AccountId, nonce: ::Index, ) -> Option<(Call, ::SignaturePayload)> { use sp_runtime::traits::StaticLookup; // take the biggest period possible. let period = BlockHashCount::get() .checked_next_power_of_two() .map(|c| c / 2) .unwrap_or(2) as u64; let current_block = System::block_number() .saturated_into::() // The `System::block_number` is initialized with `n+1`, // so the actual block number is `n`. .saturating_sub(1); let tip = 0; let extra: SignedExtra = ( frame_system::CheckSpecVersion::::new(), frame_system::CheckTxVersion::::new(), frame_system::CheckGenesis::::new(), frame_system::CheckMortality::::from(generic::Era::mortal(period, current_block)), frame_system::CheckNonce::::from(nonce), frame_system::CheckWeight::::new(), pallet_transaction_payment::ChargeTransactionPayment::::from(tip), ); let raw_payload = SignedPayload::new(call, extra).map_err(|e| { log::warn!("Unable to create signed payload: {:?}", e); }).ok()?; let signature = raw_payload.using_encoded(|payload| { C::sign(payload, public) })?; let (call, extra, _) = raw_payload.deconstruct(); let address = ::Lookup::unlookup(account); Some((call, (address, signature, extra))) } } impl frame_system::offchain::SigningTypes for Runtime { type Public = ::Signer; type Signature = Signature; } /// Special `FullIdentificationOf` implementation that is returning for every input `Some(Default::default())`. pub struct FullIdentificationOf; impl sp_runtime::traits::Convert> for FullIdentificationOf { fn convert(_: AccountId) -> Option<()> { Some(Default::default()) } } impl pallet_session::historical::Config for Runtime { type FullIdentification = (); type FullIdentificationOf = FullIdentificationOf; } parameter_types! { pub SessionDuration: BlockNumber = EpochDurationInBlocks::get() as _; } parameter_types! { pub const ImOnlineUnsignedPriority: TransactionPriority = TransactionPriority::max_value(); } impl pallet_im_online::Config for Runtime { type AuthorityId = ImOnlineId; type Event = Event; type ValidatorSet = Historical; type NextSessionRotation = Babe; type ReportUnresponsiveness = Offences; type UnsignedPriority = ImOnlineUnsignedPriority; type WeightInfo = (); } parameter_types! { pub const ExistentialDeposit: Balance = 1 * CENTS; pub const MaxLocks: u32 = 50; } impl pallet_balances::Config for Runtime { type Balance = Balance; type DustRemoval = (); type Event = Event; type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; type MaxLocks = MaxLocks; type WeightInfo = (); } impl frame_system::offchain::SendTransactionTypes for Runtime where Call: From, { type OverarchingCall = Call; type Extrinsic = UncheckedExtrinsic; } parameter_types! { pub const QueueSize: usize = 2; pub const MaxRetries: u32 = 3; } parameter_types! { pub OffencesWeightSoftLimit: Weight = Perbill::from_percent(60) * BlockWeights::get().max_block; } impl pallet_offences::Config for Runtime { type Event = Event; type IdentificationTuple = pallet_session::historical::IdentificationTuple; type OnOffenceHandler = (); type WeightSoftLimit = OffencesWeightSoftLimit; } impl pallet_authority_discovery::Config for Runtime {} parameter_types! { pub const MinimumPeriod: u64 = SLOT_DURATION / 2; } impl pallet_timestamp::Config for Runtime { type Moment = u64; type OnTimestampSet = Babe; type MinimumPeriod = MinimumPeriod; type WeightInfo = (); } parameter_types! { pub const TransactionByteFee: Balance = 10 * MILLICENTS; } impl pallet_transaction_payment::Config for Runtime { type OnChargeTransaction = CurrencyAdapter>; type TransactionByteFee = TransactionByteFee; type WeightToFee = WeightToFee; type FeeMultiplierUpdate = SlowAdjustingFeeUpdate; } parameter_types! { pub const DisabledValidatorsThreshold: Perbill = Perbill::from_percent(17); } /// Special `ValidatorIdOf` implementation that is just returning the input as result. pub struct ValidatorIdOf; impl sp_runtime::traits::Convert> for ValidatorIdOf { fn convert(a: AccountId) -> Option { Some(a) } } impl pallet_session::Config for Runtime { type Event = Event; type ValidatorId = AccountId; type ValidatorIdOf = ValidatorIdOf; type ShouldEndSession = Babe; type NextSessionRotation = Babe; type SessionManager = pallet_session::historical::NoteHistoricalRoot; type SessionHandler = ::KeyTypeIdProviders; type Keys = SessionKeys; type DisabledValidatorsThreshold = DisabledValidatorsThreshold; type WeightInfo = (); } parameter_types! { pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK; pub ReportLongevity: u64 = EpochDurationInBlocks::get() as u64 * 10; } impl pallet_babe::Config for Runtime { type EpochDuration = EpochDurationInBlocks; type ExpectedBlockTime = ExpectedBlockTime; // session module is the trigger type EpochChangeTrigger = pallet_babe::ExternalTrigger; type KeyOwnerProofSystem = Historical; type KeyOwnerProof = >::Proof; type KeyOwnerIdentification = >::IdentificationTuple; type HandleEquivocation = pallet_babe::EquivocationHandler; type WeightInfo = (); } parameter_types! { pub const IndexDeposit: Balance = 1 * DOLLARS; } impl pallet_indices::Config for Runtime { type AccountIndex = AccountIndex; type Currency = Balances; type Deposit = IndexDeposit; type Event = Event; type WeightInfo = (); } parameter_types! { pub const AttestationPeriod: BlockNumber = 50; } impl pallet_grandpa::Config for Runtime { type Event = Event; type Call = Call; type KeyOwnerProofSystem = Historical; type KeyOwnerProof = >::Proof; type KeyOwnerIdentification = >::IdentificationTuple; type HandleEquivocation = pallet_grandpa::EquivocationHandler; type WeightInfo = (); } parameter_types! { pub const UncleGenerations: u32 = 0; } impl pallet_authorship::Config for Runtime { type FindAuthor = pallet_session::FindAccountFromAuthorIndex; type UncleGenerations = UncleGenerations; type FilterUncle = (); type EventHandler = ImOnline; } impl parachains_origin::Config for Runtime {} impl parachains_configuration::Config for Runtime {} impl parachains_shared::Config for Runtime {} /// Special `RewardValidators` that does nothing ;) pub struct RewardValidators; impl runtime_parachains::inclusion::RewardValidators for RewardValidators { fn reward_backing(_: impl IntoIterator) {} fn reward_bitfields(_: impl IntoIterator) {} } impl parachains_inclusion::Config for Runtime { type Event = Event; type RewardValidators = RewardValidators; } impl parachains_paras::Config for Runtime { type Origin = Origin; } parameter_types! { pub const RocLocation: MultiLocation = MultiLocation::Null; pub const RococoNetwork: NetworkId = NetworkId::Polkadot; pub const Ancestry: MultiLocation = MultiLocation::Null; } pub type LocationConverter = ( ChildParachainConvertsVia, AccountId32Aliases, ); pub type LocalAssetTransactor = XcmCurrencyAdapter< // Use this currency: Balances, // Use this currency when it is a fungible asset matching the given location or name: IsConcrete, // We can convert the MultiLocations with our converter above: LocationConverter, // Our chain's account ID type (we can't get away without mentioning it explicitly): AccountId, >; type LocalOriginConverter = ( SovereignSignedViaLocation, ChildParachainAsNative, SignedAccountId32AsNative, ChildSystemParachainAsSuperuser, ); pub struct XcmConfig; impl xcm_executor::Config for XcmConfig { type Call = Call; type XcmSender = xcm_sender::RelayChainXcmSender; type AssetTransactor = LocalAssetTransactor; type OriginConverter = LocalOriginConverter; type IsReserve = (); type IsTeleporter = (); type LocationInverter = LocationInverter; } impl parachains_session_info::Config for Runtime {} impl parachains_ump::Config for Runtime { type UmpSink = crate::parachains_ump::XcmSink; } impl parachains_dmp::Config for Runtime {} impl parachains_hrmp::Config for Runtime { type Event = Event; type Origin = Origin; type Currency = Balances; } impl parachains_inclusion_inherent::Config for Runtime {} impl parachains_scheduler::Config for Runtime {} impl parachains_initializer::Config for Runtime { type Randomness = pallet_babe::RandomnessFromOneEpochAgo; } impl paras_sudo_wrapper::Config for Runtime {} parameter_types! { pub const ParaDeposit: Balance = 5 * DOLLARS; pub const DataDepositPerByte: Balance = deposit(0, 1); pub const MaxCodeSize: u32 = 10 * 1024 * 1024; // 10 MB pub const MaxHeadSize: u32 = 20 * 1024; // 20 KB } impl paras_registrar::Config for Runtime { type Event = Event; type Origin = Origin; type Currency = Balances; type OnSwap = (Crowdloan, Slots); type ParaDeposit = ParaDeposit; type DataDepositPerByte = DataDepositPerByte; type MaxCodeSize = MaxCodeSize; type MaxHeadSize = MaxHeadSize; type WeightInfo = paras_registrar::TestWeightInfo; } /// An insecure randomness beacon that uses the parent block hash as random material. /// /// THIS SHOULD ONLY BE USED FOR TESTING PURPOSES. pub struct ParentHashRandomness; impl Randomness for ParentHashRandomness { fn random(subject: &[u8]) -> (Hash, BlockNumber) { ( (System::parent_hash(), subject).using_encoded(sp_io::hashing::blake2_256).into(), System::block_number(), ) } } parameter_types! { pub const EndingPeriod: BlockNumber = 1 * HOURS; pub const SampleLength: BlockNumber = 1; } impl auctions::Config for Runtime { type Event = Event; type Leaser = Slots; type Registrar = Registrar; type EndingPeriod = EndingPeriod; type SampleLength = SampleLength; type Randomness = ParentHashRandomness; type InitiateOrigin = EnsureRoot; type WeightInfo = auctions::TestWeightInfo; } parameter_types! { pub const LeasePeriod: BlockNumber = 1 * DAYS; } impl slots::Config for Runtime { type Event = Event; type Currency = Balances; type Registrar = Registrar; type LeasePeriod = LeasePeriod; type WeightInfo = slots::TestWeightInfo; } parameter_types! { pub const CrowdloanId: ModuleId = ModuleId(*b"py/cfund"); pub const SubmissionDeposit: Balance = 100 * DOLLARS; pub const MinContribution: Balance = 1 * DOLLARS; pub const RetirementPeriod: BlockNumber = 6 * HOURS; pub const RemoveKeysLimit: u32 = 500; // Allow 32 bytes for an additional memo to a crowdloan. pub const MaxMemoLength: u8 = 32; } impl crowdloan::Config for Runtime { type Event = Event; type ModuleId = CrowdloanId; type SubmissionDeposit = SubmissionDeposit; type MinContribution = MinContribution; type RetirementPeriod = RetirementPeriod; type OrphanedFunds = (); type RemoveKeysLimit = RemoveKeysLimit; type Registrar = Registrar; type Auctioneer = Auctions; type MaxMemoLength = MaxMemoLength; type WeightInfo = crowdloan::TestWeightInfo; } impl pallet_sudo::Config for Runtime { type Event = Event; type Call = Call; } impl validator_manager::Config for Runtime { type Event = Event; type PrivilegedOrigin = EnsureRoot; } #[cfg(not(feature = "disable-runtime-api"))] sp_api::impl_runtime_apis! { impl sp_api::Core for Runtime { fn version() -> RuntimeVersion { VERSION } fn execute_block(block: Block) { Executive::execute_block(block); } fn initialize_block(header: &::Header) { Executive::initialize_block(header) } } impl sp_api::Metadata for Runtime { fn metadata() -> OpaqueMetadata { Runtime::metadata().into() } } impl block_builder_api::BlockBuilder for Runtime { fn apply_extrinsic(extrinsic: ::Extrinsic) -> ApplyExtrinsicResult { Executive::apply_extrinsic(extrinsic) } fn finalize_block() -> ::Header { Executive::finalize_block() } fn inherent_extrinsics(data: inherents::InherentData) -> Vec<::Extrinsic> { data.create_extrinsics() } fn check_inherents( block: Block, data: inherents::InherentData, ) -> inherents::CheckInherentsResult { data.check_extrinsics(&block) } fn random_seed() -> ::Hash { pallet_babe::RandomnessFromOneEpochAgo::::random_seed().0 } } impl tx_pool_api::runtime_api::TaggedTransactionQueue for Runtime { fn validate_transaction( source: TransactionSource, tx: ::Extrinsic, ) -> TransactionValidity { Executive::validate_transaction(source, tx) } } impl offchain_primitives::OffchainWorkerApi for Runtime { fn offchain_worker(header: &::Header) { Executive::offchain_worker(header) } } impl primitives::v1::ParachainHost for Runtime { fn validators() -> Vec { runtime_api_impl::validators::() } fn validator_groups() -> (Vec>, GroupRotationInfo) { runtime_api_impl::validator_groups::() } fn availability_cores() -> Vec> { runtime_api_impl::availability_cores::() } fn persisted_validation_data(para_id: Id, assumption: OccupiedCoreAssumption) -> Option> { runtime_api_impl::persisted_validation_data::(para_id, assumption) } fn check_validation_outputs( para_id: Id, outputs: primitives::v1::CandidateCommitments, ) -> bool { runtime_api_impl::check_validation_outputs::(para_id, outputs) } fn session_index_for_child() -> SessionIndex { runtime_api_impl::session_index_for_child::() } fn validation_code(para_id: Id, assumption: OccupiedCoreAssumption) -> Option { runtime_api_impl::validation_code::(para_id, assumption) } fn historical_validation_code(para_id: Id, context_height: BlockNumber) -> Option { runtime_api_impl::historical_validation_code::(para_id, context_height) } fn candidate_pending_availability(para_id: Id) -> Option> { runtime_api_impl::candidate_pending_availability::(para_id) } fn candidate_events() -> Vec> { runtime_api_impl::candidate_events::(|ev| { match ev { Event::parachains_inclusion(ev) => { Some(ev) } _ => None, } }) } fn session_info(index: SessionIndex) -> Option { runtime_api_impl::session_info::(index) } fn dmq_contents(recipient: Id) -> Vec> { runtime_api_impl::dmq_contents::(recipient) } fn inbound_hrmp_channels_contents( recipient: Id ) -> BTreeMap>> { runtime_api_impl::inbound_hrmp_channels_contents::(recipient) } } impl fg_primitives::GrandpaApi for Runtime { fn grandpa_authorities() -> Vec<(GrandpaId, u64)> { Grandpa::grandpa_authorities() } fn submit_report_equivocation_unsigned_extrinsic( equivocation_proof: fg_primitives::EquivocationProof< ::Hash, sp_runtime::traits::NumberFor, >, key_owner_proof: fg_primitives::OpaqueKeyOwnershipProof, ) -> Option<()> { let key_owner_proof = key_owner_proof.decode()?; Grandpa::submit_unsigned_equivocation_report( equivocation_proof, key_owner_proof, ) } fn generate_key_ownership_proof( _set_id: fg_primitives::SetId, authority_id: fg_primitives::AuthorityId, ) -> Option { use parity_scale_codec::Encode; Historical::prove((fg_primitives::KEY_TYPE, authority_id)) .map(|p| p.encode()) .map(fg_primitives::OpaqueKeyOwnershipProof::new) } } impl babe_primitives::BabeApi for Runtime { fn configuration() -> babe_primitives::BabeGenesisConfiguration { // The choice of `c` parameter (where `1 - c` represents the // probability of a slot being empty), is done in accordance to the // slot duration and expected target block time, for safely // resisting network delays of maximum two seconds. // babe_primitives::BabeGenesisConfiguration { slot_duration: Babe::slot_duration(), epoch_length: EpochDurationInBlocks::get().into(), c: BABE_GENESIS_EPOCH_CONFIG.c, genesis_authorities: Babe::authorities(), randomness: Babe::randomness(), allowed_slots: BABE_GENESIS_EPOCH_CONFIG.allowed_slots, } } fn current_epoch_start() -> babe_primitives::Slot { Babe::current_epoch_start() } fn current_epoch() -> babe_primitives::Epoch { Babe::current_epoch() } fn next_epoch() -> babe_primitives::Epoch { Babe::next_epoch() } fn generate_key_ownership_proof( _slot: babe_primitives::Slot, authority_id: babe_primitives::AuthorityId, ) -> Option { use parity_scale_codec::Encode; Historical::prove((babe_primitives::KEY_TYPE, authority_id)) .map(|p| p.encode()) .map(babe_primitives::OpaqueKeyOwnershipProof::new) } fn submit_report_equivocation_unsigned_extrinsic( equivocation_proof: babe_primitives::EquivocationProof<::Header>, key_owner_proof: babe_primitives::OpaqueKeyOwnershipProof, ) -> Option<()> { let key_owner_proof = key_owner_proof.decode()?; Babe::submit_unsigned_equivocation_report( equivocation_proof, key_owner_proof, ) } } impl authority_discovery_primitives::AuthorityDiscoveryApi for Runtime { fn authorities() -> Vec { runtime_api_impl::relevant_authority_ids::() } } impl sp_session::SessionKeys for Runtime { fn generate_session_keys(seed: Option>) -> Vec { SessionKeys::generate(seed) } fn decode_session_keys( encoded: Vec, ) -> Option, sp_core::crypto::KeyTypeId)>> { SessionKeys::decode_into_raw_public_keys(&encoded) } } impl frame_system_rpc_runtime_api::AccountNonceApi for Runtime { fn account_nonce(account: AccountId) -> Nonce { System::account_nonce(account) } } impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi< Block, Balance, > for Runtime { fn query_info(uxt: ::Extrinsic, len: u32) -> RuntimeDispatchInfo { TransactionPayment::query_info(uxt, len) } fn query_fee_details(uxt: ::Extrinsic, len: u32) -> FeeDetails { TransactionPayment::query_fee_details(uxt, len) } } }