#![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 authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
use frame_election_provider_support::{
    bounds::ElectionBoundsBuilder, generate_solution_type, onchain, SequentialPhragmen,
};
use frame_support::{
    construct_runtime, parameter_types, PalletId,
    weights::ConstantMultiplier,
    pallet_prelude::EnsureOrigin,
    genesis_builder_helper::{build_state, get_preset},
    traits::{
        fungible::HoldConsideration,
        tokens::{imbalance::ResolveTo, UnityAssetBalanceConversion},
        ConstU128, ConstU32, InstanceFilter, KeyOwnerProofSystem,
        LinearStoragePrice,
    },
};

#[cfg(not(feature = "runtime-benchmarks"))]
use frame_support::traits::tokens::PayFromAccount;

use frame_system::EnsureRoot;
use runtime_common::{
    impl_runtime_weights, impls::DealWithFees, prod_or_fast, BlockHashCount, BlockLength,
    CurrencyToVote, SlowAdjustingFeeUpdate,
};

#[cfg(feature = "runtime-benchmarks")]
use runtime_common::benchmarking::{BenchmarkTreasuryHelper, BenchmarkTreasuryPaymaster};

use codec::{Decode, Encode, MaxEncodedLen};
use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
use pallet_identity::legacy::IdentityInfo;
use pallet_session::historical as session_historical;
use pallet_transaction_payment::FungibleAdapter;
use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};

use primitives::{
    AccountId, Balance, BlockNumber, Hash, Moment, Nonce, Signature,
    ReserveIdentifier,
};
use sp_core::OpaqueMetadata;
use sp_genesis_builder::PresetId;
use sp_runtime::{
    create_runtime_str,
    curve::PiecewiseLinear,
    generic, impl_opaque_keys,
    traits::{
        AccountIdLookup, BlakeTwo256, Block as BlockT,
        Extrinsic as ExtrinsicT, IdentityLookup, OpaqueKeys,
        SaturatedConversion, Verify, AccountIdConversion,
    },
    transaction_validity::{
        TransactionPriority, TransactionSource, TransactionValidity,
    },
    ApplyExtrinsicResult, FixedU128, KeyTypeId, Perbill, Percent,
    Permill, RuntimeDebug,
};
use sp_std::prelude::*;
#[cfg(any(feature = "std", test))]
use sp_version::NativeVersion;
use sp_version::RuntimeVersion;

pub use frame_system::Call as SystemCall;
pub use pallet_balances::Call as BalancesCall;
pub use pallet_election_provider_multi_phase::{Call as EPMCall, GeometricDepositBase};

use ghost_weaver::sr25519::AuthorityId as GhostWeaverId;
use ghost_exodus::sr25519::AuthorityId as GhostExodusId;

#[cfg(feature = "std")]
pub use pallet_staking::StakerStatus;
use pallet_staking::UseValidatorsMap;
pub use pallet_timestamp::Call as TimestampCall;
#[cfg(any(feature = "std", test))]
pub use sp_runtime::BuildStorage;

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

mod bag_thresholds;
mod genesis_config_presets;
mod weights;

pub mod genesis {
    pub use super::genesis_config_presets::*;
}

type NetworkId = ghost_helpers::NetworkIdU64;

pub const LOG_TARGET: &str = "runtime::casper";

impl_runtime_weights!(casper_runtime_constants);

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

pub mod opaque {
    use super::*;

    pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
    pub type Block = generic::Block<Header, UncheckedExtrinsic>;

    impl_opaque_keys! {
        pub struct SessionKeys {
            pub babe: Babe,
            pub grandpa: Grandpa,
            pub authority_discovery: AuthorityDiscovery,
            pub weaver: GhostWeaver,
            pub exodus: GhostExodus,
        }
    }
}

/// Runtime version (Casper).
#[sp_version::runtime_version]
pub const VERSION: RuntimeVersion = RuntimeVersion {
    spec_name: create_runtime_str!("casper"),
    impl_name: create_runtime_str!("casper-svengali"),
    authoring_version: 0,
    spec_version: 6,
    impl_version: 4,
    apis: RUNTIME_API_VERSIONS,
    transaction_version: 1,
    state_version: 1,
};

/// 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,
    };

/// The version information used to identify this runtime when compiled natively.
#[cfg(any(feature = "std", test))]
pub fn native_version() -> NativeVersion {
    NativeVersion {
        runtime_version: VERSION,
        can_author_with: Default::default(),
    }
}

parameter_types! {
    pub const Version: RuntimeVersion = VERSION;
    pub const SS58Prefix: u16 = 1996;
}

// Configure FRAME pallets to include in runtime.
impl frame_system::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type BaseCallFilter = frame_support::traits::Everything;
    type BlockWeights = BlockWeights;
    type BlockLength = BlockLength;
    type RuntimeOrigin = RuntimeOrigin;
    type RuntimeCall = RuntimeCall;
    type RuntimeTask = RuntimeTask;
    type Nonce = Nonce;
    type Hash = Hash;
    type Hashing = BlakeTwo256;
    type AccountId = AccountId;
    type Lookup = AccountIdLookup<AccountId, ()>;
    type Block = Block;
    type BlockHashCount = BlockHashCount;
    type DbWeight = RocksDbWeight;
    type Version = Version;
    type PalletInfo = PalletInfo;
    type AccountData = pallet_balances::AccountData<Balance>;
    type OnNewAccount = ();
    type OnKilledAccount = ();
    type SystemWeightInfo = weights::frame_system::WeightInfo<Runtime>;
    type SS58Prefix = SS58Prefix;
    type OnSetCode = ();
    type MaxConsumers = ConstU32<16>;
    type SingleBlockMigrations = ();
    type MultiBlockMigrator = ();
    type PreInherents = ();
    type PostInherents = ();
    type PostTransactions = ();
}

parameter_types! {
    pub MaximumSchedulerWeight: Weight = Perbill::from_percent(20) *
        BlockWeights::get().max_block;
    pub const MaxScheduledPerBlock: u32 = 50;
}

impl pallet_scheduler::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type RuntimeOrigin = RuntimeOrigin;
    type PalletsOrigin = OriginCaller;
    type RuntimeCall = RuntimeCall;
    type MaximumWeight = MaximumSchedulerWeight;
    type ScheduleOrigin = EnsureRoot<Self::AccountId>;
    type MaxScheduledPerBlock = MaxScheduledPerBlock;
    type OriginPrivilegeCmp = frame_support::traits::EqualPrivilegeOnly;
    type Preimages = Preimage;
    type WeightInfo = weights::pallet_scheduler::WeightInfo<Runtime>;
}

