git.delta.rocks / unique-network / refs/commits / 8b54ea00d9b8

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! The Substrate Node Template runtime. This can be compiled with `#[no_std]`, ready for Wasm.1819#![cfg_attr(not(feature = "std"), no_std)]20// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.21#![recursion_limit = "1024"]22#![allow(clippy::from_over_into, clippy::identity_op)]23#![allow(clippy::fn_to_numeric_cast_with_truncation)]24// Make the WASM binary available.25#[cfg(feature = "std")]26include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));2728use sp_api::impl_runtime_apis;29use sp_core::{crypto::KeyTypeId, OpaqueMetadata, H256, U256, H160};30use sp_runtime::DispatchError;31// #[cfg(any(feature = "std", test))]32// pub use sp_runtime::BuildStorage;3334use sp_runtime::{35	Permill, Perbill, Percent, create_runtime_str, generic, impl_opaque_keys,36	generic::Era,37	traits::{38		Applyable, BlockNumberProvider, Dispatchable, PostDispatchInfoOf, Saturating,39		CheckedConversion, AccountIdLookup, BlakeTwo256, Block as BlockT, AccountIdConversion,40		Zero, Member, SignedExtension,41	},42	transaction_validity::{TransactionSource, TransactionValidity, TransactionValidityError},43	ApplyExtrinsicResult, RuntimeAppPublic, SaturatedConversion, DispatchErrorWithPostInfo,44};4546use fp_self_contained::{SelfContainedCall, CheckedSignature};47use sp_std::{cmp::Ordering, marker::PhantomData};48use pallet_unq_scheduler::DispatchCall;4950use sp_std::prelude::*;5152#[cfg(feature = "std")]53use sp_version::NativeVersion;54use sp_version::RuntimeVersion;55pub use pallet_transaction_payment::{56	Multiplier, TargetedFeeAdjustment, FeeDetails, RuntimeDispatchInfo,57};58// A few exports that help ease life for downstream crates.59pub use pallet_balances::Call as BalancesCall;60pub use pallet_evm::{EnsureAddressTruncated, HashedAddressMapping, Runner};61pub use frame_support::{62	construct_runtime, match_type,63	dispatch::DispatchResult,64	PalletId, parameter_types, StorageValue, ConsensusEngineId,65	traits::{66		tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Everything,67		Currency, ExistenceRequirement, Get, IsInVec, KeyOwnerProofSystem, LockIdentifier,68		OnUnbalanced, Randomness, FindAuthor, PrivilegeCmp,69	},70	weights::{71		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},72		DispatchClass, DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,73		WeightToFeePolynomial, WeightToFeeCoefficient, WeightToFeeCoefficients,74	},75};76use up_data_structs::*;77// use pallet_contracts::weights::WeightInfo;78// #[cfg(any(feature = "std", test))]79use frame_system::{80	self as frame_system, EnsureRoot, EnsureSigned,81	limits::{BlockWeights, BlockLength},82};83use sp_arithmetic::{84	traits::{BaseArithmetic, Unsigned},85};86use smallvec::smallvec;87use codec::{Encode, Decode};88use pallet_evm::{Account as EVMAccount, FeeCalculator, GasWeightMapping, OnMethodCall};89use fp_rpc::TransactionStatus;9091// pub use pallet_timestamp::Call as TimestampCall;9293// Polkadot imports94use pallet_xcm::XcmPassthrough;95use polkadot_parachain::primitives::Sibling;96use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};97use xcm_builder::{98	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,99	EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser,100	RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,101	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,102	ParentIsPreset,103};104use xcm_executor::{Config, XcmExecutor, Assets};105106use xcm::latest::{107	//	Xcm,108	AssetId::{Concrete},109	Fungibility::Fungible as XcmFungible,110	MultiAsset,111	Error as XcmError,112};113use xcm_executor::traits::{MatchesFungible, WeightTrader};114use unique_runtime_common::{impl_common_runtime_apis, types::*, constants::*};115116pub const RUNTIME_NAME: &str = "Unique";117118type CrossAccountId = pallet_common::account::BasicCrossAccountId<Runtime>;119120impl RuntimeInstance for Runtime {121	type CrossAccountId = self::CrossAccountId;122123	type TransactionConverter = self::TransactionConverter;124125	fn get_transaction_converter() -> TransactionConverter {126		TransactionConverter127	}128}129130/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know131/// the specifics of the runtime. They can then be made to be agnostic over specific formats132/// of data like extrinsics, allowing for them to continue syncing the network through upgrades133/// to even the core data structures.134pub mod opaque {135	use sp_std::prelude::*;136	use sp_runtime::impl_opaque_keys;137	use super::Aura;138139	pub use unique_runtime_common::types::*;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!(RUNTIME_NAME),151	impl_name: create_runtime_str!(RUNTIME_NAME),152	authoring_version: 1,153	spec_version: 917004,154	impl_version: 0,155	apis: RUNTIME_API_VERSIONS,156	transaction_version: 1,157	state_version: 0,158};159160#[derive(codec::Encode, codec::Decode)]161pub enum XCMPMessage<XAccountId, XBalance> {162	/// Transfer tokens to the given account from the Parachain account.163	TransferToken(XAccountId, XBalance),164}165166/// The version information used to identify this runtime when compiled natively.167#[cfg(feature = "std")]168pub fn native_version() -> NativeVersion {169	NativeVersion {170		runtime_version: VERSION,171		can_author_with: Default::default(),172	}173}174175type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;176177pub struct DealWithFees;178impl OnUnbalanced<NegativeImbalance> for DealWithFees {179	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {180		if let Some(fees) = fees_then_tips.next() {181			// for fees, 100% to treasury182			let mut split = fees.ration(100, 0);183			if let Some(tips) = fees_then_tips.next() {184				// for tips, if any, 100% to treasury185				tips.ration_merge_into(100, 0, &mut split);186			}187			Treasury::on_unbalanced(split.0);188			// Author::on_unbalanced(split.1);189		}190	}191}192193parameter_types! {194	pub const BlockHashCount: BlockNumber = 2400;195	pub RuntimeBlockLength: BlockLength =196		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);197	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);198	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;199	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()200		.base_block(BlockExecutionWeight::get())201		.for_class(DispatchClass::all(), |weights| {202			weights.base_extrinsic = ExtrinsicBaseWeight::get();203		})204		.for_class(DispatchClass::Normal, |weights| {205			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);206		})207		.for_class(DispatchClass::Operational, |weights| {208			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);209			// Operational transactions have some extra reserved space, so that they210			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.211			weights.reserved = Some(212				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT213			);214		})215		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)216		.build_or_panic();217	pub const Version: RuntimeVersion = VERSION;218	pub const SS58Prefix: u16 = 7391;219}220221parameter_types! {222	pub const ChainId: u64 = 8880;223}224225pub struct FixedFee;226impl FeeCalculator for FixedFee {227	fn min_gas_price() -> U256 {228		MIN_GAS_PRICE.into()229	}230}231232// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case233// (contract, which only writes a lot of data),234// approximating on top of our real store write weight235parameter_types! {236	pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;237	pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;238	pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();239}240241/// Limiting EVM execution to 50% of block for substrate users and management tasks242/// EVM transaction consumes more weight than substrate's, so we can't rely on them being243/// scheduled fairly244const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);245parameter_types! {246	pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());247}248249pub enum FixedGasWeightMapping {}250impl GasWeightMapping for FixedGasWeightMapping {251	fn gas_to_weight(gas: u64) -> Weight {252		gas.saturating_mul(WeightPerGas::get())253	}254	fn weight_to_gas(weight: Weight) -> u64 {255		weight / WeightPerGas::get()256	}257}258259impl pallet_evm::Config for Runtime {260	type BlockGasLimit = BlockGasLimit;261	type FeeCalculator = FixedFee;262	type GasWeightMapping = FixedGasWeightMapping;263	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;264	type CallOrigin = EnsureAddressTruncated;265	type WithdrawOrigin = EnsureAddressTruncated;266	type AddressMapping = HashedAddressMapping<Self::Hashing>;267	type PrecompilesType = ();268	type PrecompilesValue = ();269	type Currency = Balances;270	type Event = Event;271	type OnMethodCall = (272		pallet_evm_migration::OnMethodCall<Self>,273		pallet_unique::UniqueErcSupport<Self>,274		pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,275	);276	type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;277	type ChainId = ChainId;278	type Runner = pallet_evm::runner::stack::Runner<Self>;279	type OnChargeTransaction = pallet_evm_transaction_payment::OnChargeTransaction<Self>;280	type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;281	type FindAuthor = EthereumFindAuthor<Aura>;282}283284impl pallet_evm_migration::Config for Runtime {285	type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;286}287288pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);289impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {290	fn find_author<'a, I>(digests: I) -> Option<H160>291	where292		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,293	{294		if let Some(author_index) = F::find_author(digests) {295			let authority_id = Aura::authorities()[author_index as usize].clone();296			return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));297		}298		None299	}300}301302impl pallet_ethereum::Config for Runtime {303	type Event = Event;304	type StateRoot = pallet_ethereum::IntermediateStateRoot;305}306307impl pallet_randomness_collective_flip::Config for Runtime {}308309impl frame_system::Config for Runtime {310	/// The data to be stored in an account.311	type AccountData = pallet_balances::AccountData<Balance>;312	/// The identifier used to distinguish between accounts.313	type AccountId = AccountId;314	/// The basic call filter to use in dispatchable.315	type BaseCallFilter = Everything;316	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).317	type BlockHashCount = BlockHashCount;318	/// The maximum length of a block (in bytes).319	type BlockLength = RuntimeBlockLength;320	/// The index type for blocks.321	type BlockNumber = BlockNumber;322	/// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.323	type BlockWeights = RuntimeBlockWeights;324	/// The aggregated dispatch type that is available for extrinsics.325	type Call = Call;326	/// The weight of database operations that the runtime can invoke.327	type DbWeight = RocksDbWeight;328	/// The ubiquitous event type.329	type Event = Event;330	/// The type for hashing blocks and tries.331	type Hash = Hash;332	/// The hashing algorithm used.333	type Hashing = BlakeTwo256;334	/// The header type.335	type Header = generic::Header<BlockNumber, BlakeTwo256>;336	/// The index type for storing how many extrinsics an account has signed.337	type Index = Index;338	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.339	type Lookup = AccountIdLookup<AccountId, ()>;340	/// What to do if an account is fully reaped from the system.341	type OnKilledAccount = ();342	/// What to do if a new account is created.343	type OnNewAccount = ();344	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;345	/// The ubiquitous origin type.346	type Origin = Origin;347	/// This type is being generated by `construct_runtime!`.348	type PalletInfo = PalletInfo;349	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.350	type SS58Prefix = SS58Prefix;351	/// Weight information for the extrinsics of this pallet.352	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;353	/// Version of the runtime.354	type Version = Version;355	type MaxConsumers = ConstU32<16>;356}357358parameter_types! {359	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;360}361362impl pallet_timestamp::Config for Runtime {363	/// A timestamp: milliseconds since the unix epoch.364	type Moment = u64;365	type OnTimestampSet = ();366	type MinimumPeriod = MinimumPeriod;367	type WeightInfo = ();368}369370parameter_types! {371	// pub const ExistentialDeposit: u128 = 500;372	pub const ExistentialDeposit: u128 = 0;373	pub const MaxLocks: u32 = 50;374}375376impl pallet_balances::Config for Runtime {377	type MaxLocks = MaxLocks;378	type MaxReserves = ();379	type ReserveIdentifier = [u8; 16];380	/// The type for recording an account's balance.381	type Balance = Balance;382	/// The ubiquitous event type.383	type Event = Event;384	type DustRemoval = Treasury;385	type ExistentialDeposit = ExistentialDeposit;386	type AccountStore = System;387	type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;388}389390pub const fn deposit(items: u32, bytes: u32) -> Balance {391	items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE392}393394/*395parameter_types! {396	pub TombstoneDeposit: Balance = deposit(397		1,398		sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,399	);400	pub DepositPerContract: Balance = TombstoneDeposit::get();401	pub const DepositPerStorageByte: Balance = deposit(0, 1);402	pub const DepositPerStorageItem: Balance = deposit(1, 0);403	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);404	pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;405	pub const SignedClaimHandicap: u32 = 2;406	pub const MaxDepth: u32 = 32;407	pub const MaxValueSize: u32 = 16 * 1024;408	pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb409	// The lazy deletion runs inside on_initialize.410	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *411		RuntimeBlockWeights::get().max_block;412	// The weight needed for decoding the queue should be less or equal than a fifth413	// of the overall weight dedicated to the lazy deletion.414	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (415			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -416			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)417		)) / 5) as u32;418	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();419}420421impl pallet_contracts::Config for Runtime {422	type Time = Timestamp;423	type Randomness = RandomnessCollectiveFlip;424	type Currency = Balances;425	type Event = Event;426	type RentPayment = ();427	type SignedClaimHandicap = SignedClaimHandicap;428	type TombstoneDeposit = TombstoneDeposit;429	type DepositPerContract = DepositPerContract;430	type DepositPerStorageByte = DepositPerStorageByte;431	type DepositPerStorageItem = DepositPerStorageItem;432	type RentFraction = RentFraction;433	type SurchargeReward = SurchargeReward;434	type WeightPrice = pallet_transaction_payment::Pallet<Self>;435	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;436	type ChainExtension = NFTExtension;437	type DeletionQueueDepth = DeletionQueueDepth;438	type DeletionWeightLimit = DeletionWeightLimit;439	type Schedule = Schedule;440	type CallStack = [pallet_contracts::Frame<Self>; 31];441}442*/443444parameter_types! {445	/// This value increases the priority of `Operational` transactions by adding446	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.447	pub const OperationalFeeMultiplier: u8 = 5;448}449450/// Linear implementor of `WeightToFeePolynomial`451pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);452453impl<T> WeightToFeePolynomial for LinearFee<T>454where455	T: BaseArithmetic + From<u32> + Copy + Unsigned,456{457	type Balance = T;458459	fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {460		smallvec!(WeightToFeeCoefficient {461			// Targeting 0.1 Unique per NFT transfer462			coeff_integer: WEIGHT_TO_FEE_COEFF.into(),463			coeff_frac: Perbill::zero(),464			negative: false,465			degree: 1,466		})467	}468}469470impl pallet_transaction_payment::Config for Runtime {471	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;472	type TransactionByteFee = TransactionByteFee;473	type OperationalFeeMultiplier = OperationalFeeMultiplier;474	type WeightToFee = LinearFee<Balance>;475	type FeeMultiplierUpdate = ();476}477478parameter_types! {479	pub const ProposalBond: Permill = Permill::from_percent(5);480	pub const ProposalBondMinimum: Balance = 1 * UNIQUE;481	pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;482	pub const SpendPeriod: BlockNumber = 5 * MINUTES;483	pub const Burn: Permill = Permill::from_percent(0);484	pub const TipCountdown: BlockNumber = 1 * DAYS;485	pub const TipFindersFee: Percent = Percent::from_percent(20);486	pub const TipReportDepositBase: Balance = 1 * UNIQUE;487	pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;488	pub const BountyDepositBase: Balance = 1 * UNIQUE;489	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;490	pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");491	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;492	pub const MaximumReasonLength: u32 = 16384;493	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);494	pub const BountyValueMinimum: Balance = 5 * UNIQUE;495	pub const MaxApprovals: u32 = 100;496}497498impl pallet_treasury::Config for Runtime {499	type PalletId = TreasuryModuleId;500	type Currency = Balances;501	type ApproveOrigin = EnsureRoot<AccountId>;502	type RejectOrigin = EnsureRoot<AccountId>;503	type Event = Event;504	type OnSlash = ();505	type ProposalBond = ProposalBond;506	type ProposalBondMinimum = ProposalBondMinimum;507	type ProposalBondMaximum = ProposalBondMaximum;508	type SpendPeriod = SpendPeriod;509	type Burn = Burn;510	type BurnDestination = ();511	type SpendFunds = ();512	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;513	type MaxApprovals = MaxApprovals;514}515516impl pallet_sudo::Config for Runtime {517	type Event = Event;518	type Call = Call;519}520521pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);522523impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider524	for RelayChainBlockNumberProvider<T>525{526	type BlockNumber = BlockNumber;527528	fn current_block_number() -> Self::BlockNumber {529		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()530			.map(|d| d.relay_parent_number)531			.unwrap_or_default()532	}533}534535parameter_types! {536	pub const MinVestedTransfer: Balance = 10 * UNIQUE;537	pub const MaxVestingSchedules: u32 = 28;538}539540impl orml_vesting::Config for Runtime {541	type Event = Event;542	type Currency = pallet_balances::Pallet<Runtime>;543	type MinVestedTransfer = MinVestedTransfer;544	type VestedTransferOrigin = EnsureSigned<AccountId>;545	type WeightInfo = ();546	type MaxVestingSchedules = MaxVestingSchedules;547	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;548}549550parameter_types! {551	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;552	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;553}554555impl cumulus_pallet_parachain_system::Config for Runtime {556	type Event = Event;557	type SelfParaId = parachain_info::Pallet<Self>;558	type OnSystemEvent = ();559	// type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<560	// 	MaxDownwardMessageWeight,561	// 	XcmExecutor<XcmConfig>,562	// 	Call,563	// >;564	type OutboundXcmpMessageSource = XcmpQueue;565	type DmpMessageHandler = DmpQueue;566	type ReservedDmpWeight = ReservedDmpWeight;567	type ReservedXcmpWeight = ReservedXcmpWeight;568	type XcmpMessageHandler = XcmpQueue;569}570571impl parachain_info::Config for Runtime {}572573impl cumulus_pallet_aura_ext::Config for Runtime {}574575parameter_types! {576	pub const RelayLocation: MultiLocation = MultiLocation::parent();577	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;578	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();579	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();580}581582/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used583/// when determining ownership of accounts for asset transacting and when attempting to use XCM584/// `Transact` in order to determine the dispatch Origin.585pub type LocationToAccountId = (586	// The parent (Relay-chain) origin converts to the default `AccountId`.587	ParentIsPreset<AccountId>,588	// Sibling parachain origins convert to AccountId via the `ParaId::into`.589	SiblingParachainConvertsVia<Sibling, AccountId>,590	// Straight up local `AccountId32` origins just alias directly to `AccountId`.591	AccountId32Aliases<RelayNetwork, AccountId>,592);593594pub struct OnlySelfCurrency;595impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {596	fn matches_fungible(a: &MultiAsset) -> Option<B> {597		match (&a.id, &a.fun) {598			(Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),599			_ => None,600		}601	}602}603604/// Means for transacting assets on this chain.605pub type LocalAssetTransactor = CurrencyAdapter<606	// Use this currency:607	Balances,608	// Use this currency when it is a fungible asset matching the given location or name:609	OnlySelfCurrency,610	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:611	LocationToAccountId,612	// Our chain's account ID type (we can't get away without mentioning it explicitly):613	AccountId,614	// We don't track any teleports.615	(),616>;617618/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,619/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can620/// biases the kind of local `Origin` it will become.621pub type XcmOriginToTransactDispatchOrigin = (622	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location623	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for624	// foreign chains who want to have a local sovereign account on this chain which they control.625	SovereignSignedViaLocation<LocationToAccountId, Origin>,626	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when627	// recognised.628	RelayChainAsNative<RelayOrigin, Origin>,629	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when630	// recognised.631	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,632	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a633	// transaction from the Root origin.634	ParentAsSuperuser<Origin>,635	// Native signed account converter; this just converts an `AccountId32` origin into a normal636	// `Origin::Signed` origin of the same 32-byte value.637	SignedAccountId32AsNative<RelayNetwork, Origin>,638	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.639	XcmPassthrough<Origin>,640);641642parameter_types! {643	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.644	pub UnitWeightCost: Weight = 1_000_000;645	// 1200 UNIQUEs buy 1 second of weight.646	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);647	pub const MaxInstructions: u32 = 100;648	pub const MaxAuthorities: u32 = 100_000;649}650651match_type! {652	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {653		MultiLocation { parents: 1, interior: Here } |654		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }655	};656}657658pub type Barrier = (659	TakeWeightCredit,660	AllowTopLevelPaidExecutionFrom<Everything>,661	AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,662	// ^^^ Parent & its unit plurality gets free execution663);664665pub struct UsingOnlySelfCurrencyComponents<666	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,667	AssetId: Get<MultiLocation>,668	AccountId,669	Currency: CurrencyT<AccountId>,670	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,671>(672	Weight,673	Currency::Balance,674	PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,675);676impl<677		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,678		AssetId: Get<MultiLocation>,679		AccountId,680		Currency: CurrencyT<AccountId>,681		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,682	> WeightTrader683	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>684{685	fn new() -> Self {686		Self(0, Zero::zero(), PhantomData)687	}688689	fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {690		let amount = WeightToFee::calc(&weight);691		let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;692693		// location to this parachain through relay chain694		let option1: xcm::v1::AssetId = Concrete(MultiLocation {695			parents: 1,696			interior: X1(Parachain(ParachainInfo::parachain_id().into())),697		});698		// direct location699		let option2: xcm::v1::AssetId = Concrete(MultiLocation {700			parents: 0,701			interior: Here,702		});703704		let required = if payment.fungible.contains_key(&option1) {705			(option1, u128_amount).into()706		} else if payment.fungible.contains_key(&option2) {707			(option2, u128_amount).into()708		} else {709			(Concrete(MultiLocation::default()), u128_amount).into()710		};711712		let unused = payment713			.checked_sub(required)714			.map_err(|_| XcmError::TooExpensive)?;715		self.0 = self.0.saturating_add(weight);716		self.1 = self.1.saturating_add(amount);717		Ok(unused)718	}719720	fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {721		let weight = weight.min(self.0);722		let amount = WeightToFee::calc(&weight);723		self.0 -= weight;724		self.1 = self.1.saturating_sub(amount);725		let amount: u128 = amount.saturated_into();726		if amount > 0 {727			Some((AssetId::get(), amount).into())728		} else {729			None730		}731	}732}733impl<734		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,735		AssetId: Get<MultiLocation>,736		AccountId,737		Currency: CurrencyT<AccountId>,738		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,739	> Drop740	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>741{742	fn drop(&mut self) {743		OnUnbalanced::on_unbalanced(Currency::issue(self.1));744	}745}746747pub struct XcmConfig;748impl Config for XcmConfig {749	type Call = Call;750	type XcmSender = XcmRouter;751	// How to withdraw and deposit an asset.752	type AssetTransactor = LocalAssetTransactor;753	type OriginConverter = XcmOriginToTransactDispatchOrigin;754	type IsReserve = NativeAsset;755	type IsTeleporter = (); // Teleportation is disabled756	type LocationInverter = LocationInverter<Ancestry>;757	type Barrier = Barrier;758	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;759	type Trader = UsingOnlySelfCurrencyComponents<760		IdentityFee<Balance>,761		RelayLocation,762		AccountId,763		Balances,764		(),765	>;766	type ResponseHandler = (); // Don't handle responses for now.767	type SubscriptionService = PolkadotXcm;768769	type AssetTrap = PolkadotXcm;770	type AssetClaims = PolkadotXcm;771}772773// parameter_types! {774// 	pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;775// }776777/// No local origins on this chain are allowed to dispatch XCM sends/executions.778pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);779780/// The means for routing XCM messages which are not for local execution into the right message781/// queues.782pub type XcmRouter = (783	// Two routers - use UMP to communicate with the relay chain:784	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,785	// ..and XCMP to communicate with the sibling chains.786	XcmpQueue,787);788789impl pallet_evm_coder_substrate::Config for Runtime {790	type EthereumTransactionSender = pallet_ethereum::Pallet<Self>;791	type GasWeightMapping = FixedGasWeightMapping;792}793794impl pallet_xcm::Config for Runtime {795	type Event = Event;796	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;797	type XcmRouter = XcmRouter;798	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;799	type XcmExecuteFilter = Everything;800	type XcmExecutor = XcmExecutor<XcmConfig>;801	type XcmTeleportFilter = Everything;802	type XcmReserveTransferFilter = Everything;803	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;804	type LocationInverter = LocationInverter<Ancestry>;805	type Origin = Origin;806	type Call = Call;807	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;808	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;809}810811impl cumulus_pallet_xcm::Config for Runtime {812	type Event = Event;813	type XcmExecutor = XcmExecutor<XcmConfig>;814}815816impl cumulus_pallet_xcmp_queue::Config for Runtime {817	type Event = Event;818	type XcmExecutor = XcmExecutor<XcmConfig>;819	type ChannelInfo = ParachainSystem;820	type VersionWrapper = ();821	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;822	type ControllerOrigin = EnsureRoot<AccountId>;823	type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;824}825826impl cumulus_pallet_dmp_queue::Config for Runtime {827	type Event = Event;828	type XcmExecutor = XcmExecutor<XcmConfig>;829	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;830}831832impl pallet_aura::Config for Runtime {833	type AuthorityId = AuraId;834	type DisabledValidators = ();835	type MaxAuthorities = MaxAuthorities;836}837838parameter_types! {839	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();840	pub const CollectionCreationPrice: Balance = 2 * UNIQUE;841}842843impl pallet_common::Config for Runtime {844	type Event = Event;845	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;846	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;847	type CrossAccountId = pallet_common::account::BasicCrossAccountId<Self>;848849	type Currency = Balances;850	type CollectionCreationPrice = CollectionCreationPrice;851	type TreasuryAccountId = TreasuryAccountId;852}853854impl pallet_fungible::Config for Runtime {855	type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;856}857impl pallet_refungible::Config for Runtime {858	type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;859}860impl pallet_nonfungible::Config for Runtime {861	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;862}863864impl pallet_unique::Config for Runtime {865	type Event = Event;866	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;867}868869parameter_types! {870	pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied871}872873/// Used for the pallet inflation874impl pallet_inflation::Config for Runtime {875	type Currency = Balances;876	type TreasuryAccountId = TreasuryAccountId;877	type InflationBlockInterval = InflationBlockInterval;878	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;879}880881parameter_types! {882	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *883		RuntimeBlockWeights::get().max_block;884	pub const MaxScheduledPerBlock: u32 = 50;885}886887parameter_types! {888	pub const NoPreimagePostponement: Option<u32> = Some(10);889	pub const Preimage: Option<u32> = Some(10);890}891892/// Used the compare the privilege of an origin inside the scheduler.893pub struct OriginPrivilegeCmp;894impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {895	fn cmp_privilege(_left: &OriginCaller, _right: &OriginCaller) -> Option<Ordering> {896		Some(Ordering::Equal)897	}898}899900impl pallet_unq_scheduler::Config for Runtime {901	type Event = Event;902	type Origin = Origin;903	type Currency = Balances;904	type PalletsOrigin = OriginCaller;905	type Call = Call;906	type MaximumWeight = MaximumSchedulerWeight;907	type ScheduleOrigin = EnsureSigned<AccountId>;908	type MaxScheduledPerBlock = MaxScheduledPerBlock;909	type WeightInfo = ();910	type CallExecutor = SchedulerPaymentExecutor;911	type OriginPrivilegeCmp = OriginPrivilegeCmp;912	type PreimageProvider = ();913	type NoPreimagePostponement = NoPreimagePostponement;914}915916type ChargeTransactionPayment = pallet_charge_transaction::ChargeTransactionPayment<Runtime>;917use frame_support::traits::NamedReservableCurrency;918919fn get_signed_extras(from: <Runtime as frame_system::Config>::AccountId) -> SignedExtra {920	(921		frame_system::CheckSpecVersion::<Runtime>::new(),922		frame_system::CheckGenesis::<Runtime>::new(),923		frame_system::CheckEra::<Runtime>::from(Era::Immortal),924		frame_system::CheckNonce::<Runtime>::from(frame_system::Pallet::<Runtime>::account_nonce(925			from,926		)),927		frame_system::CheckWeight::<Runtime>::new(),928		pallet_charge_transaction::ChargeTransactionPayment::<Runtime>::new(0),929	)930}931932pub struct SchedulerPaymentExecutor;933impl<T: frame_system::Config + pallet_unq_scheduler::Config, SelfContainedSignedInfo>934	DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor935where936	<T as frame_system::Config>::Call: Member937		+ Dispatchable<Origin = Origin, Info = DispatchInfo>938		+ SelfContainedCall<SignedInfo = SelfContainedSignedInfo>939		+ GetDispatchInfo940		+ From<frame_system::Call<Runtime>>,941	SelfContainedSignedInfo: Send + Sync + 'static,942	Call: From<<T as frame_system::Config>::Call>943		+ From<<T as pallet_unq_scheduler::Config>::Call>944		+ SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,945	sp_runtime::AccountId32: From<<T as frame_system::Config>::AccountId>,946{947	fn dispatch_call(948		signer: <T as frame_system::Config>::AccountId,949		call: <T as pallet_unq_scheduler::Config>::Call,950	) -> Result<951		Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,952		TransactionValidityError,953	> {954		let dispatch_info = call.get_dispatch_info();955		let extrinsic = fp_self_contained::CheckedExtrinsic::<956			AccountId,957			Call,958			SignedExtra,959			SelfContainedSignedInfo,960		> {961			signed: CheckedSignature::<AccountId, SignedExtra, SelfContainedSignedInfo>::Signed(962				signer.clone().into(),963				get_signed_extras(signer.into()),964			),965			function: call.into(),966		};967968		extrinsic.apply::<Runtime>(&dispatch_info, 0)969	}970971	fn reserve_balance(972		id: [u8; 16],973		sponsor: <T as frame_system::Config>::AccountId,974		call: <T as pallet_unq_scheduler::Config>::Call,975		count: u32,976	) -> Result<(), DispatchError> {977		let dispatch_info = call.get_dispatch_info();978		let fee_charger = ChargeTransactionPayment::new(0);979		let pre = match fee_charger.pre_dispatch(980			&sponsor.clone().into(),981			&call.into(),982			&dispatch_info,983			0,984		) {985			Ok(p) => p,986			Err(_) => fail!("failed to get pre dispatch info"),987		};988989		let count: u128 = count.into();990		let total_fee: u128 = pre.2.map(|imbalance| imbalance.peek()).unwrap() * count;991		<Balances as NamedReservableCurrency<AccountId>>::reserve_named(992			&id,993			&(sponsor.into()),994			total_fee,995		)996	}997998	fn pay_for_call(999		id: [u8; 16],1000		sponsor: <T as frame_system::Config>::AccountId,1001		call: <T as pallet_unq_scheduler::Config>::Call,1002	) -> Result<u128, DispatchError> {1003		let dispatch_info = call.get_dispatch_info();1004		let fee_charger = ChargeTransactionPayment::new(0);1005		let pre = match fee_charger.pre_dispatch(1006			&sponsor.clone().into(),1007			&call.into(),1008			&dispatch_info,1009			0,1010		) {1011			Ok(p) => p,1012			Err(_) => fail!("failed to get pre dispatch info"),1013		};10141015		let single_fee: u128 = pre.2.map(|imbalance| imbalance.peek()).unwrap();10161017		Ok(1018			<Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1019				&id,1020				&(sponsor.into()),1021				single_fee,1022			),1023		)1024	}10251026	fn cancel_reserve(1027		id: [u8; 16],1028		sponsor: <T as frame_system::Config>::AccountId,1029	) -> Result<u128, DispatchError> {1030		Ok(1031			<Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1032				&id,1033				&(sponsor.into()),1034				u128::MAX,1035			),1036		)1037	}1038}10391040type EvmSponsorshipHandler = (1041	pallet_unique::UniqueEthSponsorshipHandler<Runtime>,1042	pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,1043);1044type SponsorshipHandler = (1045	pallet_unique::UniqueSponsorshipHandler<Runtime>,1046	//pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1047	pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1048);10491050impl pallet_evm_transaction_payment::Config for Runtime {1051	type EvmSponsorshipHandler = EvmSponsorshipHandler;1052	type Currency = Balances;1053	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;1054	type EvmBackwardsAddressMapping = up_evm_mapping::MapBackwardsAddressTruncated;1055}10561057impl pallet_charge_transaction::Config for Runtime {1058	type SponsorshipHandler = SponsorshipHandler;1059}10601061// impl pallet_contract_helpers::Config for Runtime {1062//	 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1063// }10641065parameter_types! {1066	// 0x842899ECF380553E8a4de75bF534cdf6fBF640491067	pub const HelpersContractAddress: H160 = H160([1068		0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1069	]);1070}10711072impl pallet_evm_contract_helpers::Config for Runtime {1073	type ContractAddress = HelpersContractAddress;1074	type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1075}10761077construct_runtime!(1078	pub enum Runtime where1079		Block = Block,1080		NodeBlock = opaque::Block,1081		UncheckedExtrinsic = UncheckedExtrinsic1082	{1083		ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1084		ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,10851086		Aura: pallet_aura::{Pallet, Config<T>} = 22,1087		AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,10881089		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1090		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1091		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1092		TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1093		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1094		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1095		System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1096		Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1097		// Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1098		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,10991100		// XCM helpers.1101		XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1102		PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1103		CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1104		DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11051106		// Unique Pallets1107		Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1108		Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1109		Scheduler: pallet_unq_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1110		// free = 631111		Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1112		// ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1113		Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1114		Fungible: pallet_fungible::{Pallet, Storage} = 67,1115		Refungible: pallet_refungible::{Pallet, Storage} = 68,1116		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,11171118		// Frontier1119		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1120		Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11211122		EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1123		EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1124		EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1125		EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1126	}1127);11281129pub struct TransactionConverter;11301131impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1132	fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1133		UncheckedExtrinsic::new_unsigned(1134			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1135		)1136	}1137}11381139impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1140	fn convert_transaction(1141		&self,1142		transaction: pallet_ethereum::Transaction,1143	) -> opaque::UncheckedExtrinsic {1144		let extrinsic = UncheckedExtrinsic::new_unsigned(1145			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1146		);1147		let encoded = extrinsic.encode();1148		opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1149			.expect("Encoded extrinsic is always valid")1150	}1151}11521153/// The address format for describing accounts.1154pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1155/// Block header type as expected by this runtime.1156pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1157/// Block type as expected by this runtime.1158pub type Block = generic::Block<Header, UncheckedExtrinsic>;1159/// A Block signed with a Justification1160pub type SignedBlock = generic::SignedBlock<Block>;1161/// BlockId type as expected by this runtime.1162pub type BlockId = generic::BlockId<Block>;1163/// The SignedExtension to the basic transaction logic.1164pub type SignedExtra = (1165	frame_system::CheckSpecVersion<Runtime>,1166	// system::CheckTxVersion<Runtime>,1167	frame_system::CheckGenesis<Runtime>,1168	frame_system::CheckEra<Runtime>,1169	frame_system::CheckNonce<Runtime>,1170	frame_system::CheckWeight<Runtime>,1171	pallet_charge_transaction::ChargeTransactionPayment<Runtime>,1172	//pallet_contract_helpers::ContractHelpersExtension<Runtime>,1173);1174/// Unchecked extrinsic type as expected by this runtime.1175pub type UncheckedExtrinsic =1176	fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1177/// Extrinsic type that has already been checked.1178pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1179/// Executive: handles dispatch to the various modules.1180pub type Executive = frame_executive::Executive<1181	Runtime,1182	Block,1183	frame_system::ChainContext<Runtime>,1184	Runtime,1185	AllPalletsReversedWithSystemFirst,1186>;11871188impl_opaque_keys! {1189	pub struct SessionKeys {1190		pub aura: Aura,1191	}1192}11931194impl fp_self_contained::SelfContainedCall for Call {1195	type SignedInfo = H160;11961197	fn is_self_contained(&self) -> bool {1198		match self {1199			Call::Ethereum(call) => call.is_self_contained(),1200			_ => false,1201		}1202	}12031204	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1205		match self {1206			Call::Ethereum(call) => call.check_self_contained(),1207			_ => None,1208		}1209	}12101211	fn validate_self_contained(&self, info: &Self::SignedInfo) -> Option<TransactionValidity> {1212		match self {1213			Call::Ethereum(call) => call.validate_self_contained(info),1214			_ => None,1215		}1216	}12171218	fn pre_dispatch_self_contained(1219		&self,1220		info: &Self::SignedInfo,1221	) -> Option<Result<(), TransactionValidityError>> {1222		match self {1223			Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1224			_ => None,1225		}1226	}12271228	fn apply_self_contained(1229		self,1230		info: Self::SignedInfo,1231	) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1232		match self {1233			call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1234				Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1235			)),1236			_ => None,1237		}1238	}1239}12401241macro_rules! dispatch_unique_runtime {1242	($collection:ident.$method:ident($($name:ident),*)) => {{1243		use pallet_unique::dispatch::Dispatched;12441245		let collection = Dispatched::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1246		let dispatch = collection.as_dyn();12471248		Ok(dispatch.$method($($name),*))1249	}};1250}12511252impl_common_runtime_apis!();12531254struct CheckInherents;12551256impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1257	fn check_inherents(1258		block: &Block,1259		relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1260	) -> sp_inherents::CheckInherentsResult {1261		let relay_chain_slot = relay_state_proof1262			.read_slot()1263			.expect("Could not read the relay chain slot from the proof");12641265		let inherent_data =1266			cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1267				relay_chain_slot,1268				sp_std::time::Duration::from_secs(6),1269			)1270			.create_inherent_data()1271			.expect("Could not create the timestamp inherent data");12721273		inherent_data.check_extrinsics(block)1274	}1275}12761277cumulus_pallet_parachain_system::register_validate_block!(1278	Runtime = Runtime,1279	BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1280	CheckInherents = CheckInherents,1281);