如何配置Instantiable Pallets

目标

1、如何配置instantiable pallets

用例

• 一个代币链承载两种独立的加密货币。
• 治理有两个（或更多）内部运作类似的机构。
• 维护不同金库的社交网络链。

概述

Instantiable pallets为包含多个对同一pallet引用的运行时提供单独的存储项目。这对重用单个托盘提供的逻辑的情况下很有用。接下来展示如何创建同一个托盘的两个实例以及如何配置它们的功能。

步骤

1.实现Instance类型
instantiable pallets必须调用decl_storage!宏才能Instance创建类型。

Instance在 Config trait、Event 类型和 Store trait 中添加一个泛型类型。 下面的代码片段显示了pallet的Config和Store trait所需的修改：

pub trait Config: frame_system::Config {
  type Event: From> + Into<::Event>;
}
/// Include the I: Instance type parameter in storage declaration
decl_storage! {
  trait Store for Module, I: Instance> as MintToken {
/* --snip-- */

2. 配置你的运行时
   包括mint_tokenin 的两个实例runtime/src/lib.rs：

/* --snip-- */
// Instance1 of mint_token
impl mint_token::Config for Runtime {
    type Event = Event;
}

// Instance2 of mint_token
impl mint_token::Config for Runtime {
    type Event = Event;
}

/* --snip-- */
MintToken1: mint_token::::{Pallet, Call, Storage, Event},
MintToken2: mint_token::::{Pallet, Call, Storage, Event},
/* --snip-- */

3. 示例-波卡的运行时

// Copyright 2017-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 Polkadot runtime. This can be compiled with `#[no_std]`, ready for Wasm.

#![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 runtime_common::{
    auctions, claims, crowdloan, impl_runtime_weights, impls::DealWithFees, paras_registrar,
    prod_or_fast, slots, BlockHashCount, BlockLength, CurrencyToVote, SlowAdjustingFeeUpdate,
};

use runtime_parachains::{
    configuration as parachains_configuration, disputes as parachains_disputes,
    dmp as parachains_dmp, hrmp as parachains_hrmp, inclusion as parachains_inclusion,
    initializer as parachains_initializer, origin as parachains_origin, paras as parachains_paras,
    paras_inherent as parachains_paras_inherent, reward_points as parachains_reward_points,
    runtime_api_impl::v2 as parachains_runtime_api_impl, scheduler as parachains_scheduler,
    session_info as parachains_session_info, shared as parachains_shared, ump as parachains_ump,
};

use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
use beefy_primitives::crypto::AuthorityId as BeefyId;
use frame_election_provider_support::{generate_solution_type, onchain, SequentialPhragmen};
use frame_support::{
    construct_runtime, parameter_types,
    traits::{
        Contains, EitherOfDiverse, InstanceFilter, KeyOwnerProofSystem, LockIdentifier,
        PrivilegeCmp,
    },
    weights::ConstantMultiplier,
    PalletId, RuntimeDebug,
};
use frame_system::EnsureRoot;
use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
use pallet_session::historical as session_historical;
use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
use primitives::v2::{
    AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CandidateHash,
    CommittedCandidateReceipt, CoreState, DisputeState, GroupRotationInfo, Hash, Id as ParaId,
    InboundDownwardMessage, InboundHrmpMessage, Moment, Nonce, OccupiedCoreAssumption,
    PersistedValidationData, ScrapedOnChainVotes, SessionInfo, Signature, ValidationCode,
    ValidationCodeHash, ValidatorId, ValidatorIndex,
};
use sp_core::OpaqueMetadata;
use sp_mmr_primitives as mmr;
use sp_runtime::{
    create_runtime_str,
    curve::PiecewiseLinear,
    generic, impl_opaque_keys,
    traits::{
        AccountIdLookup, BlakeTwo256, Block as BlockT, ConvertInto, Extrinsic as ExtrinsicT,
        OpaqueKeys, SaturatedConversion, Verify,
    },
    transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},
    ApplyExtrinsicResult, KeyTypeId, Perbill, Percent, Permill,
};
use sp_staking::SessionIndex;
use sp_std::{cmp::Ordering, collections::btree_map::BTreeMap, prelude::*};
#[cfg(any(feature = "std", test))]
use sp_version::NativeVersion;
use sp_version::RuntimeVersion;
use static_assertions::const_assert;

pub use frame_system::Call as SystemCall;
pub use pallet_balances::Call as BalancesCall;
pub use pallet_election_provider_multi_phase::Call as EPMCall;
#[cfg(feature = "std")]
pub use pallet_staking::StakerStatus;
pub use pallet_timestamp::Call as TimestampCall;
#[cfg(any(feature = "std", test))]
pub use sp_runtime::BuildStorage;

/// Constant values used within the runtime.
use polkadot_runtime_constants::{currency::*, fee::*, time::*};

// Weights used in the runtime.
mod weights;

mod bag_thresholds;

pub mod xcm_config;

impl_runtime_weights!(polkadot_runtime_constants);

// Make the WASM binary available.
#[cfg(feature = "std")]
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

// Polkadot version identifier;
/// Runtime version (Polkadot).
#[sp_version::runtime_version]
pub const VERSION: RuntimeVersion = RuntimeVersion {
    spec_name: create_runtime_str!("polkadot"),
    impl_name: create_runtime_str!("parity-polkadot"),
    authoring_version: 0,
    spec_version: 9230,
    impl_version: 0,
    #[cfg(not(feature = "disable-runtime-api"))]
    apis: RUNTIME_API_VERSIONS,
    #[cfg(feature = "disable-runtime-api")]
    apis: version::create_apis_vec![[]],
    transaction_version: 12,
    state_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() }
}

pub struct BaseFilter;
impl Contains for BaseFilter {
    fn contains(call: &Call) -> bool {
        match call {
            // These modules are all allowed to be called by transactions:
            Call::Democracy(_) |
            Call::Council(_) |
            Call::TechnicalCommittee(_) |
            Call::TechnicalMembership(_) |
            Call::Treasury(_) |
            Call::PhragmenElection(_) |
            Call::System(_) |
            Call::Scheduler(_) |
            Call::Preimage(_) |
            Call::Indices(_) |
            Call::Babe(_) |
            Call::Timestamp(_) |
            Call::Balances(_) |
            Call::Authorship(_) |
            Call::Staking(_) |
            Call::Session(_) |
            Call::Grandpa(_) |
            Call::ImOnline(_) |
            Call::Utility(_) |
            Call::Claims(_) |
            Call::Vesting(_) |
            Call::Identity(_) |
            Call::Proxy(_) |
            Call::Multisig(_) |
            Call::Bounties(_) |
            Call::ChildBounties(_) |
            Call::Tips(_) |
            Call::ElectionProviderMultiPhase(_) |
            Call::Configuration(_) |
            Call::ParasShared(_) |
            Call::ParaInclusion(_) |
            Call::Paras(_) |
            Call::Initializer(_) |
            Call::ParaInherent(_) |
            Call::ParasDisputes(_) |
            Call::Dmp(_) |
            Call::Ump(_) |
            Call::Hrmp(_) |
            Call::Slots(_) |
            Call::Registrar(_) |
            Call::Auctions(_) |
            Call::Crowdloan(_) |
            Call::VoterList(_) |
            Call::XcmPallet(_) => true,
            // All pallets are allowed, but exhaustive match is defensive
            // in the case of adding new pallets.
        }
    }
}

type MoreThanHalfCouncil = EitherOfDiverse<
    EnsureRoot,
    pallet_collective::EnsureProportionMoreThan,
>;

parameter_types! {
    pub const Version: RuntimeVersion = VERSION;
    pub const SS58Prefix: u8 = 0;
}

impl frame_system::Config for Runtime {
    type BaseCallFilter = BaseFilter;
    type BlockWeights = BlockWeights;
    type BlockLength = BlockLength;
    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 DbWeight = RocksDbWeight;
    type Version = Version;
    type PalletInfo = PalletInfo;
    type AccountData = pallet_balances::AccountData;
    type OnNewAccount = ();
    type OnKilledAccount = ();
    type SystemWeightInfo = weights::frame_system::WeightInfo;
    type SS58Prefix = SS58Prefix;
    type OnSetCode = ();
    type MaxConsumers = frame_support::traits::ConstU32<16>;
}

parameter_types! {
    pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
        BlockWeights::get().max_block;
    pub const MaxScheduledPerBlock: u32 = 50;
    pub const NoPreimagePostponement: Option = Some(10);
}

type ScheduleOrigin = EitherOfDiverse<
    EnsureRoot,
    pallet_collective::EnsureProportionAtLeast,
>;

/// Used the compare the privilege of an origin inside the scheduler.
pub struct OriginPrivilegeCmp;

impl PrivilegeCmp for OriginPrivilegeCmp {
    fn cmp_privilege(left: &OriginCaller, right: &OriginCaller) -> Option {
        if left == right {
            return Some(Ordering::Equal)
        }

        match (left, right) {
            // Root is greater than anything.
            (OriginCaller::system(frame_system::RawOrigin::Root), _) => Some(Ordering::Greater),
            // Check which one has more yes votes.
            (
                OriginCaller::Council(pallet_collective::RawOrigin::Members(l_yes_votes, l_count)),
                OriginCaller::Council(pallet_collective::RawOrigin::Members(r_yes_votes, r_count)),
            ) => Some((l_yes_votes * r_count).cmp(&(r_yes_votes * l_count))),
            // For every other origin we don't care, as they are not used for `ScheduleOrigin`.
            _ => None,
        }
    }
}