parameter_types! {
    pub const PreimageBaseDeposit: Balance = deposit(2, 64);
    pub const PreimageByteDeposit: Balance = deposit(0, 1);
    pub const PreimageHoldReason: RuntimeHoldReason =
        RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);
}

impl pallet_preimage::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type ManagerOrigin = EnsureRoot<Self::AccountId>;
    type Consideration = HoldConsideration<
        AccountId,
        Balances,
        PreimageHoldReason,
        LinearStoragePrice<PreimageBaseDeposit, PreimageByteDeposit, Balance>,
    >;
    type WeightInfo = weights::pallet_preimage::WeightInfo<Runtime>;
}

parameter_types! {
    pub const EpochDuration: u64 = EPOCH_DURATION_IN_SLOTS as u64;
    pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
    pub const 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 trigger
    type EpochChangeTrigger = pallet_babe::ExternalTrigger;

    type DisabledValidators = Session;
    type WeightInfo = weights::pallet_babe::WeightInfo<Runtime>;

    type MaxAuthorities = MaxActiveValidators;
    type MaxNominators = MaxElectingVoters;

    type KeyOwnerProof =
        <Historical as KeyOwnerProofSystem<(KeyTypeId, pallet_babe::AuthorityId)>>::Proof;

    type EquivocationReportSystem =
        pallet_babe::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
}

parameter_types! {
    pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT;
    pub const MaxLocks: u32 = 50;
    pub const MaxReserves: u32 = 50;
    pub const MaxFreezes: u32 = 10;
}

impl pallet_balances::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;

    type Balance = Balance;
    type AccountStore = System;
    type DustRemoval = ResolveTo<TreasuryAccount, Balances>;
    type ExistentialDeposit = ExistentialDeposit;
    type ReserveIdentifier = ReserveIdentifier;

    type RuntimeHoldReason = RuntimeHoldReason;
    type RuntimeFreezeReason = RuntimeFreezeReason;
    type FreezeIdentifier = RuntimeFreezeReason;

    type MaxLocks = MaxLocks;
    type MaxReserves = MaxReserves;
    type MaxFreezes = MaxFreezes;

    type WeightInfo = weights::pallet_balances::WeightInfo<Runtime>;
}

parameter_types! {
    pub const TransactionByteFee: Balance = 10 * STNK;
    pub const OperationalFeeMultiplier: u8 = 5;
}

impl pallet_transaction_payment::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type OnChargeTransaction = FungibleAdapter<Balances, DealWithFees<Runtime>>;
    type OperationalFeeMultiplier = OperationalFeeMultiplier;
    type WeightToFee = WeightToFee;
    type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;
    type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;
}

parameter_types! {
    pub const MinimumPeriod: u64 = SLOT_DURATION / 2;
}

impl pallet_timestamp::Config for Runtime {
    type Moment = Moment;
    type OnTimestampSet = Babe;
    type MinimumPeriod = MinimumPeriod;
    type WeightInfo = weights::pallet_timestamp::WeightInfo<Runtime>;
}

impl pallet_authorship::Config for Runtime {
    type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
    type EventHandler = Staking;
}

impl pallet_session::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type ValidatorId = AccountId;
    type ValidatorIdOf = pallet_staking::StashOf<Self>;
    type ShouldEndSession = Babe;
    type NextSessionRotation = Babe;
    type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
    type SessionHandler = <opaque::SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
    type Keys = opaque::SessionKeys;
    type WeightInfo = weights::pallet_session::WeightInfo<Runtime>;
}

impl pallet_session::historical::Config for Runtime {
    type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
    type FullIdentificationOf = pallet_staking::ExposureOf<Runtime>;
}

parameter_types! {
    pub SignedPhase: u32 = EPOCH_DURATION_IN_SLOTS / 4;
    pub UnsignedPhase: u32 = EPOCH_DURATION_IN_SLOTS / 4;

    // signed config
    pub const SignedMaxSubmissions: u32 = 16;
    pub const SignedMaxRefunds: u32 = 16 / 4;
    pub const SignedFixedDeposit: Balance = deposit(2, 0);
    pub const SignedDepositIncreaseFactor: Percent = Percent::from_percent(10);
    // 0.01 CSPR per KB of solution data.
    pub const SignedDepositByte: Balance = deposit(0, 10) / 1024;
    // Each good submission will get 0 CSPR as reward
    pub SignedRewardBase: Balance = 0 * STRH;

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

    pub const MaxElectingVoters: u32 = 3_000;
    pub const MaxElectableTargets: u32 = 400;
    pub const MaxActiveValidators: u32 = 300;

    // ... and all of the validators as electable targets. Whilist this is the
    // case, we cannot and shall increase the size of the validator intentions.
    pub ElectionBounds: frame_election_provider_support::bounds::ElectionBounds =
    	ElectionBoundsBuilder::default()
    		.voters_count(MaxElectingVoters::get().into())
    		.targets_count(MaxElectableTargets::get().into())
    		.build();
}

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<AccountId, runtime_common::elections::OnChainAccuracy>;
    type DataProvider = Staking;
    type MaxWinners = MaxActiveValidators;
    type Bounds = ElectionBounds;
    type WeightInfo = weights::frame_election_provider_support::WeightInfo<Runtime>;
}

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

    // 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 {
        <
            <Self as pallet_election_provider_multi_phase::Config>::WeightInfo
            as
            pallet_election_provider_multi_phase::WeightInfo
        >::submit_unsigned(v, t, a, d)
    }
}

