// Copyright 2019-2022 PureStake Inc.

// This file is part of Moonbeam.

// Moonbeam 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.

// Moonbeam 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 Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

//! The Moonbeam Runtime.

//!

//! Primary features of this runtime include:

//! * Ethereum compatibility

//! * Moonbeam tokenomics

#![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"]

// Make the WASM binary available.

#[cfg(feature = "std")]

include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

use account::AccountId20;

use cumulus_pallet_parachain_system::{

	RelayChainStateProof, RelayStateProof, RelaychainDataProvider, ValidationData,

};

use fp_rpc::TransactionStatus;

use cumulus_primitives_core::{relay_chain, AggregateMessageOrigin};

#[cfg(feature = "std")]

pub use fp_evm::GenesisAccount;

pub use frame_support::traits::Get;

use frame_support::{

	construct_runtime,

	dispatch::{DispatchClass, GetDispatchInfo, PostDispatchInfo},

	ensure,

	pallet_prelude::DispatchResult,

	parameter_types,

	traits::{

		fungible::{Balanced, Credit, HoldConsideration, Inspect},

		tokens::imbalance::ResolveTo,

		tokens::{PayFromAccount, UnityAssetBalanceConversion},

		ConstBool, ConstU128, ConstU16, ConstU32, ConstU64, ConstU8, Contains, EitherOfDiverse,

		EqualPrivilegeOnly, Imbalance, InstanceFilter, LinearStoragePrice, OnFinalize,

		OnUnbalanced,

	},

	weights::{

		constants::{RocksDbWeight, WEIGHT_REF_TIME_PER_SECOND},

		ConstantMultiplier, Weight, WeightToFeeCoefficient, WeightToFeeCoefficients,

		WeightToFeePolynomial,

	},

	PalletId,

};

use frame_system::{EnsureRoot, EnsureSigned};

pub use moonbeam_core_primitives::{

	AccountId, AccountIndex, Address, AssetId, Balance, BlockNumber, DigestItem, Hash, Header,

	Index, Signature,

};

use moonbeam_rpc_primitives_txpool::TxPoolResponse;

use moonbeam_runtime_common::{

	timestamp::{ConsensusHookWrapperForRelayTimestamp, RelayTimestamp},

	weights as moonbeam_weights,

};

use pallet_ethereum::Call::transact;

use pallet_ethereum::{PostLogContent, Transaction as EthereumTransaction};

use pallet_evm::{

	Account as EVMAccount, EVMFungibleAdapter, EnsureAddressNever, EnsureAddressRoot,

	FeeCalculator, GasWeightMapping, IdentityAddressMapping,

	OnChargeEVMTransaction as OnChargeEVMTransactionT, Runner,

};

pub use pallet_parachain_staking::{weights::WeightInfo, InflationInfo, Range};

use pallet_transaction_payment::{FungibleAdapter, Multiplier, TargetedFeeAdjustment};

use pallet_treasury::TreasuryAccountId;

use parity_scale_codec::{Decode, Encode, MaxEncodedLen};

use scale_info::TypeInfo;

use serde::{Deserialize, Serialize};

use smallvec::smallvec;

use sp_api::impl_runtime_apis;

use sp_consensus_slots::Slot;

use sp_core::{OpaqueMetadata, H160, H256, U256};

use sp_runtime::{

	create_runtime_str, generic, impl_opaque_keys,

	traits::{

		BlakeTwo256, Block as BlockT, DispatchInfoOf, Dispatchable, IdentityLookup,

		PostDispatchInfoOf, UniqueSaturatedInto, Zero,

	},

	transaction_validity::{

		InvalidTransaction, TransactionSource, TransactionValidity, TransactionValidityError,

	},

	ApplyExtrinsicResult, DispatchErrorWithPostInfo, FixedPointNumber, Perbill, Permill,

	Perquintill, SaturatedConversion,

};

use sp_std::{convert::TryFrom, prelude::*};

#[cfg(feature = "std")]

use sp_version::NativeVersion;

use sp_version::RuntimeVersion;

use nimbus_primitives::CanAuthor;

mod migrations;

mod precompiles;

pub use precompiles::{

	MoonbeamPrecompiles, PrecompileName, FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

};

#[cfg(any(feature = "std", test))]

pub use sp_runtime::BuildStorage;

pub type Precompiles = MoonbeamPrecompiles<Runtime>;

pub mod asset_config;

pub mod governance;

pub mod xcm_config;

use governance::councils::*;

/// GLMR, the native token, uses 18 decimals of precision.

pub mod currency {

	use super::Balance;

	// Provide a common factor between runtimes based on a supply of 10_000_000 tokens.

	pub const SUPPLY_FACTOR: Balance = 100;

	pub const WEI: Balance = 1;

	pub const KILOWEI: Balance = 1_000;

	pub const MEGAWEI: Balance = 1_000_000;

	pub const GIGAWEI: Balance = 1_000_000_000;

	pub const MICROGLMR: Balance = 1_000_000_000_000;

	pub const MILLIGLMR: Balance = 1_000_000_000_000_000;

	pub const GLMR: Balance = 1_000_000_000_000_000_000;

	pub const KILOGLMR: Balance = 1_000_000_000_000_000_000_000;

	pub const TRANSACTION_BYTE_FEE: Balance = 1 * GIGAWEI * SUPPLY_FACTOR;

	pub const STORAGE_BYTE_FEE: Balance = 100 * MICROGLMR * SUPPLY_FACTOR;

