git.delta.rocks / unique-network / refs/commits / 282c701e6ebe

5291 "cumulus-primitives-timestamp",5291 "cumulus-primitives-timestamp",
5292 "cumulus-primitives-utility",5292 "cumulus-primitives-utility",
5293 "derivative",5293 "derivative",
5294 "evm-coder",
5294 "fp-evm-mapping",5295 "fp-evm-mapping",
5295 "fp-rpc",5296 "fp-rpc",
5296 "fp-self-contained",5297 "fp-self-contained",
5352 "sp-transaction-pool",5353 "sp-transaction-pool",
5353 "sp-version",5354 "sp-version",
5354 "substrate-wasm-builder",5355 "substrate-wasm-builder",
5355 "unique-runtime-common",5356 "up-common",
5356 "up-data-structs",5357 "up-data-structs",
5357 "up-rpc",5358 "up-rpc",
5359 "up-sponsorship",
5358 "xcm",5360 "xcm",
5359 "xcm-builder",5361 "xcm-builder",
5360 "xcm-executor",5362 "xcm-executor",
8605 "cumulus-primitives-timestamp",8607 "cumulus-primitives-timestamp",
8606 "cumulus-primitives-utility",8608 "cumulus-primitives-utility",
8607 "derivative",8609 "derivative",
8610 "evm-coder",
8608 "fp-evm-mapping",8611 "fp-evm-mapping",
8609 "fp-rpc",8612 "fp-rpc",
8610 "fp-self-contained",8613 "fp-self-contained",
8666 "sp-transaction-pool",8669 "sp-transaction-pool",
8667 "sp-version",8670 "sp-version",
8668 "substrate-wasm-builder",8671 "substrate-wasm-builder",
8669 "unique-runtime-common",8672 "up-common",
8670 "up-data-structs",8673 "up-data-structs",
8671 "up-rpc",8674 "up-rpc",
8675 "up-sponsorship",
8672 "xcm",8676 "xcm",
8673 "xcm-builder",8677 "xcm-builder",
8674 "xcm-executor",8678 "xcm-executor",
11881name = "tests"11885name = "tests"
11882version = "0.1.0"11886version = "0.1.0"
11883dependencies = [11887dependencies = [
11888 "evm-coder",
11884 "fp-evm-mapping",11889 "fp-evm-mapping",
11885 "frame-support",11890 "frame-support",
11886 "frame-system",11891 "frame-system",
11902 "sp-io",11907 "sp-io",
11903 "sp-runtime",11908 "sp-runtime",
11904 "sp-std",11909 "sp-std",
11905 "unique-runtime-common",
11906 "up-data-structs",11910 "up-data-structs",
11911 "up-sponsorship",
11907]11912]
1190811913
11909[[package]]11914[[package]]
12387 "sp-core",12392 "sp-core",
12388 "sp-rpc",12393 "sp-rpc",
12389 "sp-runtime",12394 "sp-runtime",
12390 "unique-runtime-common",
12391 "up-data-structs",12395 "up-data-structs",
12392 "up-rpc",12396 "up-rpc",
12393]12397]
12541 "try-runtime-cli",12545 "try-runtime-cli",
12542 "unique-rpc",12546 "unique-rpc",
12543 "unique-runtime",12547 "unique-runtime",
12544 "unique-runtime-common",12548 "up-common",
12545 "up-data-structs",12549 "up-data-structs",
12546 "up-rpc",12550 "up-rpc",
12547]12551]
12590 "substrate-frame-rpc-system",12594 "substrate-frame-rpc-system",
12591 "tokio 0.2.25",12595 "tokio 0.2.25",
12592 "uc-rpc",12596 "uc-rpc",
12593 "unique-runtime-common",12597 "up-common",
12594 "up-data-structs",12598 "up-data-structs",
12595 "up-rpc",12599 "up-rpc",
12596]12600]
12608 "cumulus-primitives-timestamp",12612 "cumulus-primitives-timestamp",
12609 "cumulus-primitives-utility",12613 "cumulus-primitives-utility",
12610 "derivative",12614 "derivative",
12615 "evm-coder",
12611 "fp-evm-mapping",12616 "fp-evm-mapping",
12612 "fp-rpc",12617 "fp-rpc",
12613 "fp-self-contained",12618 "fp-self-contained",
12669 "sp-transaction-pool",12674 "sp-transaction-pool",
12670 "sp-version",12675 "sp-version",
12671 "substrate-wasm-builder",12676 "substrate-wasm-builder",
12672 "unique-runtime-common",12677 "up-common",
12673 "up-data-structs",12678 "up-data-structs",
12674 "up-rpc",12679 "up-rpc",
12680 "up-sponsorship",
12675 "xcm",12681 "xcm",
12676 "xcm-builder",12682 "xcm-builder",
12677 "xcm-executor",12683 "xcm-executor",
12678]12684]
12679
12680[[package]]
12681name = "unique-runtime-common"
12682version = "0.9.24"
12683dependencies = [
12684 "evm-coder",
12685 "fp-rpc",
12686 "frame-support",
12687 "frame-system",
12688 "pallet-common",
12689 "pallet-evm",
12690 "pallet-fungible",
12691 "pallet-nonfungible",
12692 "pallet-refungible",
12693 "pallet-unique",
12694 "pallet-unique-scheduler",
12695 "parity-scale-codec 3.1.5",
12696 "rmrk-rpc",
12697 "scale-info",
12698 "sp-consensus-aura",
12699 "sp-core",
12700 "sp-runtime",
12701 "sp-std",
12702 "up-data-structs",
12703 "up-sponsorship",
12704]
1270512685
12706[[package]]12686[[package]]
12707name = "universal-hash"12687name = "universal-hash"
12731source = "registry+https://github.com/rust-lang/crates.io-index"12711source = "registry+https://github.com/rust-lang/crates.io-index"
12732checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"12712checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
12713
12714[[package]]
12715name = "up-common"
12716version = "0.9.24"
12717dependencies = [
12718 "fp-rpc",
12719 "frame-support",
12720 "pallet-evm",
12721 "sp-consensus-aura",
12722 "sp-core",
12723 "sp-runtime",
12724 "sp-std",
12725]
1273312726
12734[[package]]12727[[package]]
12735name = "up-data-structs"12728name = "up-data-structs"

