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

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	TokenChild,77	RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,78	RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkThemeProperty,79	RmrkCollectionId, RmrkNftId, RmrkAccountIdOrCollectionNftTuple,80	RmrkNftChild, RmrkPropertyKey, RmrkResourceTypes, RmrkBasicResource,81	RmrkComposableResource, RmrkSlotResource, RmrkResourceId, RmrkBaseId,82	RmrkFixedPart, RmrkSlotPart, RmrkString, 83};8485// use pallet_contracts::weights::WeightInfo;86// #[cfg(any(feature = "std", test))]87use frame_system::{88	self as frame_system, EnsureRoot, EnsureSigned,89	limits::{BlockWeights, BlockLength},90};91use sp_arithmetic::{92	traits::{BaseArithmetic, Unsigned},93};94use smallvec::smallvec;95// use scale_info::TypeInfo;96use codec::{Encode, Decode};97use fp_rpc::TransactionStatus;98use sp_runtime::{99	traits::{100		Applyable, BlockNumberProvider, Dispatchable, PostDispatchInfoOf, DispatchInfoOf,101		Saturating, CheckedConversion,102	},103	generic::Era,104	transaction_validity::TransactionValidityError,105	DispatchErrorWithPostInfo, SaturatedConversion,106};107108// pub use pallet_timestamp::Call as TimestampCall;109pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;110111// Polkadot imports112use pallet_xcm::XcmPassthrough;113use polkadot_parachain::primitives::Sibling;114use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};115use xcm_builder::{116	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,117	EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser,118	RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,119	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,120	ParentIsPreset,121};122use xcm_executor::{Config, XcmExecutor, Assets};123use sp_std::{cmp::Ordering, marker::PhantomData};124125use xcm::latest::{126	//	Xcm,127	AssetId::{Concrete},128	Fungibility::Fungible as XcmFungible,129	MultiAsset,130	Error as XcmError,131};132use xcm_executor::traits::{MatchesFungible, WeightTrader};133//use xcm_executor::traits::MatchesFungible;134135use unique_runtime_common::{136	impl_common_runtime_apis,137	types::*,138	constants::*,139	dispatch::{CollectionDispatchT, CollectionDispatch},140	sponsoring::UniqueSponsorshipHandler,141	eth_sponsoring::UniqueEthSponsorshipHandler,142	weights::CommonWeights,143};144145pub const RUNTIME_NAME: &str = "opal";146pub const TOKEN_SYMBOL: &str = "OPL";147148type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;149150impl RuntimeInstance for Runtime {151	type CrossAccountId = self::CrossAccountId;152	type TransactionConverter = self::TransactionConverter;153154	fn get_transaction_converter() -> TransactionConverter {155		TransactionConverter156	}157}158159/// The type for looking up accounts. We don't expect more than 4 billion of them, but you160/// never know...161pub type AccountIndex = u32;162163/// Balance of an account.164pub type Balance = u128;165166/// Index of a transaction in the chain.167pub type Index = u32;168169/// A hash of some data used by the chain.170pub type Hash = sp_core::H256;171172/// Digest item type.173pub type DigestItem = generic::DigestItem;174175/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know176/// the specifics of the runtime. They can then be made to be agnostic over specific formats177/// of data like extrinsics, allowing for them to continue syncing the network through upgrades178/// to even the core data structures.179pub mod opaque {180	use sp_std::prelude::*;181	use sp_runtime::impl_opaque_keys;182	use super::Aura;183184	pub use unique_runtime_common::types::*;185186	impl_opaque_keys! {187		pub struct SessionKeys {188			pub aura: Aura,189		}190	}191}192193/// This runtime version.194pub const VERSION: RuntimeVersion = RuntimeVersion {195	spec_name: create_runtime_str!(RUNTIME_NAME),196	impl_name: create_runtime_str!(RUNTIME_NAME),197	authoring_version: 1,198	spec_version: 922000,199	impl_version: 0,200	apis: RUNTIME_API_VERSIONS,201	transaction_version: 1,202	state_version: 0,203};204205#[derive(codec::Encode, codec::Decode)]206pub enum XCMPMessage<XAccountId, XBalance> {207	/// Transfer tokens to the given account from the Parachain account.208	TransferToken(XAccountId, XBalance),209}210211/// The version information used to identify this runtime when compiled natively.212#[cfg(feature = "std")]213pub fn native_version() -> NativeVersion {214	NativeVersion {215		runtime_version: VERSION,216		can_author_with: Default::default(),217	}218}219220type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;221222pub struct DealWithFees;223impl OnUnbalanced<NegativeImbalance> for DealWithFees {224	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {225		if let Some(fees) = fees_then_tips.next() {226			// for fees, 100% to treasury227			let mut split = fees.ration(100, 0);228			if let Some(tips) = fees_then_tips.next() {229				// for tips, if any, 100% to treasury230				tips.ration_merge_into(100, 0, &mut split);231			}232			Treasury::on_unbalanced(split.0);233			// Author::on_unbalanced(split.1);234		}235	}236}237238parameter_types! {239	pub const BlockHashCount: BlockNumber = 2400;240	pub RuntimeBlockLength: BlockLength =241		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);242	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);243	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;244	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()245		.base_block(BlockExecutionWeight::get())246		.for_class(DispatchClass::all(), |weights| {247			weights.base_extrinsic = ExtrinsicBaseWeight::get();248		})249		.for_class(DispatchClass::Normal, |weights| {250			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);251		})252		.for_class(DispatchClass::Operational, |weights| {253			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);254			// Operational transactions have some extra reserved space, so that they255			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.256			weights.reserved = Some(257				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT258			);259		})260		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)261		.build_or_panic();262	pub const Version: RuntimeVersion = VERSION;263	pub const SS58Prefix: u8 = 42;264}265266parameter_types! {267	pub const ChainId: u64 = 8882;268}269270pub struct FixedFee;271impl FeeCalculator for FixedFee {272	fn min_gas_price() -> (U256, u64) {273		(MIN_GAS_PRICE.into(), 0)274	}275}276277// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case278// (contract, which only writes a lot of data),279// approximating on top of our real store write weight280parameter_types! {281	pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;282	pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;283	pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();284}285286/// Limiting EVM execution to 50% of block for substrate users and management tasks287/// EVM transaction consumes more weight than substrate's, so we can't rely on them being288/// scheduled fairly289const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);290parameter_types! {291	pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());292}293294pub enum FixedGasWeightMapping {}295impl GasWeightMapping for FixedGasWeightMapping {296	fn gas_to_weight(gas: u64) -> Weight {297		gas.saturating_mul(WeightPerGas::get())298	}299	fn weight_to_gas(weight: Weight) -> u64 {300		weight / WeightPerGas::get()301	}302}303304impl pallet_evm::account::Config for Runtime {305	type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Self>;306	type EvmAddressMapping = pallet_evm::HashedAddressMapping<Self::Hashing>;307	type EvmBackwardsAddressMapping = fp_evm_mapping::MapBackwardsAddressTruncated;308}309310impl pallet_evm::Config for Runtime {311	type BlockGasLimit = BlockGasLimit;312	type FeeCalculator = FixedFee;313	type GasWeightMapping = FixedGasWeightMapping;314	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;315	type CallOrigin = EnsureAddressTruncated<Self>;316	type WithdrawOrigin = EnsureAddressTruncated<Self>;317	type AddressMapping = HashedAddressMapping<Self::Hashing>;318	type PrecompilesType = ();319	type PrecompilesValue = ();320	type Currency = Balances;321	type Event = Event;322	type OnMethodCall = (323		pallet_evm_migration::OnMethodCall<Self>,324		pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,325		CollectionDispatchT<Self>,326		pallet_unique::eth::CollectionHelpersOnMethodCall<Self>,327	);328	type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;329	type ChainId = ChainId;330	type Runner = pallet_evm::runner::stack::Runner<Self>;331	type OnChargeTransaction = pallet_evm::EVMCurrencyAdapter<Balances, DealWithFees>;332	type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;333	type FindAuthor = EthereumFindAuthor<Aura>;334}335336impl pallet_evm_migration::Config for Runtime {337	type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;338}339340pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);341impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {342	fn find_author<'a, I>(digests: I) -> Option<H160>343	where344		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,345	{346		if let Some(author_index) = F::find_author(digests) {347			let authority_id = Aura::authorities()[author_index as usize].clone();348			return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));349		}350		None351	}352}353354impl pallet_ethereum::Config for Runtime {355	type Event = Event;356	type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;357}358359impl pallet_randomness_collective_flip::Config for Runtime {}360361impl frame_system::Config for Runtime {362	/// The data to be stored in an account.363	type AccountData = pallet_balances::AccountData<Balance>;364	/// The identifier used to distinguish between accounts.365	type AccountId = AccountId;366	/// The basic call filter to use in dispatchable.367	type BaseCallFilter = Everything;368	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).369	type BlockHashCount = BlockHashCount;370	/// The maximum length of a block (in bytes).371	type BlockLength = RuntimeBlockLength;372	/// The index type for blocks.373	type BlockNumber = BlockNumber;374	/// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.375	type BlockWeights = RuntimeBlockWeights;376	/// The aggregated dispatch type that is available for extrinsics.377	type Call = Call;378	/// The weight of database operations that the runtime can invoke.379	type DbWeight = RocksDbWeight;380	/// The ubiquitous event type.381	type Event = Event;382	/// The type for hashing blocks and tries.383	type Hash = Hash;384	/// The hashing algorithm used.385	type Hashing = BlakeTwo256;386	/// The header type.387	type Header = generic::Header<BlockNumber, BlakeTwo256>;388	/// The index type for storing how many extrinsics an account has signed.389	type Index = Index;390	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.391	type Lookup = AccountIdLookup<AccountId, ()>;392	/// What to do if an account is fully reaped from the system.393	type OnKilledAccount = ();394	/// What to do if a new account is created.395	type OnNewAccount = ();396	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;397	/// The ubiquitous origin type.398	type Origin = Origin;399	/// This type is being generated by `construct_runtime!`.400	type PalletInfo = PalletInfo;401	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.402	type SS58Prefix = SS58Prefix;403	/// Weight information for the extrinsics of this pallet.404	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;405	/// Version of the runtime.406	type Version = Version;407	type MaxConsumers = ConstU32<16>;408}409410parameter_types! {411	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;412}413414impl pallet_timestamp::Config for Runtime {415	/// A timestamp: milliseconds since the unix epoch.416	type Moment = u64;417	type OnTimestampSet = ();418	type MinimumPeriod = MinimumPeriod;419	type WeightInfo = ();420}421422parameter_types! {423	// pub const ExistentialDeposit: u128 = 500;424	pub const ExistentialDeposit: u128 = 0;425	pub const MaxLocks: u32 = 50;426	pub const MaxReserves: u32 = 50;427}428429impl pallet_balances::Config for Runtime {430	type MaxLocks = MaxLocks;431	type MaxReserves = MaxReserves;432	type ReserveIdentifier = [u8; 16];433	/// The type for recording an account's balance.434	type Balance = Balance;435	/// The ubiquitous event type.436	type Event = Event;437	type DustRemoval = Treasury;438	type ExistentialDeposit = ExistentialDeposit;439	type AccountStore = System;440	type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;441}442443pub const fn deposit(items: u32, bytes: u32) -> Balance {444	items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE445}446447/*448parameter_types! {449	pub TombstoneDeposit: Balance = deposit(450		1,451		sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,452	);453	pub DepositPerContract: Balance = TombstoneDeposit::get();454	pub const DepositPerStorageByte: Balance = deposit(0, 1);455	pub const DepositPerStorageItem: Balance = deposit(1, 0);456	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);457	pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;458	pub const SignedClaimHandicap: u32 = 2;459	pub const MaxDepth: u32 = 32;460	pub const MaxValueSize: u32 = 16 * 1024;461	pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb462	// The lazy deletion runs inside on_initialize.463	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *464		RuntimeBlockWeights::get().max_block;465	// The weight needed for decoding the queue should be less or equal than a fifth466	// of the overall weight dedicated to the lazy deletion.467	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (468			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -469			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)470		)) / 5) as u32;471	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();472}473474impl pallet_contracts::Config for Runtime {475	type Time = Timestamp;476	type Randomness = RandomnessCollectiveFlip;477	type Currency = Balances;478	type Event = Event;479	type RentPayment = ();480	type SignedClaimHandicap = SignedClaimHandicap;481	type TombstoneDeposit = TombstoneDeposit;482	type DepositPerContract = DepositPerContract;483	type DepositPerStorageByte = DepositPerStorageByte;484	type DepositPerStorageItem = DepositPerStorageItem;485	type RentFraction = RentFraction;486	type SurchargeReward = SurchargeReward;487	type WeightPrice = pallet_transaction_payment::Pallet<Self>;488	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;489	type ChainExtension = NFTExtension;490	type DeletionQueueDepth = DeletionQueueDepth;491	type DeletionWeightLimit = DeletionWeightLimit;492	type Schedule = Schedule;493	type CallStack = [pallet_contracts::Frame<Self>; 31];494}495*/496497parameter_types! {498	/// This value increases the priority of `Operational` transactions by adding499	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.500	pub const OperationalFeeMultiplier: u8 = 5;501}502503/// Linear implementor of `WeightToFeePolynomial`504pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);505506impl<T> WeightToFeePolynomial for LinearFee<T>507where508	T: BaseArithmetic + From<u32> + Copy + Unsigned,509{510	type Balance = T;511512	fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {513		smallvec!(WeightToFeeCoefficient {514			// Targeting 0.1 Unique per NFT transfer515			coeff_integer: WEIGHT_TO_FEE_COEFF.into(),516			coeff_frac: Perbill::zero(),517			negative: false,518			degree: 1,519		})520	}521}522523impl pallet_transaction_payment::Config for Runtime {524	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;525	type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;526	type OperationalFeeMultiplier = OperationalFeeMultiplier;527	type WeightToFee = LinearFee<Balance>;528	type FeeMultiplierUpdate = ();529}530531parameter_types! {532	pub const ProposalBond: Permill = Permill::from_percent(5);533	pub const ProposalBondMinimum: Balance = 1 * UNIQUE;534	pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;535	pub const SpendPeriod: BlockNumber = 5 * MINUTES;536	pub const Burn: Permill = Permill::from_percent(0);537	pub const TipCountdown: BlockNumber = 1 * DAYS;538	pub const TipFindersFee: Percent = Percent::from_percent(20);539	pub const TipReportDepositBase: Balance = 1 * UNIQUE;540	pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;541	pub const BountyDepositBase: Balance = 1 * UNIQUE;542	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;543	pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");544	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;545	pub const MaximumReasonLength: u32 = 16384;546	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);547	pub const BountyValueMinimum: Balance = 5 * UNIQUE;548	pub const MaxApprovals: u32 = 100;549}550551impl pallet_treasury::Config for Runtime {552	type PalletId = TreasuryModuleId;553	type Currency = Balances;554	type ApproveOrigin = EnsureRoot<AccountId>;555	type RejectOrigin = EnsureRoot<AccountId>;556	type Event = Event;557	type OnSlash = ();558	type ProposalBond = ProposalBond;559	type ProposalBondMinimum = ProposalBondMinimum;560	type ProposalBondMaximum = ProposalBondMaximum;561	type SpendPeriod = SpendPeriod;562	type Burn = Burn;563	type BurnDestination = ();564	type SpendFunds = ();565	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;566	type MaxApprovals = MaxApprovals;567}568569impl pallet_sudo::Config for Runtime {570	type Event = Event;571	type Call = Call;572}573574pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);575576impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider577	for RelayChainBlockNumberProvider<T>578{579	type BlockNumber = BlockNumber;580581	fn current_block_number() -> Self::BlockNumber {582		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()583			.map(|d| d.relay_parent_number)584			.unwrap_or_default()585	}586}587588parameter_types! {589	pub const MinVestedTransfer: Balance = 10 * UNIQUE;590	pub const MaxVestingSchedules: u32 = 28;591}592593impl orml_vesting::Config for Runtime {594	type Event = Event;595	type Currency = pallet_balances::Pallet<Runtime>;596	type MinVestedTransfer = MinVestedTransfer;597	type VestedTransferOrigin = EnsureSigned<AccountId>;598	type WeightInfo = ();599	type MaxVestingSchedules = MaxVestingSchedules;600	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;601}602603parameter_types! {604	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;605	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;606}607608impl cumulus_pallet_parachain_system::Config for Runtime {609	type Event = Event;610	type SelfParaId = parachain_info::Pallet<Self>;611	type OnSystemEvent = ();612	// type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<613	// 	MaxDownwardMessageWeight,614	// 	XcmExecutor<XcmConfig>,615	// 	Call,616	// >;617	type OutboundXcmpMessageSource = XcmpQueue;618	type DmpMessageHandler = DmpQueue;619	type ReservedDmpWeight = ReservedDmpWeight;620	type ReservedXcmpWeight = ReservedXcmpWeight;621	type XcmpMessageHandler = XcmpQueue;622}623624impl parachain_info::Config for Runtime {}625626impl cumulus_pallet_aura_ext::Config for Runtime {}627628parameter_types! {629	pub const RelayLocation: MultiLocation = MultiLocation::parent();630	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;631	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();632	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();633}634635/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used636/// when determining ownership of accounts for asset transacting and when attempting to use XCM637/// `Transact` in order to determine the dispatch Origin.638pub type LocationToAccountId = (639	// The parent (Relay-chain) origin converts to the default `AccountId`.640	ParentIsPreset<AccountId>,641	// Sibling parachain origins convert to AccountId via the `ParaId::into`.642	SiblingParachainConvertsVia<Sibling, AccountId>,643	// Straight up local `AccountId32` origins just alias directly to `AccountId`.644	AccountId32Aliases<RelayNetwork, AccountId>,645);646647pub struct OnlySelfCurrency;648impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {649	fn matches_fungible(a: &MultiAsset) -> Option<B> {650		match (&a.id, &a.fun) {651			(Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),652			_ => None,653		}654	}655}656657/// Means for transacting assets on this chain.658pub type LocalAssetTransactor = CurrencyAdapter<659	// Use this currency:660	Balances,661	// Use this currency when it is a fungible asset matching the given location or name:662	OnlySelfCurrency,663	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:664	LocationToAccountId,665	// Our chain's account ID type (we can't get away without mentioning it explicitly):666	AccountId,667	// We don't track any teleports.668	(),669>;670671/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,672/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can673/// biases the kind of local `Origin` it will become.674pub type XcmOriginToTransactDispatchOrigin = (675	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location676	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for677	// foreign chains who want to have a local sovereign account on this chain which they control.678	SovereignSignedViaLocation<LocationToAccountId, Origin>,679	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when680	// recognised.681	RelayChainAsNative<RelayOrigin, Origin>,682	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when683	// recognised.684	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,685	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a686	// transaction from the Root origin.687	ParentAsSuperuser<Origin>,688	// Native signed account converter; this just converts an `AccountId32` origin into a normal689	// `Origin::Signed` origin of the same 32-byte value.690	SignedAccountId32AsNative<RelayNetwork, Origin>,691	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.692	XcmPassthrough<Origin>,693);694695parameter_types! {696	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.697	pub UnitWeightCost: Weight = 1_000_000;698	// 1200 UNIQUEs buy 1 second of weight.699	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);700	pub const MaxInstructions: u32 = 100;701	pub const MaxAuthorities: u32 = 100_000;702}703704match_types! {705	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {706		MultiLocation { parents: 1, interior: Here } |707		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }708	};709}710711pub type Barrier = (712	TakeWeightCredit,713	AllowTopLevelPaidExecutionFrom<Everything>,714	AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,715	// ^^^ Parent & its unit plurality gets free execution716);717718pub struct UsingOnlySelfCurrencyComponents<719	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,720	AssetId: Get<MultiLocation>,721	AccountId,722	Currency: CurrencyT<AccountId>,723	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,724>(725	Weight,726	Currency::Balance,727	PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,728);729impl<730		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,731		AssetId: Get<MultiLocation>,732		AccountId,733		Currency: CurrencyT<AccountId>,734		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,735	> WeightTrader736	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>737{738	fn new() -> Self {739		Self(0, Zero::zero(), PhantomData)740	}741742	fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {743		let amount = WeightToFee::calc(&weight);744		let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;745746		// location to this parachain through relay chain747		let option1: xcm::v1::AssetId = Concrete(MultiLocation {748			parents: 1,749			interior: X1(Parachain(ParachainInfo::parachain_id().into())),750		});751		// direct location752		let option2: xcm::v1::AssetId = Concrete(MultiLocation {753			parents: 0,754			interior: Here,755		});756757		let required = if payment.fungible.contains_key(&option1) {758			(option1, u128_amount).into()759		} else if payment.fungible.contains_key(&option2) {760			(option2, u128_amount).into()761		} else {762			(Concrete(MultiLocation::default()), u128_amount).into()763		};764765		let unused = payment766			.checked_sub(required)767			.map_err(|_| XcmError::TooExpensive)?;768		self.0 = self.0.saturating_add(weight);769		self.1 = self.1.saturating_add(amount);770		Ok(unused)771	}772773	fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {774		let weight = weight.min(self.0);775		let amount = WeightToFee::calc(&weight);776		self.0 -= weight;777		self.1 = self.1.saturating_sub(amount);778		let amount: u128 = amount.saturated_into();779		if amount > 0 {780			Some((AssetId::get(), amount).into())781		} else {782			None783		}784	}785}786impl<787		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,788		AssetId: Get<MultiLocation>,789		AccountId,790		Currency: CurrencyT<AccountId>,791		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,792	> Drop793	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>794{795	fn drop(&mut self) {796		OnUnbalanced::on_unbalanced(Currency::issue(self.1));797	}798}799800pub struct XcmConfig;801impl Config for XcmConfig {802	type Call = Call;803	type XcmSender = XcmRouter;804	// How to withdraw and deposit an asset.805	type AssetTransactor = LocalAssetTransactor;806	type OriginConverter = XcmOriginToTransactDispatchOrigin;807	type IsReserve = NativeAsset;808	type IsTeleporter = (); // Teleportation is disabled809	type LocationInverter = LocationInverter<Ancestry>;810	type Barrier = Barrier;811	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;812	type Trader = UsingOnlySelfCurrencyComponents<813		IdentityFee<Balance>,814		RelayLocation,815		AccountId,816		Balances,817		(),818	>;819	type ResponseHandler = (); // Don't handle responses for now.820	type SubscriptionService = PolkadotXcm;821822	type AssetTrap = PolkadotXcm;823	type AssetClaims = PolkadotXcm;824}825826// parameter_types! {827// 	pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;828// }829830/// No local origins on this chain are allowed to dispatch XCM sends/executions.831pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);832833/// The means for routing XCM messages which are not for local execution into the right message834/// queues.835pub type XcmRouter = (836	// Two routers - use UMP to communicate with the relay chain:837	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,838	// ..and XCMP to communicate with the sibling chains.839	XcmpQueue,840);841842impl pallet_evm_coder_substrate::Config for Runtime {}843844impl pallet_xcm::Config for Runtime {845	type Event = Event;846	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;847	type XcmRouter = XcmRouter;848	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;849	type XcmExecuteFilter = Everything;850	type XcmExecutor = XcmExecutor<XcmConfig>;851	type XcmTeleportFilter = Everything;852	type XcmReserveTransferFilter = Everything;853	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;854	type LocationInverter = LocationInverter<Ancestry>;855	type Origin = Origin;856	type Call = Call;857	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;858	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;859}860861impl cumulus_pallet_xcm::Config for Runtime {862	type Event = Event;863	type XcmExecutor = XcmExecutor<XcmConfig>;864}865866impl cumulus_pallet_xcmp_queue::Config for Runtime {867	type WeightInfo = ();868	type Event = Event;869	type XcmExecutor = XcmExecutor<XcmConfig>;870	type ChannelInfo = ParachainSystem;871	type VersionWrapper = ();872	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;873	type ControllerOrigin = EnsureRoot<AccountId>;874	type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;875}876877impl cumulus_pallet_dmp_queue::Config for Runtime {878	type Event = Event;879	type XcmExecutor = XcmExecutor<XcmConfig>;880	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;881}882883impl pallet_aura::Config for Runtime {884	type AuthorityId = AuraId;885	type DisabledValidators = ();886	type MaxAuthorities = MaxAuthorities;887}888889parameter_types! {890	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();891	pub const CollectionCreationPrice: Balance = 2 * UNIQUE;892}893894impl pallet_common::Config for Runtime {895	type WeightInfo = pallet_common::weights::SubstrateWeight<Self>;896	type Event = Event;897	type Currency = Balances;898	type CollectionCreationPrice = CollectionCreationPrice;899	type TreasuryAccountId = TreasuryAccountId;900	type CollectionDispatch = CollectionDispatchT<Self>;901902	type EvmTokenAddressMapping = EvmTokenAddressMapping;903	type CrossTokenAddressMapping = CrossTokenAddressMapping<Self::AccountId>;904	type ContractAddress = EvmCollectionHelpersAddress;905}906907impl pallet_structure::Config for Runtime {908	type Event = Event;909	type Call = Call;910	type WeightInfo = pallet_structure::weights::SubstrateWeight<Self>;911}912913impl pallet_fungible::Config for Runtime {914	type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;915}916impl pallet_refungible::Config for Runtime {917	type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;918}919impl pallet_nonfungible::Config for Runtime {920	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;921}922923impl pallet_proxy_rmrk_core::Config for Runtime {924	type Event = Event;925}926927impl pallet_proxy_rmrk_equip::Config for Runtime {928	type Event = Event;929}930931impl pallet_unique::Config for Runtime {932	type Event = Event;933	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;934	type CommonWeightInfo = CommonWeights<Self>;935}936937parameter_types! {938	pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied939}940941/// Used for the pallet inflation942impl pallet_inflation::Config for Runtime {943	type Currency = Balances;944	type TreasuryAccountId = TreasuryAccountId;945	type InflationBlockInterval = InflationBlockInterval;946	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;947}948949parameter_types! {950	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *951		RuntimeBlockWeights::get().max_block;952	pub const MaxScheduledPerBlock: u32 = 50;953}954955type ChargeTransactionPayment = pallet_charge_transaction::ChargeTransactionPayment<Runtime>;956use frame_support::traits::NamedReservableCurrency;957958fn get_signed_extras(from: <Runtime as frame_system::Config>::AccountId) -> SignedExtraScheduler {959	(960		frame_system::CheckSpecVersion::<Runtime>::new(),961		frame_system::CheckGenesis::<Runtime>::new(),962		frame_system::CheckEra::<Runtime>::from(Era::Immortal),963		frame_system::CheckNonce::<Runtime>::from(frame_system::Pallet::<Runtime>::account_nonce(964			from,965		)),966		frame_system::CheckWeight::<Runtime>::new(),967		// sponsoring transaction logic968		// pallet_charge_transaction::ChargeTransactionPayment::<Runtime>::new(0),969	)970}971972pub struct SchedulerPaymentExecutor;973impl<T: frame_system::Config + pallet_unq_scheduler::Config, SelfContainedSignedInfo>974	DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor975where976	<T as frame_system::Config>::Call: Member977		+ Dispatchable<Origin = Origin, Info = DispatchInfo>978		+ SelfContainedCall<SignedInfo = SelfContainedSignedInfo>979		+ GetDispatchInfo980		+ From<frame_system::Call<Runtime>>,981	SelfContainedSignedInfo: Send + Sync + 'static,982	Call: From<<T as frame_system::Config>::Call>983		+ From<<T as pallet_unq_scheduler::Config>::Call>984		+ SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,985	sp_runtime::AccountId32: From<<T as frame_system::Config>::AccountId>,986{987	fn dispatch_call(988		signer: <T as frame_system::Config>::AccountId,989		call: <T as pallet_unq_scheduler::Config>::Call,990	) -> Result<991		Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,992		TransactionValidityError,993	> {994		let dispatch_info = call.get_dispatch_info();995		let extrinsic = fp_self_contained::CheckedExtrinsic::<996			AccountId,997			Call,998			SignedExtraScheduler,999			SelfContainedSignedInfo,1000		> {1001			signed:1002				CheckedSignature::<AccountId, SignedExtraScheduler, SelfContainedSignedInfo>::Signed(1003					signer.clone().into(),1004					get_signed_extras(signer.into()),1005				),1006			function: call.into(),1007		};10081009		extrinsic.apply::<Runtime>(&dispatch_info, 0)1010	}10111012	fn reserve_balance(1013		id: [u8; 16],1014		sponsor: <T as frame_system::Config>::AccountId,1015		call: <T as pallet_unq_scheduler::Config>::Call,1016		count: u32,1017	) -> Result<(), DispatchError> {1018		let dispatch_info = call.get_dispatch_info();1019		let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0)1020			.saturating_mul(count.into());10211022		<Balances as NamedReservableCurrency<AccountId>>::reserve_named(1023			&id,1024			&(sponsor.into()),1025			weight,1026		)1027	}10281029	fn pay_for_call(1030		id: [u8; 16],1031		sponsor: <T as frame_system::Config>::AccountId,1032		call: <T as pallet_unq_scheduler::Config>::Call,1033	) -> Result<u128, DispatchError> {1034		let dispatch_info = call.get_dispatch_info();1035		let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0);1036		Ok(1037			<Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1038				&id,1039				&(sponsor.into()),1040				weight,1041			),1042		)1043	}10441045	fn cancel_reserve(1046		id: [u8; 16],1047		sponsor: <T as frame_system::Config>::AccountId,1048	) -> Result<u128, DispatchError> {1049		Ok(1050			<Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1051				&id,1052				&(sponsor.into()),1053				u128::MAX,1054			),1055		)1056	}1057}10581059parameter_types! {1060	pub const NoPreimagePostponement: Option<u32> = Some(10);1061	pub const Preimage: Option<u32> = Some(10);1062}10631064/// Used the compare the privilege of an origin inside the scheduler.1065pub struct OriginPrivilegeCmp;10661067impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {1068	fn cmp_privilege(_left: &OriginCaller, _right: &OriginCaller) -> Option<Ordering> {1069		Some(Ordering::Equal)1070	}1071}10721073impl pallet_unq_scheduler::Config for Runtime {1074	type Event = Event;1075	type Origin = Origin;1076	type Currency = Balances;1077	type PalletsOrigin = OriginCaller;1078	type Call = Call;1079	type MaximumWeight = MaximumSchedulerWeight;1080	type ScheduleOrigin = EnsureSigned<AccountId>;1081	type MaxScheduledPerBlock = MaxScheduledPerBlock;1082	type WeightInfo = ();1083	type CallExecutor = SchedulerPaymentExecutor;1084	type OriginPrivilegeCmp = OriginPrivilegeCmp;1085	type PreimageProvider = ();1086	type NoPreimagePostponement = NoPreimagePostponement;1087}10881089type EvmSponsorshipHandler = (1090	UniqueEthSponsorshipHandler<Runtime>,1091	pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,1092);10931094type SponsorshipHandler = (1095	UniqueSponsorshipHandler<Runtime>,1096	//pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1097	pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1098);10991100impl pallet_evm_transaction_payment::Config for Runtime {1101	type EvmSponsorshipHandler = EvmSponsorshipHandler;1102	type Currency = Balances;1103}11041105impl pallet_charge_transaction::Config for Runtime {1106	type SponsorshipHandler = SponsorshipHandler;1107}11081109// impl pallet_contract_helpers::Config for Runtime {1110//	 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1111// }11121113parameter_types! {1114	// 0x842899ECF380553E8a4de75bF534cdf6fBF640491115	pub const HelpersContractAddress: H160 = H160([1116		0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1117	]);11181119	// 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f1120	pub const EvmCollectionHelpersAddress: H160 = H160([1121		0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,1122	]);1123}11241125impl pallet_evm_contract_helpers::Config for Runtime {1126	type ContractAddress = HelpersContractAddress;1127	type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1128}11291130construct_runtime!(1131	pub enum Runtime where1132		Block = Block,1133		NodeBlock = opaque::Block,1134		UncheckedExtrinsic = UncheckedExtrinsic1135	{1136		ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1137		ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,11381139		Aura: pallet_aura::{Pallet, Config<T>} = 22,1140		AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,11411142		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1143		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1144		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1145		TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1146		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1147		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1148		System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1149		Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1150		// Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1151		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,11521153		// XCM helpers.1154		XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1155		PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1156		CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1157		DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11581159		// Unique Pallets1160		Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1161		Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1162		Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1163		// free = 631164		Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1165		// ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1166		Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1167		Fungible: pallet_fungible::{Pallet, Storage} = 67,1168		Refungible: pallet_refungible::{Pallet, Storage} = 68,1169		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1170		Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,1171		RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,1172		RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,11731174		// Frontier1175		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1176		Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11771178		EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1179		EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1180		EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1181		EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1182	}1183);11841185pub struct TransactionConverter;11861187impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1188	fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1189		UncheckedExtrinsic::new_unsigned(1190			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1191		)1192	}1193}11941195impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1196	fn convert_transaction(1197		&self,1198		transaction: pallet_ethereum::Transaction,1199	) -> opaque::UncheckedExtrinsic {1200		let extrinsic = UncheckedExtrinsic::new_unsigned(1201			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1202		);1203		let encoded = extrinsic.encode();1204		opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1205			.expect("Encoded extrinsic is always valid")1206	}1207}12081209/// The address format for describing accounts.1210pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1211/// Block header type as expected by this runtime.1212pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1213/// Block type as expected by this runtime.1214pub type Block = generic::Block<Header, UncheckedExtrinsic>;1215/// A Block signed with a Justification1216pub type SignedBlock = generic::SignedBlock<Block>;1217/// BlockId type as expected by this runtime.1218pub type BlockId = generic::BlockId<Block>;1219/// The SignedExtension to the basic transaction logic.1220pub type SignedExtra = (1221	frame_system::CheckSpecVersion<Runtime>,1222	// system::CheckTxVersion<Runtime>,1223	frame_system::CheckGenesis<Runtime>,1224	frame_system::CheckEra<Runtime>,1225	frame_system::CheckNonce<Runtime>,1226	frame_system::CheckWeight<Runtime>,1227	ChargeTransactionPayment,1228	//pallet_contract_helpers::ContractHelpersExtension<Runtime>,1229	pallet_ethereum::FakeTransactionFinalizer<Runtime>,1230);1231pub type SignedExtraScheduler = (1232	frame_system::CheckSpecVersion<Runtime>,1233	frame_system::CheckGenesis<Runtime>,1234	frame_system::CheckEra<Runtime>,1235	frame_system::CheckNonce<Runtime>,1236	frame_system::CheckWeight<Runtime>,1237);1238/// Unchecked extrinsic type as expected by this runtime.1239pub type UncheckedExtrinsic =1240	fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1241/// Extrinsic type that has already been checked.1242pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1243/// Executive: handles dispatch to the various modules.1244pub type Executive = frame_executive::Executive<1245	Runtime,1246	Block,1247	frame_system::ChainContext<Runtime>,1248	Runtime,1249	AllPalletsReversedWithSystemFirst,1250>;12511252impl_opaque_keys! {1253	pub struct SessionKeys {1254		pub aura: Aura,1255	}1256}12571258impl fp_self_contained::SelfContainedCall for Call {1259	type SignedInfo = H160;12601261	fn is_self_contained(&self) -> bool {1262		match self {1263			Call::Ethereum(call) => call.is_self_contained(),1264			_ => false,1265		}1266	}12671268	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1269		match self {1270			Call::Ethereum(call) => call.check_self_contained(),1271			_ => None,1272		}1273	}12741275	fn validate_self_contained(1276		&self,1277		info: &Self::SignedInfo,1278		dispatch_info: &DispatchInfoOf<Call>,1279		len: usize,1280	) -> Option<TransactionValidity> {1281		match self {1282			Call::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),1283			_ => None,1284		}1285	}12861287	fn pre_dispatch_self_contained(1288		&self,1289		info: &Self::SignedInfo,1290	) -> Option<Result<(), TransactionValidityError>> {1291		match self {1292			Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1293			_ => None,1294		}1295	}12961297	fn apply_self_contained(1298		self,1299		info: Self::SignedInfo,1300	) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1301		match self {1302			call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1303				Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1304			)),1305			_ => None,1306		}1307	}1308}13091310macro_rules! dispatch_unique_runtime {1311	($collection:ident.$method:ident($($name:ident),*)) => {{1312		let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1313		let dispatch = collection.as_dyn();13141315		Ok::<_, DispatchError>(dispatch.$method($($name),*))1316	}};1317}13181319impl_common_runtime_apis!();13201321struct CheckInherents;13221323impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1324	fn check_inherents(1325		block: &Block,1326		relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1327	) -> sp_inherents::CheckInherentsResult {1328		let relay_chain_slot = relay_state_proof1329			.read_slot()1330			.expect("Could not read the relay chain slot from the proof");13311332		let inherent_data =1333			cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1334				relay_chain_slot,1335				sp_std::time::Duration::from_secs(6),1336			)1337			.create_inherent_data()1338			.expect("Could not create the timestamp inherent data");13391340		inherent_data.check_extrinsics(block)1341	}1342}13431344cumulus_pallet_parachain_system::register_validate_block!(1345	Runtime = Runtime,1346	BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1347	CheckInherents = CheckInherents,1348);