	pub const WEIGHT_FEE: Balance = 50 * KILOWEI * SUPPLY_FACTOR;

}

/// Maximum weight per block

pub const MAXIMUM_BLOCK_WEIGHT: Weight = Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, u64::MAX)

	.saturating_div(2)

	.set_proof_size(relay_chain::MAX_POV_SIZE as u64);

pub const MILLISECS_PER_BLOCK: u64 = 6_000;

pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);

pub const HOURS: BlockNumber = MINUTES * 60;

pub const DAYS: BlockNumber = HOURS * 24;

pub const WEEKS: BlockNumber = DAYS * 7;

pub const MONTHS: BlockNumber = DAYS * 30;

/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know

/// the specifics of the runtime. They can then be made to be agnostic over specific formats

/// of data like extrinsics, allowing for them to continue syncing the network through upgrades

/// to even the core datastructures.

pub mod opaque {

	use super::*;

	pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;

	pub type Block = generic::Block<Header, UncheckedExtrinsic>;

}

/// This runtime version.

/// The spec_version is composed of 2x2 digits. The first 2 digits represent major changes

/// that can't be skipped, such as data migration upgrades. The last 2 digits represent minor

/// changes which can be skipped.

#[sp_version::runtime_version]

pub const VERSION: RuntimeVersion = RuntimeVersion {

	spec_name: create_runtime_str!("moonbeam"),

	impl_name: create_runtime_str!("moonbeam"),

	authoring_version: 3,

	spec_version: 3100,

	impl_version: 0,

	apis: RUNTIME_API_VERSIONS,

	transaction_version: 2,

	state_version: 0,

};

/// The version information used to identify this runtime when compiled natively.

#[cfg(feature = "std")]

const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);

pub const NORMAL_WEIGHT: Weight = MAXIMUM_BLOCK_WEIGHT.saturating_mul(3).saturating_div(4);

// Here we assume Ethereum's base fee of 21000 gas and convert to weight, but we

// subtract roughly the cost of a balance transfer from it (about 1/3 the cost)

// and some cost to account for per-byte-fee.

// TODO: we should use benchmarking's overhead feature to measure this

pub const EXTRINSIC_BASE_WEIGHT: Weight = Weight::from_parts(10000 * WEIGHT_PER_GAS, 0);

pub struct RuntimeBlockWeights;

impl Get<frame_system::limits::BlockWeights> for RuntimeBlockWeights {

}

parameter_types! {

	pub const Version: RuntimeVersion = VERSION;

	/// We allow for 5 MB blocks.

	pub BlockLength: frame_system::limits::BlockLength = frame_system::limits::BlockLength

		::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);

}

impl frame_system::Config for Runtime {

	/// The identifier used to distinguish between accounts.

	type AccountId = AccountId;

	/// The aggregated dispatch type that is available for extrinsics.

	type RuntimeCall = RuntimeCall;

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

	type Lookup = IdentityLookup<AccountId>;

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

	type Nonce = Index;

	/// The index type for blocks.

	type Block = Block;

	/// The type for hashing blocks and tries.

	type Hash = Hash;

	/// The hashing algorithm used.

	type Hashing = BlakeTwo256;

	/// The ubiquitous event type.

	type RuntimeEvent = RuntimeEvent;

	/// The ubiquitous origin type.

	type RuntimeOrigin = RuntimeOrigin;

	/// The aggregated RuntimeTask type.

	type RuntimeTask = RuntimeTask;

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

	type BlockHashCount = ConstU32<256>;

	/// Maximum weight of each block. With a default weight system of 1byte == 1weight, 4mb is ok.

	type BlockWeights = RuntimeBlockWeights;

	/// Maximum size of all encoded transactions (in bytes) that are allowed in one block.

	type BlockLength = BlockLength;

	/// Runtime version.

	type Version = Version;

	type PalletInfo = PalletInfo;

	type AccountData = pallet_balances::AccountData<Balance>;

	type OnNewAccount = ();

	type OnKilledAccount = ();

	type DbWeight = RocksDbWeight;

	type BaseCallFilter = MaintenanceMode;

	type SystemWeightInfo = ();

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

	type SS58Prefix = ConstU16<1284>;

	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;

	type MaxConsumers = frame_support::traits::ConstU32<16>;

	type SingleBlockMigrations = ();

	type MultiBlockMigrator = ();

	type PreInherents = ();

	type PostInherents = ();

	type PostTransactions = ();

}

impl pallet_utility::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type RuntimeCall = RuntimeCall;

	type PalletsOrigin = OriginCaller;

	type WeightInfo = moonbeam_weights::pallet_utility::WeightInfo<Runtime>;

}

impl pallet_timestamp::Config for Runtime {

	/// A timestamp: milliseconds since the unix epoch.

	type Moment = u64;

	type OnTimestampSet = ();

	type MinimumPeriod = ConstU64<3000>;

	type WeightInfo = moonbeam_weights::pallet_timestamp::WeightInfo<Runtime>;

}

parameter_types! {

	pub const ExistentialDeposit: Balance = 0;

}

impl pallet_balances::Config for Runtime {

	type MaxReserves = ConstU32<50>;

	type ReserveIdentifier = [u8; 4];

	type MaxLocks = ConstU32<50>;

	/// The type for recording an account's balance.

	type Balance = Balance;

	/// The ubiquitous event type.

	type RuntimeEvent = RuntimeEvent;

	type DustRemoval = ();