5edition = "2021"5edition = "2021"
66
7[dependencies]7[dependencies]
8unique-runtime-common = { default-features = false, path = "../../runtime/common" }
9pallet-common = { default-features = false, path = '../../pallets/common' }8pallet-common = { default-features = false, path = '../../pallets/common' }
10up-data-structs = { default-features = false, path = '../../primitives/data-structs' }9up-data-structs = { default-features = false, path = '../../primitives/data-structs' }
11up-rpc = { path = "../../primitives/rpc" }10up-rpc = { path = "../../primitives/rpc" }

253################################################################################253################################################################################
254# Local dependencies254# Local dependencies
255255
256[dependencies.unique-runtime-common]256[dependencies.up-common]
257default-features = false
258path = "../../runtime/common"257path = "../../primitives/common"
259258
260[dependencies.unique-runtime]259[dependencies.unique-runtime]
261path = '../../runtime/unique'260path = '../../runtime/unique'

23use serde::{Deserialize, Serialize};23use serde::{Deserialize, Serialize};
24use serde_json::map::Map;24use serde_json::map::Map;
2525
26use unique_runtime_common::types::*;26use up_common::types::opaque::*;
2727
28#[cfg(feature = "unique-runtime")]28#[cfg(feature = "unique-runtime")]
29pub use unique_runtime as default_runtime;29pub use unique_runtime as default_runtime;