impl pallet_election_provider_multi_phase::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type EstimateCallFee = TransactionPayment;
    type SignedPhase = SignedPhase;
    type UnsignedPhase = UnsignedPhase;
    type SignedMaxSubmissions = SignedMaxSubmissions;
    type SignedMaxRefunds = SignedMaxRefunds;
    type SignedRewardBase = SignedRewardBase;
    type SignedDepositBase =
        GeometricDepositBase<Balance, SignedFixedDeposit, SignedDepositIncreaseFactor>;
    type SignedDepositByte = SignedDepositByte;
    type SignedDepositWeight = ();
    type SignedMaxWeight =
        <Self::MinerConfig as pallet_election_provider_multi_phase::MinerConfig>::MaxWeight;
    type MinerConfig = Self;
    type SlashHandler = ();
    type RewardHandler = ();
    type BetterSignedThreshold = ();
    type OffchainRepeat = OffchainRepeat;
    type MinerTxPriority = NposSolutionPriority;
    type DataProvider = Staking;
    #[cfg(any(feature = "fast-runtime", feature = "runtime-benchmarks"))]
    type Fallback = onchain::OnChainExecution<OnChainSeqPhragmen>;
    #[cfg(not(any(feature = "fast-runtime", feature = "runtime-benchmarks")))]
    type Fallback = frame_election_provider_support::NoElection<(
        AccountId,
        BlockNumber,
        Staking,
        MaxActiveValidators,
    )>;
    type GovernanceFallback = onchain::OnChainExecution<OnChainSeqPhragmen>;
    type Solver = SequentialPhragmen<
        AccountId,
        pallet_election_provider_multi_phase::SolutionAccuracyOf<Self>,
        (),
    >;
    type BenchmarkingConfig = runtime_common::elections::BenchmarkConfig;
    type ForceOrigin = EnsureRoot<Self::AccountId>;
    type MaxWinners = MaxActiveValidators;
    type ElectionBounds = ElectionBounds;
    type WeightInfo = weights::pallet_election_provider_multi_phase::WeightInfo<Runtime>;
}

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

type VoterBagsListInstance = pallet_bags_list::Instance1;
impl pallet_bags_list::Config<VoterBagsListInstance> for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type ScoreProvider = Staking;
    type BagThresholds = BagThresholds;
    type Score = sp_npos_elections::VoteWeight;
    type WeightInfo = weights::pallet_bags_list::WeightInfo<Runtime>;
}

pallet_staking_reward_curve::build! {
    const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
        min_inflation: 0_006_900,
        max_inflation: 0_690_000,
        ideal_stake: 0_690_000,
        falloff: 0_050_000,
        max_piece_count: 100,
        test_precision: 0_005_000,
    );
}

parameter_types! {
    pub const SessionsPerEra: sp_staking::SessionIndex = prod_or_fast!(6, 1);
    pub const BondingDuration: sp_staking::EraIndex = prod_or_fast!(1, 1);
    pub const SlashDeferDuration: sp_staking::EraIndex = prod_or_fast!(0, 0);
    pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
    pub const MaxExposurePageSize: u32 = 512;
    pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(17);
    pub const MaxNominations: u32 =
        <NposCompactSolution16 as frame_election_provider_support::NposSolution>::LIMIT as u32;
    pub const StakingHistoryDepth: u32 = 14;
    pub const MaxUnlockingChunks: u32 = 32;
}

impl pallet_staking::Config for Runtime {
    type Currency = Balances;
    type CurrencyBalance = Balance;
    type UnixTime = Timestamp;
    type CurrencyToVote = CurrencyToVote;
    type RewardRemainder = Treasury;
    type RuntimeEvent = RuntimeEvent;
    type Slash = Treasury;
    type Reward = (); // rewards are minted from the void
    type SessionsPerEra = SessionsPerEra;
    type BondingDuration = BondingDuration;
    type SlashDeferDuration = SlashDeferDuration;
    type AdminOrigin = EnsureRoot<Self::AccountId>;
    type SessionInterface = Self;
    type EraPayout = ghost_networks::BridgedInflationCurve<RewardCurve, Self>;
    type MaxExposurePageSize = MaxExposurePageSize;
    type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
    type NextNewSession = Session;
    type ElectionProvider = ElectionProviderMultiPhase;
    type GenesisElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
    type VoterList = VoterList;
    type TargetList = UseValidatorsMap<Self>;
    type NominationsQuota = pallet_staking::FixedNominationsQuota<{ MaxNominations::get() }>;
    type MaxUnlockingChunks = MaxUnlockingChunks;
    type HistoryDepth = StakingHistoryDepth;
    type MaxControllersInDeprecationBatch = ConstU32<5314>;
    type BenchmarkingConfig = runtime_common::StakingBenchmarkingConfig;
    type EventListeners = NominationPools;
    type WeightInfo = weights::pallet_staking::WeightInfo<Runtime>;
}

parameter_types! {
    pub const BasicDeposit: Balance = deposit(1, 258);
    pub const ByteDeposit: Balance = deposit(0, 1);
    pub const SubAccountDeposit: Balance = deposit(1, 53);
    pub const MaxSubAccounts: u32 = 100;
    pub const MaxAdditionalFields: u32 = 100;
    pub const MaxRegistrars: u32 = 100;
}

impl pallet_identity::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type BasicDeposit = BasicDeposit;
    type ByteDeposit = ByteDeposit;
    type SubAccountDeposit = SubAccountDeposit;
    type MaxSubAccounts = MaxSubAccounts;
    type IdentityInformation = IdentityInfo<MaxAdditionalFields>;
    type MaxRegistrars = MaxRegistrars;
    type Slashed = Treasury;

    type ForceOrigin = EnsureRoot<Self::AccountId>;
    type RegistrarOrigin = EnsureRoot<Self::AccountId>;
    type UsernameAuthorityOrigin = EnsureRoot<Self::AccountId>;

    type OffchainSignature = Signature;
    type SigningPublicKey = <Signature as Verify>::Signer;
    type PendingUsernameExpiration = ConstU32<{ 7 * DAYS }>;
    type MaxSuffixLength = ConstU32<7>;
    type MaxUsernameLength = ConstU32<32>;
    type WeightInfo = weights::pallet_identity::WeightInfo<Runtime>;
}

parameter_types! {
    pub const ProposalBond: Permill = Permill::from_percent(5);
    pub const Burn: Permill = Permill::from_percent(0);
    pub const MaxBalance: Balance = Balance::MAX;
    pub const PayoutPeriod: BlockNumber = 30 * DAYS;
    pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");

    pub const DataDepositPerByte: Balance = 1 * STRH;
    pub const MaxApprovals: u32 = 10;
}

#[cfg(not(feature = "runtime-benchmarks"))]
parameter_types! {
    pub const ProposalBondMinimum: Balance = 100 * STRH;
    pub const ProposalBondMaximum: Balance = 500 * STRH;
    pub const SpendPeriod: BlockNumber = 6 * DAYS;
}