impl pallet_scheduler::Config for Runtime {
    type Event = Event;
    type Origin = Origin;
    type PalletsOrigin = OriginCaller;
    type Call = Call;
    type MaximumWeight = MaximumSchedulerWeight;
    type ScheduleOrigin = ScheduleOrigin;
    type MaxScheduledPerBlock = MaxScheduledPerBlock;
    type WeightInfo = weights::pallet_scheduler::WeightInfo;
    type OriginPrivilegeCmp = OriginPrivilegeCmp;
    type PreimageProvider = Preimage;
    type NoPreimagePostponement = NoPreimagePostponement;
}

parameter_types! {
    pub const PreimageMaxSize: u32 = 4096 * 1024;
    pub const PreimageBaseDeposit: Balance = deposit(2, 64);
    pub const PreimageByteDeposit: Balance = deposit(0, 1);
}

impl pallet_preimage::Config for Runtime {
    type WeightInfo = pallet_preimage::weights::SubstrateWeight;
    type Event = Event;
    type Currency = Balances;
    type ManagerOrigin = EnsureRoot;
    type MaxSize = PreimageMaxSize;
    type BaseDeposit = PreimageBaseDeposit;
    type ByteDeposit = PreimageByteDeposit;
}

parameter_types! {
    pub EpochDuration: u64 = prod_or_fast!(
        EPOCH_DURATION_IN_SLOTS as u64,
        2 * MINUTES as u64,
        "DOT_EPOCH_DURATION"
    );
    pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
    pub ReportLongevity: u64 =
        BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * EpochDuration::get();
}

impl pallet_babe::Config for Runtime {
    type EpochDuration = EpochDuration;
    type ExpectedBlockTime = ExpectedBlockTime;

    // session module is the trigger
    type EpochChangeTrigger = pallet_babe::ExternalTrigger;

    type DisabledValidators = Session;

    type KeyOwnerProofSystem = Historical;

    type KeyOwnerProof = >::Proof;

    type KeyOwnerIdentification = >::IdentificationTuple;

    type HandleEquivocation =
        pallet_babe::EquivocationHandler;

    type WeightInfo = ();

    type MaxAuthorities = MaxAuthorities;
}

parameter_types! {
    pub const IndexDeposit: Balance = 10 * DOLLARS;
}

impl pallet_indices::Config for Runtime {
    type AccountIndex = AccountIndex;
    type Currency = Balances;
    type Deposit = IndexDeposit;
    type Event = Event;
    type WeightInfo = weights::pallet_indices::WeightInfo;
}

parameter_types! {
    pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT;
    pub const MaxLocks: u32 = 50;
    pub const MaxReserves: 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 MaxReserves = MaxReserves;
    type ReserveIdentifier = [u8; 8];
    type WeightInfo = weights::pallet_balances::WeightInfo;
}

parameter_types! {
    pub const TransactionByteFee: Balance = 10 * MILLICENTS;
    /// This value increases the priority of `Operational` transactions by adding
    /// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.
    pub const OperationalFeeMultiplier: u8 = 5;
}

impl pallet_transaction_payment::Config for Runtime {
    type OnChargeTransaction = CurrencyAdapter>;
    type OperationalFeeMultiplier = OperationalFeeMultiplier;
    type WeightToFee = WeightToFee;
    type LengthToFee = ConstantMultiplier;
    type FeeMultiplierUpdate = SlowAdjustingFeeUpdate;
}

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 = weights::pallet_timestamp::WeightInfo;
}

parameter_types! {
    pub const UncleGenerations: u32 = 0;
}

// TODO: substrate#2986 implement this properly
impl pallet_authorship::Config for Runtime {
    type FindAuthor = pallet_session::FindAccountFromAuthorIndex;
    type UncleGenerations = UncleGenerations;
    type FilterUncle = ();
    type EventHandler = (Staking, ImOnline);
}

impl_opaque_keys! {
    pub struct SessionKeys {
        pub grandpa: Grandpa,
        pub babe: Babe,
        pub im_online: ImOnline,
        pub para_validator: Initializer,
        pub para_assignment: ParaSessionInfo,
        pub authority_discovery: AuthorityDiscovery,
    }
}

impl pallet_session::Config for Runtime {
    type Event = Event;
    type ValidatorId = AccountId;
    type ValidatorIdOf = pallet_staking::StashOf;
    type ShouldEndSession = Babe;
    type NextSessionRotation = Babe;
    type SessionManager = pallet_session::historical::NoteHistoricalRoot;
    type SessionHandler = ::KeyTypeIdProviders;
    type Keys = SessionKeys;
    type WeightInfo = weights::pallet_session::WeightInfo;
}

impl pallet_session::historical::Config for Runtime {
    type FullIdentification = pallet_staking::Exposure;
    type FullIdentificationOf = pallet_staking::ExposureOf;
}

parameter_types! {
    // phase durations. 1/4 of the last session for each.
    // in testing: 1min or half of the session for each
    pub SignedPhase: u32 = prod_or_fast!(
        EPOCH_DURATION_IN_SLOTS / 4,
        (1 * MINUTES).min(EpochDuration::get().saturated_into::() / 2),
        "DOT_SIGNED_PHASE"
    );
    pub UnsignedPhase: u32 = prod_or_fast!(
        EPOCH_DURATION_IN_SLOTS / 4,
        (1 * MINUTES).min(EpochDuration::get().saturated_into::() / 2),
        "DOT_UNSIGNED_PHASE"
    );

    // signed config
    pub const SignedMaxSubmissions: u32 = 16;
    pub const SignedMaxRefunds: u32 = 16 / 4;
    // 40 DOTs fixed deposit..
    pub const SignedDepositBase: Balance = deposit(2, 0);
    // 0.01 DOT per KB of solution data.
    pub const SignedDepositByte: Balance = deposit(0, 10) / 1024;
    // Each good submission will get 1 DOT as reward
    pub SignedRewardBase: Balance = 1 * UNITS;
    pub BetterUnsignedThreshold: Perbill = Perbill::from_rational(5u32, 10_000);

    // 4 hour session, 1 hour unsigned phase, 32 offchain executions.
    pub OffchainRepeat: BlockNumber = UnsignedPhase::get() / 32;

    /// We take the top 22500 nominators as electing voters..
    pub const MaxElectingVoters: u32 = 22_500;
    /// ... and all of the validators as electable targets. Whilst this is the case, we cannot and
    /// shall not increase the size of the validator intentions.
    pub const MaxElectableTargets: u16 = u16::MAX;
}

generate_solution_type!(
    #[compact]
    pub struct NposCompactSolution16::<
        VoterIndex = u32,
        TargetIndex = u16,
        Accuracy = sp_runtime::PerU16,
        MaxVoters = MaxElectingVoters,
    >(16)
);

pub struct OnChainSeqPhragmen;
impl onchain::Config for OnChainSeqPhragmen {
    type System = Runtime;
    type Solver = SequentialPhragmen;
    type DataProvider = Staking;
    type WeightInfo = weights::frame_election_provider_support::WeightInfo;
}

impl pallet_election_provider_multi_phase::MinerConfig for Runtime {
    type AccountId = AccountId;
    type MaxLength = OffchainSolutionLengthLimit;
    type MaxWeight = OffchainSolutionWeightLimit;
    type Solution = NposCompactSolution16;
    type MaxVotesPerVoter = <
        ::DataProvider
        as
        frame_election_provider_support::ElectionDataProvider
    >::MaxVotesPerVoter;

    // The unsigned submissions have to respect the weight of the submit_unsigned call, thus their
    // weight estimate function is wired to this call's weight.
    fn solution_weight(v: u32, t: u32, a: u32, d: u32) -> Weight {
        <
            ::WeightInfo
            as
            pallet_election_provider_multi_phase::WeightInfo
        >::submit_unsigned(v, t, a, d)
    }
}

impl pallet_election_provider_multi_phase::Config for Runtime {
    type Event = Event;
    type Currency = Balances;
    type EstimateCallFee = TransactionPayment;
    type SignedPhase = SignedPhase;
    type UnsignedPhase = UnsignedPhase;
    type SignedMaxSubmissions = SignedMaxSubmissions;
    type SignedMaxRefunds = SignedMaxRefunds;
    type SignedRewardBase = SignedRewardBase;
    type SignedDepositBase = SignedDepositBase;
    type SignedDepositByte = SignedDepositByte;
    type SignedDepositWeight = ();
    type SignedMaxWeight =
        ::MaxWeight;
    type MinerConfig = Self;
    type SlashHandler = (); // burn slashes
    type RewardHandler = (); // nothing to do upon rewards
    type BetterUnsignedThreshold = BetterUnsignedThreshold;
    type BetterSignedThreshold = ();
    type OffchainRepeat = OffchainRepeat;
    type MinerTxPriority = NposSolutionPriority;
    type DataProvider = Staking;
    type Fallback = pallet_election_provider_multi_phase::NoFallback;
    type GovernanceFallback = onchain::UnboundedExecution;
    type Solver = SequentialPhragmen<
        AccountId,
        pallet_election_provider_multi_phase::SolutionAccuracyOf,
        (),
    >;
    type BenchmarkingConfig = runtime_common::elections::BenchmarkConfig;
    type ForceOrigin = EitherOfDiverse<
        EnsureRoot,
        pallet_collective::EnsureProportionAtLeast,
    >;
    type WeightInfo = weights::pallet_election_provider_multi_phase::WeightInfo;
    type MaxElectingVoters = MaxElectingVoters;
    type MaxElectableTargets = MaxElectableTargets;
}