64use sp_runtime::traits::{AccountIdConversion, Block as BlockT};64use sp_runtime::traits::{AccountIdConversion, Block as BlockT};
65use std::{io::Write, net::SocketAddr, time::Duration};65use std::{io::Write, net::SocketAddr, time::Duration};
6666
67use unique_runtime_common::types::Block;67use up_common::types::opaque::Block;
6868
69macro_rules! no_runtime_err {69macro_rules! no_runtime_err {
70	($chain_name:expr) => {70	($chain_name:expr) => {

63use fc_rpc_core::types::FilterPool;63use fc_rpc_core::types::FilterPool;
64use fc_mapping_sync::{MappingSyncWorker, SyncStrategy};64use fc_mapping_sync::{MappingSyncWorker, SyncStrategy};
6565
66use unique_runtime_common::types::{AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block};66use up_common::types::opaque::{AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block};
6767
68// RMRK68// RMRK
69use up_data_structs::{69use up_data_structs::{

49fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }49fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }
5050
51pallet-common = { default-features = false, path = "../../pallets/common" }51pallet-common = { default-features = false, path = "../../pallets/common" }
52unique-runtime-common = { default-features = false, path = "../../runtime/common" }52up-common = { path = "../../primitives/common" }
53pallet-unique = { path = "../../pallets/unique" }53pallet-unique = { path = "../../pallets/unique" }
54uc-rpc = { path = "../../client/rpc" }54uc-rpc = { path = "../../client/rpc" }
55up-rpc = { path = "../../primitives/rpc" }55up-rpc = { path = "../../primitives/rpc" }

40use sc_service::TransactionPool;40use sc_service::TransactionPool;
41use std::{collections::BTreeMap, sync::Arc};41use std::{collections::BTreeMap, sync::Arc};
4242
43use unique_runtime_common::types::{43use up_common::types::opaque::{Hash, AccountId, RuntimeInstance, Index, Block, BlockNumber, Balance};
44	Hash, AccountId, RuntimeInstance, Index, Block, BlockNumber, Balance,44
45};
46// RMRK45// RMRK
47use up_data_structs::{46use up_data_structs::{

535535
536		/// Can't transfer tokens to ethereum zero address536		/// Can't transfer tokens to ethereum zero address
537		AddressIsZero,537		AddressIsZero,
538		/// Target collection doesn't support this operation538
539		/// The oprtation is not supported
539		UnsupportedOperation,540		UnsupportedOperation,
540541
541		/// Insufficient funds to perform an action542		/// Insufficient funds to perform an action
1353/// Indicates unsupported methods by returning [Error::UnsupportedOperation].1354/// Indicates unsupported methods by returning [Error::UnsupportedOperation].
1354#[macro_export]1355#[macro_export]
1355macro_rules! unsupported {1356macro_rules! unsupported {
1356	() => {1357	($runtime:path) => {
1357		Err(<Error<T>>::UnsupportedOperation.into())1358		Err($crate::Error::<$runtime>::UnsupportedOperation.into())
1358	};1359	};
1359}1360}
13601361

16targets = ['x86_64-unknown-linux-gnu']16targets = ['x86_64-unknown-linux-gnu']
1717
18[features]18[features]
19default = ['std']19default = ['std', 'opal-runtime']
20runtime-benchmarks = [20runtime-benchmarks = [
21    'hex-literal',21    'hex-literal',
22    'frame-benchmarking',22    'frame-benchmarking',
113    'xcm/std',113    'xcm/std',
114    'xcm-builder/std',114    'xcm-builder/std',
115    'xcm-executor/std',115    'xcm-executor/std',
116    'unique-runtime-common/std',116    'up-common/std',
117    'rmrk-rpc/std',117    'rmrk-rpc/std',
118    'evm-coder/std',
119    'up-sponsorship/std',
118120
119    "orml-vesting/std",121    "orml-vesting/std",
120]122]
121limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing']123limit-testing = ['pallet-unique/limit-testing', 'up-data-structs/limit-testing']
124opal-runtime = ['refungible', 'scheduler', 'rmrk']
125
126refungible = []
127scheduler = []
128rmrk = []
122129
123################################################################################130################################################################################
124# Substrate Dependencies131# Substrate Dependencies
396403
397[dependencies]404[dependencies]
398log = { version = "0.4.16", default-features = false }405log = { version = "0.4.16", default-features = false }
399unique-runtime-common = { path = "../common", default-features = false }406up-common = { path = "../../primitives/common", default-features = false }
400scale-info = { version = "2.0.1", default-features = false, features = [407scale-info = { version = "2.0.1", default-features = false, features = [
401    "derive",408    "derive",
402] }409] }
426pallet-base-fee = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }433pallet-base-fee = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }
427fp-rpc = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }434fp-rpc = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }
428fp-self-contained = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }435fp-self-contained = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.24" }
436evm-coder = { default-features = false, path = '../../crates/evm-coder' }
437up-sponsorship = { default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = 'polkadot-v0.9.24' }
429438
430################################################################################439################################################################################
431# Build Dependencies440# Build Dependencies

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