	type ExistentialDeposit = ExistentialDeposit;

	type AccountStore = System;

	type FreezeIdentifier = ();

	type MaxFreezes = ConstU32<0>;

	type RuntimeHoldReason = RuntimeHoldReason;

	type RuntimeFreezeReason = RuntimeFreezeReason;

	type WeightInfo = moonbeam_weights::pallet_balances::WeightInfo<Runtime>;

}

pub struct DealWithFees<R>(sp_std::marker::PhantomData<R>);

impl<R> OnUnbalanced<Credit<R::AccountId, pallet_balances::Pallet<R>>> for DealWithFees<R>

where

	R: pallet_balances::Config + pallet_treasury::Config,

{

	// this seems to be called for substrate-based transactions

			// for fees, 80% are burned, 20% to the treasury

			// handle tip if there is one

	// this is called from pallet_evm for Ethereum-based transactions

	// (technically, it calls on_unbalanced, which calls this when non-zero)

}

pub struct LengthToFee;

impl WeightToFeePolynomial for LengthToFee {

	type Balance = Balance;

			WeightToFeeCoefficient {

				degree: 1,

				coeff_integer: currency::TRANSACTION_BYTE_FEE,

				negative: false,

			},

			WeightToFeeCoefficient {

				degree: 3,

				negative: false,

			},

		]

}

impl pallet_transaction_payment::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type OnChargeTransaction = FungibleAdapter<Balances, DealWithFees<Runtime>>;

	type OperationalFeeMultiplier = ConstU8<5>;

	type WeightToFee = ConstantMultiplier<Balance, ConstU128<{ currency::WEIGHT_FEE }>>;

	type LengthToFee = LengthToFee;

	type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Runtime>;

}

impl pallet_evm_chain_id::Config for Runtime {}

/// Current approximation of the gas/s consumption considering

/// EVM execution over compiled WASM (on 4.4Ghz CPU).

/// Given the 500ms Weight, from which 75% only are used for transactions,

/// the total EVM execution gas limit is: GAS_PER_SECOND * 0.500 * 0.75 ~= 15_000_000.

pub const GAS_PER_SECOND: u64 = 40_000_000;

/// Approximate ratio of the amount of Weight per Gas.

/// u64 works for approximations because Weight is a very small unit compared to gas.

pub const WEIGHT_PER_GAS: u64 = WEIGHT_REF_TIME_PER_SECOND / GAS_PER_SECOND;

parameter_types! {

	pub BlockGasLimit: U256

		= U256::from(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT.ref_time() / WEIGHT_PER_GAS);

	/// The portion of the `NORMAL_DISPATCH_RATIO` that we adjust the fees with. Blocks filled less

	/// than this will decrease the weight and more will increase.

	pub const TargetBlockFullness: Perquintill = Perquintill::from_percent(35);

	/// The adjustment variable of the runtime. Higher values will cause `TargetBlockFullness` to

	/// change the fees more rapidly. This low value causes changes to occur slowly over time.

	pub AdjustmentVariable: Multiplier = Multiplier::saturating_from_rational(4, 1_000);

	/// Minimum amount of the multiplier. This value cannot be too low. A test case should ensure

	/// that combined with `AdjustmentVariable`, we can recover from the minimum.

	/// See `multiplier_can_grow_from_zero` in integration_tests.rs.

	/// This value is currently only used by pallet-transaction-payment as an assertion that the

	/// next multiplier is always > min value.

	pub MinimumMultiplier: Multiplier = Multiplier::from(1u128);

	/// Maximum multiplier. We pick a value that is expensive but not impossibly so; it should act

	/// as a safety net.

	pub MaximumMultiplier: Multiplier = Multiplier::from(100_000u128);

	pub PrecompilesValue: MoonbeamPrecompiles<Runtime> = MoonbeamPrecompiles::<_>::new();

	pub WeightPerGas: Weight = Weight::from_parts(WEIGHT_PER_GAS, 0);

	/// The amount of gas per pov. A ratio of 4 if we convert ref_time to gas and we compare

	/// it with the pov_size for a block. E.g.

	/// ceil(

	///     (max_extrinsic.ref_time() / max_extrinsic.proof_size()) / WEIGHT_PER_GAS

	/// )

	/// We should re-check `xcm_config::Erc20XcmBridgeTransferGasLimit` when changing this value

	pub const GasLimitPovSizeRatio: u64 = 4;

	/// The amount of gas per storage (in bytes): BLOCK_GAS_LIMIT / BLOCK_STORAGE_LIMIT

	/// The current definition of BLOCK_STORAGE_LIMIT is 40 KB, resulting in a value of 366.

	pub GasLimitStorageGrowthRatio: u64 = 366;

}

pub struct TransactionPaymentAsGasPrice;

impl FeeCalculator for TransactionPaymentAsGasPrice {

}

/// Parameterized slow adjusting fee updated based on

/// https://w3f-research.readthedocs.io/en/latest/polkadot/overview/2-token-economics.html#-2.-slow-adjusting-mechanism // editorconfig-checker-disable-line

///

/// The adjustment algorithm boils down to:

///

/// diff = (previous_block_weight - target) / maximum_block_weight

/// next_multiplier = prev_multiplier * (1 + (v * diff) + ((v * diff)^2 / 2))

/// assert(next_multiplier > min)

///     where: v is AdjustmentVariable

///            target is TargetBlockFullness

///            min is MinimumMultiplier