#[cfg(feature = "runtime-benchmarks")]
parameter_types! {
    pub const ProposalBondMinimum: Balance = ExistentialDeposit::get() * 100;
    pub const ProposalBondMaximum: Balance = ExistentialDeposit::get() * 500;
    pub const SpendPeriod: BlockNumber = 1;
}

pub struct RootSpendOrigin;
impl EnsureOrigin<RuntimeOrigin> for RootSpendOrigin {
    type Success = Balance;

    fn try_origin(o: RuntimeOrigin) -> Result<Self::Success, RuntimeOrigin> {
        EnsureRoot::<AccountId>::try_origin(o)?;
        Ok(Balance::MAX)
    }

    #[cfg(feature = "runtime-benchmarks")]
    fn try_successful_origin() -> Result<RuntimeOrigin, ()> {
        EnsureRoot::<AccountId>::try_successful_origin()
    }
}

pub struct TreasuryAccount;
impl frame_support::traits::Get<AccountId> for TreasuryAccount {
    fn get() -> AccountId {
        TreasuryPalletId::get().into_account_truncating()
    }
}

impl frame_support::pallet_prelude::TypedGet for TreasuryAccount {
    type Type = AccountId;

    fn get() -> Self::Type {
        TreasuryPalletId::get().into_account_truncating()
    }
}

impl pallet_treasury::Config for Runtime {
    type PalletId = TreasuryPalletId;
    type Currency = Balances;

    type ApproveOrigin = EnsureRoot<Self::AccountId>;
    type RejectOrigin = EnsureRoot<Self::AccountId>;

    type RuntimeEvent = RuntimeEvent;
    type ProposalBond = ProposalBond;
    type OnSlash = ();

    type ProposalBondMinimum = ProposalBondMinimum;
    type ProposalBondMaximum = ProposalBondMaximum;
    type SpendPeriod = SpendPeriod;

    type Burn = Burn;
    type SpendFunds = ();
    type BurnDestination = ();
    type MaxApprovals = MaxApprovals;

    type SpendOrigin = RootSpendOrigin;

    type AssetKind = ();
    type Beneficiary = AccountId;
    type BeneficiaryLookup = IdentityLookup<Self::Beneficiary>;

    #[cfg(not(feature = "runtime-benchmarks"))]
    type Paymaster = PayFromAccount<Balances, TreasuryAccount>;
    #[cfg(feature = "runtime-benchmarks")]
    type Paymaster = BenchmarkTreasuryPaymaster;

    type BalanceConverter = UnityAssetBalanceConversion;
    type PayoutPeriod = PayoutPeriod;

    #[cfg(feature = "runtime-benchmarks")]
    type BenchmarkHelper = BenchmarkTreasuryHelper;

    type WeightInfo = weights::pallet_treasury::WeightInfo<Runtime>;
}

impl pallet_offences::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type OnOffenceHandler = Staking;
    type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
}

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

parameter_types! {
    pub NposSolutionPriority: TransactionPriority =
        Perbill::from_percent(90) * TransactionPriority::MAX;

}
parameter_types! {
    pub MaxSetIdSessionEntries: u32 =
        BondingDuration::get() * SessionsPerEra::get();
}

impl pallet_grandpa::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type WeightInfo = weights::pallet_grandpa::WeightInfo<Runtime>;

    type MaxAuthorities = MaxActiveValidators;
    type MaxNominators = MaxElectingVoters;
    type MaxSetIdSessionEntries = MaxSetIdSessionEntries;

    type KeyOwnerProof = <Historical as KeyOwnerProofSystem<(KeyTypeId, GrandpaId)>>::Proof;

    type EquivocationReportSystem =
        pallet_grandpa::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
}

/// Submits a transaction with the node's public and signature type. Adheres
/// to the signed extension format of the chain.
impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime
where
    RuntimeCall: From<LocalCall>,
{
    fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
        call: RuntimeCall,
        public: <Signature as Verify>::Signer,
        account: AccountId,
        nonce: <Runtime as frame_system::Config>::Nonce,
    ) -> Option<(
        RuntimeCall,
        <UncheckedExtrinsic as ExtrinsicT>::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::<u64>()
            // 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::<Runtime>::new(),
            frame_system::CheckSpecVersion::<Runtime>::new(),
            frame_system::CheckTxVersion::<Runtime>::new(),
            frame_system::CheckGenesis::<Runtime>::new(),
            frame_system::CheckMortality::<Runtime>::from(generic::Era::mortal(
                period,
                current_block,
            )),
            frame_system::CheckNonce::<Runtime>::from(nonce),
            frame_system::CheckWeight::<Runtime>::new(),
            pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
        );
        let raw_payload = SignedPayload::new(call, extra)
            .map_err(|e| {
                log::warn!(target: LOG_TARGET, "🫢 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 = <Runtime as frame_system::Config>::Lookup::unlookup(account);
        Some((call, (address, signature, extra)))
    }
}

impl frame_system::offchain::SigningTypes for Runtime {
    type Public = <Signature as Verify>::Signer;
    type Signature = Signature;
}

impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime
where
    RuntimeCall: From<C>,
{
    type Extrinsic = UncheckedExtrinsic;
    type OverarchingCall = RuntimeCall;
}

impl pallet_utility::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type RuntimeCall = RuntimeCall;
    type PalletsOrigin = OriginCaller;
    type WeightInfo = weights::pallet_utility::WeightInfo<Runtime>;
}

parameter_types! {
    pub const ProxyDepositBase: Balance = deposit(1, 8);
    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,
    Transfer = 1,
    Staking = 2,
    CancelProxy = 3,
    IdentityJudgement = 4,
    NominationPools = 5,
}

impl Default for ProxyType {
    fn default() -> Self {
        Self::Any
    }
}

impl InstanceFilter<RuntimeCall> for ProxyType {
    fn filter(&self, c: &RuntimeCall) -> bool {
        match self {
            ProxyType::Any => true,
            ProxyType::Transfer => matches!(c, RuntimeCall::Balances { .. }),
            ProxyType::Staking => matches!(
                c,
                RuntimeCall::Staking { .. }
                    | RuntimeCall::Session { .. }
                    | RuntimeCall::Utility { .. }
                    | RuntimeCall::VoterList { .. }
            ),
            ProxyType::IdentityJudgement => matches!(
                c,
                RuntimeCall::Identity(pallet_identity::Call::provide_judgement { .. })
                    | RuntimeCall::Utility { .. }
            ),
            ProxyType::CancelProxy => matches!(
                c,
                RuntimeCall::Proxy(pallet_proxy::Call::reject_announcement { .. })
                    | RuntimeCall::Utility { .. }
            ),
            ProxyType::NominationPools => matches!(
                c,
                RuntimeCall::NominationPools { .. } | RuntimeCall::Utility { .. }
            ),
        }
    }