parameter_types! {
    pub const BagThresholds: &'static [u64] = &bag_thresholds::THRESHOLDS;
}

impl pallet_bags_list::Config for Runtime {
    type Event = Event;
    type ScoreProvider = Staking;
    type WeightInfo = weights::pallet_bags_list::WeightInfo;
    type BagThresholds = BagThresholds;
    type Score = sp_npos_elections::VoteWeight;
}

// TODO #6469: This shouldn't be static, but a lazily cached value, not built unless needed, and
// re-built in case input parameters have changed. The `ideal_stake` should be determined by the
// amount of parachain slots being bid on: this should be around `(75 - 25.min(slots / 4))%`.
pallet_staking_reward_curve::build! {
    const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
        min_inflation: 0_025_000,
        max_inflation: 0_100_000,
        // 3:2:1 staked : parachains : float.
        // while there's no parachains, then this is 75% staked : 25% float.
        ideal_stake: 0_750_000,
        falloff: 0_050_000,
        max_piece_count: 40,
        test_precision: 0_005_000,
    );
}

parameter_types! {
    // Six sessions in an era (24 hours).
    pub const SessionsPerEra: SessionIndex = 6;
    // 28 eras for unbonding (28 days).
    pub const BondingDuration: sp_staking::EraIndex = 28;
    pub const SlashDeferDuration: sp_staking::EraIndex = 27;
    pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
    pub const MaxNominatorRewardedPerValidator: u32 = 256;
    pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(17);
    // 16
    pub const MaxNominations: u32 = ::LIMIT as u32;
}

type SlashCancelOrigin = EitherOfDiverse<
    EnsureRoot,
    pallet_collective::EnsureProportionAtLeast,
>;

impl pallet_staking::Config for Runtime {
    type MaxNominations = MaxNominations;
    type Currency = Balances;
    type CurrencyBalance = Balance;
    type UnixTime = Timestamp;
    type CurrencyToVote = CurrencyToVote;
    type RewardRemainder = Treasury;
    type Event = Event;
    type Slash = Treasury;
    type Reward = ();
    type SessionsPerEra = SessionsPerEra;
    type BondingDuration = BondingDuration;
    type SlashDeferDuration = SlashDeferDuration;
    // A super-majority of the council can cancel the slash.
    type SlashCancelOrigin = SlashCancelOrigin;
    type SessionInterface = Self;
    type EraPayout = pallet_staking::ConvertCurve;
    type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
    type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
    type NextNewSession = Session;
    type ElectionProvider = ElectionProviderMultiPhase;
    type GenesisElectionProvider = onchain::UnboundedExecution;
    type VoterList = VoterList;
    type MaxUnlockingChunks = frame_support::traits::ConstU32<32>;
    type BenchmarkingConfig = runtime_common::StakingBenchmarkingConfig;
    type OnStakerSlash = ();
    type WeightInfo = weights::pallet_staking::WeightInfo;
}

parameter_types! {
    // Minimum 4 CENTS/byte
    pub const BasicDeposit: Balance = deposit(1, 258);
    pub const FieldDeposit: Balance = deposit(0, 66);
    pub const SubAccountDeposit: Balance = deposit(1, 53);
    pub const MaxSubAccounts: u32 = 100;
    pub const MaxAdditionalFields: u32 = 100;
    pub const MaxRegistrars: u32 = 20;
}

impl pallet_identity::Config for Runtime {
    type Event = Event;
    type Currency = Balances;
    type BasicDeposit = BasicDeposit;
    type FieldDeposit = FieldDeposit;
    type SubAccountDeposit = SubAccountDeposit;
    type MaxSubAccounts = MaxSubAccounts;
    type MaxAdditionalFields = MaxAdditionalFields;
    type MaxRegistrars = MaxRegistrars;
    type Slashed = Treasury;
    type ForceOrigin = MoreThanHalfCouncil;
    type RegistrarOrigin = MoreThanHalfCouncil;
    type WeightInfo = weights::pallet_identity::WeightInfo;
}

parameter_types! {
    pub LaunchPeriod: BlockNumber = prod_or_fast!(28 * DAYS, 1, "DOT_LAUNCH_PERIOD");
    pub VotingPeriod: BlockNumber = prod_or_fast!(28 * DAYS, 1 * MINUTES, "DOT_VOTING_PERIOD");
    pub FastTrackVotingPeriod: BlockNumber = prod_or_fast!(3 * HOURS, 1 * MINUTES, "DOT_FAST_TRACK_VOTING_PERIOD");
    pub const MinimumDeposit: Balance = 100 * DOLLARS;
    pub EnactmentPeriod: BlockNumber = prod_or_fast!(28 * DAYS, 1, "DOT_ENACTMENT_PERIOD");
    pub CooloffPeriod: BlockNumber = prod_or_fast!(7 * DAYS, 1, "DOT_COOLOFF_PERIOD");
    pub const InstantAllowed: bool = true;
    pub const MaxVotes: u32 = 100;
    pub const MaxProposals: u32 = 100;
}

impl pallet_democracy::Config for Runtime {
    type Proposal = Call;
    type Event = Event;
    type Currency = Balances;
    type EnactmentPeriod = EnactmentPeriod;
    type VoteLockingPeriod = EnactmentPeriod;
    type LaunchPeriod = LaunchPeriod;
    type VotingPeriod = VotingPeriod;
    type MinimumDeposit = MinimumDeposit;
    /// A straight majority of the council can decide what their next motion is.
    type ExternalOrigin = EitherOfDiverse<
        pallet_collective::EnsureProportionAtLeast,
        frame_system::EnsureRoot,
    >;
    /// A 60% super-majority can have the next scheduled referendum be a straight majority-carries vote.
    type ExternalMajorityOrigin = EitherOfDiverse<
        pallet_collective::EnsureProportionAtLeast,
        frame_system::EnsureRoot,
    >;
    /// A unanimous council can have the next scheduled referendum be a straight default-carries
    /// (NTB) vote.
    type ExternalDefaultOrigin = EitherOfDiverse<
        pallet_collective::EnsureProportionAtLeast,
        frame_system::EnsureRoot,
    >;
    /// Two thirds of the technical committee can have an `ExternalMajority/ExternalDefault` vote
    /// be tabled immediately and with a shorter voting/enactment period.
    type FastTrackOrigin = EitherOfDiverse<
        pallet_collective::EnsureProportionAtLeast,
        frame_system::EnsureRoot,
    >;
    type InstantOrigin = EitherOfDiverse<
        pallet_collective::EnsureProportionAtLeast,
        frame_system::EnsureRoot,
    >;
    type InstantAllowed = InstantAllowed;
    type FastTrackVotingPeriod = FastTrackVotingPeriod;
    // To cancel a proposal which has been passed, 2/3 of the council must agree to it.
    type CancellationOrigin = EitherOfDiverse<
        pallet_collective::EnsureProportionAtLeast,
        EnsureRoot,
    >;
    // To cancel a proposal before it has been passed, the technical committee must be unanimous or
    // Root must agree.
    type CancelProposalOrigin = EitherOfDiverse<
        pallet_collective::EnsureProportionAtLeast,
        EnsureRoot,
    >;
    type BlacklistOrigin = EnsureRoot;
    // Any single technical committee member may veto a coming council proposal, however they can
    // only do it once and it lasts only for the cooloff period.
    type VetoOrigin = pallet_collective::EnsureMember;
    type CooloffPeriod = CooloffPeriod;
    type PreimageByteDeposit = PreimageByteDeposit;
    type OperationalPreimageOrigin = pallet_collective::EnsureMember;
    type Slash = Treasury;
    type Scheduler = Scheduler;
    type PalletsOrigin = OriginCaller;
    type MaxVotes = MaxVotes;
    type WeightInfo = weights::pallet_democracy::WeightInfo;
    type MaxProposals = MaxProposals;
}

parameter_types! {
    pub CouncilMotionDuration: BlockNumber = prod_or_fast!(7 * DAYS, 2 * MINUTES, "DOT_MOTION_DURATION");
    pub const CouncilMaxProposals: u32 = 100;
    pub const CouncilMaxMembers: u32 = 100;
}