pub type SlowAdjustingFeeUpdate<R> = TargetedFeeAdjustment<

	R,

	TargetBlockFullness,

	AdjustmentVariable,

	MinimumMultiplier,

	MaximumMultiplier,

>;

use frame_support::traits::FindAuthor;

//TODO It feels like this shold be able to work for any T: H160, but I tried for

// embarassingly long and couldn't figure that out.

/// The author inherent provides a AccountId20, but pallet evm needs an H160.

/// This simple adapter makes the conversion.

pub struct FindAuthorAdapter<Inner>(sp_std::marker::PhantomData<Inner>);

impl<Inner> FindAuthor<H160> for FindAuthorAdapter<Inner>

where

	Inner: FindAuthor<AccountId20>,

{

}

moonbeam_runtime_common::impl_on_charge_evm_transaction!();

impl pallet_evm::Config for Runtime {

	type FeeCalculator = TransactionPaymentAsGasPrice;

	type GasWeightMapping = pallet_evm::FixedGasWeightMapping<Self>;

	type WeightPerGas = WeightPerGas;

	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;

	type CallOrigin = EnsureAddressRoot<AccountId>;

	type WithdrawOrigin = EnsureAddressNever<AccountId>;

	type AddressMapping = IdentityAddressMapping;

	type Currency = Balances;

	type RuntimeEvent = RuntimeEvent;

	type Runner = pallet_evm::runner::stack::Runner<Self>;

	type PrecompilesType = MoonbeamPrecompiles<Self>;

	type PrecompilesValue = PrecompilesValue;

	type ChainId = EthereumChainId;

	type OnChargeTransaction = OnChargeEVMTransaction<DealWithFees<Runtime>>;

	type BlockGasLimit = BlockGasLimit;

	type FindAuthor = FindAuthorAdapter<AuthorInherent>;

	type OnCreate = ();

	type GasLimitPovSizeRatio = GasLimitPovSizeRatio;

	type SuicideQuickClearLimit = ConstU32<0>;

	type GasLimitStorageGrowthRatio = GasLimitStorageGrowthRatio;

	type Timestamp = RelayTimestamp;

	type WeightInfo = moonbeam_weights::pallet_evm::WeightInfo<Runtime>;

}

parameter_types! {

	pub MaximumSchedulerWeight: Weight = NORMAL_DISPATCH_RATIO * RuntimeBlockWeights::get().max_block;

}

impl pallet_scheduler::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type RuntimeOrigin = RuntimeOrigin;

	type PalletsOrigin = OriginCaller;

	type RuntimeCall = RuntimeCall;

	type MaximumWeight = MaximumSchedulerWeight;

	type ScheduleOrigin = EnsureRoot<AccountId>;

	type MaxScheduledPerBlock = ConstU32<50>;

	type WeightInfo = moonbeam_weights::pallet_scheduler::WeightInfo<Runtime>;

	type OriginPrivilegeCmp = EqualPrivilegeOnly;

	type Preimages = Preimage;

}

parameter_types! {

	pub const PreimageBaseDeposit: Balance = 5 * currency::GLMR * currency::SUPPLY_FACTOR ;

	pub const PreimageByteDeposit: Balance = currency::STORAGE_BYTE_FEE;

	pub const PreimageHoldReason: RuntimeHoldReason =

		RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);

}

impl pallet_preimage::Config for Runtime {

	type WeightInfo = moonbeam_weights::pallet_preimage::WeightInfo<Runtime>;

	type RuntimeEvent = RuntimeEvent;

	type Currency = Balances;

	type ManagerOrigin = EnsureRoot<AccountId>;

	type Consideration = HoldConsideration<

		AccountId,

		Balances,

		PreimageHoldReason,

		LinearStoragePrice<PreimageBaseDeposit, PreimageByteDeposit, Balance>,

	>;

}

parameter_types! {

	pub const ProposalBond: Permill = Permill::from_percent(5);

	pub const TreasuryId: PalletId = PalletId(*b"py/trsry");

	pub TreasuryAccount: AccountId = Treasury::account_id();

}

type TreasuryApproveOrigin = EitherOfDiverse<

	EnsureRoot<AccountId>,

	pallet_collective::EnsureProportionAtLeast<AccountId, TreasuryCouncilInstance, 3, 5>,

>;

type TreasuryRejectOrigin = EitherOfDiverse<

	EnsureRoot<AccountId>,

	pallet_collective::EnsureProportionMoreThan<AccountId, TreasuryCouncilInstance, 1, 2>,

>;

impl pallet_treasury::Config for Runtime {

	type PalletId = TreasuryId;

	type Currency = Balances;

	// At least three-fifths majority of the council is required (or root) to approve a proposal

	type ApproveOrigin = TreasuryApproveOrigin;

	// More than half of the council is required (or root) to reject a proposal

	type RejectOrigin = TreasuryRejectOrigin;

	type RuntimeEvent = RuntimeEvent;

	// If spending proposal rejected, transfer proposer bond to treasury

	type OnSlash = Treasury;

	type ProposalBond = ProposalBond;

	type ProposalBondMinimum = ConstU128<{ 1 * currency::GLMR * currency::SUPPLY_FACTOR }>;

	type SpendPeriod = ConstU32<{ 6 * DAYS }>;

	type Burn = ();

	type BurnDestination = ();

	type MaxApprovals = ConstU32<100>;

	type WeightInfo = moonbeam_weights::pallet_treasury::WeightInfo<Runtime>;

