git.delta.rocks / unique-network / refs/commits / 7b0d1cf9062a

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::*;32use sp_runtime::traits::{Member};33// #[cfg(any(feature = "std", test))]34// pub use sp_runtime::BuildStorage;3536use sp_runtime::{37	Permill, Perbill, Percent, create_runtime_str, generic, impl_opaque_keys,38	traits::{AccountIdLookup, BlakeTwo256, Block as BlockT, AccountIdConversion, Zero},39	transaction_validity::{TransactionSource, TransactionValidity},40	ApplyExtrinsicResult, RuntimeAppPublic,41};4243use sp_std::prelude::*;4445#[cfg(feature = "std")]46use sp_version::NativeVersion;47use sp_version::RuntimeVersion;48pub use pallet_transaction_payment::{49	Multiplier, TargetedFeeAdjustment, FeeDetails, RuntimeDispatchInfo,50};51// A few exports that help ease life for downstream crates.52pub use pallet_balances::Call as BalancesCall;53pub use pallet_evm::{54	EnsureAddressTruncated, HashedAddressMapping, Runner, account::CrossAccountId as _,55	OnMethodCall, Account as EVMAccount, FeeCalculator, GasWeightMapping,56};57pub use frame_support::{58	construct_runtime, match_types,59	dispatch::DispatchResult,60	PalletId, parameter_types, StorageValue, ConsensusEngineId,61	traits::{62		tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Everything,63		Currency, ExistenceRequirement, Get, IsInVec, KeyOwnerProofSystem, LockIdentifier,64		OnUnbalanced, Randomness, FindAuthor, ConstU32, Imbalance, PrivilegeCmp,65	},66	weights::{67		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},68		DispatchClass, DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,69		WeightToFeePolynomial, WeightToFeeCoefficient, WeightToFeeCoefficients, ConstantMultiplier,70	},71};72use pallet_unq_scheduler::DispatchCall;73use up_data_structs::mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping};7475// use pallet_contracts::weights::WeightInfo;76// #[cfg(any(feature = "std", test))]77use frame_system::{78	self as frame_system, EnsureRoot, EnsureSigned,79	limits::{BlockWeights, BlockLength},80};81use sp_arithmetic::{82	traits::{BaseArithmetic, Unsigned},83};84use smallvec::smallvec;85// use scale_info::TypeInfo;86use codec::{Encode, Decode};87use fp_rpc::TransactionStatus;88use sp_runtime::{89	traits::{90		Applyable, BlockNumberProvider, Dispatchable, PostDispatchInfoOf, Saturating,91		CheckedConversion,92	},93	generic::Era,94	transaction_validity::TransactionValidityError,95	DispatchErrorWithPostInfo, SaturatedConversion,96};9798// pub use pallet_timestamp::Call as TimestampCall;99pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;100101// Polkadot imports102use pallet_xcm::XcmPassthrough;103use polkadot_parachain::primitives::Sibling;104use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};105use xcm_builder::{106	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,107	EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser,108	RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,109	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,110	ParentIsPreset,111};112use xcm_executor::{Config, XcmExecutor, Assets};113use sp_std::{cmp::Ordering, marker::PhantomData};114115use xcm::latest::{116	//	Xcm,117	AssetId::{Concrete},118	Fungibility::Fungible as XcmFungible,119	MultiAsset,120	Error as XcmError,121};122use xcm_executor::traits::{MatchesFungible, WeightTrader};123//use xcm_executor::traits::MatchesFungible;124125use unique_runtime_common::{126	impl_common_runtime_apis,127	types::*,128	constants::*,129	dispatch::{CollectionDispatchT, CollectionDispatch},130	sponsoring::UniqueSponsorshipHandler,131	eth_sponsoring::UniqueEthSponsorshipHandler,132	weights::CommonWeights,133};134135pub const RUNTIME_NAME: &str = "opal";136pub const TOKEN_SYMBOL: &str = "OPL";137138type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;139140impl RuntimeInstance for Runtime {141	type CrossAccountId = self::CrossAccountId;142	type TransactionConverter = self::TransactionConverter;143144	fn get_transaction_converter() -> TransactionConverter {145		TransactionConverter146	}147}148149/// The type for looking up accounts. We don't expect more than 4 billion of them, but you150/// never know...151pub type AccountIndex = u32;152153/// Balance of an account.154pub type Balance = u128;155156/// Index of a transaction in the chain.157pub type Index = u32;158159/// A hash of some data used by the chain.160pub type Hash = sp_core::H256;161162/// Digest item type.163pub type DigestItem = generic::DigestItem;164165/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know166/// the specifics of the runtime. They can then be made to be agnostic over specific formats167/// of data like extrinsics, allowing for them to continue syncing the network through upgrades168/// to even the core data structures.169pub mod opaque {170	use sp_std::prelude::*;171	use sp_runtime::impl_opaque_keys;172	use super::Aura;173174	pub use unique_runtime_common::types::*;175176	impl_opaque_keys! {177		pub struct SessionKeys {178			pub aura: Aura,179		}180	}181}182183/// This runtime version.184pub const VERSION: RuntimeVersion = RuntimeVersion {185	spec_name: create_runtime_str!(RUNTIME_NAME),186	impl_name: create_runtime_str!(RUNTIME_NAME),187	authoring_version: 1,188	spec_version: 921000,189	impl_version: 0,190	apis: RUNTIME_API_VERSIONS,191	transaction_version: 1,192	state_version: 0,193};194195#[derive(codec::Encode, codec::Decode)]196pub enum XCMPMessage<XAccountId, XBalance> {197	/// Transfer tokens to the given account from the Parachain account.198	TransferToken(XAccountId, XBalance),199}200201/// The version information used to identify this runtime when compiled natively.202#[cfg(feature = "std")]203pub fn native_version() -> NativeVersion {204	NativeVersion {205		runtime_version: VERSION,206		can_author_with: Default::default(),207	}208}209210type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;211212pub struct DealWithFees;213impl OnUnbalanced<NegativeImbalance> for DealWithFees {214	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {215		if let Some(fees) = fees_then_tips.next() {216			// for fees, 100% to treasury217			let mut split = fees.ration(100, 0);218			if let Some(tips) = fees_then_tips.next() {219				// for tips, if any, 100% to treasury220				tips.ration_merge_into(100, 0, &mut split);221			}222			Treasury::on_unbalanced(split.0);223			// Author::on_unbalanced(split.1);224		}225	}226}227228parameter_types! {229	pub const BlockHashCount: BlockNumber = 2400;230	pub RuntimeBlockLength: BlockLength =231		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);232	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);233	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;234	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()235		.base_block(BlockExecutionWeight::get())236		.for_class(DispatchClass::all(), |weights| {237			weights.base_extrinsic = ExtrinsicBaseWeight::get();238		})239		.for_class(DispatchClass::Normal, |weights| {240			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);241		})242		.for_class(DispatchClass::Operational, |weights| {243			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);244			// Operational transactions have some extra reserved space, so that they245			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.246			weights.reserved = Some(247				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT248			);249		})250		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)251		.build_or_panic();252	pub const Version: RuntimeVersion = VERSION;253	pub const SS58Prefix: u8 = 42;254}255256parameter_types! {257	pub const ChainId: u64 = 8882;258}259260pub struct FixedFee;261impl FeeCalculator for FixedFee {262	fn min_gas_price() -> U256 {263		MIN_GAS_PRICE.into()264	}265}266267// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case268// (contract, which only writes a lot of data),269// approximating on top of our real store write weight270parameter_types! {271	pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;272	pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;273	pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();274}275276/// Limiting EVM execution to 50% of block for substrate users and management tasks277/// EVM transaction consumes more weight than substrate's, so we can't rely on them being278/// scheduled fairly279const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);280parameter_types! {281	pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());282}283284pub enum FixedGasWeightMapping {}285impl GasWeightMapping for FixedGasWeightMapping {286	fn gas_to_weight(gas: u64) -> Weight {287		gas.saturating_mul(WeightPerGas::get())288	}289	fn weight_to_gas(weight: Weight) -> u64 {290		weight / WeightPerGas::get()291	}292}293294impl pallet_evm::account::Config for Runtime {295	type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Self>;296	type EvmAddressMapping = pallet_evm::HashedAddressMapping<Self::Hashing>;297	type EvmBackwardsAddressMapping = fp_evm_mapping::MapBackwardsAddressTruncated;298}299300impl pallet_evm::Config for Runtime {301	type BlockGasLimit = BlockGasLimit;302	type FeeCalculator = FixedFee;303	type GasWeightMapping = FixedGasWeightMapping;304	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;305	type CallOrigin = EnsureAddressTruncated<Self>;306	type WithdrawOrigin = EnsureAddressTruncated<Self>;307	type AddressMapping = HashedAddressMapping<Self::Hashing>;308	type PrecompilesType = ();309	type PrecompilesValue = ();310	type Currency = Balances;311	type Event = Event;312	type OnMethodCall = (313		pallet_evm_migration::OnMethodCall<Self>,314		pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,315		CollectionDispatchT<Self>,316		pallet_unique::eth::CollectionHelpersOnMethodCall<Self>,317	);318	type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;319	type ChainId = ChainId;320	type Runner = pallet_evm::runner::stack::Runner<Self>;321	type OnChargeTransaction = pallet_evm::EVMCurrencyAdapter<Balances, DealWithFees>;322	type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;323	type FindAuthor = EthereumFindAuthor<Aura>;324}325326impl pallet_evm_migration::Config for Runtime {327	type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;328}329330pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);331impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {332	fn find_author<'a, I>(digests: I) -> Option<H160>333	where334		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,335	{336		if let Some(author_index) = F::find_author(digests) {337			let authority_id = Aura::authorities()[author_index as usize].clone();338			return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));339		}340		None341	}342}343344impl pallet_ethereum::Config for Runtime {345	type Event = Event;346	type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;347}348349impl pallet_randomness_collective_flip::Config for Runtime {}350351impl frame_system::Config for Runtime {352	/// The data to be stored in an account.353	type AccountData = pallet_balances::AccountData<Balance>;354	/// The identifier used to distinguish between accounts.355	type AccountId = AccountId;356	/// The basic call filter to use in dispatchable.357	type BaseCallFilter = Everything;358	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).359	type BlockHashCount = BlockHashCount;360	/// The maximum length of a block (in bytes).361	type BlockLength = RuntimeBlockLength;362	/// The index type for blocks.363	type BlockNumber = BlockNumber;364	/// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.365	type BlockWeights = RuntimeBlockWeights;366	/// The aggregated dispatch type that is available for extrinsics.367	type Call = Call;368	/// The weight of database operations that the runtime can invoke.369	type DbWeight = RocksDbWeight;370	/// The ubiquitous event type.371	type Event = Event;372	/// The type for hashing blocks and tries.373	type Hash = Hash;374	/// The hashing algorithm used.375	type Hashing = BlakeTwo256;376	/// The header type.377	type Header = generic::Header<BlockNumber, BlakeTwo256>;378	/// The index type for storing how many extrinsics an account has signed.379	type Index = Index;380	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.381	type Lookup = AccountIdLookup<AccountId, ()>;382	/// What to do if an account is fully reaped from the system.383	type OnKilledAccount = ();384	/// What to do if a new account is created.385	type OnNewAccount = ();386	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;387	/// The ubiquitous origin type.388	type Origin = Origin;389	/// This type is being generated by `construct_runtime!`.390	type PalletInfo = PalletInfo;391	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.392	type SS58Prefix = SS58Prefix;393	/// Weight information for the extrinsics of this pallet.394	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;395	/// Version of the runtime.396	type Version = Version;397	type MaxConsumers = ConstU32<16>;398}399400parameter_types! {401	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;402}403404impl pallet_timestamp::Config for Runtime {405	/// A timestamp: milliseconds since the unix epoch.406	type Moment = u64;407	type OnTimestampSet = ();408	type MinimumPeriod = MinimumPeriod;409	type WeightInfo = ();410}411412parameter_types! {413	// pub const ExistentialDeposit: u128 = 500;414	pub const ExistentialDeposit: u128 = 0;415	pub const MaxLocks: u32 = 50;416	pub const MaxReserves: u32 = 50;417}418419impl pallet_balances::Config for Runtime {420	type MaxLocks = MaxLocks;421	type MaxReserves = MaxReserves;422	type ReserveIdentifier = [u8; 16];423	/// The type for recording an account's balance.424	type Balance = Balance;425	/// The ubiquitous event type.426	type Event = Event;427	type DustRemoval = Treasury;428	type ExistentialDeposit = ExistentialDeposit;429	type AccountStore = System;430	type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;431}432433pub const fn deposit(items: u32, bytes: u32) -> Balance {434	items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE435}436437/*438parameter_types! {439	pub TombstoneDeposit: Balance = deposit(440		1,441		sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,442	);443	pub DepositPerContract: Balance = TombstoneDeposit::get();444	pub const DepositPerStorageByte: Balance = deposit(0, 1);445	pub const DepositPerStorageItem: Balance = deposit(1, 0);446	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);447	pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;448	pub const SignedClaimHandicap: u32 = 2;449	pub const MaxDepth: u32 = 32;450	pub const MaxValueSize: u32 = 16 * 1024;451	pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb452	// The lazy deletion runs inside on_initialize.453	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *454		RuntimeBlockWeights::get().max_block;455	// The weight needed for decoding the queue should be less or equal than a fifth456	// of the overall weight dedicated to the lazy deletion.457	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (458			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -459			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)460		)) / 5) as u32;461	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();462}463464impl pallet_contracts::Config for Runtime {465	type Time = Timestamp;466	type Randomness = RandomnessCollectiveFlip;467	type Currency = Balances;468	type Event = Event;469	type RentPayment = ();470	type SignedClaimHandicap = SignedClaimHandicap;471	type TombstoneDeposit = TombstoneDeposit;472	type DepositPerContract = DepositPerContract;473	type DepositPerStorageByte = DepositPerStorageByte;474	type DepositPerStorageItem = DepositPerStorageItem;475	type RentFraction = RentFraction;476	type SurchargeReward = SurchargeReward;477	type WeightPrice = pallet_transaction_payment::Pallet<Self>;478	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;479	type ChainExtension = NFTExtension;480	type DeletionQueueDepth = DeletionQueueDepth;481	type DeletionWeightLimit = DeletionWeightLimit;482	type Schedule = Schedule;483	type CallStack = [pallet_contracts::Frame<Self>; 31];484}485*/486487parameter_types! {488	/// This value increases the priority of `Operational` transactions by adding489	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.490	pub const OperationalFeeMultiplier: u8 = 5;491}492493/// Linear implementor of `WeightToFeePolynomial`494pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);495496impl<T> WeightToFeePolynomial for LinearFee<T>497where498	T: BaseArithmetic + From<u32> + Copy + Unsigned,499{500	type Balance = T;501502	fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {503		smallvec!(WeightToFeeCoefficient {504			// Targeting 0.1 Unique per NFT transfer505			coeff_integer: WEIGHT_TO_FEE_COEFF.into(),506			coeff_frac: Perbill::zero(),507			negative: false,508			degree: 1,509		})510	}511}512513impl pallet_transaction_payment::Config for Runtime {514	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;515	type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;516	type OperationalFeeMultiplier = OperationalFeeMultiplier;517	type WeightToFee = LinearFee<Balance>;518	type FeeMultiplierUpdate = ();519}520521parameter_types! {522	pub const ProposalBond: Permill = Permill::from_percent(5);523	pub const ProposalBondMinimum: Balance = 1 * UNIQUE;524	pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;525	pub const SpendPeriod: BlockNumber = 5 * MINUTES;526	pub const Burn: Permill = Permill::from_percent(0);527	pub const TipCountdown: BlockNumber = 1 * DAYS;528	pub const TipFindersFee: Percent = Percent::from_percent(20);529	pub const TipReportDepositBase: Balance = 1 * UNIQUE;530	pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;531	pub const BountyDepositBase: Balance = 1 * UNIQUE;532	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;533	pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");534	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;535	pub const MaximumReasonLength: u32 = 16384;536	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);537	pub const BountyValueMinimum: Balance = 5 * UNIQUE;538	pub const MaxApprovals: u32 = 100;539}540541impl pallet_treasury::Config for Runtime {542	type PalletId = TreasuryModuleId;543	type Currency = Balances;544	type ApproveOrigin = EnsureRoot<AccountId>;545	type RejectOrigin = EnsureRoot<AccountId>;546	type Event = Event;547	type OnSlash = ();548	type ProposalBond = ProposalBond;549	type ProposalBondMinimum = ProposalBondMinimum;550	type ProposalBondMaximum = ProposalBondMaximum;551	type SpendPeriod = SpendPeriod;552	type Burn = Burn;553	type BurnDestination = ();554	type SpendFunds = ();555	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;556	type MaxApprovals = MaxApprovals;557}558559impl pallet_sudo::Config for Runtime {560	type Event = Event;561	type Call = Call;562}563564pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);565566impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider567	for RelayChainBlockNumberProvider<T>568{569	type BlockNumber = BlockNumber;570571	fn current_block_number() -> Self::BlockNumber {572		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()573			.map(|d| d.relay_parent_number)574			.unwrap_or_default()575	}576}577578parameter_types! {579	pub const MinVestedTransfer: Balance = 10 * UNIQUE;580	pub const MaxVestingSchedules: u32 = 28;581}582583impl orml_vesting::Config for Runtime {584	type Event = Event;585	type Currency = pallet_balances::Pallet<Runtime>;586	type MinVestedTransfer = MinVestedTransfer;587	type VestedTransferOrigin = EnsureSigned<AccountId>;588	type WeightInfo = ();589	type MaxVestingSchedules = MaxVestingSchedules;590	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;591}592593parameter_types! {594	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;595	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;596}597598impl cumulus_pallet_parachain_system::Config for Runtime {599	type Event = Event;600	type SelfParaId = parachain_info::Pallet<Self>;601	type OnSystemEvent = ();602	// type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<603	// 	MaxDownwardMessageWeight,604	// 	XcmExecutor<XcmConfig>,605	// 	Call,606	// >;607	type OutboundXcmpMessageSource = XcmpQueue;608	type DmpMessageHandler = DmpQueue;609	type ReservedDmpWeight = ReservedDmpWeight;610	type ReservedXcmpWeight = ReservedXcmpWeight;611	type XcmpMessageHandler = XcmpQueue;612}613614impl parachain_info::Config for Runtime {}615616impl cumulus_pallet_aura_ext::Config for Runtime {}617618parameter_types! {619	pub const RelayLocation: MultiLocation = MultiLocation::parent();620	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;621	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();622	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();623}624625/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used626/// when determining ownership of accounts for asset transacting and when attempting to use XCM627/// `Transact` in order to determine the dispatch Origin.628pub type LocationToAccountId = (629	// The parent (Relay-chain) origin converts to the default `AccountId`.630	ParentIsPreset<AccountId>,631	// Sibling parachain origins convert to AccountId via the `ParaId::into`.632	SiblingParachainConvertsVia<Sibling, AccountId>,633	// Straight up local `AccountId32` origins just alias directly to `AccountId`.634	AccountId32Aliases<RelayNetwork, AccountId>,635);636637pub struct OnlySelfCurrency;638impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {639	fn matches_fungible(a: &MultiAsset) -> Option<B> {640		match (&a.id, &a.fun) {641			(Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),642			_ => None,643		}644	}645}646647/// Means for transacting assets on this chain.648pub type LocalAssetTransactor = CurrencyAdapter<649	// Use this currency:650	Balances,651	// Use this currency when it is a fungible asset matching the given location or name:652	OnlySelfCurrency,653	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:654	LocationToAccountId,655	// Our chain's account ID type (we can't get away without mentioning it explicitly):656	AccountId,657	// We don't track any teleports.658	(),659>;660661/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,662/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can663/// biases the kind of local `Origin` it will become.664pub type XcmOriginToTransactDispatchOrigin = (665	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location666	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for667	// foreign chains who want to have a local sovereign account on this chain which they control.668	SovereignSignedViaLocation<LocationToAccountId, Origin>,669	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when670	// recognised.671	RelayChainAsNative<RelayOrigin, Origin>,672	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when673	// recognised.674	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,675	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a676	// transaction from the Root origin.677	ParentAsSuperuser<Origin>,678	// Native signed account converter; this just converts an `AccountId32` origin into a normal679	// `Origin::Signed` origin of the same 32-byte value.680	SignedAccountId32AsNative<RelayNetwork, Origin>,681	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.682	XcmPassthrough<Origin>,683);684685parameter_types! {686	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.687	pub UnitWeightCost: Weight = 1_000_000;688	// 1200 UNIQUEs buy 1 second of weight.689	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);690	pub const MaxInstructions: u32 = 100;691	pub const MaxAuthorities: u32 = 100_000;692}693694match_types! {695	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {696		MultiLocation { parents: 1, interior: Here } |697		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }698	};699}700701pub type Barrier = (702	TakeWeightCredit,703	AllowTopLevelPaidExecutionFrom<Everything>,704	AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,705	// ^^^ Parent & its unit plurality gets free execution706);707708pub struct UsingOnlySelfCurrencyComponents<709	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,710	AssetId: Get<MultiLocation>,711	AccountId,712	Currency: CurrencyT<AccountId>,713	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,714>(715	Weight,716	Currency::Balance,717	PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,718);719impl<720		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,721		AssetId: Get<MultiLocation>,722		AccountId,723		Currency: CurrencyT<AccountId>,724		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,725	> WeightTrader726	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>727{728	fn new() -> Self {729		Self(0, Zero::zero(), PhantomData)730	}731732	fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {733		let amount = WeightToFee::calc(&weight);734		let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;735736		// location to this parachain through relay chain737		let option1: xcm::v1::AssetId = Concrete(MultiLocation {738			parents: 1,739			interior: X1(Parachain(ParachainInfo::parachain_id().into())),740		});741		// direct location742		let option2: xcm::v1::AssetId = Concrete(MultiLocation {743			parents: 0,744			interior: Here,745		});746747		let required = if payment.fungible.contains_key(&option1) {748			(option1, u128_amount).into()749		} else if payment.fungible.contains_key(&option2) {750			(option2, u128_amount).into()751		} else {752			(Concrete(MultiLocation::default()), u128_amount).into()753		};754755		let unused = payment756			.checked_sub(required)757			.map_err(|_| XcmError::TooExpensive)?;758		self.0 = self.0.saturating_add(weight);759		self.1 = self.1.saturating_add(amount);760		Ok(unused)761	}762763	fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {764		let weight = weight.min(self.0);765		let amount = WeightToFee::calc(&weight);766		self.0 -= weight;767		self.1 = self.1.saturating_sub(amount);768		let amount: u128 = amount.saturated_into();769		if amount > 0 {770			Some((AssetId::get(), amount).into())771		} else {772			None773		}774	}775}776impl<777		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,778		AssetId: Get<MultiLocation>,779		AccountId,780		Currency: CurrencyT<AccountId>,781		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,782	> Drop783	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>784{785	fn drop(&mut self) {786		OnUnbalanced::on_unbalanced(Currency::issue(self.1));787	}788}789790pub struct XcmConfig;791impl Config for XcmConfig {792	type Call = Call;793	type XcmSender = XcmRouter;794	// How to withdraw and deposit an asset.795	type AssetTransactor = LocalAssetTransactor;796	type OriginConverter = XcmOriginToTransactDispatchOrigin;797	type IsReserve = NativeAsset;798	type IsTeleporter = (); // Teleportation is disabled799	type LocationInverter = LocationInverter<Ancestry>;800	type Barrier = Barrier;801	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;802	type Trader = UsingOnlySelfCurrencyComponents<803		IdentityFee<Balance>,804		RelayLocation,805		AccountId,806		Balances,807		(),808	>;809	type ResponseHandler = (); // Don't handle responses for now.810	type SubscriptionService = PolkadotXcm;811812	type AssetTrap = PolkadotXcm;813	type AssetClaims = PolkadotXcm;814}815816// parameter_types! {817// 	pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;818// }819820/// No local origins on this chain are allowed to dispatch XCM sends/executions.821pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);822823/// The means for routing XCM messages which are not for local execution into the right message824/// queues.825pub type XcmRouter = (826	// Two routers - use UMP to communicate with the relay chain:827	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,828	// ..and XCMP to communicate with the sibling chains.829	XcmpQueue,830);831832impl pallet_evm_coder_substrate::Config for Runtime {}833834impl pallet_xcm::Config for Runtime {835	type Event = Event;836	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;837	type XcmRouter = XcmRouter;838	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;839	type XcmExecuteFilter = Everything;840	type XcmExecutor = XcmExecutor<XcmConfig>;841	type XcmTeleportFilter = Everything;842	type XcmReserveTransferFilter = Everything;843	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;844	type LocationInverter = LocationInverter<Ancestry>;845	type Origin = Origin;846	type Call = Call;847	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;848	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;849}850851impl cumulus_pallet_xcm::Config for Runtime {852	type Event = Event;853	type XcmExecutor = XcmExecutor<XcmConfig>;854}855856impl cumulus_pallet_xcmp_queue::Config for Runtime {857	type WeightInfo = ();858	type Event = Event;859	type XcmExecutor = XcmExecutor<XcmConfig>;860	type ChannelInfo = ParachainSystem;861	type VersionWrapper = ();862	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;863	type ControllerOrigin = EnsureRoot<AccountId>;864	type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;865}866867impl cumulus_pallet_dmp_queue::Config for Runtime {868	type Event = Event;869	type XcmExecutor = XcmExecutor<XcmConfig>;870	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;871}872873impl pallet_aura::Config for Runtime {874	type AuthorityId = AuraId;875	type DisabledValidators = ();876	type MaxAuthorities = MaxAuthorities;877}878879parameter_types! {880	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();881	pub const CollectionCreationPrice: Balance = 2 * UNIQUE;882}883884impl pallet_common::Config for Runtime {885	type WeightInfo = pallet_common::weights::SubstrateWeight<Self>;886	type Event = Event;887	type Currency = Balances;888	type CollectionCreationPrice = CollectionCreationPrice;889	type TreasuryAccountId = TreasuryAccountId;890	type CollectionDispatch = CollectionDispatchT<Self>;891892	type EvmTokenAddressMapping = EvmTokenAddressMapping;893	type CrossTokenAddressMapping = CrossTokenAddressMapping<Self::AccountId>;894	type ContractAddress = EvmCollectionHelpersAddress;895}896897impl pallet_structure::Config for Runtime {898	type Event = Event;899	type Call = Call;900	type WeightInfo = pallet_structure::weights::SubstrateWeight<Self>;901}902903impl pallet_fungible::Config for Runtime {904	type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;905}906impl pallet_refungible::Config for Runtime {907	type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;908}909impl pallet_nonfungible::Config for Runtime {910	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;911}912913/*914TODO 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,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,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);10851086type SponsorshipHandler = (1087	UniqueSponsorshipHandler<Runtime>,1088	//pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1089	pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1090);10911092impl pallet_evm_transaction_payment::Config for Runtime {1093	type EvmSponsorshipHandler = EvmSponsorshipHandler;1094	type Currency = Balances;1095}10961097impl pallet_charge_transaction::Config for Runtime {1098	type SponsorshipHandler = SponsorshipHandler;1099}11001101// impl pallet_contract_helpers::Config for Runtime {1102//	 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1103// }11041105parameter_types! {1106	// 0x842899ECF380553E8a4de75bF534cdf6fBF640491107	pub const HelpersContractAddress: H160 = H160([1108		0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1109	]);11101111	// 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f1112	pub const EvmCollectionHelpersAddress: H160 = H160([1113		0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,1114	]);1115}11161117impl pallet_evm_contract_helpers::Config for Runtime {1118	type ContractAddress = HelpersContractAddress;1119	type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1120}11211122construct_runtime!(1123	pub enum Runtime where1124		Block = Block,1125		NodeBlock = opaque::Block,1126		UncheckedExtrinsic = UncheckedExtrinsic1127	{1128		ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1129		ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,11301131		Aura: pallet_aura::{Pallet, Config<T>} = 22,1132		AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,11331134		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1135		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1136		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1137		TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1138		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1139		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1140		System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1141		Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1142		// Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1143		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,11441145		// XCM helpers.1146		XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1147		PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1148		CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1149		DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11501151		// Unique Pallets1152		Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1153		Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1154		Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1155		// free = 631156		Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1157		// ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1158		Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1159		Fungible: pallet_fungible::{Pallet, Storage} = 67,1160		Refungible: pallet_refungible::{Pallet, Storage} = 68,1161		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1162		Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,1163		/* TODO free RMRK!1164		RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,1165		RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,1166		*/11671168		// Frontier1169		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1170		Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11711172		EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1173		EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1174		EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1175		EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1176	}1177);11781179pub struct TransactionConverter;11801181impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1182	fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1183		UncheckedExtrinsic::new_unsigned(1184			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1185		)1186	}1187}11881189impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1190	fn convert_transaction(1191		&self,1192		transaction: pallet_ethereum::Transaction,1193	) -> opaque::UncheckedExtrinsic {1194		let extrinsic = UncheckedExtrinsic::new_unsigned(1195			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1196		);1197		let encoded = extrinsic.encode();1198		opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1199			.expect("Encoded extrinsic is always valid")1200	}1201}12021203/// The address format for describing accounts.1204pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1205/// Block header type as expected by this runtime.1206pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1207/// Block type as expected by this runtime.1208pub type Block = generic::Block<Header, UncheckedExtrinsic>;1209/// A Block signed with a Justification1210pub type SignedBlock = generic::SignedBlock<Block>;1211/// BlockId type as expected by this runtime.1212pub type BlockId = generic::BlockId<Block>;1213/// The SignedExtension to the basic transaction logic.1214pub type SignedExtra = (1215	frame_system::CheckSpecVersion<Runtime>,1216	// system::CheckTxVersion<Runtime>,1217	frame_system::CheckGenesis<Runtime>,1218	frame_system::CheckEra<Runtime>,1219	frame_system::CheckNonce<Runtime>,1220	frame_system::CheckWeight<Runtime>,1221	ChargeTransactionPayment,1222	//pallet_contract_helpers::ContractHelpersExtension<Runtime>,1223	pallet_ethereum::FakeTransactionFinalizer<Runtime>,1224);1225pub type SignedExtraScheduler = (1226	frame_system::CheckSpecVersion<Runtime>,1227	frame_system::CheckGenesis<Runtime>,1228	frame_system::CheckEra<Runtime>,1229	frame_system::CheckNonce<Runtime>,1230	frame_system::CheckWeight<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(&self, info: &Self::SignedInfo) -> Option<TransactionValidity> {1270		match self {1271			Call::Ethereum(call) => call.validate_self_contained(info),1272			_ => None,1273		}1274	}12751276	fn pre_dispatch_self_contained(1277		&self,1278		info: &Self::SignedInfo,1279	) -> Option<Result<(), TransactionValidityError>> {1280		match self {1281			Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1282			_ => None,1283		}1284	}12851286	fn apply_self_contained(1287		self,1288		info: Self::SignedInfo,1289	) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1290		match self {1291			call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1292				Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1293			)),1294			_ => None,1295		}1296	}1297}12981299macro_rules! dispatch_unique_runtime {1300	($collection:ident.$method:ident($($name:ident),*)) => {{1301		let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1302		let dispatch = collection.as_dyn();13031304		Ok::<_, DispatchError>(dispatch.$method($($name),*))1305	}};1306}13071308impl_common_runtime_apis!();13091310struct CheckInherents;13111312impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1313	fn check_inherents(1314		block: &Block,1315		relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1316	) -> sp_inherents::CheckInherentsResult {1317		let relay_chain_slot = relay_state_proof1318			.read_slot()1319			.expect("Could not read the relay chain slot from the proof");13201321		let inherent_data =1322			cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1323				relay_chain_slot,1324				sp_std::time::Duration::from_secs(6),1325			)1326			.create_inherent_data()1327			.expect("Could not create the timestamp inherent data");13281329		inherent_data.check_extrinsics(block)1330	}1331}13321333cumulus_pallet_parachain_system::register_validate_block!(1334	Runtime = Runtime,1335	BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1336	CheckInherents = CheckInherents,1337);