pub type CouncilCollective = pallet_collective::Instance1;
impl pallet_collective::Config for Runtime {
    type Origin = Origin;
    type Proposal = Call;
    type Event = Event;
    type MotionDuration = CouncilMotionDuration;
    type MaxProposals = CouncilMaxProposals;
    type MaxMembers = CouncilMaxMembers;
    type DefaultVote = pallet_collective::PrimeDefaultVote;
    type WeightInfo = weights::pallet_collective_council::WeightInfo;
}

parameter_types! {
    pub const CandidacyBond: Balance = 100 * DOLLARS;
    // 1 storage item created, key size is 32 bytes, value size is 16+16.
    pub const VotingBondBase: Balance = deposit(1, 64);
    // additional data per vote is 32 bytes (account id).
    pub const VotingBondFactor: Balance = deposit(0, 32);
    /// Weekly council elections; scaling up to monthly eventually.
    pub TermDuration: BlockNumber = prod_or_fast!(7 * DAYS, 2 * MINUTES, "DOT_TERM_DURATION");
    /// 13 members initially, to be increased to 23 eventually.
    pub const DesiredMembers: u32 = 13;
    pub const DesiredRunnersUp: u32 = 20;
    pub const PhragmenElectionPalletId: LockIdentifier = *b"phrelect";
}
// Make sure that there are no more than `MaxMembers` members elected via phragmen.
const_assert!(DesiredMembers::get() <= CouncilMaxMembers::get());

impl pallet_elections_phragmen::Config for Runtime {
    type Event = Event;
    type PalletId = PhragmenElectionPalletId;
    type Currency = Balances;
    type ChangeMembers = Council;
    type InitializeMembers = Council;
    type CurrencyToVote = frame_support::traits::U128CurrencyToVote;
    type CandidacyBond = CandidacyBond;
    type VotingBondBase = VotingBondBase;
    type VotingBondFactor = VotingBondFactor;
    type LoserCandidate = Treasury;
    type KickedMember = Treasury;
    type DesiredMembers = DesiredMembers;
    type DesiredRunnersUp = DesiredRunnersUp;
    type TermDuration = TermDuration;
    type WeightInfo = weights::pallet_elections_phragmen::WeightInfo;
}

parameter_types! {
    pub const TechnicalMotionDuration: BlockNumber = 7 * DAYS;
    pub const TechnicalMaxProposals: u32 = 100;
    pub const TechnicalMaxMembers: u32 = 100;
}

pub type TechnicalCollective = pallet_collective::Instance2;
impl pallet_collective::Config for Runtime {
    type Origin = Origin;
    type Proposal = Call;
    type Event = Event;
    type MotionDuration = TechnicalMotionDuration;
    type MaxProposals = TechnicalMaxProposals;
    type MaxMembers = TechnicalMaxMembers;
    type DefaultVote = pallet_collective::PrimeDefaultVote;
    type WeightInfo = weights::pallet_collective_technical_committee::WeightInfo;
}

impl pallet_membership::Config for Runtime {
    type Event = Event;
    type AddOrigin = MoreThanHalfCouncil;
    type RemoveOrigin = MoreThanHalfCouncil;
    type SwapOrigin = MoreThanHalfCouncil;
    type ResetOrigin = MoreThanHalfCouncil;
    type PrimeOrigin = MoreThanHalfCouncil;
    type MembershipInitialized = TechnicalCommittee;
    type MembershipChanged = TechnicalCommittee;
    type MaxMembers = TechnicalMaxMembers;
    type WeightInfo = weights::pallet_membership::WeightInfo;
}

parameter_types! {
    pub const ProposalBond: Permill = Permill::from_percent(5);
    pub const ProposalBondMinimum: Balance = 100 * DOLLARS;
    pub const ProposalBondMaximum: Balance = 500 * DOLLARS;
    pub const SpendPeriod: BlockNumber = 24 * DAYS;
    pub const Burn: Permill = Permill::from_percent(1);
    pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");

    pub const TipCountdown: BlockNumber = 1 * DAYS;
    pub const TipFindersFee: Percent = Percent::from_percent(20);
    pub const TipReportDepositBase: Balance = 1 * DOLLARS;
    pub const DataDepositPerByte: Balance = 1 * CENTS;
    pub const MaxApprovals: u32 = 100;
    pub const MaxAuthorities: u32 = 100_000;
    pub const MaxKeys: u32 = 10_000;
    pub const MaxPeerInHeartbeats: u32 = 10_000;
    pub const MaxPeerDataEncodingSize: u32 = 1_000;
}

type ApproveOrigin = EitherOfDiverse<
    EnsureRoot,
    pallet_collective::EnsureProportionAtLeast,
>;

impl pallet_treasury::Config for Runtime {
    type PalletId = TreasuryPalletId;
    type Currency = Balances;
    type ApproveOrigin = ApproveOrigin;
    type RejectOrigin = MoreThanHalfCouncil;
    type Event = Event;
    type OnSlash = Treasury;
    type ProposalBond = ProposalBond;
    type ProposalBondMinimum = ProposalBondMinimum;
    type ProposalBondMaximum = ProposalBondMaximum;
    type SpendPeriod = SpendPeriod;
    type Burn = Burn;
    type BurnDestination = ();
    type SpendFunds = Bounties;
    type MaxApprovals = MaxApprovals;
    type WeightInfo = weights::pallet_treasury::WeightInfo;
    type SpendOrigin = frame_support::traits::NeverEnsureOrigin;
}

parameter_types! {
    pub const BountyDepositBase: Balance = 1 * DOLLARS;
    pub const BountyDepositPayoutDelay: BlockNumber = 8 * DAYS;
    pub const BountyUpdatePeriod: BlockNumber = 90 * DAYS;
    pub const MaximumReasonLength: u32 = 16384;
    pub const CuratorDepositMultiplier: Permill = Permill::from_percent(50);
    pub const CuratorDepositMin: Balance = 10 * DOLLARS;
    pub const CuratorDepositMax: Balance = 200 * DOLLARS;
    pub const BountyValueMinimum: Balance = 10 * DOLLARS;
}

impl pallet_bounties::Config for Runtime {
    type Event = Event;
    type BountyDepositBase = BountyDepositBase;
    type BountyDepositPayoutDelay = BountyDepositPayoutDelay;
    type BountyUpdatePeriod = BountyUpdatePeriod;
    type CuratorDepositMultiplier = CuratorDepositMultiplier;
    type CuratorDepositMin = CuratorDepositMin;
    type CuratorDepositMax = CuratorDepositMax;
    type BountyValueMinimum = BountyValueMinimum;
    type ChildBountyManager = ChildBounties;
    type DataDepositPerByte = DataDepositPerByte;
    type MaximumReasonLength = MaximumReasonLength;
    type WeightInfo = weights::pallet_bounties::WeightInfo;
}

parameter_types! {
    pub const MaxActiveChildBountyCount: u32 = 100;
    pub const ChildBountyValueMinimum: Balance = BountyValueMinimum::get() / 10;
}

impl pallet_child_bounties::Config for Runtime {
    type Event = Event;
    type MaxActiveChildBountyCount = MaxActiveChildBountyCount;
    type ChildBountyValueMinimum = ChildBountyValueMinimum;
    type WeightInfo = weights::pallet_child_bounties::WeightInfo;
}

impl pallet_tips::Config for Runtime {
    type Event = Event;
    type DataDepositPerByte = DataDepositPerByte;
    type MaximumReasonLength = MaximumReasonLength;
    type Tippers = PhragmenElection;
    type TipCountdown = TipCountdown;
    type TipFindersFee = TipFindersFee;
    type TipReportDepositBase = TipReportDepositBase;
    type WeightInfo = weights::pallet_tips::WeightInfo;
}

impl pallet_offences::Config for Runtime {
    type Event = Event;
    type IdentificationTuple = pallet_session::historical::IdentificationTuple;
    type OnOffenceHandler = Staking;
}

impl pallet_authority_discovery::Config for Runtime {
    type MaxAuthorities = MaxAuthorities;
}

parameter_types! {
    pub NposSolutionPriority: TransactionPriority =
        Perbill::from_percent(90) * TransactionPriority::max_value();
    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 = weights::pallet_im_online::WeightInfo;
    type MaxKeys = MaxKeys;
    type MaxPeerInHeartbeats = MaxPeerInHeartbeats;
    type MaxPeerDataEncodingSize = MaxPeerDataEncodingSize;
}

impl pallet_grandpa::Config for Runtime {
    type Event = Event;
    type Call = Call;

    type KeyOwnerProof =
        >::Proof;

    type KeyOwnerIdentification = >::IdentificationTuple;

    type KeyOwnerProofSystem = Historical;

    type HandleEquivocation = pallet_grandpa::EquivocationHandler<
        Self::KeyOwnerIdentification,
        Offences,
        ReportLongevity,
    >;

    type WeightInfo = ();
    type MaxAuthorities = MaxAuthorities;
}

/// 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::CheckNonZeroSender::::new(),
            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),
            claims::PrevalidateAttests::::new(),
        );
        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;
}

impl frame_system::offchain::SendTransactionTypes for Runtime
where
    Call: From,
{
    type Extrinsic = UncheckedExtrinsic;
    type OverarchingCall = Call;
}

parameter_types! {
    pub const ParathreadDeposit: Balance = 500 * DOLLARS;
    pub const MaxRetries: u32 = 3;
}