	type SpendFunds = ();

	type ProposalBondMaximum = ();

	#[cfg(not(feature = "runtime-benchmarks"))]

	type SpendOrigin = frame_support::traits::NeverEnsureOrigin<Balance>; // Disabled, no spending

	#[cfg(feature = "runtime-benchmarks")]

	type SpendOrigin =

		frame_system::EnsureWithSuccess<EnsureRoot<AccountId>, AccountId, benches::MaxBalance>;

	type AssetKind = ();

	type Beneficiary = AccountId;

	type BeneficiaryLookup = IdentityLookup<AccountId>;

	type Paymaster = PayFromAccount<Balances, TreasuryAccount>;

	type BalanceConverter = UnityAssetBalanceConversion;

	type PayoutPeriod = ConstU32<{ 30 * DAYS }>;

	#[cfg(feature = "runtime-benchmarks")]

	type BenchmarkHelper = BenchmarkHelper;

}

parameter_types! {

	pub const MaxSubAccounts: u32 = 100;

	pub const MaxAdditionalFields: u32 = 100;

	pub const MaxRegistrars: u32 = 20;

	pub const PendingUsernameExpiration: u32 = 7 * DAYS;

	pub const MaxSuffixLength: u32 = 7;

	pub const MaxUsernameLength: u32 = 32;

}

type IdentityForceOrigin =

	EitherOfDiverse<EnsureRoot<AccountId>, governance::custom_origins::GeneralAdmin>;

type IdentityRegistrarOrigin =

	EitherOfDiverse<EnsureRoot<AccountId>, governance::custom_origins::GeneralAdmin>;

impl pallet_identity::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type Currency = Balances;

	// Add one item in storage and take 258 bytes

	type BasicDeposit = ConstU128<{ currency::deposit(1, 258) }>;

	// Does not add any item to the storage but takes 1 bytes

	type ByteDeposit = ConstU128<{ currency::deposit(0, 1) }>;

	// Add one item in storage and take 53 bytes

	type SubAccountDeposit = ConstU128<{ currency::deposit(1, 53) }>;

	type MaxSubAccounts = MaxSubAccounts;

	type IdentityInformation = pallet_identity::legacy::IdentityInfo<MaxAdditionalFields>;

	type MaxRegistrars = MaxRegistrars;

	type Slashed = Treasury;

	type ForceOrigin = IdentityForceOrigin;

	type RegistrarOrigin = IdentityRegistrarOrigin;

	type OffchainSignature = Signature;

	type SigningPublicKey = <Signature as sp_runtime::traits::Verify>::Signer;

	type UsernameAuthorityOrigin = EnsureRoot<AccountId>;

	type PendingUsernameExpiration = PendingUsernameExpiration;

	type MaxSuffixLength = MaxSuffixLength;

	type MaxUsernameLength = MaxUsernameLength;

	type WeightInfo = moonbeam_weights::pallet_identity::WeightInfo<Runtime>;

}

pub struct TransactionConverter;

impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {

}

impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {

}

parameter_types! {

	pub const PostBlockAndTxnHashes: PostLogContent = PostLogContent::BlockAndTxnHashes;

}

impl pallet_ethereum::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;

	type PostLogContent = PostBlockAndTxnHashes;

	type ExtraDataLength = ConstU32<30>;

}

/// Maximum number of blocks simultaneously accepted by the Runtime, not yet included

/// into the relay chain.

const UNINCLUDED_SEGMENT_CAPACITY: u32 = 3;

/// How many parachain blocks are processed by the relay chain per parent. Limits the

/// number of blocks authored per slot.

const BLOCK_PROCESSING_VELOCITY: u32 = 1;

type ConsensusHook = pallet_async_backing::consensus_hook::FixedVelocityConsensusHook<

	Runtime,

	BLOCK_PROCESSING_VELOCITY,

	UNINCLUDED_SEGMENT_CAPACITY,

>;

impl cumulus_pallet_parachain_system::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type OnSystemEvent = ();

	type SelfParaId = ParachainInfo;

	type ReservedDmpWeight = ReservedDmpWeight;

	type OutboundXcmpMessageSource = XcmpQueue;

	type XcmpMessageHandler = XcmpQueue;

	type ReservedXcmpWeight = ReservedXcmpWeight;

	type CheckAssociatedRelayNumber =

		cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases;

	type ConsensusHook = ConsensusHookWrapperForRelayTimestamp<Runtime, ConsensusHook>;

	type DmpQueue = frame_support::traits::EnqueueWithOrigin<MessageQueue, RelayOrigin>;

	type WeightInfo = cumulus_pallet_parachain_system::weights::SubstrateWeight<Runtime>;

}

pub struct EthereumXcmEnsureProxy;

impl xcm_primitives::EnsureProxy<AccountId> for EthereumXcmEnsureProxy {

		// The EVM implicitely contains an Any proxy, so we only allow for "Any" proxies

		// We only allow to use it for delay zero proxies, as the call will immediatly be executed

}

impl pallet_ethereum_xcm::Config for Runtime {

	type InvalidEvmTransactionError = pallet_ethereum::InvalidTransactionWrapper;

	type ValidatedTransaction = pallet_ethereum::ValidatedTransaction<Self>;

	type XcmEthereumOrigin = pallet_ethereum_xcm::EnsureXcmEthereumTransaction;

	type ReservedXcmpWeight = ReservedXcmpWeight;

