git.delta.rocks / unique-network / refs/commits / dfe6d1900e26

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! The Substrate Node Template runtime. This can be compiled with `#[no_std]`, ready for Wasm.1819#![cfg_attr(not(feature = "std"), no_std)]20// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.21#![recursion_limit = "1024"]22#![allow(clippy::from_over_into, clippy::identity_op)]23#![allow(clippy::fn_to_numeric_cast_with_truncation)]24// Make the WASM binary available.25#[cfg(feature = "std")]26include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));2728use sp_api::impl_runtime_apis;29use sp_core::{crypto::KeyTypeId, OpaqueMetadata, H256, U256, H160};30use sp_runtime::DispatchError;31use fp_self_contained::*;32// #[cfg(any(feature = "std", test))]33// pub use sp_runtime::BuildStorage;3435use sp_runtime::{36	Permill, Perbill, Percent, create_runtime_str, generic, impl_opaque_keys,37	traits::{AccountIdLookup, BlakeTwo256, Block as BlockT, AccountIdConversion, Zero, Member},38	transaction_validity::{TransactionSource, TransactionValidity},39	ApplyExtrinsicResult, RuntimeAppPublic,40};4142use sp_std::prelude::*;4344#[cfg(feature = "std")]45use sp_version::NativeVersion;46use sp_version::RuntimeVersion;47pub use pallet_transaction_payment::{48	Multiplier, TargetedFeeAdjustment, FeeDetails, RuntimeDispatchInfo,49};50// A few exports that help ease life for downstream crates.51pub use pallet_balances::Call as BalancesCall;52pub use pallet_evm::{53	EnsureAddressTruncated, HashedAddressMapping, Runner, account::CrossAccountId as _,54	OnMethodCall, Account as EVMAccount, FeeCalculator, GasWeightMapping,55};56pub use frame_support::{57	construct_runtime, match_types,58	dispatch::DispatchResult,59	PalletId, parameter_types, StorageValue, ConsensusEngineId,60	traits::{61		tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Everything,62		Currency, ExistenceRequirement, Get, IsInVec, KeyOwnerProofSystem, LockIdentifier,63		OnUnbalanced, Randomness, FindAuthor, ConstU32, Imbalance, PrivilegeCmp,64	},65	weights::{66		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},67		DispatchClass, DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,68		WeightToFeePolynomial, WeightToFeeCoefficient, WeightToFeeCoefficients, ConstantMultiplier,69	},70};71use pallet_unq_scheduler::DispatchCall;72use up_data_structs::{73	CollectionId, TokenId, TokenData, Property, PropertyKeyPermission, CollectionLimits, 74	CollectionStats, RpcCollection, 75	mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping}76};7778// use pallet_contracts::weights::WeightInfo;79// #[cfg(any(feature = "std", test))]80use frame_system::{81	self as frame_system, EnsureRoot, EnsureSigned,82	limits::{BlockWeights, BlockLength},83};84use sp_arithmetic::{85	traits::{BaseArithmetic, Unsigned},86};87use smallvec::smallvec;88use codec::{Encode, Decode};89use fp_rpc::TransactionStatus;90use sp_runtime::{91	traits::{92		Applyable, BlockNumberProvider, Dispatchable, PostDispatchInfoOf, DispatchInfoOf,93		Saturating, CheckedConversion,94	},95	generic::Era,96	transaction_validity::TransactionValidityError,97	DispatchErrorWithPostInfo, SaturatedConversion, 98};99100// pub use pallet_timestamp::Call as TimestampCall;101pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;102103// Polkadot imports104use pallet_xcm::XcmPassthrough;105use polkadot_parachain::primitives::Sibling;106use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};107use xcm_builder::{108	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,109	EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser,110	RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,111	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,112	ParentIsPreset,113};114use xcm_executor::{Config, XcmExecutor, Assets};115use sp_std::{cmp::Ordering, marker::PhantomData};116117use xcm::latest::{118	//	Xcm,119	AssetId::{Concrete},120	Fungibility::Fungible as XcmFungible,121	MultiAsset,122	Error as XcmError,123};124use xcm_executor::traits::{MatchesFungible, WeightTrader};125126use unique_runtime_common::{127	impl_common_runtime_apis,128	types::*,129	constants::*,130	dispatch::{CollectionDispatchT, CollectionDispatch},131	sponsoring::UniqueSponsorshipHandler,132	eth_sponsoring::UniqueEthSponsorshipHandler,133	weights::CommonWeights,134};135136pub const RUNTIME_NAME: &str = "quartz";137pub const TOKEN_SYMBOL: &str = "QTZ";138139type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;140141impl RuntimeInstance for Runtime {142	type CrossAccountId = self::CrossAccountId;143144	type TransactionConverter = self::TransactionConverter;145146	fn get_transaction_converter() -> TransactionConverter {147		TransactionConverter148	}149}150151/// The type for looking up accounts. We don't expect more than 4 billion of them, but you152/// never know...153pub type AccountIndex = u32;154155/// Balance of an account.156pub type Balance = u128;157158/// Index of a transaction in the chain.159pub type Index = u32;160161/// A hash of some data used by the chain.162pub type Hash = sp_core::H256;163164/// Digest item type.165pub type DigestItem = generic::DigestItem;166167/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know168/// the specifics of the runtime. They can then be made to be agnostic over specific formats169/// of data like extrinsics, allowing for them to continue syncing the network through upgrades170/// to even the core data structures.171pub mod opaque {172	use sp_std::prelude::*;173	use sp_runtime::impl_opaque_keys;174	use super::Aura;175176	pub use unique_runtime_common::types::*;177178	impl_opaque_keys! {179		pub struct SessionKeys {180			pub aura: Aura,181		}182	}183}184185/// This runtime version.186pub const VERSION: RuntimeVersion = RuntimeVersion {187	spec_name: create_runtime_str!(RUNTIME_NAME),188	impl_name: create_runtime_str!(RUNTIME_NAME),189	authoring_version: 1,190	spec_version: 922000,191	impl_version: 0,192	apis: RUNTIME_API_VERSIONS,193	transaction_version: 1,194	state_version: 0,195};196197#[derive(codec::Encode, codec::Decode)]198pub enum XCMPMessage<XAccountId, XBalance> {199	/// Transfer tokens to the given account from the Parachain account.200	TransferToken(XAccountId, XBalance),201}202203/// The version information used to identify this runtime when compiled natively.204#[cfg(feature = "std")]205pub fn native_version() -> NativeVersion {206	NativeVersion {207		runtime_version: VERSION,208		can_author_with: Default::default(),209	}210}211212type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;213214pub struct DealWithFees;215impl OnUnbalanced<NegativeImbalance> for DealWithFees {216	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {217		if let Some(fees) = fees_then_tips.next() {218			// for fees, 100% to treasury219			let mut split = fees.ration(100, 0);220			if let Some(tips) = fees_then_tips.next() {221				// for tips, if any, 100% to treasury222				tips.ration_merge_into(100, 0, &mut split);223			}224			Treasury::on_unbalanced(split.0);225			// Author::on_unbalanced(split.1);226		}227	}228}229230parameter_types! {231	pub const BlockHashCount: BlockNumber = 2400;232	pub RuntimeBlockLength: BlockLength =233		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);234	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);235	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;236	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()237		.base_block(BlockExecutionWeight::get())238		.for_class(DispatchClass::all(), |weights| {239			weights.base_extrinsic = ExtrinsicBaseWeight::get();240		})241		.for_class(DispatchClass::Normal, |weights| {242			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);243		})244		.for_class(DispatchClass::Operational, |weights| {245			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);246			// Operational transactions have some extra reserved space, so that they247			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.248			weights.reserved = Some(249				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT250			);251		})252		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)253		.build_or_panic();254	pub const Version: RuntimeVersion = VERSION;255	pub const SS58Prefix: u8 = 255;256}257258parameter_types! {259	pub const ChainId: u64 = 8881;260}261262pub struct FixedFee;263impl FeeCalculator for FixedFee {264	fn min_gas_price() -> (U256, u64) {265		(MIN_GAS_PRICE.into(), 0)266	}267}268269// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case270// (contract, which only writes a lot of data),271// approximating on top of our real store write weight272parameter_types! {273	pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;274	pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;275	pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();276}277278/// Limiting EVM execution to 50% of block for substrate users and management tasks279/// EVM transaction consumes more weight than substrate's, so we can't rely on them being280/// scheduled fairly281const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);282parameter_types! {283	pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());284}285286pub enum FixedGasWeightMapping {}287impl GasWeightMapping for FixedGasWeightMapping {288	fn gas_to_weight(gas: u64) -> Weight {289		gas.saturating_mul(WeightPerGas::get())290	}291	fn weight_to_gas(weight: Weight) -> u64 {292		weight / WeightPerGas::get()293	}294}295296impl pallet_evm::account::Config for Runtime {297	type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Self>;298	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;299	type EvmBackwardsAddressMapping = fp_evm_mapping::MapBackwardsAddressTruncated;300}301302impl pallet_evm::Config for Runtime {303	type BlockGasLimit = BlockGasLimit;304	type FeeCalculator = FixedFee;305	type GasWeightMapping = FixedGasWeightMapping;306	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;307	type CallOrigin = EnsureAddressTruncated<Self>;308	type WithdrawOrigin = EnsureAddressTruncated<Self>;309	type AddressMapping = HashedAddressMapping<Self::Hashing>;310	type PrecompilesType = ();311	type PrecompilesValue = ();312	type Currency = Balances;313	type Event = Event;314	type OnMethodCall = (315		pallet_evm_migration::OnMethodCall<Self>,316		pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,317		CollectionDispatchT<Self>,318		pallet_unique::eth::CollectionHelpersOnMethodCall<Self>,319	);320	type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;321	type ChainId = ChainId;322	type Runner = pallet_evm::runner::stack::Runner<Self>;323	type OnChargeTransaction = pallet_evm::EVMCurrencyAdapter<Balances, DealWithFees>;324	type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;325	type FindAuthor = EthereumFindAuthor<Aura>;326}327328impl pallet_evm_migration::Config for Runtime {329	type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;330}331332pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);333impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {334	fn find_author<'a, I>(digests: I) -> Option<H160>335	where336		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,337	{338		if let Some(author_index) = F::find_author(digests) {339			let authority_id = Aura::authorities()[author_index as usize].clone();340			return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));341		}342		None343	}344}345346impl pallet_ethereum::Config for Runtime {347	type Event = Event;348	type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;349}350351impl pallet_randomness_collective_flip::Config for Runtime {}352353impl frame_system::Config for Runtime {354	/// The data to be stored in an account.355	type AccountData = pallet_balances::AccountData<Balance>;356	/// The identifier used to distinguish between accounts.357	type AccountId = AccountId;358	/// The basic call filter to use in dispatchable.359	type BaseCallFilter = Everything;360	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).361	type BlockHashCount = BlockHashCount;362	/// The maximum length of a block (in bytes).363	type BlockLength = RuntimeBlockLength;364	/// The index type for blocks.365	type BlockNumber = BlockNumber;366	/// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.367	type BlockWeights = RuntimeBlockWeights;368	/// The aggregated dispatch type that is available for extrinsics.369	type Call = Call;370	/// The weight of database operations that the runtime can invoke.371	type DbWeight = RocksDbWeight;372	/// The ubiquitous event type.373	type Event = Event;374	/// The type for hashing blocks and tries.375	type Hash = Hash;376	/// The hashing algorithm used.377	type Hashing = BlakeTwo256;378	/// The header type.379	type Header = generic::Header<BlockNumber, BlakeTwo256>;380	/// The index type for storing how many extrinsics an account has signed.381	type Index = Index;382	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.383	type Lookup = AccountIdLookup<AccountId, ()>;384	/// What to do if an account is fully reaped from the system.385	type OnKilledAccount = ();386	/// What to do if a new account is created.387	type OnNewAccount = ();388	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;389	/// The ubiquitous origin type.390	type Origin = Origin;391	/// This type is being generated by `construct_runtime!`.392	type PalletInfo = PalletInfo;393	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.394	type SS58Prefix = SS58Prefix;395	/// Weight information for the extrinsics of this pallet.396	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;397	/// Version of the runtime.398	type Version = Version;399	type MaxConsumers = ConstU32<16>;400}401402parameter_types! {403	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;404}405406impl pallet_timestamp::Config for Runtime {407	/// A timestamp: milliseconds since the unix epoch.408	type Moment = u64;409	type OnTimestampSet = ();410	type MinimumPeriod = MinimumPeriod;411	type WeightInfo = ();412}413414parameter_types! {415	// pub const ExistentialDeposit: u128 = 500;416	pub const ExistentialDeposit: u128 = 0;417	pub const MaxLocks: u32 = 50;418	pub const MaxReserves: u32 = 50;419}420421impl pallet_balances::Config for Runtime {422	type MaxLocks = MaxLocks;423	type MaxReserves = MaxReserves;424	type ReserveIdentifier = [u8; 16];425	/// The type for recording an account's balance.426	type Balance = Balance;427	/// The ubiquitous event type.428	type Event = Event;429	type DustRemoval = Treasury;430	type ExistentialDeposit = ExistentialDeposit;431	type AccountStore = System;432	type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;433}434435pub const fn deposit(items: u32, bytes: u32) -> Balance {436	items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE437}438439/*440parameter_types! {441	pub TombstoneDeposit: Balance = deposit(442		1,443		sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,444	);445	pub DepositPerContract: Balance = TombstoneDeposit::get();446	pub const DepositPerStorageByte: Balance = deposit(0, 1);447	pub const DepositPerStorageItem: Balance = deposit(1, 0);448	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);449	pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;450	pub const SignedClaimHandicap: u32 = 2;451	pub const MaxDepth: u32 = 32;452	pub const MaxValueSize: u32 = 16 * 1024;453	pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb454	// The lazy deletion runs inside on_initialize.455	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *456		RuntimeBlockWeights::get().max_block;457	// The weight needed for decoding the queue should be less or equal than a fifth458	// of the overall weight dedicated to the lazy deletion.459	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (460			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -461			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)462		)) / 5) as u32;463	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();464}465466impl pallet_contracts::Config for Runtime {467	type Time = Timestamp;468	type Randomness = RandomnessCollectiveFlip;469	type Currency = Balances;470	type Event = Event;471	type RentPayment = ();472	type SignedClaimHandicap = SignedClaimHandicap;473	type TombstoneDeposit = TombstoneDeposit;474	type DepositPerContract = DepositPerContract;475	type DepositPerStorageByte = DepositPerStorageByte;476	type DepositPerStorageItem = DepositPerStorageItem;477	type RentFraction = RentFraction;478	type SurchargeReward = SurchargeReward;479	type WeightPrice = pallet_transaction_payment::Pallet<Self>;480	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;481	type ChainExtension = NFTExtension;482	type DeletionQueueDepth = DeletionQueueDepth;483	type DeletionWeightLimit = DeletionWeightLimit;484	type Schedule = Schedule;485	type CallStack = [pallet_contracts::Frame<Self>; 31];486}487*/488489parameter_types! {490	/// This value increases the priority of `Operational` transactions by adding491	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.492	pub const OperationalFeeMultiplier: u8 = 5;493}494495/// Linear implementor of `WeightToFeePolynomial`496pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);497498impl<T> WeightToFeePolynomial for LinearFee<T>499where500	T: BaseArithmetic + From<u32> + Copy + Unsigned,501{502	type Balance = T;503504	fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {505		smallvec!(WeightToFeeCoefficient {506			// Targeting 0.1 Unique per NFT transfer507			coeff_integer: WEIGHT_TO_FEE_COEFF.into(),508			coeff_frac: Perbill::zero(),509			negative: false,510			degree: 1,511		})512	}513}514515impl pallet_transaction_payment::Config for Runtime {516	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;517	type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;518	type OperationalFeeMultiplier = OperationalFeeMultiplier;519	type WeightToFee = LinearFee<Balance>;520	type FeeMultiplierUpdate = ();521}522523parameter_types! {524	pub const ProposalBond: Permill = Permill::from_percent(5);525	pub const ProposalBondMinimum: Balance = 1 * UNIQUE;526	pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;527	pub const SpendPeriod: BlockNumber = 5 * MINUTES;528	pub const Burn: Permill = Permill::from_percent(0);529	pub const TipCountdown: BlockNumber = 1 * DAYS;530	pub const TipFindersFee: Percent = Percent::from_percent(20);531	pub const TipReportDepositBase: Balance = 1 * UNIQUE;532	pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;533	pub const BountyDepositBase: Balance = 1 * UNIQUE;534	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;535	pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");536	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;537	pub const MaximumReasonLength: u32 = 16384;538	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);539	pub const BountyValueMinimum: Balance = 5 * UNIQUE;540	pub const MaxApprovals: u32 = 100;541}542543impl pallet_treasury::Config for Runtime {544	type PalletId = TreasuryModuleId;545	type Currency = Balances;546	type ApproveOrigin = EnsureRoot<AccountId>;547	type RejectOrigin = EnsureRoot<AccountId>;548	type Event = Event;549	type OnSlash = ();550	type ProposalBond = ProposalBond;551	type ProposalBondMinimum = ProposalBondMinimum;552	type ProposalBondMaximum = ProposalBondMaximum;553	type SpendPeriod = SpendPeriod;554	type Burn = Burn;555	type BurnDestination = ();556	type SpendFunds = ();557	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;558	type MaxApprovals = MaxApprovals;559}560561impl pallet_sudo::Config for Runtime {562	type Event = Event;563	type Call = Call;564}565566pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);567568impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider569	for RelayChainBlockNumberProvider<T>570{571	type BlockNumber = BlockNumber;572573	fn current_block_number() -> Self::BlockNumber {574		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()575			.map(|d| d.relay_parent_number)576			.unwrap_or_default()577	}578}579580parameter_types! {581	pub const MinVestedTransfer: Balance = 10 * UNIQUE;582	pub const MaxVestingSchedules: u32 = 28;583}584585impl orml_vesting::Config for Runtime {586	type Event = Event;587	type Currency = pallet_balances::Pallet<Runtime>;588	type MinVestedTransfer = MinVestedTransfer;589	type VestedTransferOrigin = EnsureSigned<AccountId>;590	type WeightInfo = ();591	type MaxVestingSchedules = MaxVestingSchedules;592	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;593}594595parameter_types! {596	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;597	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;598}599600impl cumulus_pallet_parachain_system::Config for Runtime {601	type Event = Event;602	type SelfParaId = parachain_info::Pallet<Self>;603	type OnSystemEvent = ();604	// type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<605	// 	MaxDownwardMessageWeight,606	// 	XcmExecutor<XcmConfig>,607	// 	Call,608	// >;609	type OutboundXcmpMessageSource = XcmpQueue;610	type DmpMessageHandler = DmpQueue;611	type ReservedDmpWeight = ReservedDmpWeight;612	type ReservedXcmpWeight = ReservedXcmpWeight;613	type XcmpMessageHandler = XcmpQueue;614}615616impl parachain_info::Config for Runtime {}617618impl cumulus_pallet_aura_ext::Config for Runtime {}619620parameter_types! {621	pub const RelayLocation: MultiLocation = MultiLocation::parent();622	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;623	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();624	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();625}626627/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used628/// when determining ownership of accounts for asset transacting and when attempting to use XCM629/// `Transact` in order to determine the dispatch Origin.630pub type LocationToAccountId = (631	// The parent (Relay-chain) origin converts to the default `AccountId`.632	ParentIsPreset<AccountId>,633	// Sibling parachain origins convert to AccountId via the `ParaId::into`.634	SiblingParachainConvertsVia<Sibling, AccountId>,635	// Straight up local `AccountId32` origins just alias directly to `AccountId`.636	AccountId32Aliases<RelayNetwork, AccountId>,637);638639pub struct OnlySelfCurrency;640impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {641	fn matches_fungible(a: &MultiAsset) -> Option<B> {642		match (&a.id, &a.fun) {643			(Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),644			_ => None,645		}646	}647}648649/// Means for transacting assets on this chain.650pub type LocalAssetTransactor = CurrencyAdapter<651	// Use this currency:652	Balances,653	// Use this currency when it is a fungible asset matching the given location or name:654	OnlySelfCurrency,655	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:656	LocationToAccountId,657	// Our chain's account ID type (we can't get away without mentioning it explicitly):658	AccountId,659	// We don't track any teleports.660	(),661>;662663/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,664/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can665/// biases the kind of local `Origin` it will become.666pub type XcmOriginToTransactDispatchOrigin = (667	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location668	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for669	// foreign chains who want to have a local sovereign account on this chain which they control.670	SovereignSignedViaLocation<LocationToAccountId, Origin>,671	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when672	// recognised.673	RelayChainAsNative<RelayOrigin, Origin>,674	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when675	// recognised.676	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,677	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a678	// transaction from the Root origin.679	ParentAsSuperuser<Origin>,680	// Native signed account converter; this just converts an `AccountId32` origin into a normal681	// `Origin::Signed` origin of the same 32-byte value.682	SignedAccountId32AsNative<RelayNetwork, Origin>,683	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.684	XcmPassthrough<Origin>,685);686687parameter_types! {688	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.689	pub UnitWeightCost: Weight = 1_000_000;690	// 1200 UNIQUEs buy 1 second of weight.691	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);692	pub const MaxInstructions: u32 = 100;693	pub const MaxAuthorities: u32 = 100_000;694}695696match_types! {697	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {698		MultiLocation { parents: 1, interior: Here } |699		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }700	};701}702703pub type Barrier = (704	TakeWeightCredit,705	AllowTopLevelPaidExecutionFrom<Everything>,706	AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,707	// ^^^ Parent & its unit plurality gets free execution708);709710pub struct UsingOnlySelfCurrencyComponents<711	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,712	AssetId: Get<MultiLocation>,713	AccountId,714	Currency: CurrencyT<AccountId>,715	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,716>(717	Weight,718	Currency::Balance,719	PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,720);721impl<722		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,723		AssetId: Get<MultiLocation>,724		AccountId,725		Currency: CurrencyT<AccountId>,726		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,727	> WeightTrader728	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>729{730	fn new() -> Self {731		Self(0, Zero::zero(), PhantomData)732	}733734	fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {735		let amount = WeightToFee::calc(&weight);736		let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;737738		// location to this parachain through relay chain739		let option1: xcm::v1::AssetId = Concrete(MultiLocation {740			parents: 1,741			interior: X1(Parachain(ParachainInfo::parachain_id().into())),742		});743		// direct location744		let option2: xcm::v1::AssetId = Concrete(MultiLocation {745			parents: 0,746			interior: Here,747		});748749		let required = if payment.fungible.contains_key(&option1) {750			(option1, u128_amount).into()751		} else if payment.fungible.contains_key(&option2) {752			(option2, u128_amount).into()753		} else {754			(Concrete(MultiLocation::default()), u128_amount).into()755		};756757		let unused = payment758			.checked_sub(required)759			.map_err(|_| XcmError::TooExpensive)?;760		self.0 = self.0.saturating_add(weight);761		self.1 = self.1.saturating_add(amount);762		Ok(unused)763	}764765	fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {766		let weight = weight.min(self.0);767		let amount = WeightToFee::calc(&weight);768		self.0 -= weight;769		self.1 = self.1.saturating_sub(amount);770		let amount: u128 = amount.saturated_into();771		if amount > 0 {772			Some((AssetId::get(), amount).into())773		} else {774			None775		}776	}777}778impl<779		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,780		AssetId: Get<MultiLocation>,781		AccountId,782		Currency: CurrencyT<AccountId>,783		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,784	> Drop785	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>786{787	fn drop(&mut self) {788		OnUnbalanced::on_unbalanced(Currency::issue(self.1));789	}790}791792pub struct XcmConfig;793impl Config for XcmConfig {794	type Call = Call;795	type XcmSender = XcmRouter;796	// How to withdraw and deposit an asset.797	type AssetTransactor = LocalAssetTransactor;798	type OriginConverter = XcmOriginToTransactDispatchOrigin;799	type IsReserve = NativeAsset;800	type IsTeleporter = (); // Teleportation is disabled801	type LocationInverter = LocationInverter<Ancestry>;802	type Barrier = Barrier;803	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;804	type Trader = UsingOnlySelfCurrencyComponents<805		IdentityFee<Balance>,806		RelayLocation,807		AccountId,808		Balances,809		(),810	>;811	type ResponseHandler = (); // Don't handle responses for now.812	type SubscriptionService = PolkadotXcm;813814	type AssetTrap = PolkadotXcm;815	type AssetClaims = PolkadotXcm;816}817818// parameter_types! {819// 	pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;820// }821822/// No local origins on this chain are allowed to dispatch XCM sends/executions.823pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);824825/// The means for routing XCM messages which are not for local execution into the right message826/// queues.827pub type XcmRouter = (828	// Two routers - use UMP to communicate with the relay chain:829	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,830	// ..and XCMP to communicate with the sibling chains.831	XcmpQueue,832);833834impl pallet_evm_coder_substrate::Config for Runtime {}835836impl pallet_xcm::Config for Runtime {837	type Event = Event;838	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;839	type XcmRouter = XcmRouter;840	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;841	type XcmExecuteFilter = Everything;842	type XcmExecutor = XcmExecutor<XcmConfig>;843	type XcmTeleportFilter = Everything;844	type XcmReserveTransferFilter = Everything;845	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;846	type LocationInverter = LocationInverter<Ancestry>;847	type Origin = Origin;848	type Call = Call;849	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;850	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;851}852853impl cumulus_pallet_xcm::Config for Runtime {854	type Event = Event;855	type XcmExecutor = XcmExecutor<XcmConfig>;856}857858impl cumulus_pallet_xcmp_queue::Config for Runtime {859	type WeightInfo = ();860	type Event = Event;861	type XcmExecutor = XcmExecutor<XcmConfig>;862	type ChannelInfo = ParachainSystem;863	type VersionWrapper = ();864	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;865	type ControllerOrigin = EnsureRoot<AccountId>;866	type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;867}868869impl cumulus_pallet_dmp_queue::Config for Runtime {870	type Event = Event;871	type XcmExecutor = XcmExecutor<XcmConfig>;872	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;873}874875impl pallet_aura::Config for Runtime {876	type AuthorityId = AuraId;877	type DisabledValidators = ();878	type MaxAuthorities = MaxAuthorities;879}880881parameter_types! {882	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();883	pub const CollectionCreationPrice: Balance = 2 * UNIQUE;884}885886impl pallet_common::Config for Runtime {887	type WeightInfo = pallet_common::weights::SubstrateWeight<Self>;888	type Event = Event;889	type Currency = Balances;890	type CollectionCreationPrice = CollectionCreationPrice;891	type TreasuryAccountId = TreasuryAccountId;892	type CollectionDispatch = CollectionDispatchT<Self>;893894	type EvmTokenAddressMapping = EvmTokenAddressMapping;895	type CrossTokenAddressMapping = CrossTokenAddressMapping<Self::AccountId>;896	type ContractAddress = EvmCollectionHelpersAddress;897}898899impl pallet_structure::Config for Runtime {900	type Event = Event;901	type Call = Call;902	type WeightInfo = pallet_structure::weights::SubstrateWeight<Self>;903}904905impl pallet_fungible::Config for Runtime {906	type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;907}908impl pallet_refungible::Config for Runtime {909	type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;910}911impl pallet_nonfungible::Config for Runtime {912	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;913}914/* TODO free RMRK!915impl pallet_proxy_rmrk_core::Config for Runtime {916	type Event = Event;917}918919impl pallet_proxy_rmrk_equip::Config for Runtime {920	type Event = Event;921}*/922923impl pallet_unique::Config for Runtime {924	type Event = Event;925	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;926	type CommonWeightInfo = CommonWeights<Self>;927}928929parameter_types! {930	pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied931}932933/// Used for the pallet inflation934impl pallet_inflation::Config for Runtime {935	type Currency = Balances;936	type TreasuryAccountId = TreasuryAccountId;937	type InflationBlockInterval = InflationBlockInterval;938	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;939}940941parameter_types! {942	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *943		RuntimeBlockWeights::get().max_block;944	pub const MaxScheduledPerBlock: u32 = 50;945}946947type ChargeTransactionPayment = pallet_charge_transaction::ChargeTransactionPayment<Runtime>;948use frame_support::traits::NamedReservableCurrency;949950fn get_signed_extras(from: <Runtime as frame_system::Config>::AccountId) -> SignedExtraScheduler {951	(952		frame_system::CheckSpecVersion::<Runtime>::new(),953		frame_system::CheckGenesis::<Runtime>::new(),954		frame_system::CheckEra::<Runtime>::from(Era::Immortal),955		frame_system::CheckNonce::<Runtime>::from(frame_system::Pallet::<Runtime>::account_nonce(956			from,957		)),958		frame_system::CheckWeight::<Runtime>::new(),959		// sponsoring transaction logic960		// pallet_charge_transaction::ChargeTransactionPayment::<Runtime>::new(0),961	)962}963964pub struct SchedulerPaymentExecutor;965impl<T: frame_system::Config + pallet_unq_scheduler::Config, SelfContainedSignedInfo>966	DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor967where968	<T as frame_system::Config>::Call: Member969		+ Dispatchable<Origin = Origin, Info = DispatchInfo>970		+ SelfContainedCall<SignedInfo = SelfContainedSignedInfo>971		+ GetDispatchInfo972		+ From<frame_system::Call<Runtime>>,973	SelfContainedSignedInfo: Send + Sync + 'static,974	Call: From<<T as frame_system::Config>::Call>975		+ From<<T as pallet_unq_scheduler::Config>::Call>976		+ SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,977	sp_runtime::AccountId32: From<<T as frame_system::Config>::AccountId>,978{979	fn dispatch_call(980		signer: <T as frame_system::Config>::AccountId,981		call: <T as pallet_unq_scheduler::Config>::Call,982	) -> Result<983		Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,984		TransactionValidityError,985	> {986		let dispatch_info = call.get_dispatch_info();987		let extrinsic = fp_self_contained::CheckedExtrinsic::<988			AccountId,989			Call,990			SignedExtraScheduler,991			SelfContainedSignedInfo,992		> {993			signed:994				CheckedSignature::<AccountId, SignedExtraScheduler, SelfContainedSignedInfo>::Signed(995					signer.clone().into(),996					get_signed_extras(signer.into()),997				),998			function: call.into(),999		};10001001		extrinsic.apply::<Runtime>(&dispatch_info, 0)1002	}10031004	fn reserve_balance(1005		id: [u8; 16],1006		sponsor: <T as frame_system::Config>::AccountId,1007		call: <T as pallet_unq_scheduler::Config>::Call,1008		count: u32,1009	) -> Result<(), DispatchError> {1010		let dispatch_info = call.get_dispatch_info();1011		let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0)1012			.saturating_mul(count.into());10131014		<Balances as NamedReservableCurrency<AccountId>>::reserve_named(1015			&id,1016			&(sponsor.into()),1017			weight.into(),1018		)1019	}10201021	fn pay_for_call(1022		id: [u8; 16],1023		sponsor: <T as frame_system::Config>::AccountId,1024		call: <T as pallet_unq_scheduler::Config>::Call,1025	) -> Result<u128, DispatchError> {1026		let dispatch_info = call.get_dispatch_info();1027		let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0);1028		Ok(1029			<Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1030				&id,1031				&(sponsor.into()),1032				weight.into(),1033			),1034		)1035	}10361037	fn cancel_reserve(1038		id: [u8; 16],1039		sponsor: <T as frame_system::Config>::AccountId,1040	) -> Result<u128, DispatchError> {1041		Ok(1042			<Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1043				&id,1044				&(sponsor.into()),1045				u128::MAX,1046			),1047		)1048	}1049}10501051parameter_types! {1052	pub const NoPreimagePostponement: Option<u32> = Some(10);1053	pub const Preimage: Option<u32> = Some(10);1054}10551056/// Used the compare the privilege of an origin inside the scheduler.1057pub struct OriginPrivilegeCmp;10581059impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {1060	fn cmp_privilege(_left: &OriginCaller, _right: &OriginCaller) -> Option<Ordering> {1061		Some(Ordering::Equal)1062	}1063}10641065impl pallet_unq_scheduler::Config for Runtime {1066	type Event = Event;1067	type Origin = Origin;1068	type Currency = Balances;1069	type PalletsOrigin = OriginCaller;1070	type Call = Call;1071	type MaximumWeight = MaximumSchedulerWeight;1072	type ScheduleOrigin = EnsureSigned<AccountId>;1073	type MaxScheduledPerBlock = MaxScheduledPerBlock;1074	type WeightInfo = ();1075	type CallExecutor = SchedulerPaymentExecutor;1076	type OriginPrivilegeCmp = OriginPrivilegeCmp;1077	type PreimageProvider = ();1078	type NoPreimagePostponement = NoPreimagePostponement;1079}10801081type EvmSponsorshipHandler = (1082	UniqueEthSponsorshipHandler<Runtime>,1083	pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,1084);1085type SponsorshipHandler = (1086	UniqueSponsorshipHandler<Runtime>,1087	//pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1088	pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1089);10901091impl pallet_evm_transaction_payment::Config for Runtime {1092	type EvmSponsorshipHandler = EvmSponsorshipHandler;1093	type Currency = Balances;1094}10951096impl pallet_charge_transaction::Config for Runtime {1097	type SponsorshipHandler = SponsorshipHandler;1098}10991100// impl pallet_contract_helpers::Config for Runtime {1101//	 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1102// }11031104parameter_types! {1105	// 0x842899ECF380553E8a4de75bF534cdf6fBF640491106	pub const HelpersContractAddress: H160 = H160([1107		0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1108	]);1109		1110	// 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f1111	pub const EvmCollectionHelpersAddress: H160 = H160([1112		0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,1113	]);1114}11151116impl pallet_evm_contract_helpers::Config for Runtime {1117	type ContractAddress = HelpersContractAddress;1118	type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1119}11201121construct_runtime!(1122	pub enum Runtime where1123		Block = Block,1124		NodeBlock = opaque::Block,1125		UncheckedExtrinsic = UncheckedExtrinsic1126	{1127		ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1128		ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,11291130		Aura: pallet_aura::{Pallet, Config<T>} = 22,1131		AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,11321133		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1134		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1135		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1136		TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1137		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1138		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1139		System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1140		Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1141		// Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1142		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,11431144		// XCM helpers.1145		XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1146		PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1147		CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1148		DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11491150		// Unique Pallets1151		Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1152		Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1153		Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1154		// free = 631155		Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1156		// ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1157		Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1158		Fungible: pallet_fungible::{Pallet, Storage} = 67,1159		Refungible: pallet_refungible::{Pallet, Storage} = 68,1160		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1161		Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,1162		/* TODO free RMRK!1163		RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,1164		RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,*/11651166		// Frontier1167		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1168		Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11691170		EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1171		EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1172		EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1173		EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1174	}1175);11761177pub struct TransactionConverter;11781179impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1180	fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1181		UncheckedExtrinsic::new_unsigned(1182			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1183		)1184	}1185}11861187impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1188	fn convert_transaction(1189		&self,1190		transaction: pallet_ethereum::Transaction,1191	) -> opaque::UncheckedExtrinsic {1192		let extrinsic = UncheckedExtrinsic::new_unsigned(1193			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1194		);1195		let encoded = extrinsic.encode();1196		opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1197			.expect("Encoded extrinsic is always valid")1198	}1199}12001201/// The address format for describing accounts.1202pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1203/// Block header type as expected by this runtime.1204pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1205/// Block type as expected by this runtime.1206pub type Block = generic::Block<Header, UncheckedExtrinsic>;1207/// A Block signed with a Justification1208pub type SignedBlock = generic::SignedBlock<Block>;1209/// BlockId type as expected by this runtime.1210pub type BlockId = generic::BlockId<Block>;1211/// The SignedExtension to the basic transaction logic.1212pub type SignedExtra = (1213	frame_system::CheckSpecVersion<Runtime>,1214	// system::CheckTxVersion<Runtime>,1215	frame_system::CheckGenesis<Runtime>,1216	frame_system::CheckEra<Runtime>,1217	frame_system::CheckNonce<Runtime>,1218	frame_system::CheckWeight<Runtime>,1219	ChargeTransactionPayment,1220	//pallet_contract_helpers::ContractHelpersExtension<Runtime>,1221	pallet_ethereum::FakeTransactionFinalizer<Runtime>,1222);12231224pub type SignedExtraScheduler = (1225	frame_system::CheckSpecVersion<Runtime>,1226	frame_system::CheckGenesis<Runtime>,1227	frame_system::CheckEra<Runtime>,1228	frame_system::CheckNonce<Runtime>,1229	frame_system::CheckWeight<Runtime>,1230	// pallet_charge_transaction::ChargeTransactionPayment<Runtime>,1231);1232/// Unchecked extrinsic type as expected by this runtime.1233pub type UncheckedExtrinsic =1234	fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1235/// Extrinsic type that has already been checked.1236pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1237/// Executive: handles dispatch to the various modules.1238pub type Executive = frame_executive::Executive<1239	Runtime,1240	Block,1241	frame_system::ChainContext<Runtime>,1242	Runtime,1243	AllPalletsReversedWithSystemFirst,1244>;12451246impl_opaque_keys! {1247	pub struct SessionKeys {1248		pub aura: Aura,1249	}1250}12511252impl fp_self_contained::SelfContainedCall for Call {1253	type SignedInfo = H160;12541255	fn is_self_contained(&self) -> bool {1256		match self {1257			Call::Ethereum(call) => call.is_self_contained(),1258			_ => false,1259		}1260	}12611262	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1263		match self {1264			Call::Ethereum(call) => call.check_self_contained(),1265			_ => None,1266		}1267	}12681269	fn validate_self_contained(1270		&self,1271		info: &Self::SignedInfo,1272		dispatch_info: &DispatchInfoOf<Call>,1273		len: usize,1274	) -> Option<TransactionValidity> {1275		match self {1276			Call::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),1277			_ => None,1278		}1279	}12801281	fn pre_dispatch_self_contained(1282		&self,1283		info: &Self::SignedInfo,1284	) -> Option<Result<(), TransactionValidityError>> {1285		match self {1286			Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1287			_ => None,1288		}1289	}12901291	fn apply_self_contained(1292		self,1293		info: Self::SignedInfo,1294	) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1295		match self {1296			call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1297				Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1298			)),1299			_ => None,1300		}1301	}1302}13031304macro_rules! dispatch_unique_runtime {1305	($collection:ident.$method:ident($($name:ident),*)) => {{1306		let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1307		let dispatch = collection.as_dyn();13081309		Ok::<_, DispatchError>(dispatch.$method($($name),*))1310	}};1311}13121313impl_common_runtime_apis!();13141315struct CheckInherents;13161317impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1318	fn check_inherents(1319		block: &Block,1320		relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1321	) -> sp_inherents::CheckInherentsResult {1322		let relay_chain_slot = relay_state_proof1323			.read_slot()1324			.expect("Could not read the relay chain slot from the proof");13251326		let inherent_data =1327			cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1328				relay_chain_slot,1329				sp_std::time::Duration::from_secs(6),1330			)1331			.create_inherent_data()1332			.expect("Could not create the timestamp inherent data");13331334		inherent_data.check_extrinsics(block)1335	}1336}13371338cumulus_pallet_parachain_system::register_validate_block!(1339	Runtime = Runtime,1340	BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1341	CheckInherents = CheckInherents,1342);