git.delta.rocks / unique-network / refs/commits / 5900bfd2d2db

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.common-types]
257default-features = false
258path = "../../runtime/common"257path = "../../common-types"
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 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 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 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" }52common-types = { path = "../../common-types" }
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 common_types::opaque::{
44	Hash, AccountId, RuntimeInstance, Index, Block, BlockNumber, Balance,44	Hash, AccountId, RuntimeInstance, Index, Block, BlockNumber, Balance,
45};45};
46

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