parameter_types! {
    pub Prefix: &'static [u8] = b"Pay DOTs to the Polkadot account:";
}

impl claims::Config for Runtime {
    type Event = Event;
    type VestingSchedule = Vesting;
    type Prefix = Prefix;
    /// At least 3/4 of the council must agree to a claim move before it can happen.
    type MoveClaimOrigin =
        pallet_collective::EnsureProportionAtLeast;
    type WeightInfo = weights::runtime_common_claims::WeightInfo;
}

parameter_types! {
    pub const MinVestedTransfer: Balance = 1 * DOLLARS;
}

impl pallet_vesting::Config for Runtime {
    type Event = Event;
    type Currency = Balances;
    type BlockNumberToBalance = ConvertInto;
    type MinVestedTransfer = MinVestedTransfer;
    type WeightInfo = weights::pallet_vesting::WeightInfo;
    const MAX_VESTING_SCHEDULES: u32 = 28;
}

impl pallet_utility::Config for Runtime {
    type Event = Event;
    type Call = Call;
    type PalletsOrigin = OriginCaller;
    type WeightInfo = weights::pallet_utility::WeightInfo;
}

parameter_types! {
    // One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.
    pub const DepositBase: Balance = deposit(1, 88);
    // Additional storage item size of 32 bytes.
    pub const DepositFactor: Balance = deposit(0, 32);
    pub const MaxSignatories: u16 = 100;
}

impl pallet_multisig::Config for Runtime {
    type Event = Event;
    type Call = Call;
    type Currency = Balances;
    type DepositBase = DepositBase;
    type DepositFactor = DepositFactor;
    type MaxSignatories = MaxSignatories;
    type WeightInfo = weights::pallet_multisig::WeightInfo;
}

parameter_types! {
    // One storage item; key size 32, value size 8; .
    pub const ProxyDepositBase: Balance = deposit(1, 8);
    // Additional storage item size of 33 bytes.
    pub const ProxyDepositFactor: Balance = deposit(0, 33);
    pub const MaxProxies: u16 = 32;
    pub const AnnouncementDepositBase: Balance = deposit(1, 8);
    pub const AnnouncementDepositFactor: Balance = deposit(0, 66);
    pub const MaxPending: u16 = 32;
}

/// The type used to represent the kinds of proxying allowed.
#[derive(
    Copy,
    Clone,
    Eq,
    PartialEq,
    Ord,
    PartialOrd,
    Encode,
    Decode,
    RuntimeDebug,
    MaxEncodedLen,
    scale_info::TypeInfo,
)]
pub enum ProxyType {
    Any = 0,
    NonTransfer = 1,
    Governance = 2,
    Staking = 3,
    // Skip 4 as it is now removed (was SudoBalances)
    IdentityJudgement = 5,
    CancelProxy = 6,
    Auction = 7,
}

#[cfg(test)]
mod proxy_type_tests {
    use super::*;

    #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, RuntimeDebug)]
    pub enum OldProxyType {
        Any,
        NonTransfer,
        Governance,
        Staking,
        SudoBalances,
        IdentityJudgement,
    }

    #[test]
    fn proxy_type_decodes_correctly() {
        for (i, j) in vec![
            (OldProxyType::Any, ProxyType::Any),
            (OldProxyType::NonTransfer, ProxyType::NonTransfer),
            (OldProxyType::Governance, ProxyType::Governance),
            (OldProxyType::Staking, ProxyType::Staking),
            (OldProxyType::IdentityJudgement, ProxyType::IdentityJudgement),
        ]
        .into_iter()
        {
            assert_eq!(i.encode(), j.encode());
        }
        assert!(ProxyType::decode(&mut &OldProxyType::SudoBalances.encode()[..]).is_err());
    }
}

impl Default for ProxyType {
    fn default() -> Self {
        Self::Any
    }
}
impl InstanceFilter for ProxyType {
    fn filter(&self, c: &Call) -> bool {
        match self {
            ProxyType::Any => true,
            ProxyType::NonTransfer => matches!(
                c,
                Call::System(..) |
                Call::Scheduler(..) |
                Call::Babe(..) |
                Call::Timestamp(..) |
                Call::Indices(pallet_indices::Call::claim{..}) |
                Call::Indices(pallet_indices::Call::free{..}) |
                Call::Indices(pallet_indices::Call::freeze{..}) |
                // Specifically omitting Indices `transfer`, `force_transfer`
                // Specifically omitting the entire Balances pallet
                Call::Authorship(..) |
                Call::Staking(..) |
                Call::Session(..) |
                Call::Grandpa(..) |
                Call::ImOnline(..) |
                Call::Democracy(..) |
                Call::Council(..) |
                Call::TechnicalCommittee(..) |
                Call::PhragmenElection(..) |
                Call::TechnicalMembership(..) |
                Call::Treasury(..) |
                Call::Bounties(..) |
                Call::ChildBounties(..) |
                Call::Tips(..) |
                Call::Claims(..) |
                Call::Vesting(pallet_vesting::Call::vest{..}) |
                Call::Vesting(pallet_vesting::Call::vest_other{..}) |
                // Specifically omitting Vesting `vested_transfer`, and `force_vested_transfer`
                Call::Utility(..) |
                Call::Identity(..) |
                Call::Proxy(..) |
                Call::Multisig(..) |
                Call::Registrar(paras_registrar::Call::register {..}) |
                Call::Registrar(paras_registrar::Call::deregister {..}) |
                // Specifically omitting Registrar `swap`
                Call::Registrar(paras_registrar::Call::reserve {..}) |
                Call::Crowdloan(..) |
                Call::Slots(..) |
                Call::Auctions(..) | // Specifically omitting the entire XCM Pallet
                Call::VoterList(..)
            ),
            ProxyType::Governance => matches!(
                c,
                Call::Democracy(..) |
                    Call::Council(..) | Call::TechnicalCommittee(..) |
                    Call::PhragmenElection(..) |
                    Call::Treasury(..) | Call::Bounties(..) |
                    Call::Tips(..) | Call::Utility(..) |
                    Call::ChildBounties(..)
            ),
            ProxyType::Staking => {
                matches!(c, Call::Staking(..) | Call::Session(..) | Call::Utility(..))
            },
            ProxyType::IdentityJudgement => matches!(
                c,
                Call::Identity(pallet_identity::Call::provide_judgement { .. }) | Call::Utility(..)
            ),
            ProxyType::CancelProxy => {
                matches!(c, Call::Proxy(pallet_proxy::Call::reject_announcement { .. }))
            },
            ProxyType::Auction => matches!(
                c,
                Call::Auctions(..) | Call::Crowdloan(..) | Call::Registrar(..) | Call::Slots(..)
            ),
        }
    }
    fn is_superset(&self, o: &Self) -> bool {
        match (self, o) {
            (x, y) if x == y => true,
            (ProxyType::Any, _) => true,
            (_, ProxyType::Any) => false,
            (ProxyType::NonTransfer, _) => true,
            _ => false,
        }
    }
}

impl pallet_proxy::Config for Runtime {
    type Event = Event;
    type Call = Call;
    type Currency = Balances;
    type ProxyType = ProxyType;
    type ProxyDepositBase = ProxyDepositBase;
    type ProxyDepositFactor = ProxyDepositFactor;
    type MaxProxies = MaxProxies;
    type WeightInfo = weights::pallet_proxy::WeightInfo;
    type MaxPending = MaxPending;
    type CallHasher = BlakeTwo256;
    type AnnouncementDepositBase = AnnouncementDepositBase;
    type AnnouncementDepositFactor = AnnouncementDepositFactor;
}

impl parachains_origin::Config for Runtime {}

impl parachains_configuration::Config for Runtime {
    type WeightInfo = weights::runtime_parachains_configuration::WeightInfo;
}

impl parachains_shared::Config for Runtime {}

impl parachains_session_info::Config for Runtime {
    type ValidatorSet = Historical;
}

impl parachains_inclusion::Config for Runtime {
    type Event = Event;
    type DisputesHandler = ParasDisputes;
    type RewardValidators = parachains_reward_points::RewardValidatorsWithEraPoints;
}

parameter_types! {
    pub const ParasUnsignedPriority: TransactionPriority = TransactionPriority::max_value();
}

impl parachains_paras::Config for Runtime {
    type Event = Event;
    type WeightInfo = weights::runtime_parachains_paras::WeightInfo;
    type UnsignedPriority = ParasUnsignedPriority;
    type NextSessionRotation = Babe;
}

parameter_types! {
    pub const FirstMessageFactorPercent: u64 = 100;
}

impl parachains_ump::Config for Runtime {
    type Event = Event;
    type UmpSink =
        crate::parachains_ump::XcmSink, Runtime>;
    type FirstMessageFactorPercent = FirstMessageFactorPercent;
    type ExecuteOverweightOrigin = EnsureRoot;
    type WeightInfo = parachains_ump::TestWeightInfo;
}

impl parachains_dmp::Config for Runtime {}

impl parachains_hrmp::Config for Runtime {
    type Event = Event;
    type Origin = Origin;
    type Currency = Balances;
    type WeightInfo = weights::runtime_parachains_hrmp::WeightInfo;
}