    fn is_superset(&self, o: &Self) -> bool {
        match (self, o) {
            (x, y) if x == y => true,
            (ProxyType::Any, _) => true,
            (_, ProxyType::Any) => false,
            (ProxyType::Transfer, _) => true,
            _ => false,
        }
    }
}

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

parameter_types! {
    pub const PoolsPalletId: PalletId = PalletId(*b"py/nopls");
    pub const MaxPointsToBalance: u8 = 10;
}

impl ghost_nomination_pools::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type Currency = Balances;
    type RuntimeFreezeReason = RuntimeFreezeReason;
    type RewardCounter = FixedU128;
    type BalanceToU256 = runtime_common::BalanceToU256;
    type U256ToBalance = runtime_common::U256ToBalance;
    type Staking = Staking;
    type PostUnbondingPoolsWindow = frame_support::traits::ConstU32<4>;
    type MaxMetadataLen = frame_support::traits::ConstU32<128>;
    type MaxUnbonding = <Self as pallet_staking::Config>::MaxUnlockingChunks;
    type PalletId = PoolsPalletId;
    type MaxPointsToBalance = MaxPointsToBalance;
    type AdminOrigin = EnsureRoot<Self::AccountId>;
    type WeightInfo = (); // TODO: weights::ghost_nomination_pools::WeightInfo<Runtime>;
}

impl ghost_networks::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type NetworkId = NetworkId;
    type Currency = Balances;
    type MaxNetworks = ConstU32<30>;

    type RegisterOrigin = EnsureRoot<Self::AccountId>;
    type UpdateOrigin = EnsureRoot<Self::AccountId>;
    type RemoveOrigin = EnsureRoot<Self::AccountId>;

    type WeightInfo = ();
}

parameter_types! {
    pub MaximumWithdrawAmount: Balance = 500 * CSPR;
    pub VestingBlocks: u32 = 10 * WEEKS;
}

impl ghost_governance::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;

    type Currency = Balances;
    type NetworkDataHandler = GhostNetworks;
    type MinimumDonation = ConstU128<{ 6_900 * STRH }>;
    type MaxProofDepth = ConstU32<20>;

    type WeightInfo = ();
}

impl ghost_sudo::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;
    type RuntimeCall = RuntimeCall;
    type WeightInfo = weights::ghost_sudo::WeightInfo<Runtime>;
}

parameter_types! {
    pub WeaverUnsignedPriority: TransactionPriority =
    	Perbill::from_percent(30) * TransactionPriority::MAX;

    pub ExodusUnsignedPriority: TransactionPriority =
    	Perbill::from_percent(90) * TransactionPriority::MAX;

    pub MaxAuthoritiesChunks: u32 = 32;
    pub WeavingDelay: u64 = 50;
    pub AttestationDelay: u64 = 25;
    pub ExodusUnsignedLongevity: u64 = 10;

    pub ExodusDkgRoundPeriod: u64 = 50;
    pub ExodusRemovalLimit: u32 = 64;
    pub ExodusMaxCursorLen: u32 = 100;
}

impl ghost_weaver::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;

    type Currency = Balances;
    type AuthorityId = GhostWeaverId;
    type BlockNumberProvider = System;
    type NetworkDataHandler = GhostNetworks;

    type MaxAuthorities = MaxActiveValidators;
    type MaxAuthoritiesChunks = MaxAuthoritiesChunks;

    type WeavingDelay = WeavingDelay;
    type AttestationDelay = AttestationDelay;
    type UnsignedPriority = WeaverUnsignedPriority;

    type WeightInfo = ();
}

impl ghost_exodus::Config for Runtime {
    type RuntimeEvent = RuntimeEvent;

    type AuthorityId = GhostExodusId;
    type ValidatorSet = Historical;
    type Currency = Balances;
    type NetworkDataHandler = GhostNetworks;
    type BlockNumberProvider = System;
    type DisabledValidators = Session;

    type UnsignedLongevity = ExodusUnsignedLongevity;
    type UnsignedPriority = ExodusUnsignedPriority;
    type MaxAuthorities = MaxActiveValidators;
    type MaxAuthoritiesChunks = MaxAuthoritiesChunks;

    type DkgRoundPeriod = ExodusDkgRoundPeriod;
    type RemovalLimit = ExodusRemovalLimit;
    type MaxCursorLen = ExodusMaxCursorLen;

    type WeightInfo = ();
}

construct_runtime! {
    pub enum Runtime
    {
        // Basic stuff; balances is uncallable initially.
        System: frame_system = 0,
        Scheduler: pallet_scheduler = 2,
        Preimage: pallet_preimage = 10,

        // Babe must be before session.
        Babe: pallet_babe = 1,

        Timestamp: pallet_timestamp = 3,
        Balances: pallet_balances = 5,
        TransactionPayment: pallet_transaction_payment = 28,

        // Consensus support.
        // Authorship must be before session in order to note authoer in the
        // correct session and era for im-online and staking.
        Authorship: pallet_authorship = 6,
        Staking: pallet_staking = 7,
        Offences: pallet_offences = 8,
        Historical: session_historical = 29,

        Session: pallet_session = 9,
        Grandpa: pallet_grandpa = 11,
        AuthorityDiscovery: pallet_authority_discovery = 12,
        GhostSudo: ghost_sudo = 13,

        // Governance stuff.
        Treasury: pallet_treasury = 19,
        Utility: pallet_utility = 24,
        Identity: pallet_identity = 25,
        Proxy: pallet_proxy = 26,

        // Election pallet. Only works with staking, but places here to
        // maintain indicies.
        ElectionProviderMultiPhase: pallet_election_provider_multi_phase = 32,

        // Provides a semi-sorted list of nominators for staking.
        VoterList: pallet_bags_list::<Instance1> = 33,
        NominationPools: ghost_nomination_pools = 34,

        // Ghosts stuff. Start indicies at 50 to leave room.
        GhostNetworks: ghost_networks = 50,
        GhostGovernance: ghost_governance = 51,
        GhostWeaver: ghost_weaver = 52,
        GhostExodus: ghost_exodus = 53,
    }
}

