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

25#[cfg(feature = "std")]25#[cfg(feature = "std")]
26include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));26include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
2727
28use sp_api::impl_runtime_apis;28use frame_support::parameter_types;
29
29use sp_core::{crypto::KeyTypeId, OpaqueMetadata, H256, U256, H160};30use sp_version::RuntimeVersion;
30use sp_runtime::DispatchError;
31#[cfg(feature = "scheduler")]
32use fp_self_contained::*;
33
34#[cfg(feature = "scheduler")]
35use sp_runtime::{
36	traits::{Applyable, Member},
37	generic::Era,
38	DispatchErrorWithPostInfo,
39};
40// #[cfg(any(feature = "std", test))]
41// pub use sp_runtime::BuildStorage;
42
43use sp_runtime::{31use sp_runtime::create_runtime_str;
44	Permill, Perbill, Percent, create_runtime_str, generic, impl_opaque_keys,
45	traits::{AccountIdLookup, BlakeTwo256, Block as BlockT, AccountIdConversion, Zero},
46	transaction_validity::{TransactionSource, TransactionValidity},
47	ApplyExtrinsicResult, RuntimeAppPublic,
48};
4932
50use sp_std::prelude::*;33use common_types::*;
51
52#[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::{
61	EnsureAddressTruncated, HashedAddressMapping, Runner, account::CrossAccountId as _,
62	OnMethodCall, Account as EVMAccount, FeeCalculator, GasWeightMapping,
63};
64pub use frame_support::{
65	match_types,
66	dispatch::DispatchResult,
67	PalletId, parameter_types, StorageValue, ConsensusEngineId,
68	traits::{
69		tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Everything,
70		Currency, ExistenceRequirement, Get, IsInVec, KeyOwnerProofSystem, LockIdentifier,
71		OnUnbalanced, Randomness, FindAuthor, ConstU32, Imbalance, PrivilegeCmp,
72	},
73	weights::{
74		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},
75		DispatchClass, DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,
76		WeightToFeePolynomial, WeightToFeeCoefficient, WeightToFeeCoefficients, ConstantMultiplier,
77		WeightToFee,
78	},
79};
8034
81#[cfg(feature = "scheduler")]35#[path = "../../common/mod.rs"]
82use pallet_unique_scheduler::DispatchCall;36mod runtime_common;
8337
84use up_data_structs::{
85	CollectionId, TokenId, TokenData, Property, PropertyKeyPermission, CollectionLimits,
86	CollectionStats, RpcCollection,
87	mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},
88	TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,
89	RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkCollectionId, RmrkNftId,
90	RmrkNftChild, RmrkPropertyKey, RmrkResourceId, RmrkBaseId,
91};
92
93// use pallet_contracts::weights::WeightInfo;
94// #[cfg(any(feature = "std", test))]
95use frame_system::{
96	self as frame_system, EnsureRoot, EnsureSigned,
97	limits::{BlockWeights, BlockLength},
98};
99use sp_arithmetic::{
100	traits::{BaseArithmetic, Unsigned},
101};
102use smallvec::smallvec;
103use codec::{Encode, Decode};
104use fp_rpc::TransactionStatus;
105use sp_runtime::{
106	traits::{
107		BlockNumberProvider, Dispatchable, PostDispatchInfoOf, DispatchInfoOf, Saturating,
108		CheckedConversion,
109	},
110	transaction_validity::TransactionValidityError,
111	SaturatedConversion,
112};
113
114// pub use pallet_timestamp::Call as TimestampCall;
115pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;38pub use runtime_common::*;
116
117// Polkadot imports
118use pallet_xcm::XcmPassthrough;
119use polkadot_parachain::primitives::Sibling;
120use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};
121use xcm_builder::{
122	AccountId32Aliases, AllowTopLevelPaidExecutionFrom, CurrencyAdapter, EnsureXcmOrigin,
123	FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser, RelayChainAsNative,
124	SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative,
125	SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, ParentIsPreset,
126};
127use xcm_executor::{Config, XcmExecutor, Assets};
128use sp_std::{cmp::Ordering, marker::PhantomData};
129
130use xcm::latest::{
131	//	Xcm,
132	AssetId::{Concrete},
133	Fungibility::Fungible as XcmFungible,
134	MultiAsset,
135	Error as XcmError,
136};
137use xcm_executor::traits::{MatchesFungible, WeightTrader};
138
139use unique_runtime_common::{
140	construct_runtime, impl_common_runtime_apis,
141	types::*,
142	constants::*,
143	dispatch::{CollectionDispatchT, CollectionDispatch},
144	sponsoring::UniqueSponsorshipHandler,
145	eth_sponsoring::UniqueEthSponsorshipHandler,
146	weights::CommonWeights,
147};
14839
149pub const RUNTIME_NAME: &str = "quartz";40pub const RUNTIME_NAME: &str = "quartz";
150pub const TOKEN_SYMBOL: &str = "QTZ";41pub const TOKEN_SYMBOL: &str = "QTZ";
151
152type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;
153
154impl RuntimeInstance for Runtime {
155	type CrossAccountId = self::CrossAccountId;
156
157	type TransactionConverter = self::TransactionConverter;
158
159	fn get_transaction_converter() -> TransactionConverter {
160		TransactionConverter
161	}
162}
163
164/// The type for looking up accounts. We don't expect more than 4 billion of them, but you
165/// never know...
166pub type AccountIndex = u32;
167
168/// Balance of an account.
169pub type Balance = u128;
170
171/// Index of a transaction in the chain.
172pub type Index = u32;
173
174/// A hash of some data used by the chain.
175pub type Hash = sp_core::H256;
176
177/// Digest item type.
178pub type DigestItem = generic::DigestItem;
179
180/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
181/// the specifics of the runtime. They can then be made to be agnostic over specific formats
182/// of data like extrinsics, allowing for them to continue syncing the network through upgrades
183/// to even the core data structures.
184pub mod opaque {
185	use sp_std::prelude::*;
186	use sp_runtime::impl_opaque_keys;
187	use super::Aura;
188
189	pub use unique_runtime_common::types::*;
190
191	impl_opaque_keys! {
192		pub struct SessionKeys {
193			pub aura: Aura,
194		}
195	}
196}
19742
198/// This runtime version.43/// This runtime version.
199pub const VERSION: RuntimeVersion = RuntimeVersion {44pub const VERSION: RuntimeVersion = RuntimeVersion {
207	state_version: 0,52	state_version: 0,
208};53};
209
210#[derive(codec::Encode, codec::Decode)]
211pub enum XCMPMessage<XAccountId, XBalance> {
212	/// Transfer tokens to the given account from the Parachain account.
213	TransferToken(XAccountId, XBalance),
214}
215
216/// The version information used to identify this runtime when compiled natively.
217#[cfg(feature = "std")]
218pub fn native_version() -> NativeVersion {
219	NativeVersion {
220		runtime_version: VERSION,
221		can_author_with: Default::default(),
222	}
223}
224
225type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;
226
227pub struct DealWithFees;
228impl OnUnbalanced<NegativeImbalance> for DealWithFees {
229	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {
230		if let Some(fees) = fees_then_tips.next() {
231			// for fees, 100% to treasury
232			let mut split = fees.ration(100, 0);
233			if let Some(tips) = fees_then_tips.next() {
234				// for tips, if any, 100% to treasury
235				tips.ration_merge_into(100, 0, &mut split);
236			}
237			Treasury::on_unbalanced(split.0);
238			// Author::on_unbalanced(split.1);
239		}
240	}
241}
24254
243parameter_types! {55parameter_types! {
244	pub const BlockHashCount: BlockNumber = 2400;
245	pub RuntimeBlockLength: BlockLength =
246		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
247	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);
248	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;
249	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()
250		.base_block(BlockExecutionWeight::get())
251		.for_class(DispatchClass::all(), |weights| {
252			weights.base_extrinsic = ExtrinsicBaseWeight::get();
253		})
254		.for_class(DispatchClass::Normal, |weights| {
255			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
256		})
257		.for_class(DispatchClass::Operational, |weights| {
258			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);
259			// Operational transactions have some extra reserved space, so that they
260			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.
261			weights.reserved = Some(
262				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT
263			);
264		})
265		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)
266		.build_or_panic();
267	pub const Version: RuntimeVersion = VERSION;56	pub const Version: RuntimeVersion = VERSION;
268	pub const SS58Prefix: u8 = 255;57	pub const SS58Prefix: u8 = 255;
269}
270
271parameter_types! {
272	pub const ChainId: u64 = 8881;58	pub const ChainId: u64 = 8881;
273}59}
274
275pub struct FixedFee;
276impl FeeCalculator for FixedFee {
277	fn min_gas_price() -> (U256, u64) {
278		(MIN_GAS_PRICE.into(), 0)
279	}
280}
281
282// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case
283// (contract, which only writes a lot of data),
284// approximating on top of our real store write weight
285parameter_types! {
286	pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;
287	pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;
288	pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();
289}
290
291/// Limiting EVM execution to 50% of block for substrate users and management tasks
292/// EVM transaction consumes more weight than substrate's, so we can't rely on them being
293/// scheduled fairly
294const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);
295parameter_types! {
296	pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());
297}
298
299pub enum FixedGasWeightMapping {}
300impl GasWeightMapping for FixedGasWeightMapping {
301	fn gas_to_weight(gas: u64) -> Weight {
302		gas.saturating_mul(WeightPerGas::get())
303	}
304	fn weight_to_gas(weight: Weight) -> u64 {
305		weight / WeightPerGas::get()
306	}
307}
308
309impl pallet_evm::account::Config for Runtime {
310	type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Self>;
311	type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;
312	type EvmBackwardsAddressMapping = fp_evm_mapping::MapBackwardsAddressTruncated;
313}
314
315impl pallet_evm::Config for Runtime {
316	type BlockGasLimit = BlockGasLimit;
317	type FeeCalculator = FixedFee;
318	type GasWeightMapping = FixedGasWeightMapping;
319	type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;
320	type CallOrigin = EnsureAddressTruncated<Self>;
321	type WithdrawOrigin = EnsureAddressTruncated<Self>;
322	type AddressMapping = HashedAddressMapping<Self::Hashing>;
323	type PrecompilesType = ();
324	type PrecompilesValue = ();
325	type Currency = Balances;
326	type Event = Event;
327	type OnMethodCall = (
328		pallet_evm_migration::OnMethodCall<Self>,
329		pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,
330		CollectionDispatchT<Self>,
331		pallet_unique::eth::CollectionHelpersOnMethodCall<Self>,
332	);
333	type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;
334	type ChainId = ChainId;
335	type Runner = pallet_evm::runner::stack::Runner<Self>;
336	type OnChargeTransaction = pallet_evm::EVMCurrencyAdapter<Balances, DealWithFees>;
337	type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;
338	type FindAuthor = EthereumFindAuthor<Aura>;
339}
340
341impl pallet_evm_migration::Config for Runtime {
342	type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;
343}
344
345pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);
346impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {
347	fn find_author<'a, I>(digests: I) -> Option<H160>
348	where
349		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
350	{
351		if let Some(author_index) = F::find_author(digests) {
352			let authority_id = Aura::authorities()[author_index as usize].clone();
353			return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));
354		}
355		None
356	}
357}
358
359impl pallet_ethereum::Config for Runtime {
360	type Event = Event;
361	type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;
362}
363
364impl pallet_randomness_collective_flip::Config for Runtime {}
365
366impl frame_system::Config for Runtime {
367	/// The data to be stored in an account.
368	type AccountData = pallet_balances::AccountData<Balance>;
369	/// The identifier used to distinguish between accounts.
370	type AccountId = AccountId;
371	/// The basic call filter to use in dispatchable.
372	type BaseCallFilter = Everything;
373	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
374	type BlockHashCount = BlockHashCount;
375	/// The maximum length of a block (in bytes).
376	type BlockLength = RuntimeBlockLength;
377	/// The index type for blocks.
378	type BlockNumber = BlockNumber;
379	/// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.
380	type BlockWeights = RuntimeBlockWeights;
381	/// The aggregated dispatch type that is available for extrinsics.
382	type Call = Call;
383	/// The weight of database operations that the runtime can invoke.
384	type DbWeight = RocksDbWeight;
385	/// The ubiquitous event type.
386	type Event = Event;
387	/// The type for hashing blocks and tries.
388	type Hash = Hash;
389	/// The hashing algorithm used.
390	type Hashing = BlakeTwo256;
391	/// The header type.
392	type Header = generic::Header<BlockNumber, BlakeTwo256>;
393	/// The index type for storing how many extrinsics an account has signed.
394	type Index = Index;
395	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.
396	type Lookup = AccountIdLookup<AccountId, ()>;
397	/// What to do if an account is fully reaped from the system.
398	type OnKilledAccount = ();
399	/// What to do if a new account is created.
400	type OnNewAccount = ();
401	type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;
402	/// The ubiquitous origin type.
403	type Origin = Origin;
404	/// This type is being generated by `construct_runtime!`.
405	type PalletInfo = PalletInfo;
406	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.
407	type SS58Prefix = SS58Prefix;
408	/// Weight information for the extrinsics of this pallet.
409	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;
410	/// Version of the runtime.
411	type Version = Version;
412	type MaxConsumers = ConstU32<16>;
413}
414
415parameter_types! {
416	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;
417}
418
419impl pallet_timestamp::Config for Runtime {
420	/// A timestamp: milliseconds since the unix epoch.
421	type Moment = u64;
422	type OnTimestampSet = ();
423	type MinimumPeriod = MinimumPeriod;
424	type WeightInfo = ();
425}
426
427parameter_types! {
428	// pub const ExistentialDeposit: u128 = 500;
429	pub const ExistentialDeposit: u128 = 0;
430	pub const MaxLocks: u32 = 50;
431	pub const MaxReserves: u32 = 50;
432}
433
434impl pallet_balances::Config for Runtime {
435	type MaxLocks = MaxLocks;
436	type MaxReserves = MaxReserves;
437	type ReserveIdentifier = [u8; 16];
438	/// The type for recording an account's balance.
439	type Balance = Balance;
440	/// The ubiquitous event type.
441	type Event = Event;
442	type DustRemoval = Treasury;
443	type ExistentialDeposit = ExistentialDeposit;
444	type AccountStore = System;
445	type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;
446}
447
448pub const fn deposit(items: u32, bytes: u32) -> Balance {
449	items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE
450}
451
452/*
453parameter_types! {
454	pub TombstoneDeposit: Balance = deposit(
455		1,
456		sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,
457	);
458	pub DepositPerContract: Balance = TombstoneDeposit::get();
459	pub const DepositPerStorageByte: Balance = deposit(0, 1);
460	pub const DepositPerStorageItem: Balance = deposit(1, 0);
461	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);
462	pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;
463	pub const SignedClaimHandicap: u32 = 2;
464	pub const MaxDepth: u32 = 32;
465	pub const MaxValueSize: u32 = 16 * 1024;
466	pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb
467	// The lazy deletion runs inside on_initialize.
468	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *
469		RuntimeBlockWeights::get().max_block;
470	// The weight needed for decoding the queue should be less or equal than a fifth
471	// of the overall weight dedicated to the lazy deletion.
472	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (
473			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -
474			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)
475		)) / 5) as u32;
476	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();
477}
478
479impl pallet_contracts::Config for Runtime {
480	type Time = Timestamp;
481	type Randomness = RandomnessCollectiveFlip;
482	type Currency = Balances;
483	type Event = Event;
484	type RentPayment = ();
485	type SignedClaimHandicap = SignedClaimHandicap;
486	type TombstoneDeposit = TombstoneDeposit;
487	type DepositPerContract = DepositPerContract;
488	type DepositPerStorageByte = DepositPerStorageByte;
489	type DepositPerStorageItem = DepositPerStorageItem;
490	type RentFraction = RentFraction;
491	type SurchargeReward = SurchargeReward;
492	type WeightPrice = pallet_transaction_payment::Pallet<Self>;
493	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;
494	type ChainExtension = NFTExtension;
495	type DeletionQueueDepth = DeletionQueueDepth;
496	type DeletionWeightLimit = DeletionWeightLimit;
497	type Schedule = Schedule;
498	type CallStack = [pallet_contracts::Frame<Self>; 31];
499}
500*/
501
502parameter_types! {
503	/// This value increases the priority of `Operational` transactions by adding
504	/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.
505	pub const OperationalFeeMultiplier: u8 = 5;
506}
507
508/// Linear implementor of `WeightToFeePolynomial`
509pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);
510
511impl<T> WeightToFeePolynomial for LinearFee<T>
512where
513	T: BaseArithmetic + From<u32> + Copy + Unsigned,
514{
515	type Balance = T;
516
517	fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {
518		smallvec!(WeightToFeeCoefficient {
519			coeff_integer: WEIGHT_TO_FEE_COEFF.into(),
520			coeff_frac: Perbill::zero(),
521			negative: false,
522			degree: 1,
523		})
524	}
525}
526
527impl pallet_transaction_payment::Config for Runtime {
528	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;
529	type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;
530	type OperationalFeeMultiplier = OperationalFeeMultiplier;
531	type WeightToFee = LinearFee<Balance>;
532	type FeeMultiplierUpdate = ();
533}
534
535parameter_types! {
536	pub const ProposalBond: Permill = Permill::from_percent(5);
537	pub const ProposalBondMinimum: Balance = 1 * UNIQUE;
538	pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;
539	pub const SpendPeriod: BlockNumber = 5 * MINUTES;
540	pub const Burn: Permill = Permill::from_percent(0);
541	pub const TipCountdown: BlockNumber = 1 * DAYS;
542	pub const TipFindersFee: Percent = Percent::from_percent(20);
543	pub const TipReportDepositBase: Balance = 1 * UNIQUE;
544	pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;
545	pub const BountyDepositBase: Balance = 1 * UNIQUE;
546	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;
547	pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");
548	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;
549	pub const MaximumReasonLength: u32 = 16384;
550	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);
551	pub const BountyValueMinimum: Balance = 5 * UNIQUE;
552	pub const MaxApprovals: u32 = 100;
553}
554
555impl pallet_treasury::Config for Runtime {
556	type PalletId = TreasuryModuleId;
557	type Currency = Balances;
558	type ApproveOrigin = EnsureRoot<AccountId>;
559	type RejectOrigin = EnsureRoot<AccountId>;
560	type Event = Event;
561	type OnSlash = ();
562	type ProposalBond = ProposalBond;
563	type ProposalBondMinimum = ProposalBondMinimum;
564	type ProposalBondMaximum = ProposalBondMaximum;
565	type SpendPeriod = SpendPeriod;
566	type Burn = Burn;
567	type BurnDestination = ();
568	type SpendFunds = ();
569	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;
570	type MaxApprovals = MaxApprovals;
571}
572
573impl pallet_sudo::Config for Runtime {
574	type Event = Event;
575	type Call = Call;
576}
577
578pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);
579
580impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider
581	for RelayChainBlockNumberProvider<T>
582{
583	type BlockNumber = BlockNumber;
584
585	fn current_block_number() -> Self::BlockNumber {
586		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()
587			.map(|d| d.relay_parent_number)
588			.unwrap_or_default()
589	}
590}
591
592parameter_types! {
593	pub const MinVestedTransfer: Balance = 10 * UNIQUE;
594	pub const MaxVestingSchedules: u32 = 28;
595}
596
597impl orml_vesting::Config for Runtime {
598	type Event = Event;
599	type Currency = pallet_balances::Pallet<Runtime>;
600	type MinVestedTransfer = MinVestedTransfer;
601	type VestedTransferOrigin = EnsureSigned<AccountId>;
602	type WeightInfo = ();
603	type MaxVestingSchedules = MaxVestingSchedules;
604	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;
605}
606
607parameter_types! {
608	pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;
609	pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;
610}
611
612impl cumulus_pallet_parachain_system::Config for Runtime {
613	type Event = Event;
614	type SelfParaId = parachain_info::Pallet<Self>;
615	type OnSystemEvent = ();
616	// type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<
617	// 	MaxDownwardMessageWeight,
618	// 	XcmExecutor<XcmConfig>,
619	// 	Call,
620	// >;
621	type OutboundXcmpMessageSource = XcmpQueue;
622	type DmpMessageHandler = DmpQueue;
623	type ReservedDmpWeight = ReservedDmpWeight;
624	type ReservedXcmpWeight = ReservedXcmpWeight;
625	type XcmpMessageHandler = XcmpQueue;
626}
627
628impl parachain_info::Config for Runtime {}
629
630impl cumulus_pallet_aura_ext::Config for Runtime {}
631
632parameter_types! {
633	pub const RelayLocation: MultiLocation = MultiLocation::parent();
634	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;
635	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();
636	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();
637}
638
639/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used
640/// when determining ownership of accounts for asset transacting and when attempting to use XCM
641/// `Transact` in order to determine the dispatch Origin.
642pub type LocationToAccountId = (
643	// The parent (Relay-chain) origin converts to the default `AccountId`.
644	ParentIsPreset<AccountId>,
645	// Sibling parachain origins convert to AccountId via the `ParaId::into`.
646	SiblingParachainConvertsVia<Sibling, AccountId>,
647	// Straight up local `AccountId32` origins just alias directly to `AccountId`.
648	AccountId32Aliases<RelayNetwork, AccountId>,
649);
650
651pub struct OnlySelfCurrency;
652impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {
653	fn matches_fungible(a: &MultiAsset) -> Option<B> {
654		match (&a.id, &a.fun) {
655			(Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),
656			_ => None,
657		}
658	}
659}
660
661/// Means for transacting assets on this chain.
662pub type LocalAssetTransactor = CurrencyAdapter<
663	// Use this currency:
664	Balances,
665	// Use this currency when it is a fungible asset matching the given location or name:
666	OnlySelfCurrency,
667	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:
668	LocationToAccountId,
669	// Our chain's account ID type (we can't get away without mentioning it explicitly):
670	AccountId,
671	// We don't track any teleports.
672	(),
673>;
674
675/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,
676/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can
677/// biases the kind of local `Origin` it will become.
678pub type XcmOriginToTransactDispatchOrigin = (
679	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location
680	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for
681	// foreign chains who want to have a local sovereign account on this chain which they control.
682	SovereignSignedViaLocation<LocationToAccountId, Origin>,
683	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when
684	// recognised.
685	RelayChainAsNative<RelayOrigin, Origin>,
686	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when
687	// recognised.
688	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,
689	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a
690	// transaction from the Root origin.
691	ParentAsSuperuser<Origin>,
692	// Native signed account converter; this just converts an `AccountId32` origin into a normal
693	// `Origin::Signed` origin of the same 32-byte value.
694	SignedAccountId32AsNative<RelayNetwork, Origin>,
695	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.
696	XcmPassthrough<Origin>,
697);
698
699parameter_types! {
700	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.
701	pub UnitWeightCost: Weight = 1_000_000;
702	// 1200 UNIQUEs buy 1 second of weight.
703	pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);
704	pub const MaxInstructions: u32 = 100;
705	pub const MaxAuthorities: u32 = 100_000;
706}
707
708match_types! {
709	pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {
710		MultiLocation { parents: 1, interior: Here } |
711		MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }
712	};
713}
714
715pub type Barrier = (
716	TakeWeightCredit,
717	AllowTopLevelPaidExecutionFrom<Everything>,
718	// ^^^ Parent & its unit plurality gets free execution
719);
720
721pub struct UsingOnlySelfCurrencyComponents<
722	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
723	AssetId: Get<MultiLocation>,
724	AccountId,
725	Currency: CurrencyT<AccountId>,
726	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
727>(
728	Weight,
729	Currency::Balance,
730	PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,
731);
732impl<
733		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
734		AssetId: Get<MultiLocation>,
735		AccountId,
736		Currency: CurrencyT<AccountId>,
737		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
738	> WeightTrader
739	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>
740{
741	fn new() -> Self {
742		Self(0, Zero::zero(), PhantomData)
743	}
744
745	fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {
746		let amount = WeightToFee::weight_to_fee(&weight);
747		let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;
748
749		// location to this parachain through relay chain
750		let option1: xcm::v1::AssetId = Concrete(MultiLocation {
751			parents: 1,
752			interior: X1(Parachain(ParachainInfo::parachain_id().into())),
753		});
754		// direct location
755		let option2: xcm::v1::AssetId = Concrete(MultiLocation {
756			parents: 0,
757			interior: Here,
758		});
759
760		let required = if payment.fungible.contains_key(&option1) {
761			(option1, u128_amount).into()
762		} else if payment.fungible.contains_key(&option2) {
763			(option2, u128_amount).into()
764		} else {
765			(Concrete(MultiLocation::default()), u128_amount).into()
766		};
767
768		let unused = payment
769			.checked_sub(required)
770			.map_err(|_| XcmError::TooExpensive)?;
771		self.0 = self.0.saturating_add(weight);
772		self.1 = self.1.saturating_add(amount);
773		Ok(unused)
774	}
775
776	fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {
777		let weight = weight.min(self.0);
778		let amount = WeightToFee::weight_to_fee(&weight);
779		self.0 -= weight;
780		self.1 = self.1.saturating_sub(amount);
781		let amount: u128 = amount.saturated_into();
782		if amount > 0 {
783			Some((AssetId::get(), amount).into())
784		} else {
785			None
786		}
787	}
788}
789impl<
790		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
791		AssetId: Get<MultiLocation>,
792		AccountId,
793		Currency: CurrencyT<AccountId>,
794		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
795	> Drop
796	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>
797{
798	fn drop(&mut self) {
799		OnUnbalanced::on_unbalanced(Currency::issue(self.1));
800	}
801}
802
803pub struct XcmConfig;
804impl Config for XcmConfig {
805	type Call = Call;
806	type XcmSender = XcmRouter;
807	// How to withdraw and deposit an asset.
808	type AssetTransactor = LocalAssetTransactor;
809	type OriginConverter = XcmOriginToTransactDispatchOrigin;
810	type IsReserve = NativeAsset;
811	type IsTeleporter = (); // Teleportation is disabled
812	type LocationInverter = LocationInverter<Ancestry>;
813	type Barrier = Barrier;
814	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
815	type Trader =
816		UsingOnlySelfCurrencyComponents<LinearFee<Balance>, RelayLocation, AccountId, Balances, ()>;
817	type ResponseHandler = (); // Don't handle responses for now.
818	type SubscriptionService = PolkadotXcm;
819
820	type AssetTrap = PolkadotXcm;
821	type AssetClaims = PolkadotXcm;
822}
823
824// parameter_types! {
825// 	pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;
826// }
827
828/// No local origins on this chain are allowed to dispatch XCM sends/executions.
829pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);
830
831/// The means for routing XCM messages which are not for local execution into the right message
832/// queues.
833pub type XcmRouter = (
834	// Two routers - use UMP to communicate with the relay chain:
835	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,
836	// ..and XCMP to communicate with the sibling chains.
837	XcmpQueue,
838);
839
840impl pallet_evm_coder_substrate::Config for Runtime {}
841
842impl pallet_xcm::Config for Runtime {
843	type Event = Event;
844	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;
845	type XcmRouter = XcmRouter;
846	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;
847	type XcmExecuteFilter = Everything;
848	type XcmExecutor = XcmExecutor<XcmConfig>;
849	type XcmTeleportFilter = Everything;
850	type XcmReserveTransferFilter = Everything;
851	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
852	type LocationInverter = LocationInverter<Ancestry>;
853	type Origin = Origin;
854	type Call = Call;
855	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
856	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
857}
858
859impl cumulus_pallet_xcm::Config for Runtime {
860	type Event = Event;
861	type XcmExecutor = XcmExecutor<XcmConfig>;
862}
863
864impl cumulus_pallet_xcmp_queue::Config for Runtime {
865	type WeightInfo = ();
866	type Event = Event;
867	type XcmExecutor = XcmExecutor<XcmConfig>;
868	type ChannelInfo = ParachainSystem;
869	type VersionWrapper = ();
870	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;
871	type ControllerOrigin = EnsureRoot<AccountId>;
872	type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;
873}
874
875impl cumulus_pallet_dmp_queue::Config for Runtime {
876	type Event = Event;
877	type XcmExecutor = XcmExecutor<XcmConfig>;
878	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;
879}
880
881impl pallet_aura::Config for Runtime {
882	type AuthorityId = AuraId;
883	type DisabledValidators = ();
884	type MaxAuthorities = MaxAuthorities;
885}
886
887parameter_types! {
888	pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account_truncating();
889	pub const CollectionCreationPrice: Balance = 2 * UNIQUE;
890}
891
892impl pallet_common::Config for Runtime {
893	type WeightInfo = pallet_common::weights::SubstrateWeight<Self>;
894	type Event = Event;
895	type Currency = Balances;
896	type CollectionCreationPrice = CollectionCreationPrice;
897	type TreasuryAccountId = TreasuryAccountId;
898	type CollectionDispatch = CollectionDispatchT<Self>;
899
900	type EvmTokenAddressMapping = EvmTokenAddressMapping;
901	type CrossTokenAddressMapping = CrossTokenAddressMapping<Self::AccountId>;
902	type ContractAddress = EvmCollectionHelpersAddress;
903}
904
905impl pallet_structure::Config for Runtime {
906	type Event = Event;
907	type Call = Call;
908	type WeightInfo = pallet_structure::weights::SubstrateWeight<Self>;
909}
910
911impl pallet_fungible::Config for Runtime {
912	type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;
913}
914impl pallet_refungible::Config for Runtime {
915	type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;
916}
917impl pallet_nonfungible::Config for Runtime {
918	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;
919}
920
921#[cfg(feature = "rmrk")]
922impl pallet_proxy_rmrk_core::Config for Runtime {
923	type WeightInfo = pallet_proxy_rmrk_core::weights::SubstrateWeight<Self>;
924	type Event = Event;
925}
926
927#[cfg(feature = "rmrk")]
928impl pallet_proxy_rmrk_equip::Config for Runtime {
929	type WeightInfo = pallet_proxy_rmrk_equip::weights::SubstrateWeight<Self>;
930	type Event = Event;
931}
932
933impl pallet_unique::Config for Runtime {
934	type Event = Event;
935	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;
936	type CommonWeightInfo = CommonWeights<Self>;
937	type RefungibleExtensionsWeightInfo = CommonWeights<Self>;
938}
939
940parameter_types! {
941	pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied
942}
943
944/// Used for the pallet inflation
945impl pallet_inflation::Config for Runtime {
946	type Currency = Balances;
947	type TreasuryAccountId = TreasuryAccountId;
948	type InflationBlockInterval = InflationBlockInterval;
949	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;
950}
951
952parameter_types! {
953	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *
954		RuntimeBlockWeights::get().max_block;
955	pub const MaxScheduledPerBlock: u32 = 50;
956}
957
958type ChargeTransactionPayment = pallet_charge_transaction::ChargeTransactionPayment<Runtime>;
959
960#[cfg(feature = "scheduler")]
961use frame_support::traits::NamedReservableCurrency;
962
963#[cfg(feature = "scheduler")]
964fn get_signed_extras(from: <Runtime as frame_system::Config>::AccountId) -> SignedExtraScheduler {
965	(
966		frame_system::CheckSpecVersion::<Runtime>::new(),
967		frame_system::CheckGenesis::<Runtime>::new(),
968		frame_system::CheckEra::<Runtime>::from(Era::Immortal),
969		frame_system::CheckNonce::<Runtime>::from(frame_system::Pallet::<Runtime>::account_nonce(
970			from,
971		)),
972		frame_system::CheckWeight::<Runtime>::new(),
973		// sponsoring transaction logic
974		// pallet_charge_transaction::ChargeTransactionPayment::<Runtime>::new(0),
975	)
976}
977
978#[cfg(feature = "scheduler")]
979pub struct SchedulerPaymentExecutor;
980
981#[cfg(feature = "scheduler")]
982impl<T: frame_system::Config + pallet_unique_scheduler::Config, SelfContainedSignedInfo>
983	DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor
984where
985	<T as frame_system::Config>::Call: Member
986		+ Dispatchable<Origin = Origin, Info = DispatchInfo>
987		+ SelfContainedCall<SignedInfo = SelfContainedSignedInfo>
988		+ GetDispatchInfo
989		+ From<frame_system::Call<Runtime>>,
990	SelfContainedSignedInfo: Send + Sync + 'static,
991	Call: From<<T as frame_system::Config>::Call>
992		+ From<<T as pallet_unique_scheduler::Config>::Call>
993		+ SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,
994	sp_runtime::AccountId32: From<<T as frame_system::Config>::AccountId>,
995{
996	fn dispatch_call(
997		signer: <T as frame_system::Config>::AccountId,
998		call: <T as pallet_unique_scheduler::Config>::Call,
999	) -> Result<
1000		Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,
1001		TransactionValidityError,
1002	> {
1003		let dispatch_info = call.get_dispatch_info();
1004		let extrinsic = fp_self_contained::CheckedExtrinsic::<
1005			AccountId,
1006			Call,
1007			SignedExtraScheduler,
1008			SelfContainedSignedInfo,
1009		> {
1010			signed:
1011				CheckedSignature::<AccountId, SignedExtraScheduler, SelfContainedSignedInfo>::Signed(
1012					signer.clone().into(),
1013					get_signed_extras(signer.into()),
1014				),
1015			function: call.into(),
1016		};
1017
1018		extrinsic.apply::<Runtime>(&dispatch_info, 0)
1019	}
1020
1021	fn reserve_balance(
1022		id: [u8; 16],
1023		sponsor: <T as frame_system::Config>::AccountId,
1024		call: <T as pallet_unique_scheduler::Config>::Call,
1025		count: u32,
1026	) -> Result<(), DispatchError> {
1027		let dispatch_info = call.get_dispatch_info();
1028		let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0)
1029			.saturating_mul(count.into());
1030
1031		<Balances as NamedReservableCurrency<AccountId>>::reserve_named(
1032			&id,
1033			&(sponsor.into()),
1034			weight.into(),
1035		)
1036	}
1037
1038	fn pay_for_call(
1039		id: [u8; 16],
1040		sponsor: <T as frame_system::Config>::AccountId,
1041		call: <T as pallet_unique_scheduler::Config>::Call,
1042	) -> Result<u128, DispatchError> {
1043		let dispatch_info = call.get_dispatch_info();
1044		let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0);
1045		Ok(
1046			<Balances as NamedReservableCurrency<AccountId>>::unreserve_named(
1047				&id,
1048				&(sponsor.into()),
1049				weight.into(),
1050			),
1051		)
1052	}
1053
1054	fn cancel_reserve(
1055		id: [u8; 16],
1056		sponsor: <T as frame_system::Config>::AccountId,
1057	) -> Result<u128, DispatchError> {
1058		Ok(
1059			<Balances as NamedReservableCurrency<AccountId>>::unreserve_named(
1060				&id,
1061				&(sponsor.into()),
1062				u128::MAX,
1063			),
1064		)
1065	}
1066}
1067
1068parameter_types! {
1069	pub const NoPreimagePostponement: Option<u32> = Some(10);
1070	pub const Preimage: Option<u32> = Some(10);
1071}
1072
1073/// Used the compare the privilege of an origin inside the scheduler.
1074pub struct OriginPrivilegeCmp;
1075
1076impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {
1077	fn cmp_privilege(_left: &OriginCaller, _right: &OriginCaller) -> Option<Ordering> {
1078		Some(Ordering::Equal)
1079	}
1080}
1081
1082#[cfg(feature = "scheduler")]
1083impl pallet_unique_scheduler::Config for Runtime {
1084	type Event = Event;
1085	type Origin = Origin;
1086	type Currency = Balances;
1087	type PalletsOrigin = OriginCaller;
1088	type Call = Call;
1089	type MaximumWeight = MaximumSchedulerWeight;
1090	type ScheduleOrigin = EnsureSigned<AccountId>;
1091	type MaxScheduledPerBlock = MaxScheduledPerBlock;
1092	type WeightInfo = ();
1093	type CallExecutor = SchedulerPaymentExecutor;
1094	type OriginPrivilegeCmp = OriginPrivilegeCmp;
1095	type PreimageProvider = ();
1096	type NoPreimagePostponement = NoPreimagePostponement;
1097}
1098
1099type EvmSponsorshipHandler = (
1100	UniqueEthSponsorshipHandler<Runtime>,
1101	pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,
1102);
1103type SponsorshipHandler = (
1104	UniqueSponsorshipHandler<Runtime>,
1105	//pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,
1106	pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,
1107);
1108
1109impl pallet_evm_transaction_payment::Config for Runtime {
1110	type EvmSponsorshipHandler = EvmSponsorshipHandler;
1111	type Currency = Balances;
1112}
1113
1114impl pallet_charge_transaction::Config for Runtime {
1115	type SponsorshipHandler = SponsorshipHandler;
1116}
1117
1118// impl pallet_contract_helpers::Config for Runtime {
1119//	 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;
1120// }
1121
1122parameter_types! {
1123	// 0x842899ECF380553E8a4de75bF534cdf6fBF64049
1124	pub const HelpersContractAddress: H160 = H160([
1125		0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,
1126	]);
1127
1128	// 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f
1129	pub const EvmCollectionHelpersAddress: H160 = H160([
1130		0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,
1131	]);
1132}
1133
1134impl pallet_evm_contract_helpers::Config for Runtime {
1135	type ContractAddress = HelpersContractAddress;
1136	type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;
1137}
113860
1139construct_runtime!(quartz);61construct_runtime!(quartz);
1140
1141pub struct TransactionConverter;
1142
1143impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {
1144	fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {
1145		UncheckedExtrinsic::new_unsigned(
1146			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),
1147		)
1148	}
1149}
1150
1151impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {
1152	fn convert_transaction(
1153		&self,
1154		transaction: pallet_ethereum::Transaction,
1155	) -> opaque::UncheckedExtrinsic {
1156		let extrinsic = UncheckedExtrinsic::new_unsigned(
1157			pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),
1158		);
1159		let encoded = extrinsic.encode();
1160		opaque::UncheckedExtrinsic::decode(&mut &encoded[..])
1161			.expect("Encoded extrinsic is always valid")
1162	}
1163}
1164
1165/// The address format for describing accounts.
1166pub type Address = sp_runtime::MultiAddress<AccountId, ()>;
1167/// Block header type as expected by this runtime.
1168pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
1169/// Block type as expected by this runtime.
1170pub type Block = generic::Block<Header, UncheckedExtrinsic>;
1171/// A Block signed with a Justification
1172pub type SignedBlock = generic::SignedBlock<Block>;
1173/// BlockId type as expected by this runtime.
1174pub type BlockId = generic::BlockId<Block>;
1175/// The SignedExtension to the basic transaction logic.
1176pub type SignedExtra = (
1177	frame_system::CheckSpecVersion<Runtime>,
1178	// system::CheckTxVersion<Runtime>,
1179	frame_system::CheckGenesis<Runtime>,
1180	frame_system::CheckEra<Runtime>,
1181	frame_system::CheckNonce<Runtime>,
1182	frame_system::CheckWeight<Runtime>,
1183	ChargeTransactionPayment,
1184	//pallet_contract_helpers::ContractHelpersExtension<Runtime>,
1185	pallet_ethereum::FakeTransactionFinalizer<Runtime>,
1186);
1187
1188pub type SignedExtraScheduler = (
1189	frame_system::CheckSpecVersion<Runtime>,
1190	frame_system::CheckGenesis<Runtime>,
1191	frame_system::CheckEra<Runtime>,
1192	frame_system::CheckNonce<Runtime>,
1193	frame_system::CheckWeight<Runtime>,
1194	// pallet_charge_transaction::ChargeTransactionPayment<Runtime>,
1195);
1196/// Unchecked extrinsic type as expected by this runtime.
1197pub type UncheckedExtrinsic =
1198	fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
1199/// Extrinsic type that has already been checked.
1200pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;
1201/// Executive: handles dispatch to the various modules.
1202pub type Executive = frame_executive::Executive<
1203	Runtime,
1204	Block,
1205	frame_system::ChainContext<Runtime>,
1206	Runtime,
1207	AllPalletsReversedWithSystemFirst,
1208>;
1209
1210impl_opaque_keys! {
1211	pub struct SessionKeys {
1212		pub aura: Aura,
1213	}
1214}
1215
1216impl fp_self_contained::SelfContainedCall for Call {
1217	type SignedInfo = H160;
1218
1219	fn is_self_contained(&self) -> bool {
1220		match self {
1221			Call::Ethereum(call) => call.is_self_contained(),
1222			_ => false,
1223		}
1224	}
1225
1226	fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {
1227		match self {
1228			Call::Ethereum(call) => call.check_self_contained(),
1229			_ => None,
1230		}
1231	}
1232
1233	fn validate_self_contained(
1234		&self,
1235		info: &Self::SignedInfo,
1236		dispatch_info: &DispatchInfoOf<Call>,
1237		len: usize,
1238	) -> Option<TransactionValidity> {
1239		match self {
1240			Call::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),
1241			_ => None,
1242		}
1243	}
1244
1245	fn pre_dispatch_self_contained(
1246		&self,
1247		info: &Self::SignedInfo,
1248	) -> Option<Result<(), TransactionValidityError>> {
1249		match self {
1250			Call::Ethereum(call) => call.pre_dispatch_self_contained(info),
1251			_ => None,
1252		}
1253	}
1254
1255	fn apply_self_contained(
1256		self,
1257		info: Self::SignedInfo,
1258	) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {
1259		match self {
1260			call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(
1261				Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),
1262			)),
1263			_ => None,
1264		}
1265	}
1266}
1267
1268macro_rules! dispatch_unique_runtime {
1269	($collection:ident.$method:ident($($name:ident),*)) => {{
1270		let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);
1271		let dispatch = collection.as_dyn();
1272
1273		Ok::<_, DispatchError>(dispatch.$method($($name),*))
1274	}};
1275}
127662
1277impl_common_runtime_apis!();63impl_common_runtime_apis!();
1278
1279struct CheckInherents;
1280
1281impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {
1282	fn check_inherents(
1283		block: &Block,
1284		relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,
1285	) -> sp_inherents::CheckInherentsResult {
1286		let relay_chain_slot = relay_state_proof
1287			.read_slot()
1288			.expect("Could not read the relay chain slot from the proof");
1289
1290		let inherent_data =
1291			cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(
1292				relay_chain_slot,
1293				sp_std::time::Duration::from_secs(6),
1294			)
1295			.create_inherent_data()
1296			.expect("Could not create the timestamp inherent data");
1297
1298		inherent_data.check_extrinsics(block)
1299	}
1300}
130164
1302cumulus_pallet_parachain_system::register_validate_block!(65cumulus_pallet_parachain_system::register_validate_block!(
1303	Runtime = Runtime,66	Runtime = Runtime,