	type EnsureProxy = EthereumXcmEnsureProxy;

	type ControllerOrigin = EnsureRoot<AccountId>;

}

parameter_types! {

	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT.saturating_div(4);

	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT.saturating_div(4);

	pub const RelayOrigin: AggregateMessageOrigin = AggregateMessageOrigin::Parent;

}

impl parachain_info::Config for Runtime {}

pub struct OnNewRound;

impl pallet_parachain_staking::OnNewRound for OnNewRound {

}

pub struct PayoutCollatorOrOrbiterReward;

impl pallet_parachain_staking::PayoutCollatorReward<Runtime> for PayoutCollatorOrOrbiterReward {

			} else {

			};

}

pub struct OnInactiveCollator;

impl pallet_parachain_staking::OnInactiveCollator<Runtime> for OnInactiveCollator {

		} else {

		};

}

type MonetaryGovernanceOrigin =

	EitherOfDiverse<EnsureRoot<AccountId>, governance::custom_origins::GeneralAdmin>;

pub struct RelayChainSlotProvider;

impl Get<Slot> for RelayChainSlotProvider {

}

impl pallet_parachain_staking::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type Currency = Balances;

	type MonetaryGovernanceOrigin = MonetaryGovernanceOrigin;

	/// Minimum round length is 2 minutes (10 * 12 second block times)

	type MinBlocksPerRound = ConstU32<10>;

	/// If a collator doesn't produce any block on this number of rounds, it is notified as inactive

	type MaxOfflineRounds = ConstU32<1>;

	/// Rounds before the collator leaving the candidates request can be executed

	type LeaveCandidatesDelay = ConstU32<{ 4 * 7 }>;

	/// Rounds before the candidate bond increase/decrease can be executed

	type CandidateBondLessDelay = ConstU32<{ 4 * 7 }>;

	/// Rounds before the delegator exit can be executed

	type LeaveDelegatorsDelay = ConstU32<{ 4 * 7 }>;

	/// Rounds before the delegator revocation can be executed

	type RevokeDelegationDelay = ConstU32<{ 4 * 7 }>;

	/// Rounds before the delegator bond increase/decrease can be executed

	type DelegationBondLessDelay = ConstU32<{ 4 * 7 }>;

	/// Rounds before the reward is paid

	type RewardPaymentDelay = ConstU32<2>;

	/// Minimum collators selected per round, default at genesis and minimum forever after

	type MinSelectedCandidates = ConstU32<8>;

	/// Maximum top delegations per candidate

	type MaxTopDelegationsPerCandidate = ConstU32<300>;

	/// Maximum bottom delegations per candidate

	type MaxBottomDelegationsPerCandidate = ConstU32<50>;

	/// Maximum delegations per delegator

	type MaxDelegationsPerDelegator = ConstU32<100>;

	/// Minimum stake required to be reserved to be a candidate

	type MinCandidateStk = ConstU128<{ 20_000 * currency::GLMR * currency::SUPPLY_FACTOR }>;

	/// Minimum stake required to be reserved to be a delegator

	type MinDelegation = ConstU128<{ 500 * currency::MILLIGLMR * currency::SUPPLY_FACTOR }>;

	type BlockAuthor = AuthorInherent;

	type OnCollatorPayout = ();

	type PayoutCollatorReward = PayoutCollatorOrOrbiterReward;

	type OnInactiveCollator = OnInactiveCollator;

	type OnNewRound = OnNewRound;

	type SlotProvider = RelayChainSlotProvider;

	type WeightInfo = moonbeam_weights::pallet_parachain_staking::WeightInfo<Runtime>;

	type MaxCandidates = ConstU32<200>;

	type SlotDuration = ConstU64<6_000>;

	type BlockTime = ConstU64<6_000>;

}

impl pallet_author_inherent::Config for Runtime {

	type SlotBeacon = RelaychainDataProvider<Self>;

	type AccountLookup = MoonbeamOrbiters;

	type CanAuthor = AuthorFilter;

	type AuthorId = AccountId;

	type WeightInfo = moonbeam_weights::pallet_author_inherent::WeightInfo<Runtime>;

}

impl pallet_author_slot_filter::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type RandomnessSource = Randomness;

	type PotentialAuthors = ParachainStaking;

	type WeightInfo = moonbeam_weights::pallet_author_slot_filter::WeightInfo<Runtime>;

}

impl pallet_async_backing::Config for Runtime {

	type AllowMultipleBlocksPerSlot = ConstBool<true>;

	type GetAndVerifySlot = pallet_async_backing::RelaySlot;

	type ExpectedBlockTime = ConstU64<6000>;

}

parameter_types! {

	pub const InitializationPayment: Perbill = Perbill::from_percent(30);

	pub const RelaySignaturesThreshold: Perbill = Perbill::from_percent(100);

	pub const SignatureNetworkIdentifier:  &'static [u8] = b"moonbeam-";

}

impl pallet_crowdloan_rewards::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type Initialized = ConstBool<false>;

	type InitializationPayment = InitializationPayment;

	type MaxInitContributors = ConstU32<500>;

	type MinimumReward = ConstU128<0>;

	type RewardCurrency = Balances;

	type RelayChainAccountId = [u8; 32];

	type RewardAddressAssociateOrigin = EnsureSigned<Self::AccountId>;

	type RewardAddressChangeOrigin = EnsureSigned<Self::AccountId>;

	type RewardAddressRelayVoteThreshold = RelaySignaturesThreshold;

	type SignatureNetworkIdentifier = SignatureNetworkIdentifier;

	type VestingBlockNumber = relay_chain::BlockNumber;

	type VestingBlockProvider = RelaychainDataProvider<Self>;

	type WeightInfo = moonbeam_weights::pallet_crowdloan_rewards::WeightInfo<Runtime>;

}

