git.delta.rocks / unique-network / refs/commits / 0660dd124ff7

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56//! The Substrate Node Template runtime. This can be compiled with `#[no_std]`, ready for Wasm.78#![cfg_attr(not(feature = "std"), no_std)]9// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.10#![recursion_limit = "1024"]11#![allow(clippy::from_over_into, clippy::identity_op)]12#![allow(clippy::fn_to_numeric_cast_with_truncation)]13// Make the WASM binary available.14#[cfg(feature = "std")]15include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));1617use sp_api::impl_runtime_apis;18use sp_core::{crypto::KeyTypeId, OpaqueMetadata, H256, U256, H160};19use sp_runtime::DispatchError;20// #[cfg(any(feature = "std", test))]21// pub use sp_runtime::BuildStorage;2223use sp_runtime::{24	Permill, Perbill, Percent, create_runtime_str, generic, impl_opaque_keys,25	traits::{26		AccountIdLookup, BlakeTwo256, Block as BlockT, IdentifyAccount, Verify,27		AccountIdConversion, Zero,28	},29	transaction_validity::{TransactionSource, TransactionValidity},30	ApplyExtrinsicResult, MultiSignature, RuntimeAppPublic,31};3233use sp_std::prelude::*;3435#[cfg(feature = "std")]36use sp_version::NativeVersion;37use sp_version::RuntimeVersion;38pub use pallet_transaction_payment::{39	Multiplier, TargetedFeeAdjustment, FeeDetails, RuntimeDispatchInfo,40};41// A few exports that help ease life for downstream crates.42pub use pallet_balances::Call as BalancesCall;43pub use pallet_evm::{EnsureAddressTruncated, HashedAddressMapping, Runner};44pub use frame_support::{45	construct_runtime, match_type,46	dispatch::DispatchResult,47	PalletId, parameter_types, StorageValue, ConsensusEngineId,48	traits::{49		tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Everything,50		Currency, ExistenceRequirement, Get, IsInVec, KeyOwnerProofSystem, LockIdentifier,51		OnUnbalanced, Randomness, FindAuthor,52	},53	weights::{54		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},55		DispatchClass, DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,56		WeightToFeePolynomial, WeightToFeeCoefficient, WeightToFeeCoefficients,57	},58};59use up_data_structs::*;60// use pallet_contracts::weights::WeightInfo;61// #[cfg(any(feature = "std", test))]62use frame_system::{63	self as frame_system, EnsureRoot, EnsureSigned,64	limits::{BlockWeights, BlockLength},65};66use sp_arithmetic::{67	traits::{BaseArithmetic, Unsigned},68};69use smallvec::smallvec;70use codec::{Encode, Decode};71use pallet_evm::{Account as EVMAccount, FeeCalculator, GasWeightMapping, OnMethodCall};72use fp_rpc::TransactionStatus;73use sp_runtime::{74	traits::{BlockNumberProvider, Dispatchable, PostDispatchInfoOf, Saturating},75	transaction_validity::TransactionValidityError,76	SaturatedConversion,77};7879// pub use pallet_timestamp::Call as TimestampCall;80pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;8182// Polkadot imports83use pallet_xcm::XcmPassthrough;84use polkadot_parachain::primitives::Sibling;85use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};86use xcm_builder::{87	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,88	EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser,89	ParentIsDefault, RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,90	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,91};92use xcm_executor::{Config, XcmExecutor, Assets};93use sp_std::{marker::PhantomData};9495use xcm::latest::{96	//	Xcm,97	AssetId::{Concrete},98	Fungibility::Fungible as XcmFungible,99	MultiAsset,100	Error as XcmError,101};102use xcm_executor::traits::{MatchesFungible, WeightTrader};103//use xcm_executor::traits::MatchesFungible;104use sp_runtime::traits::CheckedConversion;105106// mod chain_extension;107// use crate::chain_extension::{NFTExtension, Imbalance};108109/// An index to a block.110pub type BlockNumber = u32;111112/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.113pub type Signature = MultiSignature;114115/// Some way of identifying an account on the chain. We intentionally make it equivalent116/// to the public key of our transaction signing scheme.117pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;118119pub type CrossAccountId = pallet_common::account::BasicCrossAccountId<Runtime>;120121/// The type for looking up accounts. We don't expect more than 4 billion of them, but you122/// never know...123pub type AccountIndex = u32;124125/// Balance of an account.126pub type Balance = u128;127128/// Index of a transaction in the chain.129pub type Index = u32;130131/// A hash of some data used by the chain.132pub type Hash = sp_core::H256;133134/// Digest item type.135pub type DigestItem = generic::DigestItem;136137/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know138/// the specifics of the runtime. They can then be made to be agnostic over specific formats139/// of data like extrinsics, allowing for them to continue syncing the network through upgrades140/// to even the core data structures.141pub mod opaque {142	use super::*;143144	pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;145146	/// Opaque block type.147	pub type Block = generic::Block<Header, UncheckedExtrinsic>;148149	pub type SessionHandlers = ();150151	impl_opaque_keys! {152		pub struct SessionKeys {153			pub aura: Aura,154		}155	}156}157158/// This runtime version.159pub const VERSION: RuntimeVersion = RuntimeVersion {160	spec_name: create_runtime_str!("opal"),161	impl_name: create_runtime_str!("opal"),162	authoring_version: 1,163	spec_version: 916001,164	impl_version: 0,165	apis: RUNTIME_API_VERSIONS,166	transaction_version: 1,167	state_version: 0,168};169170pub const MILLISECS_PER_BLOCK: u64 = 12000;171172pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;173174// These time units are defined in number of blocks.175pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);176pub const HOURS: BlockNumber = MINUTES * 60;177pub const DAYS: BlockNumber = HOURS * 24;178179parameter_types! {180	pub const DefaultSponsoringRateLimit: BlockNumber = 1 * DAYS;181}182183#[derive(codec::Encode, codec::Decode)]184pub enum XCMPMessage<XAccountId, XBalance> {185	/// Transfer tokens to the given account from the Parachain account.186	TransferToken(XAccountId, XBalance),187}188189/// The version information used to identify this runtime when compiled natively.190#[cfg(feature = "std")]191pub fn native_version() -> NativeVersion {192	NativeVersion {193		runtime_version: VERSION,194		can_author_with: Default::default(),195	}196}197198type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;199200pub struct DealWithFees;201impl OnUnbalanced<NegativeImbalance> for DealWithFees {202	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {203		if let Some(fees) = fees_then_tips.next() {204			// for fees, 100% to treasury205			let mut split = fees.ration(100, 0);206			if let Some(tips) = fees_then_tips.next() {207				// for tips, if any, 100% to treasury208				tips.ration_merge_into(100, 0, &mut split);209			}210			Treasury::on_unbalanced(split.0);211			// Author::on_unbalanced(split.1);212		}213	}214}215216/// We assume that ~10% of the block weight is consumed by `on_initalize` handlers.217/// This is used to limit the maximal weight of a single extrinsic.218const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);219/// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used220/// by  Operational  extrinsics.221const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);222/// We allow for 2 seconds of compute with a 6 second average block time.223const MAXIMUM_BLOCK_WEIGHT: Weight = WEIGHT_PER_SECOND / 2;224225parameter_types! {226	pub const BlockHashCount: BlockNumber = 2400;227	pub RuntimeBlockLength: BlockLength =228		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);229	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);230	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;231	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()232		.base_block(BlockExecutionWeight::get())233		.for_class(DispatchClass::all(), |weights| {234			weights.base_extrinsic = ExtrinsicBaseWeight::get();235		})236		.for_class(DispatchClass::Normal, |weights| {237			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);238		})239		.for_class(DispatchClass::Operational, |weights| {240			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);241			// Operational transactions have some extra reserved space, so that they242			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.243			weights.reserved = Some(244				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT245			);246		})247		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)248		.build_or_panic();249	pub const Version: RuntimeVersion = VERSION;250	pub const SS58Prefix: u8 = 42;251}252253parameter_types! {254	pub const ChainId: u64 = 8888;255}256257pub struct FixedFee;258impl FeeCalculator for FixedFee {259	fn min_gas_price() -> U256 {260		// Targeting 0.15 UNQ per transfer261		1_024_947_215_000u64.into()262	}263}264265// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case266// (contract, which only writes a lot of data),267// approximating on top of our real store write weight268parameter_types! {269	pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;270	pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;271	pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();272}273274/// Limiting EVM execution to 50% of block for substrate users and management tasks275/// EVM transaction consumes more weight than substrate's, so we can't rely on them being276/// scheduled fairly277const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);278parameter_types! {279	pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());280}281282pub enum FixedGasWeightMapping {}283impl GasWeightMapping for FixedGasWeightMapping {284	fn gas_to_weight(gas: u64) -> Weight {285		gas.saturating_mul(WeightPerGas::get())286	}287	fn weight_to_gas(weight: Weight) -> u64 {288		weight / WeightPerGas::get()289	}290}291292impl pallet_evm::Config for Runtime {293	type BlockGasLimit = BlockGasLimit;294	type FeeCalculator = FixedFee;295	type GasWeightMapping = FixedGasWeightMapping;296	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;297	type CallOrigin = EnsureAddressTruncated;298	type WithdrawOrigin = EnsureAddressTruncated;299	type AddressMapping = HashedAddressMapping<Self::Hashing>;300	type PrecompilesType = ();301	type PrecompilesValue = ();302	type Currency = Balances;303	type Event = Event;304	type OnMethodCall = (305		pallet_evm_migration::OnMethodCall<Self>,306		pallet_unique::UniqueErcSupport<Self>,307		pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,308	);309	type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;310	type ChainId = ChainId;311	type Runner = pallet_evm::runner::stack::Runner<Self>;312	type OnChargeTransaction = pallet_evm_transaction_payment::OnChargeTransaction<Self>;313	type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;314	type FindAuthor = EthereumFindAuthor<Aura>;315}316317impl pallet_evm_migration::Config for Runtime {318	type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;319}320321pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);322impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {323	fn find_author<'a, I>(digests: I) -> Option<H160>324	where325		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,326	{327		if let Some(author_index) = F::find_author(digests) {328			let authority_id = Aura::authorities()[author_index as usize].clone();329			return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));330		}331		None332	}333}334335impl pallet_ethereum::Config for Runtime {336	type Event = Event;337	type StateRoot = pallet_ethereum::IntermediateStateRoot;338}339340impl pallet_randomness_collective_flip::Config for Runtime {}341342impl frame_system::Config for Runtime {343	/// The data to be stored in an account.344	type AccountData = pallet_balances::AccountData<Balance>;345	/// The identifier used to distinguish between accounts.346	type AccountId = AccountId;347	/// The basic call filter to use in dispatchable.348	type BaseCallFilter = Everything;349	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).350	type BlockHashCount = BlockHashCount;351	/// The maximum length of a block (in bytes).352	type BlockLength = RuntimeBlockLength;353	/// The index type for blocks.354	type BlockNumber = BlockNumber;355	/// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.356	type BlockWeights = RuntimeBlockWeights;357	/// The aggregated dispatch type that is available for extrinsics.358	type Call = Call;359	/// The weight of database operations that the runtime can invoke.360	type DbWeight = RocksDbWeight;361	/// The ubiquitous event type.362	type Event = Event;363	/// The type for hashing blocks and tries.364	type Hash = Hash;365	/// The hashing algorithm used.366	type Hashing = BlakeTwo256;367	/// The header type.368	type Header = generic::Header<BlockNumber, BlakeTwo256>;369	/// The index type for storing how many extrinsics an account has signed.370	type Index = Index;371	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.372	type Lookup = AccountIdLookup<AccountId, ()>;373	/// What to do if an account is fully reaped from the system.374	type OnKilledAccount = ();375	/// What to do if a new account is created.376	type OnNewAccount = ();377	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;378	/// The ubiquitous origin type.379	type Origin = Origin;380	/// This type is being generated by `construct_runtime!`.381	type PalletInfo = PalletInfo;382	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.383	type SS58Prefix = SS58Prefix;384	/// Weight information for the extrinsics of this pallet.385	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;386	/// Version of the runtime.387	type Version = Version;388	type MaxConsumers = ConstU32<16>;389}390391parameter_types! {392	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;393}394395impl pallet_timestamp::Config for Runtime {396	/// A timestamp: milliseconds since the unix epoch.397	type Moment = u64;398	type OnTimestampSet = ();399	type MinimumPeriod = MinimumPeriod;400	type WeightInfo = ();401}402403parameter_types! {404	// pub const ExistentialDeposit: u128 = 500;405	pub const ExistentialDeposit: u128 = 0;406	pub const MaxLocks: u32 = 50;407}408409impl pallet_balances::Config for Runtime {410	type MaxLocks = MaxLocks;411	type MaxReserves = ();412	type ReserveIdentifier = [u8; 8];413	/// The type for recording an account's balance.414	type Balance = Balance;415	/// The ubiquitous event type.416	type Event = Event;417	type DustRemoval = Treasury;418	type ExistentialDeposit = ExistentialDeposit;419	type AccountStore = System;420	type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;421}422423pub const MICROUNIQUE: Balance = 1_000_000_000_000;424pub const MILLIUNIQUE: Balance = 1_000 * MICROUNIQUE;425pub const CENTIUNIQUE: Balance = 10 * MILLIUNIQUE;426pub const UNIQUE: Balance = 100 * CENTIUNIQUE;427428pub const fn deposit(items: u32, bytes: u32) -> Balance {429	items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE430}431432/*433parameter_types! {434	pub TombstoneDeposit: Balance = deposit(435		1,436		sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,437	);438	pub DepositPerContract: Balance = TombstoneDeposit::get();439	pub const DepositPerStorageByte: Balance = deposit(0, 1);440	pub const DepositPerStorageItem: Balance = deposit(1, 0);441	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);442	pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;443	pub const SignedClaimHandicap: u32 = 2;444	pub const MaxDepth: u32 = 32;445	pub const MaxValueSize: u32 = 16 * 1024;446	pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb447	// The lazy deletion runs inside on_initialize.448	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *449		RuntimeBlockWeights::get().max_block;450	// The weight needed for decoding the queue should be less or equal than a fifth451	// of the overall weight dedicated to the lazy deletion.452	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (453			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -454			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)455		)) / 5) as u32;456	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();457}458459impl pallet_contracts::Config for Runtime {460	type Time = Timestamp;461	type Randomness = RandomnessCollectiveFlip;462	type Currency = Balances;463	type Event = Event;464	type RentPayment = ();465	type SignedClaimHandicap = SignedClaimHandicap;466	type TombstoneDeposit = TombstoneDeposit;467	type DepositPerContract = DepositPerContract;468	type DepositPerStorageByte = DepositPerStorageByte;469	type DepositPerStorageItem = DepositPerStorageItem;470	type RentFraction = RentFraction;471	type SurchargeReward = SurchargeReward;472	type WeightPrice = pallet_transaction_payment::Pallet<Self>;473	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;474	type ChainExtension = NFTExtension;475	type DeletionQueueDepth = DeletionQueueDepth;476	type DeletionWeightLimit = DeletionWeightLimit;477	type Schedule = Schedule;478	type CallStack = [pallet_contracts::Frame<Self>; 31];479}480*/481482parameter_types! {483	pub const TransactionByteFee: Balance = 501 * MICROUNIQUE; // Targeting 0.1 Unique per NFT transfer484	/// This value increases the priority of `Operational` transactions by adding485	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.486	pub const OperationalFeeMultiplier: u8 = 5;487}488489/// Linear implementor of `WeightToFeePolynomial`490pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);491492impl<T> WeightToFeePolynomial for LinearFee<T>493where494	T: BaseArithmetic + From<u32> + Copy + Unsigned,495{496	type Balance = T;497498	fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {499		smallvec!(WeightToFeeCoefficient {500			// Targeting 0.1 Unique per NFT transfer501			coeff_integer: 142_688_000u32.into(),502			coeff_frac: Perbill::zero(),503			negative: false,504			degree: 1,505		})506	}507}508509impl pallet_transaction_payment::Config for Runtime {510	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;511	type TransactionByteFee = TransactionByteFee;512	type OperationalFeeMultiplier = OperationalFeeMultiplier;513	type WeightToFee = LinearFee<Balance>;514	type FeeMultiplierUpdate = ();515}516517parameter_types! {518	pub const ProposalBond: Permill = Permill::from_percent(5);519	pub const ProposalBondMinimum: Balance = 1 * UNIQUE;520	pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;521	pub const SpendPeriod: BlockNumber = 5 * MINUTES;522	pub const Burn: Permill = Permill::from_percent(0);523	pub const TipCountdown: BlockNumber = 1 * DAYS;524	pub const TipFindersFee: Percent = Percent::from_percent(20);525	pub const TipReportDepositBase: Balance = 1 * UNIQUE;526	pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;527	pub const BountyDepositBase: Balance = 1 * UNIQUE;528	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;529	pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");530	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;531	pub const MaximumReasonLength: u32 = 16384;532	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);533	pub const BountyValueMinimum: Balance = 5 * UNIQUE;534	pub const MaxApprovals: u32 = 100;535}536537impl pallet_treasury::Config for Runtime {538	type PalletId = TreasuryModuleId;539	type Currency = Balances;540	type ApproveOrigin = EnsureRoot<AccountId>;541	type RejectOrigin = EnsureRoot<AccountId>;542	type Event = Event;543	type OnSlash = ();544	type ProposalBond = ProposalBond;545	type ProposalBondMinimum = ProposalBondMinimum;546	type ProposalBondMaximum = ProposalBondMaximum;547	type SpendPeriod = SpendPeriod;548	type Burn = Burn;549	type BurnDestination = ();550	type SpendFunds = ();551	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;552	type MaxApprovals = MaxApprovals;553}554555impl pallet_sudo::Config for Runtime {556	type Event = Event;557	type Call = Call;558}559560pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);561562impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider563	for RelayChainBlockNumberProvider<T>564{565	type BlockNumber = BlockNumber;566567	fn current_block_number() -> Self::BlockNumber {568		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()569			.map(|d| d.relay_parent_number)570			.unwrap_or_default()571	}572}573574parameter_types! {575	pub const MinVestedTransfer: Balance = 10 * UNIQUE;576	pub const MaxVestingSchedules: u32 = 28;577}578579impl orml_vesting::Config for Runtime {580	type Event = Event;581	type Currency = pallet_balances::Pallet<Runtime>;582	type MinVestedTransfer = MinVestedTransfer;583	type VestedTransferOrigin = EnsureSigned<AccountId>;584	type WeightInfo = ();585	type MaxVestingSchedules = MaxVestingSchedules;586	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;587}588589parameter_types! {590	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;591	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;592}593594impl cumulus_pallet_parachain_system::Config for Runtime {595	type Event = Event;596	type SelfParaId = parachain_info::Pallet<Self>;597	type OnSystemEvent = ();598	// type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<599	// 	MaxDownwardMessageWeight,600	// 	XcmExecutor<XcmConfig>,601	// 	Call,602	// >;603	type OutboundXcmpMessageSource = XcmpQueue;604	type DmpMessageHandler = DmpQueue;605	type ReservedDmpWeight = ReservedDmpWeight;606	type ReservedXcmpWeight = ReservedXcmpWeight;607	type XcmpMessageHandler = XcmpQueue;608}609610impl parachain_info::Config for Runtime {}611612impl cumulus_pallet_aura_ext::Config for Runtime {}613614parameter_types! {615	pub const RelayLocation: MultiLocation = MultiLocation::parent();616	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;617	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();618	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();619}620621/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used622/// when determining ownership of accounts for asset transacting and when attempting to use XCM623/// `Transact` in order to determine the dispatch Origin.624pub type LocationToAccountId = (625	// The parent (Relay-chain) origin converts to the default `AccountId`.626	ParentIsDefault<AccountId>,627	// Sibling parachain origins convert to AccountId via the `ParaId::into`.628	SiblingParachainConvertsVia<Sibling, AccountId>,629	// Straight up local `AccountId32` origins just alias directly to `AccountId`.630	AccountId32Aliases<RelayNetwork, AccountId>,631);632633pub struct OnlySelfCurrency;634impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {635	fn matches_fungible(a: &MultiAsset) -> Option<B> {636		match (&a.id, &a.fun) {637			(Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),638			_ => None,639		}640	}641}642643/// Means for transacting assets on this chain.644pub type LocalAssetTransactor = CurrencyAdapter<645	// Use this currency:646	Balances,647	// Use this currency when it is a fungible asset matching the given location or name:648	OnlySelfCurrency,649	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:650	LocationToAccountId,651	// Our chain's account ID type (we can't get away without mentioning it explicitly):652	AccountId,653	// We don't track any teleports.654	(),655>;656657/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,658/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can659/// biases the kind of local `Origin` it will become.660pub type XcmOriginToTransactDispatchOrigin = (661	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location662	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for663	// foreign chains who want to have a local sovereign account on this chain which they control.664	SovereignSignedViaLocation<LocationToAccountId, Origin>,665	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when666	// recognised.667	RelayChainAsNative<RelayOrigin, Origin>,668	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when669	// recognised.670	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,671	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a672	// transaction from the Root origin.673	ParentAsSuperuser<Origin>,674	// Native signed account converter; this just converts an `AccountId32` origin into a normal675	// `Origin::Signed` origin of the same 32-byte value.676	SignedAccountId32AsNative<RelayNetwork, Origin>,677	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.678	XcmPassthrough<Origin>,679);680681parameter_types! {682	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.683	pub UnitWeightCost: Weight = 1_000_000;684	// 1200 UNIQUEs buy 1 second of weight.685	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);686	pub const MaxInstructions: u32 = 100;687	pub const MaxAuthorities: u32 = 100_000;688}689690match_type! {691	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {692		MultiLocation { parents: 1, interior: Here } |693		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }694	};695}696697pub type Barrier = (698	TakeWeightCredit,699	AllowTopLevelPaidExecutionFrom<Everything>,700	AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,701	// ^^^ Parent & its unit plurality gets free execution702);703704pub struct UsingOnlySelfCurrencyComponents<705	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,706	AssetId: Get<MultiLocation>,707	AccountId,708	Currency: CurrencyT<AccountId>,709	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,710>(711	Weight,712	Currency::Balance,713	PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,714);715impl<716		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,717		AssetId: Get<MultiLocation>,718		AccountId,719		Currency: CurrencyT<AccountId>,720		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,721	> WeightTrader722	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>723{724	fn new() -> Self {725		Self(0, Zero::zero(), PhantomData)726	}727728	fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {729		let amount = WeightToFee::calc(&weight);730		let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;731732		// location to this parachain through relay chain733		let option1: xcm::v1::AssetId = Concrete(MultiLocation {734			parents: 1,735			interior: X1(Parachain(ParachainInfo::parachain_id().into())),736		});737		// direct location738		let option2: xcm::v1::AssetId = Concrete(MultiLocation {739			parents: 0,740			interior: Here,741		});742743		let required = if payment.fungible.contains_key(&option1) {744			(option1, u128_amount).into()745		} else if payment.fungible.contains_key(&option2) {746			(option2, u128_amount).into()747		} else {748			(Concrete(MultiLocation::default()), u128_amount).into()749		};750751		let unused = payment752			.checked_sub(required)753			.map_err(|_| XcmError::TooExpensive)?;754		self.0 = self.0.saturating_add(weight);755		self.1 = self.1.saturating_add(amount);756		Ok(unused)757	}758759	fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {760		let weight = weight.min(self.0);761		let amount = WeightToFee::calc(&weight);762		self.0 -= weight;763		self.1 = self.1.saturating_sub(amount);764		let amount: u128 = amount.saturated_into();765		if amount > 0 {766			Some((AssetId::get(), amount).into())767		} else {768			None769		}770	}771}772impl<773		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,774		AssetId: Get<MultiLocation>,775		AccountId,776		Currency: CurrencyT<AccountId>,777		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,778	> Drop779	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>780{781	fn drop(&mut self) {782		OnUnbalanced::on_unbalanced(Currency::issue(self.1));783	}784}785786pub struct XcmConfig;787impl Config for XcmConfig {788	type Call = Call;789	type XcmSender = XcmRouter;790	// How to withdraw and deposit an asset.791	type AssetTransactor = LocalAssetTransactor;792	type OriginConverter = XcmOriginToTransactDispatchOrigin;793	type IsReserve = NativeAsset;794	type IsTeleporter = (); // Teleportation is disabled795	type LocationInverter = LocationInverter<Ancestry>;796	type Barrier = Barrier;797	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;798	type Trader = UsingOnlySelfCurrencyComponents<799		IdentityFee<Balance>,800		RelayLocation,801		AccountId,802		Balances,803		(),804	>;805	type ResponseHandler = (); // Don't handle responses for now.806	type SubscriptionService = PolkadotXcm;807808	type AssetTrap = PolkadotXcm;809	type AssetClaims = PolkadotXcm;810}811812// parameter_types! {813// 	pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;814// }815816/// No local origins on this chain are allowed to dispatch XCM sends/executions.817pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);818819/// The means for routing XCM messages which are not for local execution into the right message820/// queues.821pub type XcmRouter = (822	// Two routers - use UMP to communicate with the relay chain:823	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,824	// ..and XCMP to communicate with the sibling chains.825	XcmpQueue,826);827828impl pallet_evm_coder_substrate::Config for Runtime {829	type EthereumTransactionSender = pallet_ethereum::Pallet<Self>;830	type GasWeightMapping = FixedGasWeightMapping;831}832833impl pallet_xcm::Config for Runtime {834	type Event = Event;835	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;836	type XcmRouter = XcmRouter;837	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;838	type XcmExecuteFilter = Everything;839	type XcmExecutor = XcmExecutor<XcmConfig>;840	type XcmTeleportFilter = Everything;841	type XcmReserveTransferFilter = Everything;842	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;843	type LocationInverter = LocationInverter<Ancestry>;844	type Origin = Origin;845	type Call = Call;846	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;847	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;848}849850impl cumulus_pallet_xcm::Config for Runtime {851	type Event = Event;852	type XcmExecutor = XcmExecutor<XcmConfig>;853}854855impl cumulus_pallet_xcmp_queue::Config for Runtime {856	type Event = Event;857	type XcmExecutor = XcmExecutor<XcmConfig>;858	type ChannelInfo = ParachainSystem;859	type VersionWrapper = ();860	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;861}862863impl cumulus_pallet_dmp_queue::Config for Runtime {864	type Event = Event;865	type XcmExecutor = XcmExecutor<XcmConfig>;866	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;867}868869impl pallet_aura::Config for Runtime {870	type AuthorityId = AuraId;871	type DisabledValidators = ();872	type MaxAuthorities = MaxAuthorities;873}874875parameter_types! {876	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();877	pub const CollectionCreationPrice: Balance = 100 * UNIQUE;878}879880impl pallet_common::Config for Runtime {881	type Event = Event;882	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;883	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;884	type CrossAccountId = pallet_common::account::BasicCrossAccountId<Self>;885886	type Currency = Balances;887	type CollectionCreationPrice = CollectionCreationPrice;888	type TreasuryAccountId = TreasuryAccountId;889}890891impl pallet_fungible::Config for Runtime {892	type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;893}894impl pallet_refungible::Config for Runtime {895	type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;896}897impl pallet_nonfungible::Config for Runtime {898	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;899}900901impl pallet_unique::Config for Runtime {902	type Event = Event;903	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;904}905906parameter_types! {907	pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied908}909910/// Used for the pallet inflation911impl pallet_inflation::Config for Runtime {912	type Currency = Balances;913	type TreasuryAccountId = TreasuryAccountId;914	type InflationBlockInterval = InflationBlockInterval;915	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;916}917918// parameter_types! {919// 	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *920// 		RuntimeBlockWeights::get().max_block;921// 	pub const MaxScheduledPerBlock: u32 = 50;922// }923924type EvmSponsorshipHandler = (925	pallet_unique::UniqueEthSponsorshipHandler<Runtime>,926	pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,927);928type SponsorshipHandler = (929	pallet_unique::UniqueSponsorshipHandler<Runtime>,930	//pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,931	pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,932);933934// impl pallet_unq_scheduler::Config for Runtime {935// 	type Event = Event;936// 	type Origin = Origin;937// 	type PalletsOrigin = OriginCaller;938// 	type Call = Call;939// 	type MaximumWeight = MaximumSchedulerWeight;940// 	type ScheduleOrigin = EnsureSigned<AccountId>;941// 	type MaxScheduledPerBlock = MaxScheduledPerBlock;942// 	type SponsorshipHandler = SponsorshipHandler;943// 	type WeightInfo = ();944// }945946impl pallet_evm_transaction_payment::Config for Runtime {947	type EvmSponsorshipHandler = EvmSponsorshipHandler;948	type Currency = Balances;949	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;950	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;951}952953impl pallet_charge_transaction::Config for Runtime {954	type SponsorshipHandler = SponsorshipHandler;955}956957// impl pallet_contract_helpers::Config for Runtime {958//	 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;959// }960961parameter_types! {962	// 0x842899ECF380553E8a4de75bF534cdf6fBF64049963	pub const HelpersContractAddress: H160 = H160([964		0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,965	]);966}967968impl pallet_evm_contract_helpers::Config for Runtime {969	type ContractAddress = HelpersContractAddress;970	type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;971}972973construct_runtime!(974	pub enum Runtime where975		Block = Block,976		NodeBlock = opaque::Block,977		UncheckedExtrinsic = UncheckedExtrinsic978	{979		ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,980		ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,981982		Aura: pallet_aura::{Pallet, Config<T>} = 22,983		AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,984985		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,986		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,987		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,988		TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,989		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,990		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,991		System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,992		Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,993		// Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,994		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,995996		// XCM helpers.997		XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,998		PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,999		CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1000		DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,10011002		// Unique Pallets1003		Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1004		Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1005		// Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1006		// free = 631007		Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1008		// ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1009		Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1010		Fungible: pallet_fungible::{Pallet, Storage} = 67,1011		Refungible: pallet_refungible::{Pallet, Storage} = 68,1012		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,10131014		// Frontier1015		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1016		Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,10171018		EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1019		EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1020		EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1021		EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1022	}1023);10241025pub struct TransactionConverter;10261027impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1028	fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1029		UncheckedExtrinsic::new_unsigned(1030			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1031		)1032	}1033}10341035impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1036	fn convert_transaction(1037		&self,1038		transaction: pallet_ethereum::Transaction,1039	) -> opaque::UncheckedExtrinsic {1040		let extrinsic = UncheckedExtrinsic::new_unsigned(1041			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1042		);1043		let encoded = extrinsic.encode();1044		opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1045			.expect("Encoded extrinsic is always valid")1046	}1047}10481049/// The address format for describing accounts.1050pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1051/// Block header type as expected by this runtime.1052pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1053/// Block type as expected by this runtime.1054pub type Block = generic::Block<Header, UncheckedExtrinsic>;1055/// A Block signed with a Justification1056pub type SignedBlock = generic::SignedBlock<Block>;1057/// BlockId type as expected by this runtime.1058pub type BlockId = generic::BlockId<Block>;1059/// The SignedExtension to the basic transaction logic.1060pub type SignedExtra = (1061	frame_system::CheckSpecVersion<Runtime>,1062	// system::CheckTxVersion<Runtime>,1063	frame_system::CheckGenesis<Runtime>,1064	frame_system::CheckEra<Runtime>,1065	frame_system::CheckNonce<Runtime>,1066	frame_system::CheckWeight<Runtime>,1067	pallet_charge_transaction::ChargeTransactionPayment<Runtime>,1068	//pallet_contract_helpers::ContractHelpersExtension<Runtime>,1069);1070/// Unchecked extrinsic type as expected by this runtime.1071pub type UncheckedExtrinsic =1072	fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1073/// Extrinsic type that has already been checked.1074pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1075/// Executive: handles dispatch to the various modules.1076pub type Executive = frame_executive::Executive<1077	Runtime,1078	Block,1079	frame_system::ChainContext<Runtime>,1080	Runtime,1081	AllPalletsReversedWithSystemFirst,1082>;10831084impl_opaque_keys! {1085	pub struct SessionKeys {1086		pub aura: Aura,1087	}1088}10891090impl fp_self_contained::SelfContainedCall for Call {1091	type SignedInfo = H160;10921093	fn is_self_contained(&self) -> bool {1094		match self {1095			Call::Ethereum(call) => call.is_self_contained(),1096			_ => false,1097		}1098	}10991100	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1101		match self {1102			Call::Ethereum(call) => call.check_self_contained(),1103			_ => None,1104		}1105	}11061107	fn validate_self_contained(&self, info: &Self::SignedInfo) -> Option<TransactionValidity> {1108		match self {1109			Call::Ethereum(call) => call.validate_self_contained(info),1110			_ => None,1111		}1112	}11131114	fn pre_dispatch_self_contained(1115		&self,1116		info: &Self::SignedInfo,1117	) -> Option<Result<(), TransactionValidityError>> {1118		match self {1119			Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1120			_ => None,1121		}1122	}11231124	fn apply_self_contained(1125		self,1126		info: Self::SignedInfo,1127	) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1128		match self {1129			call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1130				Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1131			)),1132			_ => None,1133		}1134	}1135}11361137macro_rules! dispatch_unique_runtime {1138	($collection:ident.$method:ident($($name:ident),*)) => {{1139		use pallet_unique::dispatch::Dispatched;11401141		let collection = Dispatched::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1142		let dispatch = collection.as_dyn();11431144		Ok(dispatch.$method($($name),*))1145	}};1146}1147impl_runtime_apis! {1148	impl up_rpc::UniqueApi<Block, CrossAccountId, AccountId>1149		for Runtime1150	{1151		fn account_tokens(collection: CollectionId, account: CrossAccountId) -> Result<Vec<TokenId>, DispatchError> {1152			dispatch_unique_runtime!(collection.account_tokens(account))1153		}1154		fn token_exists(collection: CollectionId, token: TokenId) -> Result<bool, DispatchError> {1155			dispatch_unique_runtime!(collection.token_exists(token))1156		}11571158		fn token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {1159			dispatch_unique_runtime!(collection.token_owner(token))1160		}1161		fn const_metadata(collection: CollectionId, token: TokenId) -> Result<Vec<u8>, DispatchError> {1162			dispatch_unique_runtime!(collection.const_metadata(token))1163		}1164		fn variable_metadata(collection: CollectionId, token: TokenId) -> Result<Vec<u8>, DispatchError> {1165			dispatch_unique_runtime!(collection.variable_metadata(token))1166		}11671168		fn collection_tokens(collection: CollectionId) -> Result<u32, DispatchError> {1169			dispatch_unique_runtime!(collection.collection_tokens())1170		}1171		fn account_balance(collection: CollectionId, account: CrossAccountId) -> Result<u32, DispatchError> {1172			dispatch_unique_runtime!(collection.account_balance(account))1173		}1174		fn balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<u128, DispatchError> {1175			dispatch_unique_runtime!(collection.balance(account, token))1176		}1177		fn allowance(1178			collection: CollectionId,1179			sender: CrossAccountId,1180			spender: CrossAccountId,1181			token: TokenId,1182		) -> Result<u128, DispatchError> {1183			dispatch_unique_runtime!(collection.allowance(sender, spender, token))1184		}11851186		fn eth_contract_code(account: H160) -> Option<Vec<u8>> {1187			<pallet_unique::UniqueErcSupport<Runtime>>::get_code(&account)1188				.or_else(|| <pallet_evm_migration::OnMethodCall<Runtime>>::get_code(&account))1189				.or_else(|| <pallet_evm_contract_helpers::HelpersOnMethodCall<Self>>::get_code(&account))1190		}1191		fn adminlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {1192			Ok(<pallet_common::Pallet<Runtime>>::adminlist(collection))1193		}1194		fn allowlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {1195			Ok(<pallet_common::Pallet<Runtime>>::allowlist(collection))1196		}1197		fn allowed(collection: CollectionId, user: CrossAccountId) -> Result<bool, DispatchError> {1198			Ok(<pallet_common::Pallet<Runtime>>::allowed(collection, user))1199		}1200		fn last_token_id(collection: CollectionId) -> Result<TokenId, DispatchError> {1201			dispatch_unique_runtime!(collection.last_token_id())1202		}1203		fn collection_by_id(collection: CollectionId) -> Result<Option<Collection<AccountId>>, DispatchError> {1204			Ok(<pallet_common::CollectionById<Runtime>>::get(collection))1205		}1206		fn collection_stats() -> Result<CollectionStats, DispatchError> {1207			Ok(<pallet_common::Pallet<Runtime>>::collection_stats())1208		}1209	}12101211	impl sp_api::Core<Block> for Runtime {1212		fn version() -> RuntimeVersion {1213			VERSION1214		}12151216		fn execute_block(block: Block) {1217			Executive::execute_block(block)1218		}12191220		fn initialize_block(header: &<Block as BlockT>::Header) {1221			Executive::initialize_block(header)1222		}1223	}12241225	impl sp_api::Metadata<Block> for Runtime {1226		fn metadata() -> OpaqueMetadata {1227			OpaqueMetadata::new(Runtime::metadata().into())1228		}1229	}12301231	impl sp_block_builder::BlockBuilder<Block> for Runtime {1232		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {1233			Executive::apply_extrinsic(extrinsic)1234		}12351236		fn finalize_block() -> <Block as BlockT>::Header {1237			Executive::finalize_block()1238		}12391240		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {1241			data.create_extrinsics()1242		}12431244		fn check_inherents(1245			block: Block,1246			data: sp_inherents::InherentData,1247		) -> sp_inherents::CheckInherentsResult {1248			data.check_extrinsics(&block)1249		}12501251		// fn random_seed() -> <Block as BlockT>::Hash {1252		//     RandomnessCollectiveFlip::random_seed().01253		// }1254	}12551256	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {1257		fn validate_transaction(1258			source: TransactionSource,1259			tx: <Block as BlockT>::Extrinsic,1260			hash: <Block as BlockT>::Hash,1261		) -> TransactionValidity {1262			Executive::validate_transaction(source, tx, hash)1263		}1264	}12651266	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {1267		fn offchain_worker(header: &<Block as BlockT>::Header) {1268			Executive::offchain_worker(header)1269		}1270	}12711272	impl fp_rpc::EthereumRuntimeRPCApi<Block> for Runtime {1273		fn chain_id() -> u64 {1274			<Runtime as pallet_evm::Config>::ChainId::get()1275		}12761277		fn account_basic(address: H160) -> EVMAccount {1278			EVM::account_basic(&address)1279		}12801281		fn gas_price() -> U256 {1282			<Runtime as pallet_evm::Config>::FeeCalculator::min_gas_price()1283		}12841285		fn account_code_at(address: H160) -> Vec<u8> {1286			EVM::account_codes(address)1287		}12881289		fn author() -> H160 {1290			<pallet_evm::Pallet<Runtime>>::find_author()1291		}12921293		fn storage_at(address: H160, index: U256) -> H256 {1294			let mut tmp = [0u8; 32];1295			index.to_big_endian(&mut tmp);1296			EVM::account_storages(address, H256::from_slice(&tmp[..]))1297		}12981299		#[allow(clippy::redundant_closure)]1300		fn call(1301			from: H160,1302			to: H160,1303			data: Vec<u8>,1304			value: U256,1305			gas_limit: U256,1306			max_fee_per_gas: Option<U256>,1307			max_priority_fee_per_gas: Option<U256>,1308			nonce: Option<U256>,1309			estimate: bool,1310			access_list: Option<Vec<(H160, Vec<H256>)>>,1311		) -> Result<pallet_evm::CallInfo, sp_runtime::DispatchError> {1312			let config = if estimate {1313				let mut config = <Runtime as pallet_evm::Config>::config().clone();1314				config.estimate = true;1315				Some(config)1316			} else {1317				None1318			};13191320			<Runtime as pallet_evm::Config>::Runner::call(1321				from,1322				to,1323				data,1324				value,1325				gas_limit.low_u64(),1326				max_fee_per_gas,1327				max_priority_fee_per_gas,1328				nonce,1329				access_list.unwrap_or_default(),1330				config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),1331			).map_err(|err| err.into())1332		}13331334		#[allow(clippy::redundant_closure)]1335		fn create(1336			from: H160,1337			data: Vec<u8>,1338			value: U256,1339			gas_limit: U256,1340			max_fee_per_gas: Option<U256>,1341			max_priority_fee_per_gas: Option<U256>,1342			nonce: Option<U256>,1343			estimate: bool,1344			access_list: Option<Vec<(H160, Vec<H256>)>>,1345		) -> Result<pallet_evm::CreateInfo, sp_runtime::DispatchError> {1346			let config = if estimate {1347				let mut config = <Runtime as pallet_evm::Config>::config().clone();1348				config.estimate = true;1349				Some(config)1350			} else {1351				None1352			};13531354			<Runtime as pallet_evm::Config>::Runner::create(1355				from,1356				data,1357				value,1358				gas_limit.low_u64(),1359				max_fee_per_gas,1360				max_priority_fee_per_gas,1361				nonce,1362				access_list.unwrap_or_default(),1363				config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),1364			).map_err(|err| err.into())1365		}13661367		fn current_transaction_statuses() -> Option<Vec<TransactionStatus>> {1368			Ethereum::current_transaction_statuses()1369		}13701371		fn current_block() -> Option<pallet_ethereum::Block> {1372			Ethereum::current_block()1373		}13741375		fn current_receipts() -> Option<Vec<pallet_ethereum::Receipt>> {1376			Ethereum::current_receipts()1377		}13781379		fn current_all() -> (1380			Option<pallet_ethereum::Block>,1381			Option<Vec<pallet_ethereum::Receipt>>,1382			Option<Vec<TransactionStatus>>1383		) {1384			(1385				Ethereum::current_block(),1386				Ethereum::current_receipts(),1387				Ethereum::current_transaction_statuses()1388			)1389		}13901391		fn extrinsic_filter(xts: Vec<<Block as sp_api::BlockT>::Extrinsic>) -> Vec<pallet_ethereum::Transaction> {1392			xts.into_iter().filter_map(|xt| match xt.0.function {1393				Call::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction),1394				_ => None1395			}).collect()1396		}13971398		fn elasticity() -> Option<Permill> {1399			None1400		}1401	}14021403	impl sp_session::SessionKeys<Block> for Runtime {1404		fn decode_session_keys(1405			encoded: Vec<u8>,1406		) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {1407			SessionKeys::decode_into_raw_public_keys(&encoded)1408		}14091410		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {1411			SessionKeys::generate(seed)1412		}1413	}14141415	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {1416		fn slot_duration() -> sp_consensus_aura::SlotDuration {1417			sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())1418		}14191420		fn authorities() -> Vec<AuraId> {1421			Aura::authorities().to_vec()1422		}1423	}14241425	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {1426		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {1427			ParachainSystem::collect_collation_info(header)1428		}1429	}14301431	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {1432		fn account_nonce(account: AccountId) -> Index {1433			System::account_nonce(account)1434		}1435	}14361437	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {1438		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {1439			TransactionPayment::query_info(uxt, len)1440		}1441		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {1442			TransactionPayment::query_fee_details(uxt, len)1443		}1444	}14451446	/*1447	impl pallet_contracts_rpc_runtime_api::ContractsApi<Block, AccountId, Balance, BlockNumber, Hash>1448		for Runtime1449	{1450		fn call(1451			origin: AccountId,1452			dest: AccountId,1453			value: Balance,1454			gas_limit: u64,1455			input_data: Vec<u8>,1456		) -> pallet_contracts_primitives::ContractExecResult {1457			Contracts::bare_call(origin, dest, value, gas_limit, input_data, false)1458		}14591460		fn instantiate(1461			origin: AccountId,1462			endowment: Balance,1463			gas_limit: u64,1464			code: pallet_contracts_primitives::Code<Hash>,1465			data: Vec<u8>,1466			salt: Vec<u8>,1467		) -> pallet_contracts_primitives::ContractInstantiateResult<AccountId, BlockNumber>1468		{1469			Contracts::bare_instantiate(origin, endowment, gas_limit, code, data, salt, true, false)1470		}14711472		fn get_storage(1473			address: AccountId,1474			key: [u8; 32],1475		) -> pallet_contracts_primitives::GetStorageResult {1476			Contracts::get_storage(address, key)1477		}14781479		fn rent_projection(1480			address: AccountId,1481		) -> pallet_contracts_primitives::RentProjectionResult<BlockNumber> {1482			Contracts::rent_projection(address)1483		}1484	}1485	*/14861487	#[cfg(feature = "runtime-benchmarks")]1488	impl frame_benchmarking::Benchmark<Block> for Runtime {1489		fn benchmark_metadata(extra: bool) -> (1490			Vec<frame_benchmarking::BenchmarkList>,1491			Vec<frame_support::traits::StorageInfo>,1492		) {1493			use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList};1494			use frame_support::traits::StorageInfoTrait;14951496			let mut list = Vec::<BenchmarkList>::new();14971498			list_benchmark!(list, extra, pallet_evm_migration, EvmMigration);1499			list_benchmark!(list, extra, pallet_unique, Unique);1500			list_benchmark!(list, extra, pallet_inflation, Inflation);1501			list_benchmark!(list, extra, pallet_fungible, Fungible);1502			list_benchmark!(list, extra, pallet_refungible, Refungible);1503			list_benchmark!(list, extra, pallet_nonfungible, Nonfungible);1504			// list_benchmark!(list, extra, pallet_evm_coder_substrate, EvmCoderSubstrate);15051506			let storage_info = AllPalletsReversedWithSystemFirst::storage_info();15071508			return (list, storage_info)1509		}15101511		fn dispatch_benchmark(1512			config: frame_benchmarking::BenchmarkConfig1513		) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {1514			use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey};15151516			let allowlist: Vec<TrackedStorageKey> = vec![1517				// Block Number1518				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),1519				// Total Issuance1520				hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),1521				// Execution Phase1522				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),1523				// Event Count1524				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),1525				// System Events1526				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),1527			];15281529			let mut batches = Vec::<BenchmarkBatch>::new();1530			let params = (&config, &allowlist);15311532			add_benchmark!(params, batches, pallet_evm_migration, EvmMigration);1533			add_benchmark!(params, batches, pallet_unique, Unique);1534			add_benchmark!(params, batches, pallet_inflation, Inflation);1535			add_benchmark!(params, batches, pallet_fungible, Fungible);1536			add_benchmark!(params, batches, pallet_refungible, Refungible);1537			add_benchmark!(params, batches, pallet_nonfungible, Nonfungible);1538			// add_benchmark!(params, batches, pallet_evm_coder_substrate, EvmCoderSubstrate);15391540			if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }1541			Ok(batches)1542		}1543	}1544}15451546struct CheckInherents;15471548impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1549	fn check_inherents(1550		block: &Block,1551		relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1552	) -> sp_inherents::CheckInherentsResult {1553		let relay_chain_slot = relay_state_proof1554			.read_slot()1555			.expect("Could not read the relay chain slot from the proof");15561557		let inherent_data =1558			cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1559				relay_chain_slot,1560				sp_std::time::Duration::from_secs(6),1561			)1562			.create_inherent_data()1563			.expect("Could not create the timestamp inherent data");15641565		inherent_data.check_extrinsics(block)1566	}1567}15681569cumulus_pallet_parachain_system::register_validate_block!(1570	Runtime = Runtime,1571	BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1572	CheckInherents = CheckInherents,1573);