/// The address format for describing accounts.
pub type Address = sp_runtime::MultiAddress<AccountId, ()>;
/// Block header type as expected by this runtime.
pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
/// Block type as expected by this runtime.
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
/// A block signed with a Justification.
pub type SignedBlock = generic::SignedBlock<Block>;
/// `BlockId` type as expected by this runtime.
pub type BlockId = generic::BlockId<Block>;
/// The `SignedExtension` to the basic transaction logic.
pub type SignedExtra = (
    frame_system::CheckNonZeroSender<Runtime>,
    frame_system::CheckSpecVersion<Runtime>,
    frame_system::CheckTxVersion<Runtime>,
    frame_system::CheckGenesis<Runtime>,
    frame_system::CheckMortality<Runtime>,
    frame_system::CheckNonce<Runtime>,
    frame_system::CheckWeight<Runtime>,
    pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
);

/// All migrations that will run on the next runtime upgrade.
/// Should be cleared after release.
pub type Migrations = ();

/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic =
    generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;

/// Executive: handles dispatch to the various modules.
pub type Executive = frame_executive::Executive<
    Runtime,
    Block,
    frame_system::ChainContext<Runtime>,
    Runtime,
    AllPalletsWithSystem,
    Migrations,
>;

/// The payload being signed in transaction.
pub type SignedPayload = generic::SignedPayload<RuntimeCall, SignedExtra>;

#[cfg(feature = "runtime-benchmarks")]
mod benches {
    frame_benchmarking::define_benchmarks!(
        // Ghosts
        // Note: Make sure to prefix these with `runtime_common::` so
        // that path resolves correctly in the generated file.

        // Substrate
        [pallet_babe, Babe]
        [pallet_bags_list, VoterList]
        [pallet_balances, Balances]
        [frame_benchmarking::baseline, Baseline::<Runtime>]
        [pallet_election_provider_multi_phase, ElectionProviderMultiPhase]
        [frame_election_provider_support, ElectionProviderBench::<Runtime>]
        [pallet_grandpa, Grandpa]
        [pallet_identity, Identity]
        [pallet_offences, OffencesBench::<Runtime>]
        [pallet_preimage, Preimage]
        [pallet_proxy, Proxy]
        [pallet_scheduler, Scheduler]
        [pallet_session, SessionBench::<Runtime>]
        [pallet_staking, Staking]
        [frame_system, SystemBench::<Runtime>]
        [pallet_timestamp, Timestamp]
        [pallet_treasury, Treasury]
        [pallet_utility, Utility]

        // Ghosts
        [ghost_nomination_pools, NominationPoolsBench::<Runtime>]
        [ghost_networks, GhostNetworks]
        [ghost_governance, GhostGovernance]
        [ghost_weaver, GhostWeaver]
        [ghost_exodus, GhostExodus]
        [ghost_sudo, GhostSudo]
    );
}