impl parachains_paras_inherent::Config for Runtime {
    type WeightInfo = weights::runtime_parachains_paras_inherent::WeightInfo;
}

impl parachains_scheduler::Config for Runtime {}

impl parachains_initializer::Config for Runtime {
    type Randomness = pallet_babe::RandomnessFromOneEpochAgo;
    type ForceOrigin = EnsureRoot;
    type WeightInfo = weights::runtime_parachains_initializer::WeightInfo;
}

impl parachains_disputes::Config for Runtime {
    type Event = Event;
    type RewardValidators = ();
    type PunishValidators = ();
    type WeightInfo = weights::runtime_parachains_disputes::WeightInfo;
}

parameter_types! {
    // Mostly arbitrary deposit price, but should provide an adequate incentive not to spam reserve
    // `ParaId`s.
    pub const ParaDeposit: Balance = 100 * DOLLARS;
    pub const ParaDataByteDeposit: Balance = deposit(0, 1);
}

impl paras_registrar::Config for Runtime {
    type Event = Event;
    type Origin = Origin;
    type Currency = Balances;
    type OnSwap = (Crowdloan, Slots);
    type ParaDeposit = ParaDeposit;
    type DataDepositPerByte = ParaDataByteDeposit;
    type WeightInfo = weights::runtime_common_paras_registrar::WeightInfo;
}

parameter_types! {
    // 12 weeks = 3 months per lease period -> 8 lease periods ~ 2 years
    pub LeasePeriod: BlockNumber = prod_or_fast!(12 * WEEKS, 12 * WEEKS, "DOT_LEASE_PERIOD");
    // Polkadot Genesis was on May 26, 2020.
    // Target Parachain Onboarding Date: Dec 15, 2021.
    // Difference is 568 days.
    // We want a lease period to start on the target onboarding date.
    // 568 % (12 * 7) = 64 day offset
    pub LeaseOffset: BlockNumber = prod_or_fast!(64 * DAYS, 0, "DOT_LEASE_OFFSET");
}

impl slots::Config for Runtime {
    type Event = Event;
    type Currency = Balances;
    type Registrar = Registrar;
    type LeasePeriod = LeasePeriod;
    type LeaseOffset = LeaseOffset;
    type ForceOrigin = MoreThanHalfCouncil;
    type WeightInfo = weights::runtime_common_slots::WeightInfo;
}

parameter_types! {
    pub const CrowdloanId: PalletId = PalletId(*b"py/cfund");
    // Accounts for 10_000 contributions, each using 48 bytes (16 bytes for balance, and 32 bytes
    // for a memo).
    pub const SubmissionDeposit: Balance = deposit(1, 480_000);
    // The minimum crowdloan contribution.
    pub const MinContribution: Balance = 5 * DOLLARS;
    pub const RemoveKeysLimit: u32 = 1000;
    // Allow 32 bytes for an additional memo to a crowdloan.
    pub const MaxMemoLength: u8 = 32;
}

impl crowdloan::Config for Runtime {
    type Event = Event;
    type PalletId = CrowdloanId;
    type SubmissionDeposit = SubmissionDeposit;
    type MinContribution = MinContribution;
    type RemoveKeysLimit = RemoveKeysLimit;
    type Registrar = Registrar;
    type Auctioneer = Auctions;
    type MaxMemoLength = MaxMemoLength;
    type WeightInfo = weights::runtime_common_crowdloan::WeightInfo;
}

parameter_types! {
    // The average auction is 7 days long, so this will be 70% for ending period.
    // 5 Days = 72000 Blocks @ 6 sec per block
    pub const EndingPeriod: BlockNumber = 5 * DAYS;
    // ~ 1000 samples per day -> ~ 20 blocks per sample -> 2 minute samples
    pub const SampleLength: BlockNumber = 2 * MINUTES;
}

type AuctionInitiate = EitherOfDiverse<
    EnsureRoot,
    pallet_collective::EnsureProportionAtLeast,
>;

impl auctions::Config for Runtime {
    type Event = Event;
    type Leaser = Slots;
    type Registrar = Registrar;
    type EndingPeriod = EndingPeriod;
    type SampleLength = SampleLength;
    type Randomness = pallet_babe::RandomnessFromOneEpochAgo;
    type InitiateOrigin = AuctionInitiate;
    type WeightInfo = weights::runtime_common_auctions::WeightInfo;
}

construct_runtime! {
    pub enum Runtime where
        Block = Block,
        NodeBlock = primitives::v2::Block,
        UncheckedExtrinsic = UncheckedExtrinsic
    {
        // Basic stuff; balances is uncallable initially.
        System: frame_system::{Pallet, Call, Storage, Config, Event} = 0,
        Scheduler: pallet_scheduler::{Pallet, Call, Storage, Event} = 1,
        Preimage: pallet_preimage::{Pallet, Call, Storage, Event} = 10,

        // Babe must be before session.
        Babe: pallet_babe::{Pallet, Call, Storage, Config, ValidateUnsigned} = 2,

        Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 3,
        Indices: pallet_indices::{Pallet, Call, Storage, Config, Event} = 4,
        Balances: pallet_balances::{Pallet, Call, Storage, Config, Event} = 5,
        TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 32,

        // Consensus support.
        // Authorship must be before session in order to note author in the correct session and era
        // for im-online and staking.
        Authorship: pallet_authorship::{Pallet, Call, Storage} = 6,
        Staking: pallet_staking::{Pallet, Call, Storage, Config, Event} = 7,
        Offences: pallet_offences::{Pallet, Storage, Event} = 8,
        Historical: session_historical::{Pallet} = 33,
        Session: pallet_session::{Pallet, Call, Storage, Event, Config} = 9,
        Grandpa: pallet_grandpa::{Pallet, Call, Storage, Config, Event, ValidateUnsigned} = 11,
        ImOnline: pallet_im_online::{Pallet, Call, Storage, Event, ValidateUnsigned, Config} = 12,
        AuthorityDiscovery: pallet_authority_discovery::{Pallet, Config} = 13,

        // Governance stuff.
        Democracy: pallet_democracy::{Pallet, Call, Storage, Config, Event} = 14,
        Council: pallet_collective::::{Pallet, Call, Storage, Origin, Event, Config} = 15,
        TechnicalCommittee: pallet_collective::::{Pallet, Call, Storage, Origin, Event, Config} = 16,
        PhragmenElection: pallet_elections_phragmen::{Pallet, Call, Storage, Event, Config} = 17,
        TechnicalMembership: pallet_membership::::{Pallet, Call, Storage, Event, Config} = 18,
        Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event} = 19,


        // Claims. Usable initially.
        Claims: claims::{Pallet, Call, Storage, Event, Config, ValidateUnsigned} = 24,
        // Vesting. Usable initially, but removed once all vesting is finished.
        Vesting: pallet_vesting::{Pallet, Call, Storage, Event, Config} = 25,
        // Cunning utilities. Usable initially.
        Utility: pallet_utility::{Pallet, Call, Event} = 26,

        // Identity. Late addition.
        Identity: pallet_identity::{Pallet, Call, Storage, Event} = 28,

        // Proxy module. Late addition.
        Proxy: pallet_proxy::{Pallet, Call, Storage, Event} = 29,

        // Multisig dispatch. Late addition.
        Multisig: pallet_multisig::{Pallet, Call, Storage, Event} = 30,

        // Bounties modules.
        Bounties: pallet_bounties::{Pallet, Call, Storage, Event} = 34,
        ChildBounties: pallet_child_bounties = 38,

        // Tips module.
        Tips: pallet_tips::{Pallet, Call, Storage, Event} = 35,

        // Election pallet. Only works with staking, but placed here to maintain indices.
        ElectionProviderMultiPhase: pallet_election_provider_multi_phase::{Pallet, Call, Storage, Event, ValidateUnsigned} = 36,

        // Provides a semi-sorted list of nominators for staking.
        VoterList: pallet_bags_list::{Pallet, Call, Storage, Event} = 37,

        // Parachains pallets. Start indices at 50 to leave room.
        ParachainsOrigin: parachains_origin::{Pallet, Origin} = 50,
        Configuration: parachains_configuration::{Pallet, Call, Storage, Config} = 51,
        ParasShared: parachains_shared::{Pallet, Call, Storage} = 52,
        ParaInclusion: parachains_inclusion::{Pallet, Call, Storage, Event} = 53,
        ParaInherent: parachains_paras_inherent::{Pallet, Call, Storage, Inherent} = 54,
        ParaScheduler: parachains_scheduler::{Pallet, Storage} = 55,
        Paras: parachains_paras::{Pallet, Call, Storage, Event, Config} = 56,
        Initializer: parachains_initializer::{Pallet, Call, Storage} = 57,
        Dmp: parachains_dmp::{Pallet, Call, Storage} = 58,
        Ump: parachains_ump::{Pallet, Call, Storage, Event} = 59,
        Hrmp: parachains_hrmp::{Pallet, Call, Storage, Event, Config} = 60,
        ParaSessionInfo: parachains_session_info::{Pallet, Storage} = 61,
        ParasDisputes: parachains_disputes::{Pallet, Call, Storage, Event} = 62,

        // Parachain Onboarding Pallets. Start indices at 70 to leave room.
        Registrar: paras_registrar::{Pallet, Call, Storage, Event} = 70,
        Slots: slots::{Pallet, Call, Storage, Event} = 71,
        Auctions: auctions::{Pallet, Call, Storage, Event} = 72,
        Crowdloan: crowdloan::{Pallet, Call, Storage, Event} = 73,

        // Pallet for sending XCM.
        XcmPallet: pallet_xcm::{Pallet, Call, Storage, Event, Origin, Config} = 99,
    }
}

