`1c23d3abc9fc`

source

runtime/src/lib.rs50.5 KiBsource history
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;20use fp_self_contained::*;21use sp_runtime::traits::{Applyable, Member};22// #[cfg(any(feature = "std", test))]23// pub use sp_runtime::BuildStorage;2425use sp_runtime::{26	Permill, Perbill, Percent, create_runtime_str, generic, impl_opaque_keys,27	traits::{28		AccountIdLookup, BlakeTwo256, Block as BlockT, IdentifyAccount, Verify, AccountIdConversion,29	},30	transaction_validity::{TransactionSource, TransactionValidity},31	ApplyExtrinsicResult, MultiSignature,32};3334use sp_std::prelude::*;3536#[cfg(feature = "std")]37use sp_version::NativeVersion;38use sp_version::RuntimeVersion;39pub use pallet_transaction_payment::{40	Multiplier, TargetedFeeAdjustment, FeeDetails, RuntimeDispatchInfo,41};42// A few exports that help ease life for downstream crates.43pub use pallet_balances::Call as BalancesCall;44pub use pallet_evm::{EnsureAddressTruncated, HashedAddressMapping, Runner};45pub use frame_support::{46	construct_runtime, match_type,47	dispatch::DispatchResult,48	PalletId, parameter_types, StorageValue, ConsensusEngineId,49	traits::{50		Everything, Currency, ExistenceRequirement, Get, IsInVec, KeyOwnerProofSystem,51		LockIdentifier, 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 pallet_unq_scheduler::ApplyExtrinsic;60use up_data_structs::*;61// use pallet_contracts::weights::WeightInfo;62// #[cfg(any(feature = "std", test))]63use frame_system::{64	self as frame_system, EnsureRoot, EnsureSigned,65	limits::{BlockWeights, BlockLength},66};67use sp_arithmetic::{68	traits::{BaseArithmetic, Unsigned},69};70use smallvec::smallvec;71use codec::{Encode, Decode};72use pallet_evm::{Account as EVMAccount, FeeCalculator, GasWeightMapping, OnMethodCall};73use fp_rpc::TransactionStatus;74use sp_core::crypto::Public;75use sp_runtime::{76	traits::{BlockNumberProvider, Dispatchable, PostDispatchInfoOf},77	transaction_validity::TransactionValidityError,78};7980// pub use pallet_timestamp::Call as TimestampCall;81pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;8283// Polkadot imports84use pallet_xcm::XcmPassthrough;85use polkadot_parachain::primitives::Sibling;86use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};87use xcm_builder::{88	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,89	EnsureXcmOrigin, FixedWeightBounds, IsConcrete, LocationInverter, NativeAsset,90	ParentAsSuperuser, ParentIsDefault, RelayChainAsNative, SiblingParachainAsNative,91	SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32,92	SovereignSignedViaLocation, TakeWeightCredit, UsingComponents,93};94use xcm_executor::{Config, XcmExecutor};9596// mod chain_extension;97// use crate::chain_extension::{NFTExtension, Imbalance};9899/// An index to a block.100pub type BlockNumber = u32;101102/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.103pub type Signature = MultiSignature;104105/// Some way of identifying an account on the chain. We intentionally make it equivalent106/// to the public key of our transaction signing scheme.107pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;108109pub type CrossAccountId = pallet_common::account::BasicCrossAccountId<Runtime>;110111/// The type for looking up accounts. We don't expect more than 4 billion of them, but you112/// never know...113pub type AccountIndex = u32;114115/// Balance of an account.116pub type Balance = u128;117118/// Index of a transaction in the chain.119pub type Index = u32;120121/// A hash of some data used by the chain.122pub type Hash = sp_core::H256;123124/// Digest item type.125pub type DigestItem = generic::DigestItem;126127/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know128/// the specifics of the runtime. They can then be made to be agnostic over specific formats129/// of data like extrinsics, allowing for them to continue syncing the network through upgrades130/// to even the core data structures.131pub mod opaque {132	use super::*;133134	pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;135136	/// Opaque block type.137	pub type Block = generic::Block<Header, UncheckedExtrinsic>;138139	pub type SessionHandlers = ();140141	impl_opaque_keys! {142		pub struct SessionKeys {143			pub aura: Aura,144		}145	}146}147148/// This runtime version.149pub const VERSION: RuntimeVersion = RuntimeVersion {150	spec_name: create_runtime_str!("opal"),151	impl_name: create_runtime_str!("opal"),152	authoring_version: 1,153	spec_version: 914000,154	impl_version: 1,155	apis: RUNTIME_API_VERSIONS,156	transaction_version: 1,157};158159pub const MILLISECS_PER_BLOCK: u64 = 12000;160161pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;162163// These time units are defined in number of blocks.164pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);165pub const HOURS: BlockNumber = MINUTES * 60;166pub const DAYS: BlockNumber = HOURS * 24;167168parameter_types! {169	pub const DefaultSponsoringRateLimit: BlockNumber = 1 * DAYS;170}171172#[derive(codec::Encode, codec::Decode)]173pub enum XCMPMessage<XAccountId, XBalance> {174	/// Transfer tokens to the given account from the Parachain account.175	TransferToken(XAccountId, XBalance),176}177178/// The version information used to identify this runtime when compiled natively.179#[cfg(feature = "std")]180pub fn native_version() -> NativeVersion {181	NativeVersion {182		runtime_version: VERSION,183		can_author_with: Default::default(),184	}185}186187type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;188189pub struct DealWithFees;190impl OnUnbalanced<NegativeImbalance> for DealWithFees {191	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {192		if let Some(fees) = fees_then_tips.next() {193			// for fees, 100% to treasury194			let mut split = fees.ration(100, 0);195			if let Some(tips) = fees_then_tips.next() {196				// for tips, if any, 100% to treasury197				tips.ration_merge_into(100, 0, &mut split);198			}199			Treasury::on_unbalanced(split.0);200			// Author::on_unbalanced(split.1);201		}202	}203}204205/// We assume that ~10% of the block weight is consumed by `on_initalize` handlers.206/// This is used to limit the maximal weight of a single extrinsic.207const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);208/// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used209/// by  Operational  extrinsics.210const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);211/// We allow for 2 seconds of compute with a 6 second average block time.212const MAXIMUM_BLOCK_WEIGHT: Weight = WEIGHT_PER_SECOND / 2;213214parameter_types! {215	pub const BlockHashCount: BlockNumber = 2400;216	pub RuntimeBlockLength: BlockLength =217		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);218	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);219	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;220	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()221		.base_block(BlockExecutionWeight::get())222		.for_class(DispatchClass::all(), |weights| {223			weights.base_extrinsic = ExtrinsicBaseWeight::get();224		})225		.for_class(DispatchClass::Normal, |weights| {226			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);227		})228		.for_class(DispatchClass::Operational, |weights| {229			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);230			// Operational transactions have some extra reserved space, so that they231			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.232			weights.reserved = Some(233				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT234			);235		})236		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)237		.build_or_panic();238	pub const Version: RuntimeVersion = VERSION;239	pub const SS58Prefix: u8 = 42;240}241242parameter_types! {243	pub const ChainId: u64 = 8888;244}245246pub struct FixedFee;247impl FeeCalculator for FixedFee {248	fn min_gas_price() -> U256 {249		// Targeting 0.15 UNQ per transfer250		1_024_947_215_000u64.into()251	}252}253254// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case255// (contract, which only writes a lot of data),256// approximating on top of our real store write weight257parameter_types! {258	pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;259	pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;260	pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();261}262263/// Limiting EVM execution to 50% of block for substrate users and management tasks264/// EVM transaction consumes more weight than substrate's, so we can't rely on them being265/// scheduled fairly266const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);267parameter_types! {268	pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());269}270271pub enum FixedGasWeightMapping {}272impl GasWeightMapping for FixedGasWeightMapping {273	fn gas_to_weight(gas: u64) -> Weight {274		gas.saturating_mul(WeightPerGas::get())275	}276	fn weight_to_gas(weight: Weight) -> u64 {277		weight / WeightPerGas::get()278	}279}280281impl pallet_evm::Config for Runtime {282	type BlockGasLimit = BlockGasLimit;283	type FeeCalculator = FixedFee;284	type GasWeightMapping = FixedGasWeightMapping;285	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;286	type CallOrigin = EnsureAddressTruncated;287	type WithdrawOrigin = EnsureAddressTruncated;288	type AddressMapping = HashedAddressMapping<Self::Hashing>;289	type Precompiles = ();290	type Currency = Balances;291	type Event = Event;292	type OnMethodCall = (293		pallet_evm_migration::OnMethodCall<Self>,294		pallet_unique::UniqueErcSupport<Self>,295		pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,296	);297	type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;298	type ChainId = ChainId;299	type Runner = pallet_evm::runner::stack::Runner<Self>;300	type OnChargeTransaction = pallet_evm_transaction_payment::OnChargeTransaction<Self>;301	type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;302	type FindAuthor = EthereumFindAuthor<Aura>;303}304305impl pallet_evm_migration::Config for Runtime {306	type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;307}308309pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);310impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {311	fn find_author<'a, I>(digests: I) -> Option<H160>312	where313		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,314	{315		if let Some(author_index) = F::find_author(digests) {316			let authority_id = Aura::authorities()[author_index as usize].clone();317			return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));318		}319		None320	}321}322323impl pallet_ethereum::Config for Runtime {324	type Event = Event;325	type StateRoot = pallet_ethereum::IntermediateStateRoot;326}327328impl pallet_randomness_collective_flip::Config for Runtime {}329330impl frame_system::Config for Runtime {331	/// The data to be stored in an account.332	type AccountData = pallet_balances::AccountData<Balance>;333	/// The identifier used to distinguish between accounts.334	type AccountId = AccountId;335	/// The basic call filter to use in dispatchable.336	type BaseCallFilter = Everything;337	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).338	type BlockHashCount = BlockHashCount;339	/// The maximum length of a block (in bytes).340	type BlockLength = RuntimeBlockLength;341	/// The index type for blocks.342	type BlockNumber = BlockNumber;343	/// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.344	type BlockWeights = RuntimeBlockWeights;345	/// The aggregated dispatch type that is available for extrinsics.346	type Call = Call;347	/// The weight of database operations that the runtime can invoke.348	type DbWeight = RocksDbWeight;349	/// The ubiquitous event type.350	type Event = Event;351	/// The type for hashing blocks and tries.352	type Hash = Hash;353	/// The hashing algorithm used.354	type Hashing = BlakeTwo256;355	/// The header type.356	type Header = generic::Header<BlockNumber, BlakeTwo256>;357	/// The index type for storing how many extrinsics an account has signed.358	type Index = Index;359	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.360	type Lookup = AccountIdLookup<AccountId, ()>;361	/// What to do if an account is fully reaped from the system.362	type OnKilledAccount = ();363	/// What to do if a new account is created.364	type OnNewAccount = ();365	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;366	/// The ubiquitous origin type.367	type Origin = Origin;368	/// This type is being generated by `construct_runtime!`.369	type PalletInfo = PalletInfo;370	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.371	type SS58Prefix = SS58Prefix;372	/// Weight information for the extrinsics of this pallet.373	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;374	/// Version of the runtime.375	type Version = Version;376}377378parameter_types! {379	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;380}381382impl pallet_timestamp::Config for Runtime {383	/// A timestamp: milliseconds since the unix epoch.384	type Moment = u64;385	type OnTimestampSet = ();386	type MinimumPeriod = MinimumPeriod;387	type WeightInfo = ();388}389390parameter_types! {391	// pub const ExistentialDeposit: u128 = 500;392	pub const ExistentialDeposit: u128 = 0;393	pub const MaxLocks: u32 = 50;394}395396impl pallet_balances::Config for Runtime {397	type MaxLocks = MaxLocks;398	type MaxReserves = ();399	type ReserveIdentifier = [u8; 8];400	/// The type for recording an account's balance.401	type Balance = Balance;402	/// The ubiquitous event type.403	type Event = Event;404	type DustRemoval = Treasury;405	type ExistentialDeposit = ExistentialDeposit;406	type AccountStore = System;407	type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;408}409410pub const MICROUNIQUE: Balance = 1_000_000_000_000;411pub const MILLIUNIQUE: Balance = 1_000 * MICROUNIQUE;412pub const CENTIUNIQUE: Balance = 10 * MILLIUNIQUE;413pub const UNIQUE: Balance = 100 * CENTIUNIQUE;414415pub const fn deposit(items: u32, bytes: u32) -> Balance {416	items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE417}418419/*420parameter_types! {421	pub TombstoneDeposit: Balance = deposit(422		1,423		sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,424	);425	pub DepositPerContract: Balance = TombstoneDeposit::get();426	pub const DepositPerStorageByte: Balance = deposit(0, 1);427	pub const DepositPerStorageItem: Balance = deposit(1, 0);428	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);429	pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;430	pub const SignedClaimHandicap: u32 = 2;431	pub const MaxDepth: u32 = 32;432	pub const MaxValueSize: u32 = 16 * 1024;433	pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb434	// The lazy deletion runs inside on_initialize.435	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *436		RuntimeBlockWeights::get().max_block;437	// The weight needed for decoding the queue should be less or equal than a fifth438	// of the overall weight dedicated to the lazy deletion.439	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (440			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -441			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)442		)) / 5) as u32;443	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();444}445446impl pallet_contracts::Config for Runtime {447	type Time = Timestamp;448	type Randomness = RandomnessCollectiveFlip;449	type Currency = Balances;450	type Event = Event;451	type RentPayment = ();452	type SignedClaimHandicap = SignedClaimHandicap;453	type TombstoneDeposit = TombstoneDeposit;454	type DepositPerContract = DepositPerContract;455	type DepositPerStorageByte = DepositPerStorageByte;456	type DepositPerStorageItem = DepositPerStorageItem;457	type RentFraction = RentFraction;458	type SurchargeReward = SurchargeReward;459	type WeightPrice = pallet_transaction_payment::Pallet<Self>;460	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;461	type ChainExtension = NFTExtension;462	type DeletionQueueDepth = DeletionQueueDepth;463	type DeletionWeightLimit = DeletionWeightLimit;464	type Schedule = Schedule;465	type CallStack = [pallet_contracts::Frame<Self>; 31];466}467*/468469parameter_types! {470	pub const TransactionByteFee: Balance = 501 * MICROUNIQUE; // Targeting 0.1 Unique per NFT transfer471	/// This value increases the priority of `Operational` transactions by adding472	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.473	pub const OperationalFeeMultiplier: u8 = 5;474}475476/// Linear implementor of `WeightToFeePolynomial`477pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);478479impl<T> WeightToFeePolynomial for LinearFee<T>480where481	T: BaseArithmetic + From<u32> + Copy + Unsigned,482{483	type Balance = T;484485	fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {486		smallvec!(WeightToFeeCoefficient {487			// Targeting 0.1 Unique per NFT transfer488			coeff_integer: 142_688_000u32.into(),489			coeff_frac: Perbill::zero(),490			negative: false,491			degree: 1,492		})493	}494}495496impl pallet_transaction_payment::Config for Runtime {497	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;498	type TransactionByteFee = TransactionByteFee;499	type OperationalFeeMultiplier = OperationalFeeMultiplier;500	type WeightToFee = LinearFee<Balance>;501	type FeeMultiplierUpdate = ();502}503504parameter_types! {505	pub const ProposalBond: Permill = Permill::from_percent(5);506	pub const ProposalBondMinimum: Balance = 1 * UNIQUE;507	pub const SpendPeriod: BlockNumber = 5 * MINUTES;508	pub const Burn: Permill = Permill::from_percent(0);509	pub const TipCountdown: BlockNumber = 1 * DAYS;510	pub const TipFindersFee: Percent = Percent::from_percent(20);511	pub const TipReportDepositBase: Balance = 1 * UNIQUE;512	pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;513	pub const BountyDepositBase: Balance = 1 * UNIQUE;514	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;515	pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");516	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;517	pub const MaximumReasonLength: u32 = 16384;518	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);519	pub const BountyValueMinimum: Balance = 5 * UNIQUE;520	pub const MaxApprovals: u32 = 100;521}522523impl pallet_treasury::Config for Runtime {524	type PalletId = TreasuryModuleId;525	type Currency = Balances;526	type ApproveOrigin = EnsureRoot<AccountId>;527	type RejectOrigin = EnsureRoot<AccountId>;528	type Event = Event;529	type OnSlash = ();530	type ProposalBond = ProposalBond;531	type ProposalBondMinimum = ProposalBondMinimum;532	type SpendPeriod = SpendPeriod;533	type Burn = Burn;534	type BurnDestination = ();535	type SpendFunds = ();536	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;537	type MaxApprovals = MaxApprovals;538}539540impl pallet_sudo::Config for Runtime {541	type Event = Event;542	type Call = Call;543}544545pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);546547impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider548	for RelayChainBlockNumberProvider<T>549{550	type BlockNumber = BlockNumber;551552	fn current_block_number() -> Self::BlockNumber {553		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()554			.map(|d| d.relay_parent_number)555			.unwrap_or_default()556	}557}558559parameter_types! {560	pub const MinVestedTransfer: Balance = 10 * UNIQUE;561	pub const MaxVestingSchedules: u32 = 28;562}563564impl orml_vesting::Config for Runtime {565	type Event = Event;566	type Currency = pallet_balances::Pallet<Runtime>;567	type MinVestedTransfer = MinVestedTransfer;568	type VestedTransferOrigin = EnsureSigned<AccountId>;569	type WeightInfo = ();570	type MaxVestingSchedules = MaxVestingSchedules;571	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;572}573574parameter_types! {575	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;576	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;577}578579impl cumulus_pallet_parachain_system::Config for Runtime {580	type Event = Event;581	type OnValidationData = ();582	type SelfParaId = parachain_info::Pallet<Self>;583	// type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<584	// 	MaxDownwardMessageWeight,585	// 	XcmExecutor<XcmConfig>,586	// 	Call,587	// >;588	type OutboundXcmpMessageSource = XcmpQueue;589	type DmpMessageHandler = DmpQueue;590	type ReservedDmpWeight = ReservedDmpWeight;591	type ReservedXcmpWeight = ReservedXcmpWeight;592	type XcmpMessageHandler = XcmpQueue;593}594595impl parachain_info::Config for Runtime {}596597impl cumulus_pallet_aura_ext::Config for Runtime {}598599parameter_types! {600	pub const RelayLocation: MultiLocation = MultiLocation::parent();601	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;602	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();603	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();604}605606/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used607/// when determining ownership of accounts for asset transacting and when attempting to use XCM608/// `Transact` in order to determine the dispatch Origin.609pub type LocationToAccountId = (610	// The parent (Relay-chain) origin converts to the default `AccountId`.611	ParentIsDefault<AccountId>,612	// Sibling parachain origins convert to AccountId via the `ParaId::into`.613	SiblingParachainConvertsVia<Sibling, AccountId>,614	// Straight up local `AccountId32` origins just alias directly to `AccountId`.615	AccountId32Aliases<RelayNetwork, AccountId>,616);617618/// Means for transacting assets on this chain.619pub type LocalAssetTransactor = CurrencyAdapter<620	// Use this currency:621	Balances,622	// Use this currency when it is a fungible asset matching the given location or name:623	IsConcrete<RelayLocation>,624	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:625	LocationToAccountId,626	// Our chain's account ID type (we can't get away without mentioning it explicitly):627	AccountId,628	// We don't track any teleports.629	(),630>;631632/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,633/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can634/// biases the kind of local `Origin` it will become.635pub type XcmOriginToTransactDispatchOrigin = (636	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location637	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for638	// foreign chains who want to have a local sovereign account on this chain which they control.639	SovereignSignedViaLocation<LocationToAccountId, Origin>,640	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when641	// recognised.642	RelayChainAsNative<RelayOrigin, Origin>,643	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when644	// recognised.645	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,646	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a647	// transaction from the Root origin.648	ParentAsSuperuser<Origin>,649	// Native signed account converter; this just converts an `AccountId32` origin into a normal650	// `Origin::Signed` origin of the same 32-byte value.651	SignedAccountId32AsNative<RelayNetwork, Origin>,652	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.653	XcmPassthrough<Origin>,654);655656parameter_types! {657	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.658	pub UnitWeightCost: Weight = 1_000_000;659	// 1200 UNIQUEs buy 1 second of weight.660	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);661	pub const MaxInstructions: u32 = 100;662	pub const MaxAuthorities: u32 = 100_000;663}664665match_type! {666	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {667		MultiLocation { parents: 1, interior: Here } |668		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }669	};670}671672pub type Barrier = (673	TakeWeightCredit,674	AllowTopLevelPaidExecutionFrom<Everything>,675	AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,676	// ^^^ Parent & its unit plurality gets free execution677);678679pub struct XcmConfig;680impl Config for XcmConfig {681	type Call = Call;682	type XcmSender = XcmRouter;683	// How to withdraw and deposit an asset.684	type AssetTransactor = LocalAssetTransactor;685	type OriginConverter = XcmOriginToTransactDispatchOrigin;686	type IsReserve = NativeAsset;687	type IsTeleporter = (); // Teleportation is disabled688	type LocationInverter = LocationInverter<Ancestry>;689	type Barrier = Barrier;690	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;691	type Trader = UsingComponents<IdentityFee<Balance>, RelayLocation, AccountId, Balances, ()>;692	type ResponseHandler = (); // Don't handle responses for now.693	type SubscriptionService = PolkadotXcm;694695	type AssetTrap = PolkadotXcm;696	type AssetClaims = PolkadotXcm;697}698699// parameter_types! {700// 	pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;701// }702703/// No local origins on this chain are allowed to dispatch XCM sends/executions.704pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);705706/// The means for routing XCM messages which are not for local execution into the right message707/// queues.708pub type XcmRouter = (709	// Two routers - use UMP to communicate with the relay chain:710	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,711	// ..and XCMP to communicate with the sibling chains.712	XcmpQueue,713);714715impl pallet_evm_coder_substrate::Config for Runtime {716	type EthereumTransactionSender = pallet_ethereum::Pallet<Self>;717	type GasWeightMapping = FixedGasWeightMapping;718}719720impl pallet_xcm::Config for Runtime {721	type Event = Event;722	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;723	type XcmRouter = XcmRouter;724	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;725	type XcmExecuteFilter = Everything;726	type XcmExecutor = XcmExecutor<XcmConfig>;727	type XcmTeleportFilter = Everything;728	type XcmReserveTransferFilter = Everything;729	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;730	type LocationInverter = LocationInverter<Ancestry>;731	type Origin = Origin;732	type Call = Call;733	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;734	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;735}736737impl cumulus_pallet_xcm::Config for Runtime {738	type Event = Event;739	type XcmExecutor = XcmExecutor<XcmConfig>;740}741742impl cumulus_pallet_xcmp_queue::Config for Runtime {743	type Event = Event;744	type XcmExecutor = XcmExecutor<XcmConfig>;745	type ChannelInfo = ParachainSystem;746	type VersionWrapper = ();747}748749impl cumulus_pallet_dmp_queue::Config for Runtime {750	type Event = Event;751	type XcmExecutor = XcmExecutor<XcmConfig>;752	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;753}754755impl pallet_aura::Config for Runtime {756	type AuthorityId = AuraId;757	type DisabledValidators = ();758	type MaxAuthorities = MaxAuthorities;759}760761parameter_types! {762	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();763	pub const CollectionCreationPrice: Balance = 100 * UNIQUE;764}765766impl pallet_common::Config for Runtime {767	type Event = Event;768	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;769	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;770	type CrossAccountId = pallet_common::account::BasicCrossAccountId<Self>;771772	type Currency = Balances;773	type CollectionCreationPrice = CollectionCreationPrice;774	type TreasuryAccountId = TreasuryAccountId;775}776777impl pallet_fungible::Config for Runtime {778	type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;779}780impl pallet_refungible::Config for Runtime {781	type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;782}783impl pallet_nonfungible::Config for Runtime {784	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;785}786787impl pallet_unique::Config for Runtime {788	type Event = Event;789	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;790}791792parameter_types! {793	pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied794}795796/// Used for the pallet inflation797impl pallet_inflation::Config for Runtime {798	type Currency = Balances;799	type TreasuryAccountId = TreasuryAccountId;800	type InflationBlockInterval = InflationBlockInterval;801	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;802}803804parameter_types! {805	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *806		RuntimeBlockWeights::get().max_block;807	pub const MaxScheduledPerBlock: u32 = 50;808}809810type EvmSponsorshipHandler = (811	pallet_unique::UniqueEthSponsorshipHandler<Runtime>,812	pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,813);814type SponsorshipHandler = (815	pallet_unique::UniqueSponsorshipHandler<Runtime>,816	//pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,817	pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,818);819820impl pallet_unq_scheduler::Config for Runtime {821	type Event = Event;822	type Origin = Origin;823	type PalletsOrigin = OriginCaller;824	type Call = Call;825	type MaximumWeight = MaximumSchedulerWeight;826	type ScheduleOrigin = EnsureSigned<AccountId>;827	type MaxScheduledPerBlock = MaxScheduledPerBlock;828	type WeightInfo = ();829	type Executor = Executor;830}831832pub struct Executor;833impl<C, SelfContainedSignedInfo> ApplyExtrinsic<C, SelfContainedSignedInfo> for Executor834where835	C: Member836		+ Dispatchable<Origin = Origin, Info = DispatchInfo>837		+ SelfContainedCall<SignedInfo = SelfContainedSignedInfo>838		+ GetDispatchInfo839		+ From<frame_system::Call<Runtime>>,840	SelfContainedSignedInfo: Send + Sync + 'static,841	Call: From<C> + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,842{843	fn apply_call(signer: Address, call: C) {844		let dispatch_info = call.get_dispatch_info();845		let extrinsic = fp_self_contained::CheckedExtrinsic::<846			AccountId,847			Call,848			SignedExtra,849			SelfContainedSignedInfo,850		> {851			signed: CheckedSignature::<AccountId, SignedExtra, SelfContainedSignedInfo>::Unsigned, // change to signer852			function: call.into(),853		};854855		extrinsic.apply::<Runtime>(&dispatch_info, 0);856	}857}858859impl pallet_evm_transaction_payment::Config for Runtime {860	type EvmSponsorshipHandler = EvmSponsorshipHandler;861	type Currency = Balances;862	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;863	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;864}865866impl pallet_charge_transaction::Config for Runtime {867	type SponsorshipHandler = SponsorshipHandler;868}869870// impl pallet_contract_helpers::Config for Runtime {871//	 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;872// }873874parameter_types! {875	// 0x842899ECF380553E8a4de75bF534cdf6fBF64049876	pub const HelpersContractAddress: H160 = H160([877		0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,878	]);879}880881impl pallet_evm_contract_helpers::Config for Runtime {882	type ContractAddress = HelpersContractAddress;883	type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;884}885886construct_runtime!(887	pub enum Runtime where888		Block = Block,889		NodeBlock = opaque::Block,890		UncheckedExtrinsic = UncheckedExtrinsic891	{892		ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,893		ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,894895		Aura: pallet_aura::{Pallet, Config<T>} = 22,896		AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,897898		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,899		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,900		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,901		TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,902		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,903		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,904		System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,905		Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,906		// Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,907		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,908909		// XCM helpers.910		XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,911		PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,912		CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,913		DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,914915		// Unique Pallets916		Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,917		Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,918		Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event<T>} = 62,919		// free = 63920		Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,921		// ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,922		Common: pallet_common::{Pallet, Storage, Event<T>} = 66,923		Fungible: pallet_fungible::{Pallet, Storage} = 67,924		Refungible: pallet_refungible::{Pallet, Storage} = 68,925		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,926927		// Frontier928		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,929		Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,930931		EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,932		EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,933		EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,934		EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,935	}936);937938pub struct TransactionConverter;939940impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {941	fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {942		UncheckedExtrinsic::new_unsigned(943			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),944		)945	}946}947948impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {949	fn convert_transaction(950		&self,951		transaction: pallet_ethereum::Transaction,952	) -> opaque::UncheckedExtrinsic {953		let extrinsic = UncheckedExtrinsic::new_unsigned(954			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),955		);956		let encoded = extrinsic.encode();957		opaque::UncheckedExtrinsic::decode(&mut &encoded[..])958			.expect("Encoded extrinsic is always valid")959	}960}961962/// The address format for describing accounts.963pub type Address = sp_runtime::MultiAddress<AccountId, ()>;964/// Block header type as expected by this runtime.965pub type Header = generic::Header<BlockNumber, BlakeTwo256>;966/// Block type as expected by this runtime.967pub type Block = generic::Block<Header, UncheckedExtrinsic>;968/// A Block signed with a Justification969pub type SignedBlock = generic::SignedBlock<Block>;970/// BlockId type as expected by this runtime.971pub type BlockId = generic::BlockId<Block>;972/// The SignedExtension to the basic transaction logic.973pub type SignedExtra = (974	frame_system::CheckSpecVersion<Runtime>,975	// system::CheckTxVersion<Runtime>,976	frame_system::CheckGenesis<Runtime>,977	frame_system::CheckEra<Runtime>,978	frame_system::CheckNonce<Runtime>,979	frame_system::CheckWeight<Runtime>,980	pallet_charge_transaction::ChargeTransactionPayment<Runtime>,981	//pallet_contract_helpers::ContractHelpersExtension<Runtime>,982);983/// Unchecked extrinsic type as expected by this runtime.984pub type UncheckedExtrinsic =985	fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;986/// Extrinsic type that has already been checked.987pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;988/// Executive: handles dispatch to the various modules.989pub type Executive = frame_executive::Executive<990	Runtime,991	Block,992	frame_system::ChainContext<Runtime>,993	Runtime,994	AllPallets,995>;996997impl_opaque_keys! {998	pub struct SessionKeys {999		pub aura: Aura,1000	}1001}10021003impl fp_self_contained::SelfContainedCall for Call {1004	type SignedInfo = H160;10051006	fn is_self_contained(&self) -> bool {1007		match self {1008			Call::Ethereum(call) => call.is_self_contained(),1009			_ => false,1010		}1011	}10121013	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1014		match self {1015			Call::Ethereum(call) => call.check_self_contained(),1016			_ => None,1017		}1018	}10191020	fn validate_self_contained(&self, info: &Self::SignedInfo) -> Option<TransactionValidity> {1021		match self {1022			Call::Ethereum(call) => call.validate_self_contained(info),1023			_ => None,1024		}1025	}10261027	fn pre_dispatch_self_contained(1028		&self,1029		info: &Self::SignedInfo,1030	) -> Option<Result<(), TransactionValidityError>> {1031		match self {1032			Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1033			_ => None,1034		}1035	}10361037	fn apply_self_contained(1038		self,1039		info: Self::SignedInfo,1040	) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1041		match self {1042			call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1043				Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1044			)),1045			_ => None,1046		}1047	}1048}10491050macro_rules! dispatch_unique_runtime {1051	($collection:ident.$method:ident($($name:ident),*)) => {{1052		use pallet_unique::dispatch::Dispatched;10531054		let collection = Dispatched::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1055		let dispatch = collection.as_dyn();10561057		Ok(dispatch.$method($($name),*))1058	}};1059}1060impl_runtime_apis! {1061	impl up_rpc::UniqueApi<Block, CrossAccountId, AccountId>1062		for Runtime1063	{1064		fn account_tokens(collection: CollectionId, account: CrossAccountId) -> Result<Vec<TokenId>, DispatchError> {1065			dispatch_unique_runtime!(collection.account_tokens(account))1066		}1067		fn token_exists(collection: CollectionId, token: TokenId) -> Result<bool, DispatchError> {1068			dispatch_unique_runtime!(collection.token_exists(token))1069		}10701071		fn token_owner(collection: CollectionId, token: TokenId) -> Result<CrossAccountId, DispatchError> {1072			dispatch_unique_runtime!(collection.token_owner(token))1073		}1074		fn const_metadata(collection: CollectionId, token: TokenId) -> Result<Vec<u8>, DispatchError> {1075			dispatch_unique_runtime!(collection.const_metadata(token))1076		}1077		fn variable_metadata(collection: CollectionId, token: TokenId) -> Result<Vec<u8>, DispatchError> {1078			dispatch_unique_runtime!(collection.variable_metadata(token))1079		}10801081		fn collection_tokens(collection: CollectionId) -> Result<u32, DispatchError> {1082			dispatch_unique_runtime!(collection.collection_tokens())1083		}1084		fn account_balance(collection: CollectionId, account: CrossAccountId) -> Result<u32, DispatchError> {1085			dispatch_unique_runtime!(collection.account_balance(account))1086		}1087		fn balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<u128, DispatchError> {1088			dispatch_unique_runtime!(collection.balance(account, token))1089		}1090		fn allowance(1091			collection: CollectionId,1092			sender: CrossAccountId,1093			spender: CrossAccountId,1094			token: TokenId,1095		) -> Result<u128, DispatchError> {1096			dispatch_unique_runtime!(collection.allowance(sender, spender, token))1097		}10981099		fn eth_contract_code(account: H160) -> Option<Vec<u8>> {1100			<pallet_unique::UniqueErcSupport<Runtime>>::get_code(&account)1101				.or_else(|| <pallet_evm_migration::OnMethodCall<Runtime>>::get_code(&account))1102				.or_else(|| <pallet_evm_contract_helpers::HelpersOnMethodCall<Self>>::get_code(&account))1103		}1104		fn adminlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {1105			Ok(<pallet_common::Pallet<Runtime>>::adminlist(collection))1106		}1107		fn allowlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {1108			Ok(<pallet_common::Pallet<Runtime>>::allowlist(collection))1109		}1110		fn allowed(collection: CollectionId, user: CrossAccountId) -> Result<bool, DispatchError> {1111			Ok(<pallet_common::Pallet<Runtime>>::allowed(collection, user))1112		}1113		fn last_token_id(collection: CollectionId) -> Result<TokenId, DispatchError> {1114			dispatch_unique_runtime!(collection.last_token_id())1115		}1116		fn collection_by_id(collection: CollectionId) -> Result<Option<Collection<AccountId>>, DispatchError> {1117			Ok(<pallet_common::CollectionById<Runtime>>::get(collection))1118		}1119		fn collection_stats() -> Result<CollectionStats, DispatchError> {1120			Ok(<pallet_common::Pallet<Runtime>>::collection_stats())1121		}1122	}11231124	impl sp_api::Core<Block> for Runtime {1125		fn version() -> RuntimeVersion {1126			VERSION1127		}11281129		fn execute_block(block: Block) {1130			Executive::execute_block(block)1131		}11321133		fn initialize_block(header: &<Block as BlockT>::Header) {1134			Executive::initialize_block(header)1135		}1136	}11371138	impl sp_api::Metadata<Block> for Runtime {1139		fn metadata() -> OpaqueMetadata {1140			OpaqueMetadata::new(Runtime::metadata().into())1141		}1142	}11431144	impl sp_block_builder::BlockBuilder<Block> for Runtime {1145		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {1146			Executive::apply_extrinsic(extrinsic)1147		}11481149		fn finalize_block() -> <Block as BlockT>::Header {1150			Executive::finalize_block()1151		}11521153		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {1154			data.create_extrinsics()1155		}11561157		fn check_inherents(1158			block: Block,1159			data: sp_inherents::InherentData,1160		) -> sp_inherents::CheckInherentsResult {1161			data.check_extrinsics(&block)1162		}11631164		// fn random_seed() -> <Block as BlockT>::Hash {1165		//     RandomnessCollectiveFlip::random_seed().01166		// }1167	}11681169	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {1170		fn validate_transaction(1171			source: TransactionSource,1172			tx: <Block as BlockT>::Extrinsic,1173			hash: <Block as BlockT>::Hash,1174		) -> TransactionValidity {1175			Executive::validate_transaction(source, tx, hash)1176		}1177	}11781179	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {1180		fn offchain_worker(header: &<Block as BlockT>::Header) {1181			Executive::offchain_worker(header)1182		}1183	}11841185	impl fp_rpc::EthereumRuntimeRPCApi<Block> for Runtime {1186		fn chain_id() -> u64 {1187			<Runtime as pallet_evm::Config>::ChainId::get()1188		}11891190		fn account_basic(address: H160) -> EVMAccount {1191			EVM::account_basic(&address)1192		}11931194		fn gas_price() -> U256 {1195			<Runtime as pallet_evm::Config>::FeeCalculator::min_gas_price()1196		}11971198		fn account_code_at(address: H160) -> Vec<u8> {1199			EVM::account_codes(address)1200		}12011202		fn author() -> H160 {1203			<pallet_evm::Pallet<Runtime>>::find_author()1204		}12051206		fn storage_at(address: H160, index: U256) -> H256 {1207			let mut tmp = [0u8; 32];1208			index.to_big_endian(&mut tmp);1209			EVM::account_storages(address, H256::from_slice(&tmp[..]))1210		}12111212		#[allow(clippy::redundant_closure)]1213		fn call(1214			from: H160,1215			to: H160,1216			data: Vec<u8>,1217			value: U256,1218			gas_limit: U256,1219			gas_price: Option<U256>,1220			nonce: Option<U256>,1221			estimate: bool,1222		) -> Result<pallet_evm::CallInfo, sp_runtime::DispatchError> {1223			let config = if estimate {1224				let mut config = <Runtime as pallet_evm::Config>::config().clone();1225				config.estimate = true;1226				Some(config)1227			} else {1228				None1229			};12301231			<Runtime as pallet_evm::Config>::Runner::call(1232				from,1233				to,1234				data,1235				value,1236				gas_limit.low_u64(),1237				gas_price,1238				nonce,1239				config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),1240			).map_err(|err| err.into())1241		}12421243		#[allow(clippy::redundant_closure)]1244		fn create(1245			from: H160,1246			data: Vec<u8>,1247			value: U256,1248			gas_limit: U256,1249			gas_price: Option<U256>,1250			nonce: Option<U256>,1251			estimate: bool,1252		) -> Result<pallet_evm::CreateInfo, sp_runtime::DispatchError> {1253			let config = if estimate {1254				let mut config = <Runtime as pallet_evm::Config>::config().clone();1255				config.estimate = true;1256				Some(config)1257			} else {1258				None1259			};12601261			<Runtime as pallet_evm::Config>::Runner::create(1262				from,1263				data,1264				value,1265				gas_limit.low_u64(),1266				gas_price,1267				nonce,1268				config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),1269			).map_err(|err| err.into())1270		}12711272		fn current_transaction_statuses() -> Option<Vec<TransactionStatus>> {1273			Ethereum::current_transaction_statuses()1274		}12751276		fn current_block() -> Option<pallet_ethereum::Block> {1277			Ethereum::current_block()1278		}12791280		fn current_receipts() -> Option<Vec<pallet_ethereum::Receipt>> {1281			Ethereum::current_receipts()1282		}12831284		fn current_all() -> (1285			Option<pallet_ethereum::Block>,1286			Option<Vec<pallet_ethereum::Receipt>>,1287			Option<Vec<TransactionStatus>>1288		) {1289			(1290				Ethereum::current_block(),1291				Ethereum::current_receipts(),1292				Ethereum::current_transaction_statuses()1293			)1294		}12951296		fn extrinsic_filter(xts: Vec<<Block as sp_api::BlockT>::Extrinsic>) -> Vec<pallet_ethereum::Transaction> {1297			xts.into_iter().filter_map(|xt| match xt.0.function {1298				Call::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction),1299				_ => None1300			}).collect()1301		}1302	}13031304	impl sp_session::SessionKeys<Block> for Runtime {1305		fn decode_session_keys(1306			encoded: Vec<u8>,1307		) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {1308			SessionKeys::decode_into_raw_public_keys(&encoded)1309		}13101311		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {1312			SessionKeys::generate(seed)1313		}1314	}13151316	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {1317		fn slot_duration() -> sp_consensus_aura::SlotDuration {1318			sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())1319		}13201321		fn authorities() -> Vec<AuraId> {1322			Aura::authorities().to_vec()1323		}1324	}13251326	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {1327		fn collect_collation_info() -> cumulus_primitives_core::CollationInfo {1328			ParachainSystem::collect_collation_info()1329		}1330	}13311332	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {1333		fn account_nonce(account: AccountId) -> Index {1334			System::account_nonce(account)1335		}1336	}13371338	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {1339		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {1340			TransactionPayment::query_info(uxt, len)1341		}1342		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {1343			TransactionPayment::query_fee_details(uxt, len)1344		}1345	}13461347	/*1348	impl pallet_contracts_rpc_runtime_api::ContractsApi<Block, AccountId, Balance, BlockNumber, Hash>1349		for Runtime1350	{1351		fn call(1352			origin: AccountId,1353			dest: AccountId,1354			value: Balance,1355			gas_limit: u64,1356			input_data: Vec<u8>,1357		) -> pallet_contracts_primitives::ContractExecResult {1358			Contracts::bare_call(origin, dest, value, gas_limit, input_data, false)1359		}13601361		fn instantiate(1362			origin: AccountId,1363			endowment: Balance,1364			gas_limit: u64,1365			code: pallet_contracts_primitives::Code<Hash>,1366			data: Vec<u8>,1367			salt: Vec<u8>,1368		) -> pallet_contracts_primitives::ContractInstantiateResult<AccountId, BlockNumber>1369		{1370			Contracts::bare_instantiate(origin, endowment, gas_limit, code, data, salt, true, false)1371		}13721373		fn get_storage(1374			address: AccountId,1375			key: [u8; 32],1376		) -> pallet_contracts_primitives::GetStorageResult {1377			Contracts::get_storage(address, key)1378		}13791380		fn rent_projection(1381			address: AccountId,1382		) -> pallet_contracts_primitives::RentProjectionResult<BlockNumber> {1383			Contracts::rent_projection(address)1384		}1385	}1386	*/13871388	#[cfg(feature = "runtime-benchmarks")]1389	impl frame_benchmarking::Benchmark<Block> for Runtime {1390		fn benchmark_metadata(extra: bool) -> (1391			Vec<frame_benchmarking::BenchmarkList>,1392			Vec<frame_support::traits::StorageInfo>,1393		) {1394			use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList};1395			use frame_support::traits::StorageInfoTrait;13961397			let mut list = Vec::<BenchmarkList>::new();13981399			list_benchmark!(list, extra, pallet_evm_migration, EvmMigration);1400			list_benchmark!(list, extra, pallet_unique, Unique);1401			list_benchmark!(list, extra, pallet_inflation, Inflation);1402			list_benchmark!(list, extra, pallet_fungible, Fungible);1403			list_benchmark!(list, extra, pallet_refungible, Refungible);1404			list_benchmark!(list, extra, pallet_nonfungible, Nonfungible);1405			// list_benchmark!(list, extra, pallet_evm_coder_substrate, EvmCoderSubstrate);14061407			let storage_info = AllPalletsWithSystem::storage_info();14081409			return (list, storage_info)1410		}14111412		fn dispatch_benchmark(1413			config: frame_benchmarking::BenchmarkConfig1414		) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {1415			use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey};14161417			let allowlist: Vec<TrackedStorageKey> = vec![1418				// Block Number1419				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),1420				// Total Issuance1421				hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),1422				// Execution Phase1423				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),1424				// Event Count1425				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),1426				// System Events1427				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),1428			];14291430			let mut batches = Vec::<BenchmarkBatch>::new();1431			let params = (&config, &allowlist);14321433			add_benchmark!(params, batches, pallet_evm_migration, EvmMigration);1434			add_benchmark!(params, batches, pallet_unique, Unique);1435			add_benchmark!(params, batches, pallet_inflation, Inflation);1436			add_benchmark!(params, batches, pallet_fungible, Fungible);1437			add_benchmark!(params, batches, pallet_refungible, Refungible);1438			add_benchmark!(params, batches, pallet_nonfungible, Nonfungible);1439			// add_benchmark!(params, batches, pallet_evm_coder_substrate, EvmCoderSubstrate);14401441			if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }1442			Ok(batches)1443		}1444	}1445}14461447struct CheckInherents;14481449impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1450	fn check_inherents(1451		block: &Block,1452		relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1453	) -> sp_inherents::CheckInherentsResult {1454		let relay_chain_slot = relay_state_proof1455			.read_slot()1456			.expect("Could not read the relay chain slot from the proof");14571458		let inherent_data =1459			cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1460				relay_chain_slot,1461				sp_std::time::Duration::from_secs(6),1462			)1463			.create_inherent_data()1464			.expect("Could not create the timestamp inherent data");14651466		inherent_data.check_extrinsics(block)1467	}1468}14691470cumulus_pallet_parachain_system::register_validate_block!(1471	Runtime = Runtime,1472	BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1473	CheckInherents = CheckInherents,1474);