// This is a simple session key manager. It should probably either work with, or be replaced

// entirely by pallet sessions

impl pallet_author_mapping::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type DepositCurrency = Balances;

	type DepositAmount = ConstU128<{ 100 * currency::GLMR * currency::SUPPLY_FACTOR }>;

	type Keys = session_keys_primitives::VrfId;

	type WeightInfo = moonbeam_weights::pallet_author_mapping::WeightInfo<Runtime>;

}

/// The type used to represent the kinds of proxying allowed.

#[derive(

	Copy,

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Encode,

	Debug,

	Serialize,

)]

pub enum ProxyType {

	Any = 0,

	NonTransfer = 1,

	Governance = 2,

	Staking = 3,

	CancelProxy = 4,

	Balances = 5,

	AuthorMapping = 6,

	IdentityJudgement = 7,

}

impl Default for ProxyType {

}

		PrecompileName::ConvictionVotingPrecompile

			| PrecompileName::PreimagePrecompile

			| PrecompileName::ReferendaPrecompile

			| PrecompileName::OpenTechCommitteeInstance

			| PrecompileName::TreasuryCouncilInstance

	)

// Be careful: Each time this filter is modified, the substrate filter must also be modified

// consistently.

impl pallet_evm_precompile_proxy::EvmProxyCallFilter for ProxyType {

			ProxyType::Any => {

					// Any precompile that can execute a subcall should be forbidden here,

					// to ensure that unauthorized smart contract can't be called

					// indirectly.

					// To be safe, we only allow the precompiles we need.

					Some(

						PrecompileName::AuthorMappingPrecompile

						| PrecompileName::ParachainStakingPrecompile,

					// All non-whitelisted precompiles are forbidden

					// Allow evm transfer to "simple" account (no code nor precompile)

					// For the moment, no smart contract other than precompiles is allowed.

					// In the future, we may create a dynamic whitelist to authorize some audited

					// smart contracts through governance.

					None => {

						// If the address is not recognized, allow only evm transfert to "simple"

						// accounts (no code nor precompile).

						// Note: Checking the presence of the code is not enough because some

						// precompiles have no code.

					}

				}

			}

			ProxyType::NonTransfer => {

						Some(

							PrecompileName::AuthorMappingPrecompile

							| PrecompileName::ParachainStakingPrecompile,

					}

			}

			ProxyType::Governance => {

					)

			}

			ProxyType::Staking => {

						Some(

							PrecompileName::AuthorMappingPrecompile

								| PrecompileName::ParachainStakingPrecompile

						)

					)

			}

			// The proxy precompile does not contain method cancel_proxy

			ProxyType::Balances => {

				// Allow only "simple" accounts as recipient (no code nor precompile).

				// Note: Checking the presence of the code is not enough because some precompiles

				// have no code.

			}

			ProxyType::AuthorMapping => {

						Some(PrecompileName::AuthorMappingPrecompile)

					)

			}

			// There is no identity precompile

		})

}

// Be careful: Each time this filter is modified, the EVM filter must also be modified consistently.

impl InstanceFilter<RuntimeCall> for ProxyType {

			ProxyType::NonTransfer => {

					RuntimeCall::System(..)

						| RuntimeCall::ParachainSystem(..)

						| RuntimeCall::Timestamp(..)

						| RuntimeCall::ParachainStaking(..)

						| RuntimeCall::Referenda(..)

						| RuntimeCall::Preimage(..)

						| RuntimeCall::ConvictionVoting(..)

						| RuntimeCall::TreasuryCouncilCollective(..)

						| RuntimeCall::OpenTechCommitteeCollective(..)

						| RuntimeCall::Identity(..)

						| RuntimeCall::Utility(..)

						| RuntimeCall::Proxy(..) | RuntimeCall::AuthorMapping(..)

						| RuntimeCall::CrowdloanRewards(

							pallet_crowdloan_rewards::Call::claim { .. }

						)

				)

			}

				RuntimeCall::Referenda(..)

					| RuntimeCall::Preimage(..)

					| RuntimeCall::ConvictionVoting(..)

					| RuntimeCall::TreasuryCouncilCollective(..)

					| RuntimeCall::OpenTechCommitteeCollective(..)

					| RuntimeCall::Utility(..)

			),

				RuntimeCall::ParachainStaking(..)

					| RuntimeCall::Utility(..)

					| RuntimeCall::AuthorMapping(..)

					| RuntimeCall::MoonbeamOrbiters(..)

			),

				RuntimeCall::Proxy(pallet_proxy::Call::reject_announcement { .. })

			),

			ProxyType::Balances => {

			}

				RuntimeCall::Identity(pallet_identity::Call::provide_judgement { .. })

					| RuntimeCall::Utility(..)

			),

		}

		}

}

