git.delta.rocks / unique-network / refs/commits / 1c8c05f45308

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, AccountIdConversion,27	},28	transaction_validity::{TransactionSource, TransactionValidity},29	ApplyExtrinsicResult, MultiSignature, RuntimeAppPublic,30};3132use sp_std::prelude::*;3334#[cfg(feature = "std")]35use sp_version::NativeVersion;36use sp_version::RuntimeVersion;37pub use pallet_transaction_payment::{38	Multiplier, TargetedFeeAdjustment, FeeDetails, RuntimeDispatchInfo,39};40// A few exports that help ease life for downstream crates.41pub use pallet_balances::Call as BalancesCall;42pub use pallet_evm::{EnsureAddressTruncated, HashedAddressMapping, Runner};43pub use frame_support::{44	construct_runtime, match_type,45	dispatch::DispatchResult,46	PalletId, parameter_types, StorageValue, ConsensusEngineId,47	traits::{48		Everything, Currency, ExistenceRequirement, Get, IsInVec, KeyOwnerProofSystem,49		LockIdentifier, OnUnbalanced, Randomness, FindAuthor,50	},51	weights::{52		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},53		DispatchClass, DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,54		WeightToFeePolynomial, WeightToFeeCoefficient, WeightToFeeCoefficients,55	},56};57use up_data_structs::*;58// use pallet_contracts::weights::WeightInfo;59// #[cfg(any(feature = "std", test))]60use frame_system::{61	self as frame_system, EnsureRoot, EnsureSigned,62	limits::{BlockWeights, BlockLength},63};64use sp_arithmetic::{65	traits::{BaseArithmetic, Unsigned},66};67use smallvec::smallvec;68use codec::{Encode, Decode};69use pallet_evm::{Account as EVMAccount, FeeCalculator, GasWeightMapping, OnMethodCall};70use fp_rpc::TransactionStatus;71use sp_runtime::{72	traits::{BlockNumberProvider, Dispatchable, PostDispatchInfoOf},73	transaction_validity::TransactionValidityError,74};7576// pub use pallet_timestamp::Call as TimestampCall;77pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;7879// Polkadot imports80use pallet_xcm::XcmPassthrough;81use polkadot_parachain::primitives::Sibling;82use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};83use xcm_builder::{84	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,85	EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset,86	ParentAsSuperuser, ParentIsDefault, RelayChainAsNative, SiblingParachainAsNative,87	SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32,88	SovereignSignedViaLocation, TakeWeightCredit, UsingComponents,89};90use xcm_executor::{Config, XcmExecutor};9192use log::{debug};93use sp_std::{borrow::Borrow, marker::PhantomData};9495use xcm::latest::{96//	Xcm, 	97	AssetId::{Concrete},98	Fungibility::Fungible as XcmFungible,99	MultiAsset100};101use xcm_executor::traits::{ShouldExecute, WeightBounds, MatchesFungible, WeightTrader, Convert};102//use xcm_executor::traits::MatchesFungible;103use sp_runtime::traits::CheckedConversion;104105// mod chain_extension;106// use crate::chain_extension::{NFTExtension, Imbalance};107108/// An index to a block.109pub type BlockNumber = u32;110111/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.112pub type Signature = MultiSignature;113114/// Some way of identifying an account on the chain. We intentionally make it equivalent115/// to the public key of our transaction signing scheme.116pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;117118pub type CrossAccountId = pallet_common::account::BasicCrossAccountId<Runtime>;119120/// The type for looking up accounts. We don't expect more than 4 billion of them, but you121/// never know...122pub type AccountIndex = u32;123124/// Balance of an account.125pub type Balance = u128;126127/// Index of a transaction in the chain.128pub type Index = u32;129130/// A hash of some data used by the chain.131pub type Hash = sp_core::H256;132133/// Digest item type.134pub type DigestItem = generic::DigestItem;135136/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know137/// the specifics of the runtime. They can then be made to be agnostic over specific formats138/// of data like extrinsics, allowing for them to continue syncing the network through upgrades139/// to even the core data structures.140pub mod opaque {141	use super::*;142143	pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;144145	/// Opaque block type.146	pub type Block = generic::Block<Header, UncheckedExtrinsic>;147148	pub type SessionHandlers = ();149150	impl_opaque_keys! {151		pub struct SessionKeys {152			pub aura: Aura,153		}154	}155}156157/// This runtime version.158pub const VERSION: RuntimeVersion = RuntimeVersion {159	spec_name: create_runtime_str!("opal"),160	impl_name: create_runtime_str!("opal"),161	authoring_version: 1,162	spec_version: 914000,163	impl_version: 1,164	apis: RUNTIME_API_VERSIONS,165	transaction_version: 0,166	state_version: 0,167};168169pub const MILLISECS_PER_BLOCK: u64 = 12000;170171pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;172173// These time units are defined in number of blocks.174pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);175pub const HOURS: BlockNumber = MINUTES * 60;176pub const DAYS: BlockNumber = HOURS * 24;177178parameter_types! {179	pub const DefaultSponsoringRateLimit: BlockNumber = 1 * DAYS;180}181182#[derive(codec::Encode, codec::Decode)]183pub enum XCMPMessage<XAccountId, XBalance> {184	/// Transfer tokens to the given account from the Parachain account.185	TransferToken(XAccountId, XBalance),186}187188/// The version information used to identify this runtime when compiled natively.189#[cfg(feature = "std")]190pub fn native_version() -> NativeVersion {191	NativeVersion {192		runtime_version: VERSION,193		can_author_with: Default::default(),194	}195}196197type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;198199pub struct DealWithFees;200impl OnUnbalanced<NegativeImbalance> for DealWithFees {201	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {202		if let Some(fees) = fees_then_tips.next() {203			// for fees, 100% to treasury204			let mut split = fees.ration(100, 0);205			if let Some(tips) = fees_then_tips.next() {206				// for tips, if any, 100% to treasury207				tips.ration_merge_into(100, 0, &mut split);208			}209			Treasury::on_unbalanced(split.0);210			// Author::on_unbalanced(split.1);211		}212	}213}214215/// We assume that ~10% of the block weight is consumed by `on_initalize` handlers.216/// This is used to limit the maximal weight of a single extrinsic.217const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);218/// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used219/// by  Operational  extrinsics.220const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);221/// We allow for 2 seconds of compute with a 6 second average block time.222const MAXIMUM_BLOCK_WEIGHT: Weight = WEIGHT_PER_SECOND / 2;223224parameter_types! {225	pub const BlockHashCount: BlockNumber = 2400;226	pub RuntimeBlockLength: BlockLength =227		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);228	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);229	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;230	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()231		.base_block(BlockExecutionWeight::get())232		.for_class(DispatchClass::all(), |weights| {233			weights.base_extrinsic = ExtrinsicBaseWeight::get();234		})235		.for_class(DispatchClass::Normal, |weights| {236			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);237		})238		.for_class(DispatchClass::Operational, |weights| {239			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);240			// Operational transactions have some extra reserved space, so that they241			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.242			weights.reserved = Some(243				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT244			);245		})246		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)247		.build_or_panic();248	pub const Version: RuntimeVersion = VERSION;249	pub const SS58Prefix: u8 = 42;250}251252parameter_types! {253	pub const ChainId: u64 = 8888;254}255256pub struct FixedFee;257impl FeeCalculator for FixedFee {258	fn min_gas_price() -> U256 {259		// Targeting 0.15 UNQ per transfer260		1_024_947_215_000u64.into()261	}262}263264// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case265// (contract, which only writes a lot of data),266// approximating on top of our real store write weight267parameter_types! {268	pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;269	pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;270	pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();271}272273/// Limiting EVM execution to 50% of block for substrate users and management tasks274/// EVM transaction consumes more weight than substrate's, so we can't rely on them being275/// scheduled fairly276const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);277parameter_types! {278	pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());279}280281pub enum FixedGasWeightMapping {}282impl GasWeightMapping for FixedGasWeightMapping {283	fn gas_to_weight(gas: u64) -> Weight {284		gas.saturating_mul(WeightPerGas::get())285	}286	fn weight_to_gas(weight: Weight) -> u64 {287		weight / WeightPerGas::get()288	}289}290291impl pallet_evm::Config for Runtime {292	type BlockGasLimit = BlockGasLimit;293	type FeeCalculator = FixedFee;294	type GasWeightMapping = FixedGasWeightMapping;295	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;296	type CallOrigin = EnsureAddressTruncated;297	type WithdrawOrigin = EnsureAddressTruncated;298	type AddressMapping = HashedAddressMapping<Self::Hashing>;299	type PrecompilesType = ();300	type PrecompilesValue = ();301	type Currency = Balances;302	type Event = Event;303	type OnMethodCall = (304		pallet_evm_migration::OnMethodCall<Self>,305		pallet_unique::UniqueErcSupport<Self>,306		pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,307	);308	type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;309	type ChainId = ChainId;310	type Runner = pallet_evm::runner::stack::Runner<Self>;311	type OnChargeTransaction = pallet_evm_transaction_payment::OnChargeTransaction<Self>;312	type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;313	type FindAuthor = EthereumFindAuthor<Aura>;314}315316impl pallet_evm_migration::Config for Runtime {317	type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;318}319320pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);321impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {322	fn find_author<'a, I>(digests: I) -> Option<H160>323	where324		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,325	{326		if let Some(author_index) = F::find_author(digests) {327			let authority_id = Aura::authorities()[author_index as usize].clone();328			return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));329		}330		None331	}332}333334impl pallet_ethereum::Config for Runtime {335	type Event = Event;336	type StateRoot = pallet_ethereum::IntermediateStateRoot;337}338339impl pallet_randomness_collective_flip::Config for Runtime {}340341impl frame_system::Config for Runtime {342	/// The data to be stored in an account.343	type AccountData = pallet_balances::AccountData<Balance>;344	/// The identifier used to distinguish between accounts.345	type AccountId = AccountId;346	/// The basic call filter to use in dispatchable.347	type BaseCallFilter = Everything;348	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).349	type BlockHashCount = BlockHashCount;350	/// The maximum length of a block (in bytes).351	type BlockLength = RuntimeBlockLength;352	/// The index type for blocks.353	type BlockNumber = BlockNumber;354	/// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.355	type BlockWeights = RuntimeBlockWeights;356	/// The aggregated dispatch type that is available for extrinsics.357	type Call = Call;358	/// The weight of database operations that the runtime can invoke.359	type DbWeight = RocksDbWeight;360	/// The ubiquitous event type.361	type Event = Event;362	/// The type for hashing blocks and tries.363	type Hash = Hash;364	/// The hashing algorithm used.365	type Hashing = BlakeTwo256;366	/// The header type.367	type Header = generic::Header<BlockNumber, BlakeTwo256>;368	/// The index type for storing how many extrinsics an account has signed.369	type Index = Index;370	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.371	type Lookup = AccountIdLookup<AccountId, ()>;372	/// What to do if an account is fully reaped from the system.373	type OnKilledAccount = ();374	/// What to do if a new account is created.375	type OnNewAccount = ();376	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;377	/// The ubiquitous origin type.378	type Origin = Origin;379	/// This type is being generated by `construct_runtime!`.380	type PalletInfo = PalletInfo;381	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.382	type SS58Prefix = SS58Prefix;383	/// Weight information for the extrinsics of this pallet.384	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;385	/// Version of the runtime.386	type Version = Version;387	type MaxConsumers = ConstU32<16>;388}389390parameter_types! {391	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;392}393394impl pallet_timestamp::Config for Runtime {395	/// A timestamp: milliseconds since the unix epoch.396	type Moment = u64;397	type OnTimestampSet = ();398	type MinimumPeriod = MinimumPeriod;399	type WeightInfo = ();400}401402parameter_types! {403	// pub const ExistentialDeposit: u128 = 500;404	pub const ExistentialDeposit: u128 = 0;405	pub const MaxLocks: u32 = 50;406}407408impl pallet_balances::Config for Runtime {409	type MaxLocks = MaxLocks;410	type MaxReserves = ();411	type ReserveIdentifier = [u8; 8];412	/// The type for recording an account's balance.413	type Balance = Balance;414	/// The ubiquitous event type.415	type Event = Event;416	type DustRemoval = Treasury;417	type ExistentialDeposit = ExistentialDeposit;418	type AccountStore = System;419	type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;420}421422pub const MICROUNIQUE: Balance = 1_000_000_000_000;423pub const MILLIUNIQUE: Balance = 1_000 * MICROUNIQUE;424pub const CENTIUNIQUE: Balance = 10 * MILLIUNIQUE;425pub const UNIQUE: Balance = 100 * CENTIUNIQUE;426427pub const fn deposit(items: u32, bytes: u32) -> Balance {428	items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE429}430431/*432parameter_types! {433	pub TombstoneDeposit: Balance = deposit(434		1,435		sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,436	);437	pub DepositPerContract: Balance = TombstoneDeposit::get();438	pub const DepositPerStorageByte: Balance = deposit(0, 1);439	pub const DepositPerStorageItem: Balance = deposit(1, 0);440	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);441	pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;442	pub const SignedClaimHandicap: u32 = 2;443	pub const MaxDepth: u32 = 32;444	pub const MaxValueSize: u32 = 16 * 1024;445	pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb446	// The lazy deletion runs inside on_initialize.447	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *448		RuntimeBlockWeights::get().max_block;449	// The weight needed for decoding the queue should be less or equal than a fifth450	// of the overall weight dedicated to the lazy deletion.451	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (452			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -453			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)454		)) / 5) as u32;455	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();456}457458impl pallet_contracts::Config for Runtime {459	type Time = Timestamp;460	type Randomness = RandomnessCollectiveFlip;461	type Currency = Balances;462	type Event = Event;463	type RentPayment = ();464	type SignedClaimHandicap = SignedClaimHandicap;465	type TombstoneDeposit = TombstoneDeposit;466	type DepositPerContract = DepositPerContract;467	type DepositPerStorageByte = DepositPerStorageByte;468	type DepositPerStorageItem = DepositPerStorageItem;469	type RentFraction = RentFraction;470	type SurchargeReward = SurchargeReward;471	type WeightPrice = pallet_transaction_payment::Pallet<Self>;472	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;473	type ChainExtension = NFTExtension;474	type DeletionQueueDepth = DeletionQueueDepth;475	type DeletionWeightLimit = DeletionWeightLimit;476	type Schedule = Schedule;477	type CallStack = [pallet_contracts::Frame<Self>; 31];478}479*/480481parameter_types! {482	pub const TransactionByteFee: Balance = 501 * MICROUNIQUE; // Targeting 0.1 Unique per NFT transfer483	/// This value increases the priority of `Operational` transactions by adding484	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.485	pub const OperationalFeeMultiplier: u8 = 5;486}487488/// Linear implementor of `WeightToFeePolynomial`489pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);490491impl<T> WeightToFeePolynomial for LinearFee<T>492where493	T: BaseArithmetic + From<u32> + Copy + Unsigned,494{495	type Balance = T;496497	fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {498		smallvec!(WeightToFeeCoefficient {499			// Targeting 0.1 Unique per NFT transfer500			coeff_integer: 142_688_000u32.into(),501			coeff_frac: Perbill::zero(),502			negative: false,503			degree: 1,504		})505	}506}507508impl pallet_transaction_payment::Config for Runtime {509	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;510	type TransactionByteFee = TransactionByteFee;511	type OperationalFeeMultiplier = OperationalFeeMultiplier;512	type WeightToFee = LinearFee<Balance>;513	type FeeMultiplierUpdate = ();514}515516parameter_types! {517	pub const ProposalBond: Permill = Permill::from_percent(5);518	pub const ProposalBondMinimum: Balance = 1 * UNIQUE;519	pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;520	pub const SpendPeriod: BlockNumber = 5 * MINUTES;521	pub const Burn: Permill = Permill::from_percent(0);522	pub const TipCountdown: BlockNumber = 1 * DAYS;523	pub const TipFindersFee: Percent = Percent::from_percent(20);524	pub const TipReportDepositBase: Balance = 1 * UNIQUE;525	pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;526	pub const BountyDepositBase: Balance = 1 * UNIQUE;527	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;528	pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");529	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;530	pub const MaximumReasonLength: u32 = 16384;531	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);532	pub const BountyValueMinimum: Balance = 5 * UNIQUE;533	pub const MaxApprovals: u32 = 100;534}535536impl pallet_treasury::Config for Runtime {537	type PalletId = TreasuryModuleId;538	type Currency = Balances;539	type ApproveOrigin = EnsureRoot<AccountId>;540	type RejectOrigin = EnsureRoot<AccountId>;541	type Event = Event;542	type OnSlash = ();543	type ProposalBond = ProposalBond;544	type ProposalBondMinimum = ProposalBondMinimum;545	type ProposalBondMaximum = ProposalBondMaximum;546	type SpendPeriod = SpendPeriod;547	type Burn = Burn;548	type BurnDestination = ();549	type SpendFunds = ();550	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;551	type MaxApprovals = MaxApprovals;552}553554impl pallet_sudo::Config for Runtime {555	type Event = Event;556	type Call = Call;557}558559pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);560561impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider562	for RelayChainBlockNumberProvider<T>563{564	type BlockNumber = BlockNumber;565566	fn current_block_number() -> Self::BlockNumber {567		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()568			.map(|d| d.relay_parent_number)569			.unwrap_or_default()570	}571}572573parameter_types! {574	pub const MinVestedTransfer: Balance = 10 * UNIQUE;575	pub const MaxVestingSchedules: u32 = 28;576}577578impl orml_vesting::Config for Runtime {579	type Event = Event;580	type Currency = pallet_balances::Pallet<Runtime>;581	type MinVestedTransfer = MinVestedTransfer;582	type VestedTransferOrigin = EnsureSigned<AccountId>;583	type WeightInfo = ();584	type MaxVestingSchedules = MaxVestingSchedules;585	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;586}587588parameter_types! {589	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;590	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;591}592593impl cumulus_pallet_parachain_system::Config for Runtime {594	type Event = Event;595	type SelfParaId = parachain_info::Pallet<Self>;596	type OnSystemEvent = ();597	// type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<598	// 	MaxDownwardMessageWeight,599	// 	XcmExecutor<XcmConfig>,600	// 	Call,601	// >;602	type OutboundXcmpMessageSource = XcmpQueue;603	type DmpMessageHandler = DmpQueue;604	type ReservedDmpWeight = ReservedDmpWeight;605	type ReservedXcmpWeight = ReservedXcmpWeight;606	type XcmpMessageHandler = XcmpQueue;607}608609pub struct SiblingParachainConvertsVia2<ParaId, AccountId>(PhantomData<(ParaId, AccountId)>);610impl<ParaId: From<u32> + Into<u32> + AccountIdConversion<AccountId>, AccountId: Clone + core::fmt::Debug>611	Convert<MultiLocation, AccountId> for SiblingParachainConvertsVia2<ParaId, AccountId>612{613	fn convert_ref(location: impl Borrow<MultiLocation>) -> Result<AccountId, ()> {614615616617		match location.borrow() {618			MultiLocation { parents: 1, interior: X1(Parachain(id)) } => {619				log::debug!(620					target: "xcm::converter",621					"SiblingParachainConvertsVia2 accountId: {:?}",622					ParaId::from(*id).into_account(),623				);624				Ok(ParaId::from(*id).into_account())625			}626			_ => Err(()),627		}628	}629630	fn reverse_ref(who: impl Borrow<AccountId>) -> Result<MultiLocation, ()> {631		if let Some(id) = ParaId::try_from_account(who.borrow()) {632			Ok(MultiLocation::new(1, X1(Parachain(id.into()))))633		} else {634			Err(())635		}636	}637}638639640impl parachain_info::Config for Runtime {}641642impl cumulus_pallet_aura_ext::Config for Runtime {}643644parameter_types! {645	pub const RelayLocation: MultiLocation = MultiLocation::parent();646	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;647	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();648	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();649}650651/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used652/// when determining ownership of accounts for asset transacting and when attempting to use XCM653/// `Transact` in order to determine the dispatch Origin.654pub type LocationToAccountId = (655	// The parent (Relay-chain) origin converts to the default `AccountId`.656	ParentIsDefault<AccountId>,657	// Sibling parachain origins convert to AccountId via the `ParaId::into`.658	SiblingParachainConvertsVia2<Sibling, AccountId>,659	// Straight up local `AccountId32` origins just alias directly to `AccountId`.660	AccountId32Aliases<RelayNetwork, AccountId>,661);662663664pub struct OnlySelfCurrency;665impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {666	fn matches_fungible(a: &MultiAsset) -> Option<B> {667		match (&a.id, &a.fun) {668			(Concrete(_), XcmFungible(ref amount)) =>669				CheckedConversion::checked_from(*amount),670			_ => None,671		}672	}673}674675/// Means for transacting assets on this chain.676pub type LocalAssetTransactor = CurrencyAdapter<677	// Use this currency:678	Balances,679	// Use this currency when it is a fungible asset matching the given location or name:680	OnlySelfCurrency,681	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:682	LocationToAccountId,683	// Our chain's account ID type (we can't get away without mentioning it explicitly):684	AccountId,685	// We don't track any teleports.686	(),687>;688689/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,690/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can691/// biases the kind of local `Origin` it will become.692pub type XcmOriginToTransactDispatchOrigin = (693	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location694	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for695	// foreign chains who want to have a local sovereign account on this chain which they control.696	SovereignSignedViaLocation<LocationToAccountId, Origin>,697	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when698	// recognised.699	RelayChainAsNative<RelayOrigin, Origin>,700	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when701	// recognised.702	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,703	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a704	// transaction from the Root origin.705	ParentAsSuperuser<Origin>,706	// Native signed account converter; this just converts an `AccountId32` origin into a normal707	// `Origin::Signed` origin of the same 32-byte value.708	SignedAccountId32AsNative<RelayNetwork, Origin>,709	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.710	XcmPassthrough<Origin>,711);712713parameter_types! {714	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.715	pub UnitWeightCost: Weight = 1_000_000;716	// 1200 UNIQUEs buy 1 second of weight.717	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);718	pub const MaxInstructions: u32 = 100;719	pub const MaxAuthorities: u32 = 100_000;720}721722match_type! {723	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {724		MultiLocation { parents: 1, interior: Here } |725		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }726	};727}728729pub type Barrier = (730	TakeWeightCredit,731	AllowTopLevelPaidExecutionFrom<Everything>,732	AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,733	// ^^^ Parent & its unit plurality gets free execution734);735736pub struct XcmConfig;737impl Config for XcmConfig {738	type Call = Call;739	type XcmSender = XcmRouter;740	// How to withdraw and deposit an asset.741	type AssetTransactor = LocalAssetTransactor;742	type OriginConverter = XcmOriginToTransactDispatchOrigin;743	type IsReserve = NativeAsset;744	type IsTeleporter = (); // Teleportation is disabled745	type LocationInverter = LocationInverter<Ancestry>;746	type Barrier = Barrier;747	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;748	type Trader = UsingComponents<IdentityFee<Balance>, RelayLocation, AccountId, Balances, ()>;749	type ResponseHandler = (); // Don't handle responses for now.750	type SubscriptionService = PolkadotXcm;751752	type AssetTrap = PolkadotXcm;753	type AssetClaims = PolkadotXcm;754}755756// parameter_types! {757// 	pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;758// }759760/// No local origins on this chain are allowed to dispatch XCM sends/executions.761pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);762763/// The means for routing XCM messages which are not for local execution into the right message764/// queues.765pub type XcmRouter = (766	// Two routers - use UMP to communicate with the relay chain:767	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,768	// ..and XCMP to communicate with the sibling chains.769	XcmpQueue,770);771772impl pallet_evm_coder_substrate::Config for Runtime {773	type EthereumTransactionSender = pallet_ethereum::Pallet<Self>;774	type GasWeightMapping = FixedGasWeightMapping;775}776777impl pallet_xcm::Config for Runtime {778	type Event = Event;779	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;780	type XcmRouter = XcmRouter;781	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;782	type XcmExecuteFilter = Everything;783	type XcmExecutor = XcmExecutor<XcmConfig>;784	type XcmTeleportFilter = Everything;785	type XcmReserveTransferFilter = Everything;786	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;787	type LocationInverter = LocationInverter<Ancestry>;788	type Origin = Origin;789	type Call = Call;790	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;791	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;792}793794impl cumulus_pallet_xcm::Config for Runtime {795	type Event = Event;796	type XcmExecutor = XcmExecutor<XcmConfig>;797}798799impl cumulus_pallet_xcmp_queue::Config for Runtime {800	type Event = Event;801	type XcmExecutor = XcmExecutor<XcmConfig>;802	type ChannelInfo = ParachainSystem;803	type VersionWrapper = ();804	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;805}806807impl cumulus_pallet_dmp_queue::Config for Runtime {808	type Event = Event;809	type XcmExecutor = XcmExecutor<XcmConfig>;810	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;811}812813impl pallet_aura::Config for Runtime {814	type AuthorityId = AuraId;815	type DisabledValidators = ();816	type MaxAuthorities = MaxAuthorities;817}818819parameter_types! {820	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();821	pub const CollectionCreationPrice: Balance = 100 * UNIQUE;822}823824impl pallet_common::Config for Runtime {825	type Event = Event;826	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;827	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;828	type CrossAccountId = pallet_common::account::BasicCrossAccountId<Self>;829830	type Currency = Balances;831	type CollectionCreationPrice = CollectionCreationPrice;832	type TreasuryAccountId = TreasuryAccountId;833}834835impl pallet_fungible::Config for Runtime {836	type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;837}838impl pallet_refungible::Config for Runtime {839	type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;840}841impl pallet_nonfungible::Config for Runtime {842	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;843}844845impl pallet_unique::Config for Runtime {846	type Event = Event;847	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;848}849850parameter_types! {851	pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied852}853854/// Used for the pallet inflation855impl pallet_inflation::Config for Runtime {856	type Currency = Balances;857	type TreasuryAccountId = TreasuryAccountId;858	type InflationBlockInterval = InflationBlockInterval;859	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;860}861862// parameter_types! {863// 	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *864// 		RuntimeBlockWeights::get().max_block;865// 	pub const MaxScheduledPerBlock: u32 = 50;866// }867868type EvmSponsorshipHandler = (869	pallet_unique::UniqueEthSponsorshipHandler<Runtime>,870	pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,871);872type SponsorshipHandler = (873	pallet_unique::UniqueSponsorshipHandler<Runtime>,874	//pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,875	pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,876);877878// impl pallet_unq_scheduler::Config for Runtime {879// 	type Event = Event;880// 	type Origin = Origin;881// 	type PalletsOrigin = OriginCaller;882// 	type Call = Call;883// 	type MaximumWeight = MaximumSchedulerWeight;884// 	type ScheduleOrigin = EnsureSigned<AccountId>;885// 	type MaxScheduledPerBlock = MaxScheduledPerBlock;886// 	type SponsorshipHandler = SponsorshipHandler;887// 	type WeightInfo = ();888// }889890impl pallet_evm_transaction_payment::Config for Runtime {891	type EvmSponsorshipHandler = EvmSponsorshipHandler;892	type Currency = Balances;893	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;894	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;895}896897impl pallet_charge_transaction::Config for Runtime {898	type SponsorshipHandler = SponsorshipHandler;899}900901// impl pallet_contract_helpers::Config for Runtime {902//	 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;903// }904905parameter_types! {906	// 0x842899ECF380553E8a4de75bF534cdf6fBF64049907	pub const HelpersContractAddress: H160 = H160([908		0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,909	]);910}911912impl pallet_evm_contract_helpers::Config for Runtime {913	type ContractAddress = HelpersContractAddress;914	type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;915}916917construct_runtime!(918	pub enum Runtime where919		Block = Block,920		NodeBlock = opaque::Block,921		UncheckedExtrinsic = UncheckedExtrinsic922	{923		ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,924		ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,925926		Aura: pallet_aura::{Pallet, Config<T>} = 22,927		AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,928929		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,930		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,931		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,932		TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,933		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,934		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,935		System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,936		Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,937		// Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,938		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,939940		// XCM helpers.941		XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,942		PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,943		CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,944		DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,945946		// Unique Pallets947		Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,948		Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,949		// Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event<T>} = 62,950		// free = 63951		Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,952		// ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,953		Common: pallet_common::{Pallet, Storage, Event<T>} = 66,954		Fungible: pallet_fungible::{Pallet, Storage} = 67,955		Refungible: pallet_refungible::{Pallet, Storage} = 68,956		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,957958		// Frontier959		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,960		Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,961962		EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,963		EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,964		EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,965		EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,966	}967);968969pub struct TransactionConverter;970971impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {972	fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {973		UncheckedExtrinsic::new_unsigned(974			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),975		)976	}977}978979impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {980	fn convert_transaction(981		&self,982		transaction: pallet_ethereum::Transaction,983	) -> opaque::UncheckedExtrinsic {984		let extrinsic = UncheckedExtrinsic::new_unsigned(985			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),986		);987		let encoded = extrinsic.encode();988		opaque::UncheckedExtrinsic::decode(&mut &encoded[..])989			.expect("Encoded extrinsic is always valid")990	}991}992993/// The address format for describing accounts.994pub type Address = sp_runtime::MultiAddress<AccountId, ()>;995/// Block header type as expected by this runtime.996pub type Header = generic::Header<BlockNumber, BlakeTwo256>;997/// Block type as expected by this runtime.998pub type Block = generic::Block<Header, UncheckedExtrinsic>;999/// A Block signed with a Justification1000pub type SignedBlock = generic::SignedBlock<Block>;1001/// BlockId type as expected by this runtime.1002pub type BlockId = generic::BlockId<Block>;1003/// The SignedExtension to the basic transaction logic.1004pub type SignedExtra = (1005	frame_system::CheckSpecVersion<Runtime>,1006	// system::CheckTxVersion<Runtime>,1007	frame_system::CheckGenesis<Runtime>,1008	frame_system::CheckEra<Runtime>,1009	frame_system::CheckNonce<Runtime>,1010	frame_system::CheckWeight<Runtime>,1011	pallet_charge_transaction::ChargeTransactionPayment<Runtime>,1012	//pallet_contract_helpers::ContractHelpersExtension<Runtime>,1013);1014/// Unchecked extrinsic type as expected by this runtime.1015pub type UncheckedExtrinsic =1016	fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1017/// Extrinsic type that has already been checked.1018pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1019/// Executive: handles dispatch to the various modules.1020pub type Executive = frame_executive::Executive<1021	Runtime,1022	Block,1023	frame_system::ChainContext<Runtime>,1024	Runtime,1025	AllPalletsReversedWithSystemFirst,1026>;10271028impl_opaque_keys! {1029	pub struct SessionKeys {1030		pub aura: Aura,1031	}1032}10331034impl fp_self_contained::SelfContainedCall for Call {1035	type SignedInfo = H160;10361037	fn is_self_contained(&self) -> bool {1038		match self {1039			Call::Ethereum(call) => call.is_self_contained(),1040			_ => false,1041		}1042	}10431044	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1045		match self {1046			Call::Ethereum(call) => call.check_self_contained(),1047			_ => None,1048		}1049	}10501051	fn validate_self_contained(&self, info: &Self::SignedInfo) -> Option<TransactionValidity> {1052		match self {1053			Call::Ethereum(call) => call.validate_self_contained(info),1054			_ => None,1055		}1056	}10571058	fn pre_dispatch_self_contained(1059		&self,1060		info: &Self::SignedInfo,1061	) -> Option<Result<(), TransactionValidityError>> {1062		match self {1063			Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1064			_ => None,1065		}1066	}10671068	fn apply_self_contained(1069		self,1070		info: Self::SignedInfo,1071	) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1072		match self {1073			call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1074				Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1075			)),1076			_ => None,1077		}1078	}1079}10801081macro_rules! dispatch_unique_runtime {1082	($collection:ident.$method:ident($($name:ident),*)) => {{1083		use pallet_unique::dispatch::Dispatched;10841085		let collection = Dispatched::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1086		let dispatch = collection.as_dyn();10871088		Ok(dispatch.$method($($name),*))1089	}};1090}1091impl_runtime_apis! {1092	impl up_rpc::UniqueApi<Block, CrossAccountId, AccountId>1093		for Runtime1094	{1095		fn account_tokens(collection: CollectionId, account: CrossAccountId) -> Result<Vec<TokenId>, DispatchError> {1096			dispatch_unique_runtime!(collection.account_tokens(account))1097		}1098		fn token_exists(collection: CollectionId, token: TokenId) -> Result<bool, DispatchError> {1099			dispatch_unique_runtime!(collection.token_exists(token))1100		}11011102		fn token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {1103			dispatch_unique_runtime!(collection.token_owner(token))1104		}1105		fn const_metadata(collection: CollectionId, token: TokenId) -> Result<Vec<u8>, DispatchError> {1106			dispatch_unique_runtime!(collection.const_metadata(token))1107		}1108		fn variable_metadata(collection: CollectionId, token: TokenId) -> Result<Vec<u8>, DispatchError> {1109			dispatch_unique_runtime!(collection.variable_metadata(token))1110		}11111112		fn collection_tokens(collection: CollectionId) -> Result<u32, DispatchError> {1113			dispatch_unique_runtime!(collection.collection_tokens())1114		}1115		fn account_balance(collection: CollectionId, account: CrossAccountId) -> Result<u32, DispatchError> {1116			dispatch_unique_runtime!(collection.account_balance(account))1117		}1118		fn balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<u128, DispatchError> {1119			dispatch_unique_runtime!(collection.balance(account, token))1120		}1121		fn allowance(1122			collection: CollectionId,1123			sender: CrossAccountId,1124			spender: CrossAccountId,1125			token: TokenId,1126		) -> Result<u128, DispatchError> {1127			dispatch_unique_runtime!(collection.allowance(sender, spender, token))1128		}11291130		fn eth_contract_code(account: H160) -> Option<Vec<u8>> {1131			<pallet_unique::UniqueErcSupport<Runtime>>::get_code(&account)1132				.or_else(|| <pallet_evm_migration::OnMethodCall<Runtime>>::get_code(&account))1133				.or_else(|| <pallet_evm_contract_helpers::HelpersOnMethodCall<Self>>::get_code(&account))1134		}1135		fn adminlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {1136			Ok(<pallet_common::Pallet<Runtime>>::adminlist(collection))1137		}1138		fn allowlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {1139			Ok(<pallet_common::Pallet<Runtime>>::allowlist(collection))1140		}1141		fn allowed(collection: CollectionId, user: CrossAccountId) -> Result<bool, DispatchError> {1142			Ok(<pallet_common::Pallet<Runtime>>::allowed(collection, user))1143		}1144		fn last_token_id(collection: CollectionId) -> Result<TokenId, DispatchError> {1145			dispatch_unique_runtime!(collection.last_token_id())1146		}1147		fn collection_by_id(collection: CollectionId) -> Result<Option<Collection<AccountId>>, DispatchError> {1148			Ok(<pallet_common::CollectionById<Runtime>>::get(collection))1149		}1150		fn collection_stats() -> Result<CollectionStats, DispatchError> {1151			Ok(<pallet_common::Pallet<Runtime>>::collection_stats())1152		}1153	}11541155	impl sp_api::Core<Block> for Runtime {1156		fn version() -> RuntimeVersion {1157			VERSION1158		}11591160		fn execute_block(block: Block) {1161			Executive::execute_block(block)1162		}11631164		fn initialize_block(header: &<Block as BlockT>::Header) {1165			Executive::initialize_block(header)1166		}1167	}11681169	impl sp_api::Metadata<Block> for Runtime {1170		fn metadata() -> OpaqueMetadata {1171			OpaqueMetadata::new(Runtime::metadata().into())1172		}1173	}11741175	impl sp_block_builder::BlockBuilder<Block> for Runtime {1176		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {1177			Executive::apply_extrinsic(extrinsic)1178		}11791180		fn finalize_block() -> <Block as BlockT>::Header {1181			Executive::finalize_block()1182		}11831184		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {1185			data.create_extrinsics()1186		}11871188		fn check_inherents(1189			block: Block,1190			data: sp_inherents::InherentData,1191		) -> sp_inherents::CheckInherentsResult {1192			data.check_extrinsics(&block)1193		}11941195		// fn random_seed() -> <Block as BlockT>::Hash {1196		//     RandomnessCollectiveFlip::random_seed().01197		// }1198	}11991200	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {1201		fn validate_transaction(1202			source: TransactionSource,1203			tx: <Block as BlockT>::Extrinsic,1204			hash: <Block as BlockT>::Hash,1205		) -> TransactionValidity {1206			Executive::validate_transaction(source, tx, hash)1207		}1208	}12091210	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {1211		fn offchain_worker(header: &<Block as BlockT>::Header) {1212			Executive::offchain_worker(header)1213		}1214	}12151216	impl fp_rpc::EthereumRuntimeRPCApi<Block> for Runtime {1217		fn chain_id() -> u64 {1218			<Runtime as pallet_evm::Config>::ChainId::get()1219		}12201221		fn account_basic(address: H160) -> EVMAccount {1222			EVM::account_basic(&address)1223		}12241225		fn gas_price() -> U256 {1226			<Runtime as pallet_evm::Config>::FeeCalculator::min_gas_price()1227		}12281229		fn account_code_at(address: H160) -> Vec<u8> {1230			EVM::account_codes(address)1231		}12321233		fn author() -> H160 {1234			<pallet_evm::Pallet<Runtime>>::find_author()1235		}12361237		fn storage_at(address: H160, index: U256) -> H256 {1238			let mut tmp = [0u8; 32];1239			index.to_big_endian(&mut tmp);1240			EVM::account_storages(address, H256::from_slice(&tmp[..]))1241		}12421243		#[allow(clippy::redundant_closure)]1244		fn call(1245			from: H160,1246			to: H160,1247			data: Vec<u8>,1248			value: U256,1249			gas_limit: U256,1250			max_fee_per_gas: Option<U256>,1251			max_priority_fee_per_gas: Option<U256>,1252			nonce: Option<U256>,1253			estimate: bool,1254			access_list: Option<Vec<(H160, Vec<H256>)>>,1255		) -> Result<pallet_evm::CallInfo, sp_runtime::DispatchError> {1256			let config = if estimate {1257				let mut config = <Runtime as pallet_evm::Config>::config().clone();1258				config.estimate = true;1259				Some(config)1260			} else {1261				None1262			};12631264			<Runtime as pallet_evm::Config>::Runner::call(1265				from,1266				to,1267				data,1268				value,1269				gas_limit.low_u64(),1270				max_fee_per_gas,1271				max_priority_fee_per_gas,1272				nonce,1273				access_list.unwrap_or_default(),1274				config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),1275			).map_err(|err| err.into())1276		}12771278		#[allow(clippy::redundant_closure)]1279		fn create(1280			from: H160,1281			data: Vec<u8>,1282			value: U256,1283			gas_limit: U256,1284			max_fee_per_gas: Option<U256>,1285			max_priority_fee_per_gas: Option<U256>,1286			nonce: Option<U256>,1287			estimate: bool,1288			access_list: Option<Vec<(H160, Vec<H256>)>>,1289		) -> Result<pallet_evm::CreateInfo, sp_runtime::DispatchError> {1290			let config = if estimate {1291				let mut config = <Runtime as pallet_evm::Config>::config().clone();1292				config.estimate = true;1293				Some(config)1294			} else {1295				None1296			};12971298			<Runtime as pallet_evm::Config>::Runner::create(1299				from,1300				data,1301				value,1302				gas_limit.low_u64(),1303				max_fee_per_gas,1304				max_priority_fee_per_gas,1305				nonce,1306				access_list.unwrap_or_default(),1307				config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),1308			).map_err(|err| err.into())1309		}13101311		fn current_transaction_statuses() -> Option<Vec<TransactionStatus>> {1312			Ethereum::current_transaction_statuses()1313		}13141315		fn current_block() -> Option<pallet_ethereum::Block> {1316			Ethereum::current_block()1317		}13181319		fn current_receipts() -> Option<Vec<pallet_ethereum::Receipt>> {1320			Ethereum::current_receipts()1321		}13221323		fn current_all() -> (1324			Option<pallet_ethereum::Block>,1325			Option<Vec<pallet_ethereum::Receipt>>,1326			Option<Vec<TransactionStatus>>1327		) {1328			(1329				Ethereum::current_block(),1330				Ethereum::current_receipts(),1331				Ethereum::current_transaction_statuses()1332			)1333		}13341335		fn extrinsic_filter(xts: Vec<<Block as sp_api::BlockT>::Extrinsic>) -> Vec<pallet_ethereum::Transaction> {1336			xts.into_iter().filter_map(|xt| match xt.0.function {1337				Call::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction),1338				_ => None1339			}).collect()1340		}13411342		fn elasticity() -> Option<Permill> {1343			None1344		}1345	}13461347	impl sp_session::SessionKeys<Block> for Runtime {1348		fn decode_session_keys(1349			encoded: Vec<u8>,1350		) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {1351			SessionKeys::decode_into_raw_public_keys(&encoded)1352		}13531354		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {1355			SessionKeys::generate(seed)1356		}1357	}13581359	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {1360		fn slot_duration() -> sp_consensus_aura::SlotDuration {1361			sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())1362		}13631364		fn authorities() -> Vec<AuraId> {1365			Aura::authorities().to_vec()1366		}1367	}13681369	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {1370		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {1371			ParachainSystem::collect_collation_info(header)1372		}1373	}13741375	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {1376		fn account_nonce(account: AccountId) -> Index {1377			System::account_nonce(account)1378		}1379	}13801381	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {1382		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {1383			TransactionPayment::query_info(uxt, len)1384		}1385		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {1386			TransactionPayment::query_fee_details(uxt, len)1387		}1388	}13891390	/*1391	impl pallet_contracts_rpc_runtime_api::ContractsApi<Block, AccountId, Balance, BlockNumber, Hash>1392		for Runtime1393	{1394		fn call(1395			origin: AccountId,1396			dest: AccountId,1397			value: Balance,1398			gas_limit: u64,1399			input_data: Vec<u8>,1400		) -> pallet_contracts_primitives::ContractExecResult {1401			Contracts::bare_call(origin, dest, value, gas_limit, input_data, false)1402		}14031404		fn instantiate(1405			origin: AccountId,1406			endowment: Balance,1407			gas_limit: u64,1408			code: pallet_contracts_primitives::Code<Hash>,1409			data: Vec<u8>,1410			salt: Vec<u8>,1411		) -> pallet_contracts_primitives::ContractInstantiateResult<AccountId, BlockNumber>1412		{1413			Contracts::bare_instantiate(origin, endowment, gas_limit, code, data, salt, true, false)1414		}14151416		fn get_storage(1417			address: AccountId,1418			key: [u8; 32],1419		) -> pallet_contracts_primitives::GetStorageResult {1420			Contracts::get_storage(address, key)1421		}14221423		fn rent_projection(1424			address: AccountId,1425		) -> pallet_contracts_primitives::RentProjectionResult<BlockNumber> {1426			Contracts::rent_projection(address)1427		}1428	}1429	*/14301431	#[cfg(feature = "runtime-benchmarks")]1432	impl frame_benchmarking::Benchmark<Block> for Runtime {1433		fn benchmark_metadata(extra: bool) -> (1434			Vec<frame_benchmarking::BenchmarkList>,1435			Vec<frame_support::traits::StorageInfo>,1436		) {1437			use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList};1438			use frame_support::traits::StorageInfoTrait;14391440			let mut list = Vec::<BenchmarkList>::new();14411442			list_benchmark!(list, extra, pallet_evm_migration, EvmMigration);1443			list_benchmark!(list, extra, pallet_unique, Unique);1444			list_benchmark!(list, extra, pallet_inflation, Inflation);1445			list_benchmark!(list, extra, pallet_fungible, Fungible);1446			list_benchmark!(list, extra, pallet_refungible, Refungible);1447			list_benchmark!(list, extra, pallet_nonfungible, Nonfungible);1448			// list_benchmark!(list, extra, pallet_evm_coder_substrate, EvmCoderSubstrate);14491450			let storage_info = AllPalletsReversedWithSystemFirst::storage_info();14511452			return (list, storage_info)1453		}14541455		fn dispatch_benchmark(1456			config: frame_benchmarking::BenchmarkConfig1457		) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {1458			use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey};14591460			let allowlist: Vec<TrackedStorageKey> = vec![1461				// Block Number1462				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),1463				// Total Issuance1464				hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),1465				// Execution Phase1466				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),1467				// Event Count1468				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),1469				// System Events1470				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),1471			];14721473			let mut batches = Vec::<BenchmarkBatch>::new();1474			let params = (&config, &allowlist);14751476			add_benchmark!(params, batches, pallet_evm_migration, EvmMigration);1477			add_benchmark!(params, batches, pallet_unique, Unique);1478			add_benchmark!(params, batches, pallet_inflation, Inflation);1479			add_benchmark!(params, batches, pallet_fungible, Fungible);1480			add_benchmark!(params, batches, pallet_refungible, Refungible);1481			add_benchmark!(params, batches, pallet_nonfungible, Nonfungible);1482			// add_benchmark!(params, batches, pallet_evm_coder_substrate, EvmCoderSubstrate);14831484			if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }1485			Ok(batches)1486		}1487	}1488}14891490struct CheckInherents;14911492impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1493	fn check_inherents(1494		block: &Block,1495		relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1496	) -> sp_inherents::CheckInherentsResult {1497		let relay_chain_slot = relay_state_proof1498			.read_slot()1499			.expect("Could not read the relay chain slot from the proof");15001501		let inherent_data =1502			cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1503				relay_chain_slot,1504				sp_std::time::Duration::from_secs(6),1505			)1506			.create_inherent_data()1507			.expect("Could not create the timestamp inherent data");15081509		inherent_data.check_extrinsics(block)1510	}1511}15121513cumulus_pallet_parachain_system::register_validate_block!(1514	Runtime = Runtime,1515	BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1516	CheckInherents = CheckInherents,1517);