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

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 xcm::latest::{93//	Xcm, 	94	AssetId::{Concrete},95	Fungibility::Fungible as XcmFungible,96	MultiAsset97};98use xcm_executor::traits::MatchesFungible;99use sp_runtime::traits::CheckedConversion;100101// mod chain_extension;102// use crate::chain_extension::{NFTExtension, Imbalance};103104/// An index to a block.105pub type BlockNumber = u32;106107/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.108pub type Signature = MultiSignature;109110/// Some way of identifying an account on the chain. We intentionally make it equivalent111/// to the public key of our transaction signing scheme.112pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;113114pub type CrossAccountId = pallet_common::account::BasicCrossAccountId<Runtime>;115116/// The type for looking up accounts. We don't expect more than 4 billion of them, but you117/// never know...118pub type AccountIndex = u32;119120/// Balance of an account.121pub type Balance = u128;122123/// Index of a transaction in the chain.124pub type Index = u32;125126/// A hash of some data used by the chain.127pub type Hash = sp_core::H256;128129/// Digest item type.130pub type DigestItem = generic::DigestItem;131132/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know133/// the specifics of the runtime. They can then be made to be agnostic over specific formats134/// of data like extrinsics, allowing for them to continue syncing the network through upgrades135/// to even the core data structures.136pub mod opaque {137	use super::*;138139	pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;140141	/// Opaque block type.142	pub type Block = generic::Block<Header, UncheckedExtrinsic>;143144	pub type SessionHandlers = ();145146	impl_opaque_keys! {147		pub struct SessionKeys {148			pub aura: Aura,149		}150	}151}152153/// This runtime version.154pub const VERSION: RuntimeVersion = RuntimeVersion {155	spec_name: create_runtime_str!("opal"),156	impl_name: create_runtime_str!("opal"),157	authoring_version: 1,158	spec_version: 914000,159	impl_version: 1,160	apis: RUNTIME_API_VERSIONS,161	transaction_version: 0,162	state_version: 0,163};164165pub const MILLISECS_PER_BLOCK: u64 = 12000;166167pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;168169// These time units are defined in number of blocks.170pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);171pub const HOURS: BlockNumber = MINUTES * 60;172pub const DAYS: BlockNumber = HOURS * 24;173174parameter_types! {175	pub const DefaultSponsoringRateLimit: BlockNumber = 1 * DAYS;176}177178#[derive(codec::Encode, codec::Decode)]179pub enum XCMPMessage<XAccountId, XBalance> {180	/// Transfer tokens to the given account from the Parachain account.181	TransferToken(XAccountId, XBalance),182}183184/// The version information used to identify this runtime when compiled natively.185#[cfg(feature = "std")]186pub fn native_version() -> NativeVersion {187	NativeVersion {188		runtime_version: VERSION,189		can_author_with: Default::default(),190	}191}192193type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;194195pub struct DealWithFees;196impl OnUnbalanced<NegativeImbalance> for DealWithFees {197	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {198		if let Some(fees) = fees_then_tips.next() {199			// for fees, 100% to treasury200			let mut split = fees.ration(100, 0);201			if let Some(tips) = fees_then_tips.next() {202				// for tips, if any, 100% to treasury203				tips.ration_merge_into(100, 0, &mut split);204			}205			Treasury::on_unbalanced(split.0);206			// Author::on_unbalanced(split.1);207		}208	}209}210211/// We assume that ~10% of the block weight is consumed by `on_initalize` handlers.212/// This is used to limit the maximal weight of a single extrinsic.213const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);214/// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used215/// by  Operational  extrinsics.216const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);217/// We allow for 2 seconds of compute with a 6 second average block time.218const MAXIMUM_BLOCK_WEIGHT: Weight = WEIGHT_PER_SECOND / 2;219220parameter_types! {221	pub const BlockHashCount: BlockNumber = 2400;222	pub RuntimeBlockLength: BlockLength =223		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);224	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);225	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;226	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()227		.base_block(BlockExecutionWeight::get())228		.for_class(DispatchClass::all(), |weights| {229			weights.base_extrinsic = ExtrinsicBaseWeight::get();230		})231		.for_class(DispatchClass::Normal, |weights| {232			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);233		})234		.for_class(DispatchClass::Operational, |weights| {235			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);236			// Operational transactions have some extra reserved space, so that they237			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.238			weights.reserved = Some(239				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT240			);241		})242		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)243		.build_or_panic();244	pub const Version: RuntimeVersion = VERSION;245	pub const SS58Prefix: u8 = 42;246}247248parameter_types! {249	pub const ChainId: u64 = 8888;250}251252pub struct FixedFee;253impl FeeCalculator for FixedFee {254	fn min_gas_price() -> U256 {255		// Targeting 0.15 UNQ per transfer256		1_024_947_215_000u64.into()257	}258}259260// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case261// (contract, which only writes a lot of data),262// approximating on top of our real store write weight263parameter_types! {264	pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;265	pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;266	pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();267}268269/// Limiting EVM execution to 50% of block for substrate users and management tasks270/// EVM transaction consumes more weight than substrate's, so we can't rely on them being271/// scheduled fairly272const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);273parameter_types! {274	pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());275}276277pub enum FixedGasWeightMapping {}278impl GasWeightMapping for FixedGasWeightMapping {279	fn gas_to_weight(gas: u64) -> Weight {280		gas.saturating_mul(WeightPerGas::get())281	}282	fn weight_to_gas(weight: Weight) -> u64 {283		weight / WeightPerGas::get()284	}285}286287impl pallet_evm::Config for Runtime {288	type BlockGasLimit = BlockGasLimit;289	type FeeCalculator = FixedFee;290	type GasWeightMapping = FixedGasWeightMapping;291	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;292	type CallOrigin = EnsureAddressTruncated;293	type WithdrawOrigin = EnsureAddressTruncated;294	type AddressMapping = HashedAddressMapping<Self::Hashing>;295	type PrecompilesType = ();296	type PrecompilesValue = ();297	type Currency = Balances;298	type Event = Event;299	type OnMethodCall = (300		pallet_evm_migration::OnMethodCall<Self>,301		pallet_unique::UniqueErcSupport<Self>,302		pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,303	);304	type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;305	type ChainId = ChainId;306	type Runner = pallet_evm::runner::stack::Runner<Self>;307	type OnChargeTransaction = pallet_evm_transaction_payment::OnChargeTransaction<Self>;308	type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;309	type FindAuthor = EthereumFindAuthor<Aura>;310}311312impl pallet_evm_migration::Config for Runtime {313	type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;314}315316pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);317impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {318	fn find_author<'a, I>(digests: I) -> Option<H160>319	where320		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,321	{322		if let Some(author_index) = F::find_author(digests) {323			let authority_id = Aura::authorities()[author_index as usize].clone();324			return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));325		}326		None327	}328}329330impl pallet_ethereum::Config for Runtime {331	type Event = Event;332	type StateRoot = pallet_ethereum::IntermediateStateRoot;333}334335impl pallet_randomness_collective_flip::Config for Runtime {}336337impl frame_system::Config for Runtime {338	/// The data to be stored in an account.339	type AccountData = pallet_balances::AccountData<Balance>;340	/// The identifier used to distinguish between accounts.341	type AccountId = AccountId;342	/// The basic call filter to use in dispatchable.343	type BaseCallFilter = Everything;344	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).345	type BlockHashCount = BlockHashCount;346	/// The maximum length of a block (in bytes).347	type BlockLength = RuntimeBlockLength;348	/// The index type for blocks.349	type BlockNumber = BlockNumber;350	/// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.351	type BlockWeights = RuntimeBlockWeights;352	/// The aggregated dispatch type that is available for extrinsics.353	type Call = Call;354	/// The weight of database operations that the runtime can invoke.355	type DbWeight = RocksDbWeight;356	/// The ubiquitous event type.357	type Event = Event;358	/// The type for hashing blocks and tries.359	type Hash = Hash;360	/// The hashing algorithm used.361	type Hashing = BlakeTwo256;362	/// The header type.363	type Header = generic::Header<BlockNumber, BlakeTwo256>;364	/// The index type for storing how many extrinsics an account has signed.365	type Index = Index;366	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.367	type Lookup = AccountIdLookup<AccountId, ()>;368	/// What to do if an account is fully reaped from the system.369	type OnKilledAccount = ();370	/// What to do if a new account is created.371	type OnNewAccount = ();372	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;373	/// The ubiquitous origin type.374	type Origin = Origin;375	/// This type is being generated by `construct_runtime!`.376	type PalletInfo = PalletInfo;377	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.378	type SS58Prefix = SS58Prefix;379	/// Weight information for the extrinsics of this pallet.380	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;381	/// Version of the runtime.382	type Version = Version;383	type MaxConsumers = ConstU32<16>;384}385386parameter_types! {387	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;388}389390impl pallet_timestamp::Config for Runtime {391	/// A timestamp: milliseconds since the unix epoch.392	type Moment = u64;393	type OnTimestampSet = ();394	type MinimumPeriod = MinimumPeriod;395	type WeightInfo = ();396}397398parameter_types! {399	// pub const ExistentialDeposit: u128 = 500;400	pub const ExistentialDeposit: u128 = 0;401	pub const MaxLocks: u32 = 50;402}403404impl pallet_balances::Config for Runtime {405	type MaxLocks = MaxLocks;406	type MaxReserves = ();407	type ReserveIdentifier = [u8; 8];408	/// The type for recording an account's balance.409	type Balance = Balance;410	/// The ubiquitous event type.411	type Event = Event;412	type DustRemoval = Treasury;413	type ExistentialDeposit = ExistentialDeposit;414	type AccountStore = System;415	type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;416}417418pub const MICROUNIQUE: Balance = 1_000_000_000_000;419pub const MILLIUNIQUE: Balance = 1_000 * MICROUNIQUE;420pub const CENTIUNIQUE: Balance = 10 * MILLIUNIQUE;421pub const UNIQUE: Balance = 100 * CENTIUNIQUE;422423pub const fn deposit(items: u32, bytes: u32) -> Balance {424	items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE425}426427/*428parameter_types! {429	pub TombstoneDeposit: Balance = deposit(430		1,431		sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,432	);433	pub DepositPerContract: Balance = TombstoneDeposit::get();434	pub const DepositPerStorageByte: Balance = deposit(0, 1);435	pub const DepositPerStorageItem: Balance = deposit(1, 0);436	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);437	pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;438	pub const SignedClaimHandicap: u32 = 2;439	pub const MaxDepth: u32 = 32;440	pub const MaxValueSize: u32 = 16 * 1024;441	pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb442	// The lazy deletion runs inside on_initialize.443	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *444		RuntimeBlockWeights::get().max_block;445	// The weight needed for decoding the queue should be less or equal than a fifth446	// of the overall weight dedicated to the lazy deletion.447	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (448			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -449			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)450		)) / 5) as u32;451	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();452}453454impl pallet_contracts::Config for Runtime {455	type Time = Timestamp;456	type Randomness = RandomnessCollectiveFlip;457	type Currency = Balances;458	type Event = Event;459	type RentPayment = ();460	type SignedClaimHandicap = SignedClaimHandicap;461	type TombstoneDeposit = TombstoneDeposit;462	type DepositPerContract = DepositPerContract;463	type DepositPerStorageByte = DepositPerStorageByte;464	type DepositPerStorageItem = DepositPerStorageItem;465	type RentFraction = RentFraction;466	type SurchargeReward = SurchargeReward;467	type WeightPrice = pallet_transaction_payment::Pallet<Self>;468	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;469	type ChainExtension = NFTExtension;470	type DeletionQueueDepth = DeletionQueueDepth;471	type DeletionWeightLimit = DeletionWeightLimit;472	type Schedule = Schedule;473	type CallStack = [pallet_contracts::Frame<Self>; 31];474}475*/476477parameter_types! {478	pub const TransactionByteFee: Balance = 501 * MICROUNIQUE; // Targeting 0.1 Unique per NFT transfer479	/// This value increases the priority of `Operational` transactions by adding480	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.481	pub const OperationalFeeMultiplier: u8 = 5;482}483484/// Linear implementor of `WeightToFeePolynomial`485pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);486487impl<T> WeightToFeePolynomial for LinearFee<T>488where489	T: BaseArithmetic + From<u32> + Copy + Unsigned,490{491	type Balance = T;492493	fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {494		smallvec!(WeightToFeeCoefficient {495			// Targeting 0.1 Unique per NFT transfer496			coeff_integer: 142_688_000u32.into(),497			coeff_frac: Perbill::zero(),498			negative: false,499			degree: 1,500		})501	}502}503504impl pallet_transaction_payment::Config for Runtime {505	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;506	type TransactionByteFee = TransactionByteFee;507	type OperationalFeeMultiplier = OperationalFeeMultiplier;508	type WeightToFee = LinearFee<Balance>;509	type FeeMultiplierUpdate = ();510}511512parameter_types! {513	pub const ProposalBond: Permill = Permill::from_percent(5);514	pub const ProposalBondMinimum: Balance = 1 * UNIQUE;515	pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;516	pub const SpendPeriod: BlockNumber = 5 * MINUTES;517	pub const Burn: Permill = Permill::from_percent(0);518	pub const TipCountdown: BlockNumber = 1 * DAYS;519	pub const TipFindersFee: Percent = Percent::from_percent(20);520	pub const TipReportDepositBase: Balance = 1 * UNIQUE;521	pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;522	pub const BountyDepositBase: Balance = 1 * UNIQUE;523	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;524	pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");525	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;526	pub const MaximumReasonLength: u32 = 16384;527	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);528	pub const BountyValueMinimum: Balance = 5 * UNIQUE;529	pub const MaxApprovals: u32 = 100;530}531532impl pallet_treasury::Config for Runtime {533	type PalletId = TreasuryModuleId;534	type Currency = Balances;535	type ApproveOrigin = EnsureRoot<AccountId>;536	type RejectOrigin = EnsureRoot<AccountId>;537	type Event = Event;538	type OnSlash = ();539	type ProposalBond = ProposalBond;540	type ProposalBondMinimum = ProposalBondMinimum;541	type ProposalBondMaximum = ProposalBondMaximum;542	type SpendPeriod = SpendPeriod;543	type Burn = Burn;544	type BurnDestination = ();545	type SpendFunds = ();546	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;547	type MaxApprovals = MaxApprovals;548}549550impl pallet_sudo::Config for Runtime {551	type Event = Event;552	type Call = Call;553}554555pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);556557impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider558	for RelayChainBlockNumberProvider<T>559{560	type BlockNumber = BlockNumber;561562	fn current_block_number() -> Self::BlockNumber {563		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()564			.map(|d| d.relay_parent_number)565			.unwrap_or_default()566	}567}568569parameter_types! {570	pub const MinVestedTransfer: Balance = 10 * UNIQUE;571	pub const MaxVestingSchedules: u32 = 28;572}573574impl orml_vesting::Config for Runtime {575	type Event = Event;576	type Currency = pallet_balances::Pallet<Runtime>;577	type MinVestedTransfer = MinVestedTransfer;578	type VestedTransferOrigin = EnsureSigned<AccountId>;579	type WeightInfo = ();580	type MaxVestingSchedules = MaxVestingSchedules;581	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;582}583584parameter_types! {585	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;586	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;587}588589impl cumulus_pallet_parachain_system::Config for Runtime {590	type Event = Event;591	type SelfParaId = parachain_info::Pallet<Self>;592	type OnSystemEvent = ();593	// type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<594	// 	MaxDownwardMessageWeight,595	// 	XcmExecutor<XcmConfig>,596	// 	Call,597	// >;598	type OutboundXcmpMessageSource = XcmpQueue;599	type DmpMessageHandler = DmpQueue;600	type ReservedDmpWeight = ReservedDmpWeight;601	type ReservedXcmpWeight = ReservedXcmpWeight;602	type XcmpMessageHandler = XcmpQueue;603}604605impl parachain_info::Config for Runtime {}606607impl cumulus_pallet_aura_ext::Config for Runtime {}608609parameter_types! {610	pub const RelayLocation: MultiLocation = MultiLocation::parent();611	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;612	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();613	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();614}615616/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used617/// when determining ownership of accounts for asset transacting and when attempting to use XCM618/// `Transact` in order to determine the dispatch Origin.619pub type LocationToAccountId = (620	// The parent (Relay-chain) origin converts to the default `AccountId`.621	ParentIsDefault<AccountId>,622	// Sibling parachain origins convert to AccountId via the `ParaId::into`.623	SiblingParachainConvertsVia<Sibling, AccountId>,624	// Straight up local `AccountId32` origins just alias directly to `AccountId`.625	AccountId32Aliases<RelayNetwork, AccountId>,626);627628629pub struct OnlySelfCurrency;630impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {631	fn matches_fungible(a: &MultiAsset) -> Option<B> {632		match (&a.id, &a.fun) {633			(Concrete(_), XcmFungible(ref amount)) =>634				CheckedConversion::checked_from(*amount),635			_ => None,636		}637	}638}639640/// Means for transacting assets on this chain.641pub type LocalAssetTransactor = CurrencyAdapter<642	// Use this currency:643	Balances,644	// Use this currency when it is a fungible asset matching the given location or name:645	OnlySelfCurrency,646	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:647	LocationToAccountId,648	// Our chain's account ID type (we can't get away without mentioning it explicitly):649	AccountId,650	// We don't track any teleports.651	(),652>;653654/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,655/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can656/// biases the kind of local `Origin` it will become.657pub type XcmOriginToTransactDispatchOrigin = (658	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location659	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for660	// foreign chains who want to have a local sovereign account on this chain which they control.661	SovereignSignedViaLocation<LocationToAccountId, Origin>,662	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when663	// recognised.664	RelayChainAsNative<RelayOrigin, Origin>,665	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when666	// recognised.667	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,668	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a669	// transaction from the Root origin.670	ParentAsSuperuser<Origin>,671	// Native signed account converter; this just converts an `AccountId32` origin into a normal672	// `Origin::Signed` origin of the same 32-byte value.673	SignedAccountId32AsNative<RelayNetwork, Origin>,674	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.675	XcmPassthrough<Origin>,676);677678parameter_types! {679	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.680	pub UnitWeightCost: Weight = 1_000_000;681	// 1200 UNIQUEs buy 1 second of weight.682	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);683	pub const MaxInstructions: u32 = 100;684	pub const MaxAuthorities: u32 = 100_000;685}686687match_type! {688	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {689		MultiLocation { parents: 1, interior: Here } |690		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }691	};692}693694pub type Barrier = (695	TakeWeightCredit,696	AllowTopLevelPaidExecutionFrom<Everything>,697	AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,698	// ^^^ Parent & its unit plurality gets free execution699);700701pub struct XcmConfig;702impl Config for XcmConfig {703	type Call = Call;704	type XcmSender = XcmRouter;705	// How to withdraw and deposit an asset.706	type AssetTransactor = LocalAssetTransactor;707	type OriginConverter = XcmOriginToTransactDispatchOrigin;708	type IsReserve = NativeAsset;709	type IsTeleporter = (); // Teleportation is disabled710	type LocationInverter = LocationInverter<Ancestry>;711	type Barrier = Barrier;712	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;713	type Trader = UsingComponents<IdentityFee<Balance>, RelayLocation, AccountId, Balances, ()>;714	type ResponseHandler = (); // Don't handle responses for now.715	type SubscriptionService = PolkadotXcm;716717	type AssetTrap = PolkadotXcm;718	type AssetClaims = PolkadotXcm;719}720721// parameter_types! {722// 	pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;723// }724725/// No local origins on this chain are allowed to dispatch XCM sends/executions.726pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);727728/// The means for routing XCM messages which are not for local execution into the right message729/// queues.730pub type XcmRouter = (731	// Two routers - use UMP to communicate with the relay chain:732	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,733	// ..and XCMP to communicate with the sibling chains.734	XcmpQueue,735);736737impl pallet_evm_coder_substrate::Config for Runtime {738	type EthereumTransactionSender = pallet_ethereum::Pallet<Self>;739	type GasWeightMapping = FixedGasWeightMapping;740}741742impl pallet_xcm::Config for Runtime {743	type Event = Event;744	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;745	type XcmRouter = XcmRouter;746	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;747	type XcmExecuteFilter = Everything;748	type XcmExecutor = XcmExecutor<XcmConfig>;749	type XcmTeleportFilter = Everything;750	type XcmReserveTransferFilter = Everything;751	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;752	type LocationInverter = LocationInverter<Ancestry>;753	type Origin = Origin;754	type Call = Call;755	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;756	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;757}758759impl cumulus_pallet_xcm::Config for Runtime {760	type Event = Event;761	type XcmExecutor = XcmExecutor<XcmConfig>;762}763764impl cumulus_pallet_xcmp_queue::Config for Runtime {765	type Event = Event;766	type XcmExecutor = XcmExecutor<XcmConfig>;767	type ChannelInfo = ParachainSystem;768	type VersionWrapper = ();769	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;770}771772impl cumulus_pallet_dmp_queue::Config for Runtime {773	type Event = Event;774	type XcmExecutor = XcmExecutor<XcmConfig>;775	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;776}777778impl pallet_aura::Config for Runtime {779	type AuthorityId = AuraId;780	type DisabledValidators = ();781	type MaxAuthorities = MaxAuthorities;782}783784parameter_types! {785	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();786	pub const CollectionCreationPrice: Balance = 100 * UNIQUE;787}788789impl pallet_common::Config for Runtime {790	type Event = Event;791	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;792	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;793	type CrossAccountId = pallet_common::account::BasicCrossAccountId<Self>;794795	type Currency = Balances;796	type CollectionCreationPrice = CollectionCreationPrice;797	type TreasuryAccountId = TreasuryAccountId;798}799800impl pallet_fungible::Config for Runtime {801	type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;802}803impl pallet_refungible::Config for Runtime {804	type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;805}806impl pallet_nonfungible::Config for Runtime {807	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;808}809810impl pallet_unique::Config for Runtime {811	type Event = Event;812	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;813}814815parameter_types! {816	pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied817}818819/// Used for the pallet inflation820impl pallet_inflation::Config for Runtime {821	type Currency = Balances;822	type TreasuryAccountId = TreasuryAccountId;823	type InflationBlockInterval = InflationBlockInterval;824	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;825}826827// parameter_types! {828// 	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *829// 		RuntimeBlockWeights::get().max_block;830// 	pub const MaxScheduledPerBlock: u32 = 50;831// }832833type EvmSponsorshipHandler = (834	pallet_unique::UniqueEthSponsorshipHandler<Runtime>,835	pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,836);837type SponsorshipHandler = (838	pallet_unique::UniqueSponsorshipHandler<Runtime>,839	//pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,840	pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,841);842843// impl pallet_unq_scheduler::Config for Runtime {844// 	type Event = Event;845// 	type Origin = Origin;846// 	type PalletsOrigin = OriginCaller;847// 	type Call = Call;848// 	type MaximumWeight = MaximumSchedulerWeight;849// 	type ScheduleOrigin = EnsureSigned<AccountId>;850// 	type MaxScheduledPerBlock = MaxScheduledPerBlock;851// 	type SponsorshipHandler = SponsorshipHandler;852// 	type WeightInfo = ();853// }854855impl pallet_evm_transaction_payment::Config for Runtime {856	type EvmSponsorshipHandler = EvmSponsorshipHandler;857	type Currency = Balances;858	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;859	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;860}861862impl pallet_charge_transaction::Config for Runtime {863	type SponsorshipHandler = SponsorshipHandler;864}865866// impl pallet_contract_helpers::Config for Runtime {867//	 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;868// }869870parameter_types! {871	// 0x842899ECF380553E8a4de75bF534cdf6fBF64049872	pub const HelpersContractAddress: H160 = H160([873		0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,874	]);875}876877impl pallet_evm_contract_helpers::Config for Runtime {878	type ContractAddress = HelpersContractAddress;879	type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;880}881882construct_runtime!(883	pub enum Runtime where884		Block = Block,885		NodeBlock = opaque::Block,886		UncheckedExtrinsic = UncheckedExtrinsic887	{888		ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,889		ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,890891		Aura: pallet_aura::{Pallet, Config<T>} = 22,892		AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,893894		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,895		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,896		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,897		TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,898		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,899		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,900		System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,901		Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,902		// Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,903		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,904905		// XCM helpers.906		XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,907		PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,908		CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,909		DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,910911		// Unique Pallets912		Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,913		Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,914		// Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event<T>} = 62,915		// free = 63916		Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,917		// ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,918		Common: pallet_common::{Pallet, Storage, Event<T>} = 66,919		Fungible: pallet_fungible::{Pallet, Storage} = 67,920		Refungible: pallet_refungible::{Pallet, Storage} = 68,921		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,922923		// Frontier924		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,925		Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,926927		EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,928		EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,929		EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,930		EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,931	}932);933934pub struct TransactionConverter;935936impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {937	fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {938		UncheckedExtrinsic::new_unsigned(939			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),940		)941	}942}943944impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {945	fn convert_transaction(946		&self,947		transaction: pallet_ethereum::Transaction,948	) -> opaque::UncheckedExtrinsic {949		let extrinsic = UncheckedExtrinsic::new_unsigned(950			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),951		);952		let encoded = extrinsic.encode();953		opaque::UncheckedExtrinsic::decode(&mut &encoded[..])954			.expect("Encoded extrinsic is always valid")955	}956}957958/// The address format for describing accounts.959pub type Address = sp_runtime::MultiAddress<AccountId, ()>;960/// Block header type as expected by this runtime.961pub type Header = generic::Header<BlockNumber, BlakeTwo256>;962/// Block type as expected by this runtime.963pub type Block = generic::Block<Header, UncheckedExtrinsic>;964/// A Block signed with a Justification965pub type SignedBlock = generic::SignedBlock<Block>;966/// BlockId type as expected by this runtime.967pub type BlockId = generic::BlockId<Block>;968/// The SignedExtension to the basic transaction logic.969pub type SignedExtra = (970	frame_system::CheckSpecVersion<Runtime>,971	// system::CheckTxVersion<Runtime>,972	frame_system::CheckGenesis<Runtime>,973	frame_system::CheckEra<Runtime>,974	frame_system::CheckNonce<Runtime>,975	frame_system::CheckWeight<Runtime>,976	pallet_charge_transaction::ChargeTransactionPayment<Runtime>,977	//pallet_contract_helpers::ContractHelpersExtension<Runtime>,978);979/// Unchecked extrinsic type as expected by this runtime.980pub type UncheckedExtrinsic =981	fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;982/// Extrinsic type that has already been checked.983pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;984/// Executive: handles dispatch to the various modules.985pub type Executive = frame_executive::Executive<986	Runtime,987	Block,988	frame_system::ChainContext<Runtime>,989	Runtime,990	AllPalletsReversedWithSystemFirst,991>;992993impl_opaque_keys! {994	pub struct SessionKeys {995		pub aura: Aura,996	}997}998999impl fp_self_contained::SelfContainedCall for Call {1000	type SignedInfo = H160;10011002	fn is_self_contained(&self) -> bool {1003		match self {1004			Call::Ethereum(call) => call.is_self_contained(),1005			_ => false,1006		}1007	}10081009	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1010		match self {1011			Call::Ethereum(call) => call.check_self_contained(),1012			_ => None,1013		}1014	}10151016	fn validate_self_contained(&self, info: &Self::SignedInfo) -> Option<TransactionValidity> {1017		match self {1018			Call::Ethereum(call) => call.validate_self_contained(info),1019			_ => None,1020		}1021	}10221023	fn pre_dispatch_self_contained(1024		&self,1025		info: &Self::SignedInfo,1026	) -> Option<Result<(), TransactionValidityError>> {1027		match self {1028			Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1029			_ => None,1030		}1031	}10321033	fn apply_self_contained(1034		self,1035		info: Self::SignedInfo,1036	) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1037		match self {1038			call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1039				Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1040			)),1041			_ => None,1042		}1043	}1044}10451046macro_rules! dispatch_unique_runtime {1047	($collection:ident.$method:ident($($name:ident),*)) => {{1048		use pallet_unique::dispatch::Dispatched;10491050		let collection = Dispatched::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1051		let dispatch = collection.as_dyn();10521053		Ok(dispatch.$method($($name),*))1054	}};1055}1056impl_runtime_apis! {1057	impl up_rpc::UniqueApi<Block, CrossAccountId, AccountId>1058		for Runtime1059	{1060		fn account_tokens(collection: CollectionId, account: CrossAccountId) -> Result<Vec<TokenId>, DispatchError> {1061			dispatch_unique_runtime!(collection.account_tokens(account))1062		}1063		fn token_exists(collection: CollectionId, token: TokenId) -> Result<bool, DispatchError> {1064			dispatch_unique_runtime!(collection.token_exists(token))1065		}10661067		fn token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {1068			dispatch_unique_runtime!(collection.token_owner(token))1069		}1070		fn const_metadata(collection: CollectionId, token: TokenId) -> Result<Vec<u8>, DispatchError> {1071			dispatch_unique_runtime!(collection.const_metadata(token))1072		}1073		fn variable_metadata(collection: CollectionId, token: TokenId) -> Result<Vec<u8>, DispatchError> {1074			dispatch_unique_runtime!(collection.variable_metadata(token))1075		}10761077		fn collection_tokens(collection: CollectionId) -> Result<u32, DispatchError> {1078			dispatch_unique_runtime!(collection.collection_tokens())1079		}1080		fn account_balance(collection: CollectionId, account: CrossAccountId) -> Result<u32, DispatchError> {1081			dispatch_unique_runtime!(collection.account_balance(account))1082		}1083		fn balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<u128, DispatchError> {1084			dispatch_unique_runtime!(collection.balance(account, token))1085		}1086		fn allowance(1087			collection: CollectionId,1088			sender: CrossAccountId,1089			spender: CrossAccountId,1090			token: TokenId,1091		) -> Result<u128, DispatchError> {1092			dispatch_unique_runtime!(collection.allowance(sender, spender, token))1093		}10941095		fn eth_contract_code(account: H160) -> Option<Vec<u8>> {1096			<pallet_unique::UniqueErcSupport<Runtime>>::get_code(&account)1097				.or_else(|| <pallet_evm_migration::OnMethodCall<Runtime>>::get_code(&account))1098				.or_else(|| <pallet_evm_contract_helpers::HelpersOnMethodCall<Self>>::get_code(&account))1099		}1100		fn adminlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {1101			Ok(<pallet_common::Pallet<Runtime>>::adminlist(collection))1102		}1103		fn allowlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {1104			Ok(<pallet_common::Pallet<Runtime>>::allowlist(collection))1105		}1106		fn allowed(collection: CollectionId, user: CrossAccountId) -> Result<bool, DispatchError> {1107			Ok(<pallet_common::Pallet<Runtime>>::allowed(collection, user))1108		}1109		fn last_token_id(collection: CollectionId) -> Result<TokenId, DispatchError> {1110			dispatch_unique_runtime!(collection.last_token_id())1111		}1112		fn collection_by_id(collection: CollectionId) -> Result<Option<Collection<AccountId>>, DispatchError> {1113			Ok(<pallet_common::CollectionById<Runtime>>::get(collection))1114		}1115		fn collection_stats() -> Result<CollectionStats, DispatchError> {1116			Ok(<pallet_common::Pallet<Runtime>>::collection_stats())1117		}1118	}11191120	impl sp_api::Core<Block> for Runtime {1121		fn version() -> RuntimeVersion {1122			VERSION1123		}11241125		fn execute_block(block: Block) {1126			Executive::execute_block(block)1127		}11281129		fn initialize_block(header: &<Block as BlockT>::Header) {1130			Executive::initialize_block(header)1131		}1132	}11331134	impl sp_api::Metadata<Block> for Runtime {1135		fn metadata() -> OpaqueMetadata {1136			OpaqueMetadata::new(Runtime::metadata().into())1137		}1138	}11391140	impl sp_block_builder::BlockBuilder<Block> for Runtime {1141		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {1142			Executive::apply_extrinsic(extrinsic)1143		}11441145		fn finalize_block() -> <Block as BlockT>::Header {1146			Executive::finalize_block()1147		}11481149		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {1150			data.create_extrinsics()1151		}11521153		fn check_inherents(1154			block: Block,1155			data: sp_inherents::InherentData,1156		) -> sp_inherents::CheckInherentsResult {1157			data.check_extrinsics(&block)1158		}11591160		// fn random_seed() -> <Block as BlockT>::Hash {1161		//     RandomnessCollectiveFlip::random_seed().01162		// }1163	}11641165	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {1166		fn validate_transaction(1167			source: TransactionSource,1168			tx: <Block as BlockT>::Extrinsic,1169			hash: <Block as BlockT>::Hash,1170		) -> TransactionValidity {1171			Executive::validate_transaction(source, tx, hash)1172		}1173	}11741175	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {1176		fn offchain_worker(header: &<Block as BlockT>::Header) {1177			Executive::offchain_worker(header)1178		}1179	}11801181	impl fp_rpc::EthereumRuntimeRPCApi<Block> for Runtime {1182		fn chain_id() -> u64 {1183			<Runtime as pallet_evm::Config>::ChainId::get()1184		}11851186		fn account_basic(address: H160) -> EVMAccount {1187			EVM::account_basic(&address)1188		}11891190		fn gas_price() -> U256 {1191			<Runtime as pallet_evm::Config>::FeeCalculator::min_gas_price()1192		}11931194		fn account_code_at(address: H160) -> Vec<u8> {1195			EVM::account_codes(address)1196		}11971198		fn author() -> H160 {1199			<pallet_evm::Pallet<Runtime>>::find_author()1200		}12011202		fn storage_at(address: H160, index: U256) -> H256 {1203			let mut tmp = [0u8; 32];1204			index.to_big_endian(&mut tmp);1205			EVM::account_storages(address, H256::from_slice(&tmp[..]))1206		}12071208		#[allow(clippy::redundant_closure)]1209		fn call(1210			from: H160,1211			to: H160,1212			data: Vec<u8>,1213			value: U256,1214			gas_limit: U256,1215			max_fee_per_gas: Option<U256>,1216			max_priority_fee_per_gas: Option<U256>,1217			nonce: Option<U256>,1218			estimate: bool,1219			access_list: Option<Vec<(H160, Vec<H256>)>>,1220		) -> Result<pallet_evm::CallInfo, sp_runtime::DispatchError> {1221			let config = if estimate {1222				let mut config = <Runtime as pallet_evm::Config>::config().clone();1223				config.estimate = true;1224				Some(config)1225			} else {1226				None1227			};12281229			<Runtime as pallet_evm::Config>::Runner::call(1230				from,1231				to,1232				data,1233				value,1234				gas_limit.low_u64(),1235				max_fee_per_gas,1236				max_priority_fee_per_gas,1237				nonce,1238				access_list.unwrap_or_default(),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			max_fee_per_gas: Option<U256>,1250			max_priority_fee_per_gas: Option<U256>,1251			nonce: Option<U256>,1252			estimate: bool,1253			access_list: Option<Vec<(H160, Vec<H256>)>>,1254		) -> Result<pallet_evm::CreateInfo, sp_runtime::DispatchError> {1255			let config = if estimate {1256				let mut config = <Runtime as pallet_evm::Config>::config().clone();1257				config.estimate = true;1258				Some(config)1259			} else {1260				None1261			};12621263			<Runtime as pallet_evm::Config>::Runner::create(1264				from,1265				data,1266				value,1267				gas_limit.low_u64(),1268				max_fee_per_gas,1269				max_priority_fee_per_gas,1270				nonce,1271				access_list.unwrap_or_default(),1272				config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),1273			).map_err(|err| err.into())1274		}12751276		fn current_transaction_statuses() -> Option<Vec<TransactionStatus>> {1277			Ethereum::current_transaction_statuses()1278		}12791280		fn current_block() -> Option<pallet_ethereum::Block> {1281			Ethereum::current_block()1282		}12831284		fn current_receipts() -> Option<Vec<pallet_ethereum::Receipt>> {1285			Ethereum::current_receipts()1286		}12871288		fn current_all() -> (1289			Option<pallet_ethereum::Block>,1290			Option<Vec<pallet_ethereum::Receipt>>,1291			Option<Vec<TransactionStatus>>1292		) {1293			(1294				Ethereum::current_block(),1295				Ethereum::current_receipts(),1296				Ethereum::current_transaction_statuses()1297			)1298		}12991300		fn extrinsic_filter(xts: Vec<<Block as sp_api::BlockT>::Extrinsic>) -> Vec<pallet_ethereum::Transaction> {1301			xts.into_iter().filter_map(|xt| match xt.0.function {1302				Call::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction),1303				_ => None1304			}).collect()1305		}13061307		fn elasticity() -> Option<Permill> {1308			None1309		}1310	}13111312	impl sp_session::SessionKeys<Block> for Runtime {1313		fn decode_session_keys(1314			encoded: Vec<u8>,1315		) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {1316			SessionKeys::decode_into_raw_public_keys(&encoded)1317		}13181319		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {1320			SessionKeys::generate(seed)1321		}1322	}13231324	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {1325		fn slot_duration() -> sp_consensus_aura::SlotDuration {1326			sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())1327		}13281329		fn authorities() -> Vec<AuraId> {1330			Aura::authorities().to_vec()1331		}1332	}13331334	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {1335		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {1336			ParachainSystem::collect_collation_info(header)1337		}1338	}13391340	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {1341		fn account_nonce(account: AccountId) -> Index {1342			System::account_nonce(account)1343		}1344	}13451346	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {1347		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {1348			TransactionPayment::query_info(uxt, len)1349		}1350		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {1351			TransactionPayment::query_fee_details(uxt, len)1352		}1353	}13541355	/*1356	impl pallet_contracts_rpc_runtime_api::ContractsApi<Block, AccountId, Balance, BlockNumber, Hash>1357		for Runtime1358	{1359		fn call(1360			origin: AccountId,1361			dest: AccountId,1362			value: Balance,1363			gas_limit: u64,1364			input_data: Vec<u8>,1365		) -> pallet_contracts_primitives::ContractExecResult {1366			Contracts::bare_call(origin, dest, value, gas_limit, input_data, false)1367		}13681369		fn instantiate(1370			origin: AccountId,1371			endowment: Balance,1372			gas_limit: u64,1373			code: pallet_contracts_primitives::Code<Hash>,1374			data: Vec<u8>,1375			salt: Vec<u8>,1376		) -> pallet_contracts_primitives::ContractInstantiateResult<AccountId, BlockNumber>1377		{1378			Contracts::bare_instantiate(origin, endowment, gas_limit, code, data, salt, true, false)1379		}13801381		fn get_storage(1382			address: AccountId,1383			key: [u8; 32],1384		) -> pallet_contracts_primitives::GetStorageResult {1385			Contracts::get_storage(address, key)1386		}13871388		fn rent_projection(1389			address: AccountId,1390		) -> pallet_contracts_primitives::RentProjectionResult<BlockNumber> {1391			Contracts::rent_projection(address)1392		}1393	}1394	*/13951396	#[cfg(feature = "runtime-benchmarks")]1397	impl frame_benchmarking::Benchmark<Block> for Runtime {1398		fn benchmark_metadata(extra: bool) -> (1399			Vec<frame_benchmarking::BenchmarkList>,1400			Vec<frame_support::traits::StorageInfo>,1401		) {1402			use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList};1403			use frame_support::traits::StorageInfoTrait;14041405			let mut list = Vec::<BenchmarkList>::new();14061407			list_benchmark!(list, extra, pallet_evm_migration, EvmMigration);1408			list_benchmark!(list, extra, pallet_unique, Unique);1409			list_benchmark!(list, extra, pallet_inflation, Inflation);1410			list_benchmark!(list, extra, pallet_fungible, Fungible);1411			list_benchmark!(list, extra, pallet_refungible, Refungible);1412			list_benchmark!(list, extra, pallet_nonfungible, Nonfungible);1413			// list_benchmark!(list, extra, pallet_evm_coder_substrate, EvmCoderSubstrate);14141415			let storage_info = AllPalletsReversedWithSystemFirst::storage_info();14161417			return (list, storage_info)1418		}14191420		fn dispatch_benchmark(1421			config: frame_benchmarking::BenchmarkConfig1422		) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {1423			use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey};14241425			let allowlist: Vec<TrackedStorageKey> = vec![1426				// Block Number1427				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),1428				// Total Issuance1429				hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),1430				// Execution Phase1431				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),1432				// Event Count1433				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),1434				// System Events1435				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),1436			];14371438			let mut batches = Vec::<BenchmarkBatch>::new();1439			let params = (&config, &allowlist);14401441			add_benchmark!(params, batches, pallet_evm_migration, EvmMigration);1442			add_benchmark!(params, batches, pallet_unique, Unique);1443			add_benchmark!(params, batches, pallet_inflation, Inflation);1444			add_benchmark!(params, batches, pallet_fungible, Fungible);1445			add_benchmark!(params, batches, pallet_refungible, Refungible);1446			add_benchmark!(params, batches, pallet_nonfungible, Nonfungible);1447			// add_benchmark!(params, batches, pallet_evm_coder_substrate, EvmCoderSubstrate);14481449			if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }1450			Ok(batches)1451		}1452	}1453}14541455struct CheckInherents;14561457impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1458	fn check_inherents(1459		block: &Block,1460		relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1461	) -> sp_inherents::CheckInherentsResult {1462		let relay_chain_slot = relay_state_proof1463			.read_slot()1464			.expect("Could not read the relay chain slot from the proof");14651466		let inherent_data =1467			cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1468				relay_chain_slot,1469				sp_std::time::Duration::from_secs(6),1470			)1471			.create_inherent_data()1472			.expect("Could not create the timestamp inherent data");14731474		inherent_data.check_extrinsics(block)1475	}1476}14771478cumulus_pallet_parachain_system::register_validate_block!(1479	Runtime = Runtime,1480	BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1481	CheckInherents = CheckInherents,1482);