impl pallet_proxy::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type RuntimeCall = RuntimeCall;

	type Currency = Balances;

	type ProxyType = ProxyType;

	// One storage item; key size 32, value size 8

	type ProxyDepositBase = ConstU128<{ currency::deposit(1, 8) }>;

	// Additional storage item size of 21 bytes (20 bytes AccountId + 1 byte sizeof(ProxyType)).

	type ProxyDepositFactor = ConstU128<{ currency::deposit(0, 21) }>;

	type MaxProxies = ConstU32<32>;

	type WeightInfo = moonbeam_weights::pallet_proxy::WeightInfo<Runtime>;

	type MaxPending = ConstU32<32>;

	type CallHasher = BlakeTwo256;

	type AnnouncementDepositBase = ConstU128<{ currency::deposit(1, 8) }>;

	// Additional storage item size of 56 bytes:

	// - 20 bytes AccountId

	// - 32 bytes Hasher (Blake2256)

	// - 4 bytes BlockNumber (u32)

	type AnnouncementDepositFactor = ConstU128<{ currency::deposit(0, 56) }>;

}

impl pallet_migrations::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type MigrationsList = (

		moonbeam_runtime_common::migrations::CommonMigrations<Runtime>,

		migrations::MoonbeamMigrations,

	);

	type XcmExecutionManager = XcmExecutionManager;

}

impl pallet_moonbeam_lazy_migrations::Config for Runtime {

	type WeightInfo = moonbeam_weights::pallet_moonbeam_lazy_migrations::WeightInfo<Runtime>;

}

/// Maintenance mode Call filter

pub struct MaintenanceFilter;

impl Contains<RuntimeCall> for MaintenanceFilter {

		}

}

/// Normal Call Filter

/// We dont allow to create nor mint assets, this for now is disabled

/// We only allow transfers. For now creation of assets will go through

/// asset-manager, while minting/burning only happens through xcm messages

/// This can change in the future

pub struct NormalFilter;

impl Contains<RuntimeCall> for NormalFilter {

			},

			// We just want to enable this in case of live chains, since the default version

			// is populated at genesis

			},

			// We filter anonymous proxy as they make "reserve" inconsistent

			// See: https://github.com/paritytech/substrate/blob/37cca710eed3dadd4ed5364c7686608f5175cce1/frame/proxy/src/lib.rs#L270 // editorconfig-checker-disable-line

				}

			},

			// Filtering the EVM prevents possible re-entrancy from the precompiles which could

			// lead to unexpected scenarios.

			// See https://github.com/PureStake/sr-moonbeam/issues/30

			// Note: It is also assumed that EVM calls are only allowed through `Origin::Root` so

			// this can be seen as an additional security

			RuntimeCall::Treasury(

				pallet_treasury::Call::spend { .. }

				| pallet_treasury::Call::payout { .. }

				| pallet_treasury::Call::check_status { .. }

				| pallet_treasury::Call::void_spend { .. },

		}

}

pub struct XcmExecutionManager;

impl moonkit_xcm_primitives::PauseXcmExecution for XcmExecutionManager {

}

impl pallet_maintenance_mode::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type NormalCallFilter = NormalFilter;

	type MaintenanceCallFilter = MaintenanceFilter;

	type MaintenanceOrigin =

		pallet_collective::EnsureProportionAtLeast<AccountId, OpenTechCommitteeInstance, 5, 9>;

	type XcmExecutionManager = XcmExecutionManager;

}

impl pallet_proxy_genesis_companion::Config for Runtime {

	type ProxyType = ProxyType;

}

parameter_types! {

	pub OrbiterReserveIdentifier: [u8; 4] = [b'o', b'r', b'b', b'i'];

}

type AddCollatorOrigin =

	EitherOfDiverse<EnsureRoot<AccountId>, governance::custom_origins::GeneralAdmin>;

type DelCollatorOrigin =

	EitherOfDiverse<EnsureRoot<AccountId>, governance::custom_origins::GeneralAdmin>;

impl pallet_moonbeam_orbiters::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type AccountLookup = AuthorMapping;

	type AddCollatorOrigin = AddCollatorOrigin;

	type Currency = Balances;

	type DelCollatorOrigin = DelCollatorOrigin;

	/// Maximum number of orbiters per collator

	type MaxPoolSize = ConstU32<8>;

	/// Maximum number of round to keep on storage

	type MaxRoundArchive = ConstU32<4>;

	type OrbiterReserveIdentifier = OrbiterReserveIdentifier;

	type RotatePeriod = ConstU32<1>;

	/// Round index type.

	type RoundIndex = pallet_parachain_staking::RoundIndex;

	type WeightInfo = moonbeam_weights::pallet_moonbeam_orbiters::WeightInfo<Runtime>;

}

/// Only callable after `set_validation_data` is called which forms this proof the same way

pub struct BabeDataGetter<Runtime>(sp_std::marker::PhantomData<Runtime>);

impl<Runtime> pallet_randomness::GetBabeData<u64, Option<Hash>> for BabeDataGetter<Runtime>

where

	Runtime: cumulus_pallet_parachain_system::Config,

{

	// Tolerate panic here because only ever called in inherent (so can be omitted)

			// storage reads as per actual reads

			// storage reads as per actual reads

}

impl pallet_randomness::Config for Runtime {

	type RuntimeEvent = RuntimeEvent;

	type AddressMapping = sp_runtime::traits::ConvertInto;

	type Currency = Balances;

	type BabeDataGetter = BabeDataGetter<Runtime>;

	type VrfKeyLookup = AuthorMapping;

	type Deposit = ConstU128<{ 1 * currency::GLMR * currency::SUPPLY_FACTOR }>;

	type MaxRandomWords = ConstU8<100>;

	type MinBlockDelay = ConstU32<2>;