/// 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::CheckNonZeroSender,
    frame_system::CheckSpecVersion,
    frame_system::CheckTxVersion,
    frame_system::CheckGenesis,
    frame_system::CheckMortality,
    frame_system::CheckNonce,
    frame_system::CheckWeight,
    pallet_transaction_payment::ChargeTransactionPayment,
    claims::PrevalidateAttests,
);
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic = generic::UncheckedExtrinsic;
/// Executive: handles dispatch to the various modules.
pub type Executive = frame_executive::Executive<
    Runtime,
    Block,
    frame_system::ChainContext,
    Runtime,
    AllPalletsWithSystem,
    (RenameBagsListToVoterList, pallet_bags_list::migrations::AddScore),
>;
/// The payload being signed in transactions.
pub type SignedPayload = generic::SignedPayload;

/// A migration which renames the pallet `BagsList` to `VoterList`
pub struct RenameBagsListToVoterList;
impl frame_support::traits::OnRuntimeUpgrade for RenameBagsListToVoterList {
    #[cfg(feature = "try-runtime")]
    fn pre_upgrade() -> Result<(), &'static str> {
        // For other pre-upgrade checks, we need the storage to already be migrated.
        frame_support::storage::migration::move_pallet(b"BagsList", b"VoterList");
        Ok(())
    }
    fn on_runtime_upgrade() -> frame_support::weights::Weight {
        frame_support::storage::migration::move_pallet(b"BagsList", b"VoterList");
        frame_support::weights::Weight::MAX
    }
}

#[cfg(feature = "runtime-benchmarks")]
#[macro_use]
extern crate frame_benchmarking;

#[cfg(feature = "runtime-benchmarks")]
mod benches {
    define_benchmarks!(
        // Polkadot
        // NOTE: Make sure to prefix these with `runtime_common::` so
        // the that path resolves correctly in the generated file.
        [runtime_common::auctions, Auctions]
        [runtime_common::claims, Claims]
        [runtime_common::crowdloan, Crowdloan]
        [runtime_common::slots, Slots]
        [runtime_common::paras_registrar, Registrar]
        [runtime_parachains::configuration, Configuration]
        [runtime_parachains::disputes, ParasDisputes]
        [runtime_parachains::initializer, Initializer]
        [runtime_parachains::paras, Paras]
        [runtime_parachains::paras_inherent, ParaInherent]
        [runtime_parachains::ump, Ump]
        // Substrate
        [pallet_bags_list, VoterList]
        [pallet_balances, Balances]
        [frame_benchmarking::baseline, Baseline::]
        [pallet_bounties, Bounties]
        [pallet_child_bounties, ChildBounties]
        [pallet_collective, Council]
        [pallet_collective, TechnicalCommittee]
        [pallet_democracy, Democracy]
        [pallet_elections_phragmen, PhragmenElection]
        [pallet_election_provider_multi_phase, ElectionProviderMultiPhase]
        [frame_election_provider_support, ElectionProviderBench::]
        [pallet_identity, Identity]
        [pallet_im_online, ImOnline]
        [pallet_indices, Indices]
        [pallet_membership, TechnicalMembership]
        [pallet_multisig, Multisig]
        [pallet_offences, OffencesBench::]
        [pallet_preimage, Preimage]
        [pallet_proxy, Proxy]
        [pallet_scheduler, Scheduler]
        [pallet_session, SessionBench::]
        [pallet_staking, Staking]
        [frame_system, SystemBench::]
        [pallet_timestamp, Timestamp]
        [pallet_tips, Tips]
        [pallet_treasury, Treasury]
        [pallet_utility, Utility]
        [pallet_vesting, Vesting]
    );
}

#[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 {
            OpaqueMetadata::new(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)
        }
    }

    impl tx_pool_api::runtime_api::TaggedTransactionQueue for Runtime {
        fn validate_transaction(
            source: TransactionSource,
            tx: ::Extrinsic,
            block_hash: ::Hash,
        ) -> TransactionValidity {
            Executive::validate_transaction(source, tx, block_hash)
        }
    }

    impl offchain_primitives::OffchainWorkerApi for Runtime {
        fn offchain_worker(header: &::Header) {
            Executive::offchain_worker(header)
        }
    }

    impl primitives::runtime_api::ParachainHost for Runtime {
        fn validators() -> Vec {
            parachains_runtime_api_impl::validators::()
        }

        fn validator_groups() -> (Vec>, GroupRotationInfo) {
            parachains_runtime_api_impl::validator_groups::()
        }

        fn availability_cores() -> Vec> {
            parachains_runtime_api_impl::availability_cores::()
        }

        fn persisted_validation_data(para_id: ParaId, assumption: OccupiedCoreAssumption)
            -> Option> {
            parachains_runtime_api_impl::persisted_validation_data::(para_id, assumption)
        }

        fn assumed_validation_data(
            para_id: ParaId,
            expected_persisted_validation_data_hash: Hash,
        ) -> Option<(PersistedValidationData, ValidationCodeHash)> {
            parachains_runtime_api_impl::assumed_validation_data::(
                para_id,
                expected_persisted_validation_data_hash,
            )
        }

        fn check_validation_outputs(
            para_id: ParaId,
            outputs: primitives::v2::CandidateCommitments,
        ) -> bool {
            parachains_runtime_api_impl::check_validation_outputs::(para_id, outputs)
        }

        fn session_index_for_child() -> SessionIndex {
            parachains_runtime_api_impl::session_index_for_child::()
        }

        fn validation_code(para_id: ParaId, assumption: OccupiedCoreAssumption)
            -> Option {
            parachains_runtime_api_impl::validation_code::(para_id, assumption)
        }

        fn candidate_pending_availability(para_id: ParaId) -> Option> {
            parachains_runtime_api_impl::candidate_pending_availability::(para_id)
        }

        fn candidate_events() -> Vec> {
            parachains_runtime_api_impl::candidate_events::(|ev| {
                match ev {
                    Event::ParaInclusion(ev) => {
                        Some(ev)
                    }
                    _ => None,
                }
            })
        }

        fn session_info(index: SessionIndex) -> Option {
            parachains_runtime_api_impl::session_info::(index)
        }

        fn dmq_contents(recipient: ParaId) -> Vec> {
            parachains_runtime_api_impl::dmq_contents::(recipient)
        }

        fn inbound_hrmp_channels_contents(
            recipient: ParaId
        ) -> BTreeMap>> {
            parachains_runtime_api_impl::inbound_hrmp_channels_contents::(recipient)
        }

        fn validation_code_by_hash(hash: ValidationCodeHash) -> Option {
            parachains_runtime_api_impl::validation_code_by_hash::(hash)
        }

        fn on_chain_votes() -> Option> {
            parachains_runtime_api_impl::on_chain_votes::()
        }

        fn submit_pvf_check_statement(
            stmt: primitives::v2::PvfCheckStatement,
            signature: primitives::v2::ValidatorSignature,
        ) {
            parachains_runtime_api_impl::submit_pvf_check_statement::(stmt, signature)
        }

        fn pvfs_require_precheck() -> Vec {
            parachains_runtime_api_impl::pvfs_require_precheck::()
        }

        fn validation_code_hash(para_id: ParaId, assumption: OccupiedCoreAssumption)
            -> Option
        {
            parachains_runtime_api_impl::validation_code_hash::(para_id, assumption)
        }

        fn staging_get_disputes() -> Vec<(SessionIndex, CandidateHash, DisputeState)> {
            unimplemented!()
        }
    }

    impl beefy_primitives::BeefyApi for Runtime {
        fn validator_set() -> Option> {
            // dummy implementation due to lack of BEEFY pallet.
            None
        }
    }

    impl mmr::MmrApi for Runtime {
        fn generate_proof(_leaf_index: u64)
            -> Result<(mmr::EncodableOpaqueLeaf, mmr::Proof), mmr::Error>
        {
            Err(mmr::Error::PalletNotIncluded)
        }

        fn verify_proof(_leaf: mmr::EncodableOpaqueLeaf, _proof: mmr::Proof)
            -> Result<(), mmr::Error>
        {
            Err(mmr::Error::PalletNotIncluded)
        }

        fn verify_proof_stateless(
            _root: Hash,
            _leaf: mmr::EncodableOpaqueLeaf,
            _proof: mmr::Proof
        ) -> Result<(), mmr::Error> {
            Err(mmr::Error::PalletNotIncluded)
        }

        fn mmr_root() -> Result {
            Err(mmr::Error::PalletNotIncluded)
        }

        fn generate_batch_proof(_leaf_indices: Vec)
            -> Result<(Vec, mmr::BatchProof), mmr::Error>
        {
            Err(mmr::Error::PalletNotIncluded)
        }

        fn verify_batch_proof(_leaves: Vec, _proof: mmr::BatchProof)
            -> Result<(), mmr::Error>
        {
            Err(mmr::Error::PalletNotIncluded)
        }

        fn verify_batch_proof_stateless(
            _root: Hash,
            _leaves: Vec,
            _proof: mmr::BatchProof
        ) -> Result<(), mmr::Error> {
            Err(mmr::Error::PalletNotIncluded)
        }
    }

    impl fg_primitives::GrandpaApi for Runtime {
        fn grandpa_authorities() -> Vec<(GrandpaId, u64)> {
            Grandpa::grandpa_authorities()
        }

        fn current_set_id() -> fg_primitives::SetId {
            Grandpa::current_set_id()
        }

        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: EpochDuration::get(),
                c: BABE_GENESIS_EPOCH_CONFIG.c,
                genesis_authorities: Babe::authorities().to_vec(),
                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 {
            parachains_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)
        }
    }

    #[cfg(feature = "try-runtime")]
    impl frame_try_runtime::TryRuntime for Runtime {
        fn on_runtime_upgrade() -> (Weight, Weight) {
            log::info!("try-runtime::on_runtime_upgrade polkadot.");
            let weight = Executive::try_runtime_upgrade().unwrap();
            (weight, BlockWeights::get().max_block)
        }

        fn execute_block_no_check(block: Block) -> Weight {
            Executive::execute_block_no_check(block)
        }
    }

    #[cfg(feature = "runtime-benchmarks")]
    impl frame_benchmarking::Benchmark for Runtime {
        fn benchmark_metadata(extra: bool) -> (
            Vec,
            Vec,
        ) {
            use frame_benchmarking::{Benchmarking, BenchmarkList};
            use frame_support::traits::StorageInfoTrait;

            use pallet_session_benchmarking::Pallet as SessionBench;
            use pallet_offences_benchmarking::Pallet as OffencesBench;
            use pallet_election_provider_support_benchmarking::Pallet as ElectionProviderBench;
            use frame_system_benchmarking::Pallet as SystemBench;
            use frame_benchmarking::baseline::Pallet as Baseline;

            let mut list = Vec::::new();
            list_benchmarks!(list, extra);

            let storage_info = AllPalletsWithSystem::storage_info();
            return (list, storage_info)
        }

        fn dispatch_benchmark(
            config: frame_benchmarking::BenchmarkConfig
        ) -> Result<
            Vec,
            sp_runtime::RuntimeString,
        > {
            use frame_benchmarking::{Benchmarking, BenchmarkBatch, TrackedStorageKey};
            // Trying to add benchmarks directly to some pallets caused cyclic dependency issues.
            // To get around that, we separated the benchmarks into its own crate.
            use pallet_session_benchmarking::Pallet as SessionBench;
            use pallet_offences_benchmarking::Pallet as OffencesBench;
            use pallet_election_provider_support_benchmarking::Pallet as ElectionProviderBench;
            use frame_system_benchmarking::Pallet as SystemBench;
            use frame_benchmarking::baseline::Pallet as Baseline;

            impl pallet_session_benchmarking::Config for Runtime {}
            impl pallet_offences_benchmarking::Config for Runtime {}
            impl pallet_election_provider_support_benchmarking::Config for Runtime {}
            impl frame_system_benchmarking::Config for Runtime {}
            impl frame_benchmarking::baseline::Config for Runtime {}

            let whitelist: Vec = vec![
                // Block Number
                hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),
                // Total Issuance
                hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),
                // Execution Phase
                hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),
                // Event Count
                hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),
                // System Events
                hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),
                // Treasury Account
                hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da95ecffd7b6c0f78751baa9d281e0bfa3a6d6f646c70792f74727372790000000000000000000000000000000000000000").to_vec().into(),
            ];

            let mut batches = Vec::::new();
            let params = (&config, &whitelist);

            add_benchmarks!(params, batches);

            Ok(batches)
        }
    }
}