sp_api::impl_runtime_apis! {
    impl sp_api::Core<Block> for Runtime {
        fn version() -> RuntimeVersion {
            VERSION
        }

        fn execute_block(block: Block) {
            Executive::execute_block(block);
        }

        fn initialize_block(header: &<Block as BlockT>::Header) -> sp_runtime::ExtrinsicInclusionMode {
            Executive::initialize_block(header)
        }
    }

    impl sp_api::Metadata<Block> for Runtime {
        fn metadata() -> OpaqueMetadata {
            OpaqueMetadata::new(Runtime::metadata().into())
        }

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

        fn metadata_versions() -> sp_std::vec::Vec<u32> {
            Runtime::metadata_versions()
        }
    }

    impl block_builder_api::BlockBuilder<Block> for Runtime {
        fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
            Executive::apply_extrinsic(extrinsic)
        }

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

        fn inherent_extrinsics(data: inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
            data.create_extrinsics()
        }

        fn check_inherents(
            block: Block,
            data: inherents::InherentData,
        ) -> inherents::CheckInherentsResult {
            data.check_extrinsics(&block)
        }
    }

    impl ghost_nomination_pools_runtime_api::NominationPoolsApi<
        Block,
        AccountId,
        Balance,
    > for Runtime {
        fn pending_rewards(member: AccountId) -> Balance {
            NominationPools::api_pending_rewards(member).unwrap_or_default()
        }

        fn points_to_balance(pool_id: ghost_nomination_pools::PoolId, points: Balance) -> Balance {
            NominationPools::api_points_to_balance(pool_id, points)
        }

        fn balance_to_points(pool_id: ghost_nomination_pools::PoolId, new_funds: Balance) -> Balance {
            NominationPools::api_balance_to_points(pool_id, new_funds)
        }
    }

    impl pallet_staking_runtime_api::StakingApi<Block, Balance, AccountId> for Runtime {
        fn nominations_quota(balance: Balance) -> u32 {
            Staking::api_nominations_quota(balance)
        }

        fn eras_stakers_page_count(era: sp_staking::EraIndex, account: AccountId) -> sp_staking::Page {
            Staking::api_eras_stakers_page_count(era, account)
        }

        fn pending_rewards(era: sp_staking::EraIndex, account: AccountId) -> bool {
            Staking::api_pending_rewards(era, account)
        }
    }

    impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
        fn validate_transaction(
            source: TransactionSource,
            tx: <Block as BlockT>::Extrinsic,
            block_hash: <Block as BlockT>::Hash,
        ) -> TransactionValidity {
            Executive::validate_transaction(source, tx, block_hash)
        }
    }

    impl offchain_primitives::OffchainWorkerApi<Block> for Runtime {
        fn offchain_worker(header: &<Block as BlockT>::Header) {
            Executive::offchain_worker(header)
        }
    }

    impl fg_primitives::GrandpaApi<Block> 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<
                <Block as BlockT>::Hash,
                sp_runtime::traits::NumberFor<Block>,
            >,
            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<fg_primitives::OpaqueKeyOwnershipProof> {
            use codec::Encode;

            Historical::prove((fg_primitives::KEY_TYPE, authority_id))
                .map(|p| p.encode())
                .map(fg_primitives::OpaqueKeyOwnershipProof::new)
        }
    }

    impl babe_primitives::BabeApi<Block> for Runtime {
        fn configuration() -> babe_primitives::BabeConfiguration {
            let epoch_config = Babe::epoch_config().unwrap_or(BABE_GENESIS_EPOCH_CONFIG);
            babe_primitives::BabeConfiguration {
                slot_duration: Babe::slot_duration(),
                epoch_length: EpochDuration::get(),
                c: epoch_config.c,
                authorities: Babe::authorities().to_vec(),
                randomness: Babe::randomness(),
                allowed_slots: 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<babe_primitives::OpaqueKeyOwnershipProof> {
            use 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<<Block as BlockT>::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<Block> for Runtime {
        fn authorities() -> Vec<AuthorityDiscoveryId> {
            AuthorityDiscovery::authorities()
        }
    }

    impl sp_session::SessionKeys<Block> for Runtime {
        fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
            opaque::SessionKeys::generate(seed)
        }

        fn decode_session_keys(encoded: Vec<u8>) -> Option<Vec<(Vec<u8>, sp_core::crypto::KeyTypeId)>> {
            opaque::SessionKeys::decode_into_raw_public_keys(&encoded)
        }
    }

    impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> 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: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {
            TransactionPayment::query_info(uxt, len)
        }

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

        fn query_weight_to_fee(weight: Weight) -> Balance {
            TransactionPayment::weight_to_fee(weight)
        }

        fn query_length_to_fee(length: u32) -> Balance {
            TransactionPayment::length_to_fee(length)
        }
    }

    impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentCallApi<Block, Balance, RuntimeCall> for Runtime {
        fn query_call_info(call: RuntimeCall, len: u32) -> RuntimeDispatchInfo<Balance> {
            TransactionPayment::query_call_info(call, len)
        }

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

        fn query_weight_to_fee(weight: Weight) -> Balance {
            TransactionPayment::weight_to_fee(weight)
        }

        fn query_length_to_fee(length: u32) -> Balance {
            TransactionPayment::length_to_fee(length)
        }
    }

    impl sp_genesis_builder::GenesisBuilder<Block> for Runtime {
        fn build_state(json: Vec<u8>) -> sp_genesis_builder::Result {
            build_state::<RuntimeGenesisConfig>(json)
        }

        fn get_preset(id: &Option<PresetId>) -> Option<Vec<u8>> {
            get_preset::<RuntimeGenesisConfig>(id, &genesis_config_presets::get_preset)
        }

        fn preset_names() -> Vec<PresetId> {
            genesis_config_presets::preset_names()
        }
    }

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

        fn execute_block(
            block: Block,
            state_root_check: bool,
            signature_check: bool,
            select: frame_try_runtime::TryStateSelect,
        ) -> Weight {
            log::info!(
                target: LOG_TARGET,
                "😏 try-runtime::executing block {:?} / root checks: {:?} / try-state-select: {:?}",
                block.header.hash(),
                state_root_check,
                select,
            );
            Executive::try_executive_block(block, state_root_check, signature_check, select).unwrap()
        }
    }

    #[cfg(feature = "runtime-benchmarks")]
    impl frame_benchmarking::Benchmark<Block> for Runtime {
        fn benchmark_metadata(extra: bool) -> (
            Vec<frame_benchmarking::BenchmarkList>,
            Vec<frame_support::traits::StorageInfo>,
        ) {
            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 ghost_nomination_pools_benchmarking::Pallet as NominationPoolsBench;
            use frame_system_benchmarking::Pallet as SystemBench;
            use frame_benchmarking::baseline::Pallet as Baseline;

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

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

        #[allow(non_local_definitions)]
        fn dispatch_benchmark(
            config: frame_benchmarking::BenchmarkConfig,
        ) -> Result<
            Vec<frame_benchmarking::BenchmarkBatch>,
            sp_runtime::RuntimeString
        > {
            use frame_support::traits::WhitelistedStorageKeys;
            use frame_benchmarking::{Benchmarking, BenchmarkBatch};
            use sp_storage::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 ghost_nomination_pools_benchmarking::Pallet as NominationPoolsBench;
            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 ghost_nomination_pools_benchmarking::Config for Runtime {}
            impl frame_system_benchmarking::Config for Runtime {}
            impl frame_benchmarking::baseline::Config for Runtime {}

            let mut whitelist: Vec<TrackedStorageKey> = AllPalletsWithSystem::whitelisted_storage_keys();
            let treasury_key = frame_system::Account::<Runtime>::hashed_key_for(Treasury::account_id());
            whitelist.push(treasury_key.to_vec().into());

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

            add_benchmarks!(params, batches);

            Ok(batches)
        }
    }
}

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

    #[test]
    fn payout_weight_portion() {
        use pallet_staking::WeightInfo;
        let payout_weight =
            <Runtime as pallet_staking::Config>::WeightInfo::payout_stakers_alive_staked(
                MaxExposurePageSize::get(),
            )
            .ref_time() as f64;
        let block_weight = BlockWeights::get().max_block.ref_time() 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]
    fn block_cost() {
        let max_block_weight = BlockWeights::get().max_block;
        let raw_fee = WeightToFee::weight_to_fee(&max_block_weight);

        let fee_with_multiplier = |m: Multiplier| {
            println!(
				"Full Block weight == {} // multiplier: {:?} // WeightToFee(full_block) == {} plank",
				max_block_weight,
				m,
				m.saturating_mul_int(raw_fee).separated_string(),
			);
        };
        fee_with_multiplier(MinimumMultiplier::get());
        fee_with_multiplier(Multiplier::from_rational(1, 2));
        fee_with_multiplier(Multiplier::from_u32(1));
        fee_with_multiplier(Multiplier::from_u32(2));
    }

    #[test]
    fn transfer_cost_min_multiplier() {
        let min_multiplier = MinimumMultiplier::get();
        let call = pallet_balances::Call::<Runtime>::transfer_keep_alive {
            dest: Charlie.to_account_id().into(),
            value: Default::default(),
        };
        let info = call.get_dispatch_info();
        println!("call = {:?} / info = {:?}", call, info);
        // convert to runtime call.
        let call = RuntimeCall::Balances(call);
        let extra: SignedExtra = (
            frame_system::CheckNonZeroSender::<Runtime>::new(),
            frame_system::CheckSpecVersion::<Runtime>::new(),
            frame_system::CheckTxVersion::<Runtime>::new(),
            frame_system::CheckGenesis::<Runtime>::new(),
            frame_system::CheckMortality::<Runtime>::from(generic::Era::immortal()),
            frame_system::CheckNonce::<Runtime>::from(1),
            frame_system::CheckWeight::<Runtime>::new(),
            pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(0),
        );
        let uxt = UncheckedExtrinsic {
            function: call,
            signature: Some((
                MultiAddress::Id(Alice.to_account_id()),
                MultiSignature::Sr25519(Alice.sign(b"foo")),
                extra,
            )),
        };
        let len = uxt.encoded_size();

        let mut ext = sp_io::TestExternalities::new_empty();
        let mut test_with_multiplier = |m: Multiplier| {
            ext.execute_with(|| {
                pallet_transaction_payment::NextFeeMultiplier::<Runtime>::put(m);
                let fee = TransactionPayment::query_fee_details(uxt.clone(), len as u32);
                println!(
                    "multiplier = {:?} // fee details = {:?} // final fee = {:?}",
                    pallet_transaction_payment::NextFeeMultiplier::<Runtime>::get(),
                    fee,
                    fee.final_fee().separated_string(),
                );
            });
        };

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

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

        // assuming we want around 3k candidates and 300 active validators.
        let all_targets: u32 = 400;
        let desired: u32 = 300;
        let weight_with = |active| {
            <Runtime as pallet_election_provider_multi_phase::Config>::WeightInfo::submit_unsigned(
                active,
                all_targets,
                active,
                desired,
            )
        };

        let mut active = target_voters;
        while weight_with(active).all_lte(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() {
        use sp_runtime::traits::Convert;

        let items_count: usize = 1;
        let bytes_count = 1024 * 1024; // 1 MB worth of bytes

        type SignedDepositBaseConfig = <Runtime as pallet_election_provider_multi_phase::Config>::SignedDepositBase;

        let base_deposit = <SignedDepositBaseConfig as Convert<usize, Balance>>::convert(items_count);
        let deposit = base_deposit + (SignedDepositByte::get() * bytes_count);

        // ensure this number does not change, or that it is checked after each change.
        // a 1 MB solution should take (2 + 1) CSPRs of deposit.
        assert_eq_error_rate!(deposit, 2 * CSPR, CSPR);
    }
}

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

    #[test]
    fn call_size() {
        RuntimeCall::assert_size_under(256)
    }
}

#[cfg(test)]
mod multiplier_tests {
    use super::*;
    use frame_support::{dispatch::DispatchInfo, traits::OnFinalize};
    use runtime_common::{MinimumMultiplier, TargetBlockFullness};
    use separator::Separatable;
    use sp_runtime::traits::Convert;

    fn run_with_system_weight<F>(w: Weight, mut assertions: F)
    where
        F: FnMut() -> (),
    {
        let t = frame_system::GenesisConfig::<Runtime>::default()
            .build_storage()
            .unwrap();

        let mut ext = sp_io::TestExternalities::new(t);

        ext.execute_with(|| {
            System::set_block_consumed_resources(w, 0);
            assertions()
        });
    }

    #[test]
    fn multiplier_can_grow_from_zero() {
        let minimum_multiplier = MinimumMultiplier::get();
        let target = TargetBlockFullness::get()
            * BlockWeights::get()
                .get(DispatchClass::Normal)
                .max_total
                .unwrap();
        // if the min is too small, then this will not change, and we are doomed forever.
        // the weight is 1/100th bigger than target.
        run_with_system_weight(target.saturating_mul(101) / 100, || {
            let next = SlowAdjustingFeeUpdate::<Runtime>::convert(minimum_multiplier);
            assert!(
                next > minimum_multiplier,
                "{:?} !>= {:?}",
                next,
                minimum_multiplier
            );
        })
    }

    #[test]
    #[ignore]
    fn multiplier_growth_simulator() {
        // assume the multiplier is initially set to its minimum. We update it with values twice the
        //target (target is 25%, thus 50%) and we see at which point it reaches 1.
        let mut multiplier = MinimumMultiplier::get();
        let block_weight = BlockWeights::get()
            .get(DispatchClass::Normal)
            .max_total
            .unwrap();
        let mut blocks = 0;
        let mut fees_paid = 0;

        frame_system::Pallet::<Runtime>::set_block_consumed_resources(Weight::MAX, 0);
        let info = DispatchInfo {
            weight: Weight::MAX,
            ..Default::default()
        };

        let t = frame_system::GenesisConfig::<Runtime>::default()
            .build_storage()
            .unwrap();

        let mut ext = sp_io::TestExternalities::new(t);

        // set the minimum
        ext.execute_with(|| {
            pallet_transaction_payment::NextFeeMultiplier::<Runtime>::set(MinimumMultiplier::get());
        });

        while multiplier <= Multiplier::from_u32(1) {
            ext.execute_with(|| {
                // imagine this tx was called.
                let fee = TransactionPayment::compute_fee(0, &info, 0);
                fees_paid += fee;

                // this will update the multiplier.
                System::set_block_consumed_resources(block_weight, 0);
                TransactionPayment::on_finalize(1);
                let next = TransactionPayment::next_fee_multiplier();

                assert!(next > multiplier, "{:?} !>= {:?}", next, multiplier);
                multiplier = next;

                println!(
                    "block = {} / multiplier {:?} / fee = {:?} / fess so far {:?}",
                    blocks,
                    multiplier,
                    fee.separated_string(),
                    fees_paid.separated_string()
                );
            });
            blocks += 1;
        }
    }

    #[test]
    #[ignore]
    fn multiplier_cool_down_simulator() {
        // assume the multiplier is initially set to its minimum. We update it with values twice the
        //target (target is 25%, thus 50%) and we see at which point it reaches 1.
        let mut multiplier = Multiplier::from_u32(2);
        let mut blocks = 0;

        let t = frame_system::GenesisConfig::<Runtime>::default()
            .build_storage()
            .unwrap();

        let mut ext = sp_io::TestExternalities::new(t);

        // set the minimum
        ext.execute_with(|| {
            pallet_transaction_payment::NextFeeMultiplier::<Runtime>::set(multiplier);
        });

        while multiplier > Multiplier::from_u32(0) {
            ext.execute_with(|| {
                // this will update the multiplier.
                TransactionPayment::on_finalize(1);
                let next = TransactionPayment::next_fee_multiplier();

                assert!(next < multiplier, "{:?} !>= {:?}", next, multiplier);
                multiplier = next;

                println!("block = {} / multiplier {:?}", blocks, multiplier);
            });
            blocks += 1;
        }
    }
}