#[cfg(test)]
mod test_fees {
    use super::*;
    use frame_support::weights::{GetDispatchInfo, WeightToFee as WeightToFeeT};
    use keyring::Sr25519Keyring::Charlie;
    use pallet_transaction_payment::Multiplier;
    use runtime_common::MinimumMultiplier;
    use separator::Separatable;
    use sp_runtime::{assert_eq_error_rate, FixedPointNumber};

    #[test]
    fn payout_weight_portion() {
        use pallet_staking::WeightInfo;
        let payout_weight =
            ::WeightInfo::payout_stakers_alive_staked(
                MaxNominatorRewardedPerValidator::get(),
            ) as f64;
        let block_weight = BlockWeights::get().max_block as f64;

        println!(
            "a full payout takes {:.2} of the block weight [{} / {}]",
            payout_weight / block_weight,
            payout_weight,
            block_weight
        );
        assert!(payout_weight * 2f64 < block_weight);
    }

    #[test]
    #[ignore]
    fn block_cost() {
        let max_block_weight = BlockWeights::get().max_block;
        let raw_fee = WeightToFee::weight_to_fee(&max_block_weight);

        println!(
            "Full Block weight == {} // WeightToFee(full_block) == {} plank",
            max_block_weight,
            raw_fee.separated_string(),
        );
    }

    #[test]
    #[ignore]
    fn transfer_cost_min_multiplier() {
        let min_multiplier = MinimumMultiplier::get();
        let call = pallet_balances::Call::::transfer_keep_alive {
            dest: Charlie.to_account_id().into(),
            value: Default::default(),
        };
        let info = call.get_dispatch_info();
        // convert to outer call.
        let call = Call::Balances(call);
        let len = call.using_encoded(|e| e.len()) as u32;

        let mut ext = sp_io::TestExternalities::new_empty();
        let mut test_with_multiplier = |m| {
            ext.execute_with(|| {
                pallet_transaction_payment::NextFeeMultiplier::::put(m);
                let fee = TransactionPayment::compute_fee(len, &info, 0);
                println!(
                    "weight = {:?} // multiplier = {:?} // full transfer fee = {:?}",
                    info.weight.separated_string(),
                    pallet_transaction_payment::NextFeeMultiplier::::get(),
                    fee.separated_string(),
                );
            });
        };

        test_with_multiplier(min_multiplier);
        test_with_multiplier(Multiplier::saturating_from_rational(1, 1u128));
        test_with_multiplier(Multiplier::saturating_from_rational(1, 1_000u128));
        test_with_multiplier(Multiplier::saturating_from_rational(1, 1_000_000u128));
        test_with_multiplier(Multiplier::saturating_from_rational(1, 1_000_000_000u128));
    }

    #[test]
    fn full_block_council_election_cost() {
        // the number of voters needed to consume almost a full block in council election, and how
        // much it is going to cost.
        use pallet_elections_phragmen::WeightInfo;

        // Loser candidate lose a lot of money; sybil attack by candidates is even more expensive,
        // and we don't care about it here. For now, we assume no extra candidates, and only
        // superfluous voters.
        let candidates = DesiredMembers::get() + DesiredRunnersUp::get();
        let mut voters = 1u32;
        let weight_with = |v| {
            ::WeightInfo::election_phragmen(
                candidates,
                v,
                v * 16,
            )
        };

        while weight_with(voters) <= BlockWeights::get().max_block {
            voters += 1;
        }

        let cost = voters as Balance * (VotingBondBase::get() + 16 * VotingBondFactor::get());
        let cost_dollars = cost / DOLLARS;
        println!(
            "can support {} voters in a single block for council elections; total bond {}",
            voters, cost_dollars,
        );
        assert!(cost_dollars > 150_000); // DOLLAR ~ new DOT ~ 10e10
    }

    #[test]
    fn nominator_limit() {
        use pallet_election_provider_multi_phase::WeightInfo;
        // starting point of the nominators.
        let target_voters: u32 = 50_000;

        // assuming we want around 5k candidates and 1k active validators. (March 31, 2021)
        let all_targets: u32 = 5_000;
        let desired: u32 = 1_000;
        let weight_with = |active| {
            ::WeightInfo::submit_unsigned(
                active,
                all_targets,
                active,
                desired,
            )
        };

        let mut active = target_voters;
        while weight_with(active) <= OffchainSolutionWeightLimit::get() || active == target_voters {
            active += 1;
        }

        println!("can support {} nominators to yield a weight of {}", active, weight_with(active));
        assert!(active > target_voters, "we need to reevaluate the weight of the election system");
    }

    #[test]
    fn signed_deposit_is_sensible() {
        // ensure this number does not change, or that it is checked after each change.
        // a 1 MB solution should take (40 + 10) DOTs of deposit.
        let deposit = SignedDepositBase::get() + (SignedDepositByte::get() * 1024 * 1024);
        assert_eq_error_rate!(deposit, 50 * DOLLARS, DOLLARS);
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn call_size() {
        assert!(
            core::mem::size_of::() <= 230,
            "size of Call is more than 230 bytes: some calls have too big arguments, use Box to \
            reduce the size of Call.
            If the limit is too strong, maybe consider increase the limit",
        );
    }
}