difftreelog
refactor move RMRK rpc impl to proxy pallets
in: master
6 files changed
pallets/proxy-rmrk-core/src/lib.rsdiffbeforeafterboth--- a/pallets/proxy-rmrk-core/src/lib.rs
+++ b/pallets/proxy-rmrk-core/src/lib.rs
@@ -35,6 +35,7 @@
pub mod benchmarking;
pub mod misc;
pub mod property;
+pub mod rpc;
pub mod weights;
pub type SelfWeightOf<T> = <T as Config>::WeightInfo;
pallets/proxy-rmrk-core/src/rpc.rsdiffbeforeafterboth--- /dev/null
+++ b/pallets/proxy-rmrk-core/src/rpc.rs
@@ -0,0 +1,265 @@
+use super::*;
+
+pub fn last_collection_idx<T: Config>() -> Result<RmrkCollectionId, DispatchError> {
+ Ok(<Pallet<T>>::last_collection_idx())
+}
+
+pub fn collection_by_id<T: Config>(
+ collection_id: RmrkCollectionId,
+) -> Result<Option<RmrkCollectionInfo<T::AccountId>>, DispatchError> {
+ let (collection, collection_id) = match <Pallet<T>>::get_typed_nft_collection_mapped(
+ collection_id,
+ misc::CollectionType::Regular,
+ ) {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ let nfts_count = collection.total_supply();
+
+ Ok(Some(RmrkCollectionInfo {
+ issuer: collection.owner.clone(),
+ metadata: <Pallet<T>>::get_collection_property_decoded(
+ collection_id,
+ RmrkProperty::Metadata,
+ )?,
+ max: collection.limits.token_limit,
+ symbol: <Pallet<T>>::rebind(&collection.token_prefix)?,
+ nfts_count,
+ }))
+}
+
+pub fn nft_by_id<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_by_id: RmrkNftId,
+) -> Result<Option<RmrkInstanceInfo<T::AccountId>>, DispatchError> {
+ let (collection, collection_id) = match <Pallet<T>>::get_typed_nft_collection_mapped(
+ collection_id,
+ misc::CollectionType::Regular,
+ ) {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ let nft_id = TokenId(nft_by_id);
+ if !<Pallet<T>>::nft_exists(collection_id, nft_id) {
+ return Ok(None);
+ }
+
+ let owner = match collection.token_owner(nft_id) {
+ Some(owner) => match T::CrossTokenAddressMapping::address_to_token(&owner) {
+ Some((col, tok)) => {
+ let rmrk_collection = <Pallet<T>>::rmrk_collection_id(col)?;
+
+ RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)
+ }
+ None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone()),
+ },
+ None => return Ok(None),
+ };
+
+ Ok(Some(RmrkInstanceInfo {
+ owner: owner,
+ royalty: <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::RoyaltyInfo,
+ )?,
+ metadata: <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::Metadata,
+ )?,
+ equipped: <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::Equipped,
+ )?,
+ pending: <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::PendingNftAccept,
+ )?,
+ }))
+}
+
+pub fn account_tokens<T: Config>(
+ account_id: T::AccountId,
+ collection_id: RmrkCollectionId,
+) -> Result<Vec<RmrkNftId>, DispatchError> {
+ let cross_account_id = CrossAccountId::from_sub(account_id);
+
+ let (collection, collection_id) = match <Pallet<T>>::get_typed_nft_collection_mapped(
+ collection_id,
+ misc::CollectionType::Regular,
+ ) {
+ Ok(c) => c,
+ Err(_) => return Ok(Vec::new()),
+ };
+
+ let tokens = collection
+ .account_tokens(cross_account_id)
+ .into_iter()
+ .filter(|token| {
+ let is_pending = <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ *token,
+ RmrkProperty::PendingNftAccept,
+ )
+ .unwrap_or(true);
+
+ !is_pending
+ })
+ .map(|token| token.0)
+ .collect();
+
+ Ok(tokens)
+}
+
+pub fn nft_children<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_id: RmrkNftId,
+) -> Result<Vec<RmrkNftChild>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new()),
+ };
+ let nft_id = TokenId(nft_id);
+ if !<Pallet<T>>::nft_exists(collection_id, nft_id) {
+ return Ok(Vec::new());
+ }
+
+ Ok(
+ pallet_nonfungible::TokenChildren::<T>::iter_prefix((collection_id, nft_id))
+ .filter_map(|((child_collection, child_token), _)| {
+ let is_pending = <Pallet<T>>::get_nft_property_decoded(
+ child_collection,
+ child_token,
+ RmrkProperty::PendingNftAccept,
+ )
+ .ok()?;
+
+ if is_pending {
+ return None;
+ }
+
+ let rmrk_child_collection =
+ <Pallet<T>>::rmrk_collection_id(child_collection).ok()?;
+
+ Some(RmrkNftChild {
+ collection_id: rmrk_child_collection,
+ nft_id: child_token.0,
+ })
+ })
+ .collect(),
+ )
+}
+
+pub fn collection_properties<T: Config>(
+ collection_id: RmrkCollectionId,
+ filter_keys: Option<Vec<RmrkPropertyKey>>,
+) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new()),
+ };
+ if <Pallet<T>>::ensure_collection_type(collection_id, misc::CollectionType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let properties = <Pallet<T>>::filter_user_properties(
+ collection_id,
+ /* token_id = */ None,
+ filter_keys,
+ |key, value| RmrkPropertyInfo { key, value },
+ )?;
+
+ Ok(properties)
+}
+
+pub fn nft_properties<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_id: RmrkNftId,
+ filter_keys: Option<Vec<RmrkPropertyKey>>,
+) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new()),
+ };
+ let token_id = TokenId(nft_id);
+
+ if <Pallet<T>>::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let properties = <Pallet<T>>::filter_user_properties(
+ collection_id,
+ Some(token_id),
+ filter_keys,
+ |key, value| RmrkPropertyInfo { key, value },
+ )?;
+
+ Ok(properties)
+}
+
+pub fn nft_resources<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_id: RmrkNftId,
+) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new()),
+ };
+ if <Pallet<T>>::ensure_collection_type(collection_id, misc::CollectionType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let nft_id = TokenId(nft_id);
+ if <Pallet<T>>::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let resources = <pallet_nonfungible::Pallet<T>>::iterate_token_aux_properties(
+ collection_id,
+ nft_id,
+ PropertyScope::Rmrk,
+ )
+ .filter_map(|(_, value)| {
+ let resource_info: RmrkResourceInfo = <Pallet<T>>::decode_property(&value).ok()?;
+
+ Some(resource_info)
+ })
+ .collect();
+
+ Ok(resources)
+}
+
+pub fn nft_resource_priority<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_id: RmrkNftId,
+ resource_id: RmrkResourceId,
+) -> Result<Option<u32>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(None),
+ };
+ if <Pallet<T>>::ensure_collection_type(collection_id, misc::CollectionType::Regular).is_err() {
+ return Ok(None);
+ }
+
+ let nft_id = TokenId(nft_id);
+ if <Pallet<T>>::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() {
+ return Ok(None);
+ }
+
+ let priorities: Vec<_> = <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::ResourcePriorities,
+ )?;
+ Ok(priorities
+ .into_iter()
+ .enumerate()
+ .find(|(_, id)| *id == resource_id)
+ .map(|(priority, _): (usize, RmrkResourceId)| priority as u32))
+}
pallets/proxy-rmrk-equip/src/lib.rsdiffbeforeafterboth--- a/pallets/proxy-rmrk-equip/src/lib.rs
+++ b/pallets/proxy-rmrk-equip/src/lib.rs
@@ -34,6 +34,7 @@
#[cfg(feature = "runtime-benchmarks")]
pub mod benchmarking;
+pub mod rpc;
pub mod weights;
pub type SelfWeightOf<T> = <T as Config>::WeightInfo;
pallets/proxy-rmrk-equip/src/rpc.rsdiffbeforeafterboth--- /dev/null
+++ b/pallets/proxy-rmrk-equip/src/rpc.rs
@@ -0,0 +1,186 @@
+use super::*;
+use pallet_rmrk_core::{misc, property::*};
+use sp_std::vec::Vec;
+
+pub fn base<T: Config>(
+ base_id: RmrkBaseId,
+) -> Result<Option<RmrkBaseInfo<T::AccountId>>, DispatchError> {
+ let (collection, collection_id) =
+ match <PalletCore<T>>::get_typed_nft_collection_mapped(base_id, misc::CollectionType::Base)
+ {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ Ok(Some(RmrkBaseInfo {
+ issuer: collection.owner.clone(),
+ base_type: <PalletCore<T>>::get_collection_property_decoded(
+ collection_id,
+ RmrkProperty::BaseType,
+ )?,
+ symbol: <PalletCore<T>>::rebind(&collection.token_prefix)?,
+ }))
+}
+
+pub fn base_parts<T: Config>(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
+ use pallet_common::CommonCollectionOperations;
+
+ let (collection, collection_id) =
+ match <PalletCore<T>>::get_typed_nft_collection_mapped(base_id, misc::CollectionType::Base)
+ {
+ Ok(c) => c,
+ Err(_) => return Ok(Vec::new()),
+ };
+
+ let parts = collection
+ .collection_tokens()
+ .into_iter()
+ .filter_map(|token_id| {
+ let nft_type = <PalletCore<T>>::get_nft_type(collection_id, token_id).ok()?;
+
+ match nft_type {
+ NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {
+ id: <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ token_id,
+ RmrkProperty::ExternalPartId,
+ )
+ .ok()?,
+ src: <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ token_id,
+ RmrkProperty::Src,
+ )
+ .ok()?,
+ z: <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ token_id,
+ RmrkProperty::ZIndex,
+ )
+ .ok()?,
+ })),
+ NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {
+ id: <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ token_id,
+ RmrkProperty::ExternalPartId,
+ )
+ .ok()?,
+ src: <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ token_id,
+ RmrkProperty::Src,
+ )
+ .ok()?,
+ z: <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ token_id,
+ RmrkProperty::ZIndex,
+ )
+ .ok()?,
+ equippable: <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ token_id,
+ RmrkProperty::EquippableList,
+ )
+ .ok()?,
+ })),
+ _ => None,
+ }
+ })
+ .collect();
+
+ Ok(parts)
+}
+
+pub fn theme_names<T: Config>(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
+ use pallet_common::CommonCollectionOperations;
+
+ let (collection, collection_id) =
+ match <PalletCore<T>>::get_typed_nft_collection_mapped(base_id, misc::CollectionType::Base)
+ {
+ Ok(c) => c,
+ Err(_) => return Ok(Vec::new()),
+ };
+
+ let theme_names = collection
+ .collection_tokens()
+ .iter()
+ .filter_map(|token_id| {
+ let nft_type = <PalletCore<T>>::get_nft_type(collection_id, *token_id).ok()?;
+
+ match nft_type {
+ NftType::Theme => <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ *token_id,
+ RmrkProperty::ThemeName,
+ )
+ .ok(),
+ _ => None,
+ }
+ })
+ .collect();
+
+ Ok(theme_names)
+}
+
+pub fn theme<T: Config>(
+ base_id: RmrkBaseId,
+ theme_name: RmrkThemeName,
+ filter_keys: Option<Vec<RmrkPropertyKey>>,
+) -> Result<Option<RmrkTheme>, DispatchError> {
+ use pallet_common::CommonCollectionOperations;
+
+ let (collection, collection_id) =
+ match <PalletCore<T>>::get_typed_nft_collection_mapped(base_id, misc::CollectionType::Base)
+ {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ let theme_info = collection
+ .collection_tokens()
+ .into_iter()
+ .find_map(|token_id| {
+ <PalletCore<T>>::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;
+
+ let name: RmrkString = <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ token_id,
+ RmrkProperty::ThemeName,
+ )
+ .ok()?;
+
+ if name == theme_name {
+ Some((name, token_id))
+ } else {
+ None
+ }
+ });
+
+ let (name, theme_id) = match theme_info {
+ Some((name, theme_id)) => (name, theme_id),
+ None => return Ok(None),
+ };
+
+ let properties = <PalletCore<T>>::filter_user_properties(
+ collection_id,
+ Some(theme_id),
+ filter_keys,
+ |key, value| RmrkThemeProperty { key, value },
+ )?;
+
+ let inherit = <PalletCore<T>>::get_nft_property_decoded(
+ collection_id,
+ theme_id,
+ RmrkProperty::ThemeInherit,
+ )?;
+
+ let theme = RmrkTheme {
+ name,
+ properties,
+ inherit,
+ };
+
+ Ok(Some(theme))
+}
runtime/opal/src/lib.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! The Substrate Node Template runtime. This can be compiled with `#[no_std]`, ready for Wasm.1819#![cfg_attr(not(feature = "std"), no_std)]20// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.21#![recursion_limit = "1024"]22#![allow(clippy::from_over_into, clippy::identity_op)]23#![allow(clippy::fn_to_numeric_cast_with_truncation)]24// Make the WASM binary available.25#[cfg(feature = "std")]26include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));2728use sp_api::impl_runtime_apis;29use sp_core::{crypto::KeyTypeId, OpaqueMetadata, H256, U256, H160};30use sp_runtime::DispatchError;31use fp_self_contained::*;32// #[cfg(any(feature = "std", test))]33// pub use sp_runtime::BuildStorage;3435use sp_runtime::{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};4142use sp_std::prelude::*;4344#[cfg(feature = "std")]45use sp_version::NativeVersion;46use sp_version::RuntimeVersion;47pub use pallet_transaction_payment::{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 },70};71use pallet_unique_scheduler::DispatchCall;72use up_data_structs::{73 CollectionId, TokenId, TokenData, Property, PropertyKeyPermission, CollectionLimits,74 CollectionStats, RpcCollection,75 mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},76 TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,77 RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkThemeProperty, RmrkCollectionId,78 RmrkNftId, RmrkAccountIdOrCollectionNftTuple, RmrkNftChild, RmrkPropertyKey, RmrkResourceId,79 RmrkBaseId, RmrkFixedPart, RmrkSlotPart, RmrkString,80};8182// 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};104105// pub use pallet_timestamp::Call as TimestampCall;106pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;107108// Polkadot imports109use 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};121122use 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;131132use 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};141142pub const RUNTIME_NAME: &str = "opal";143pub const TOKEN_SYMBOL: &str = "OPL";144145type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;146147impl RuntimeInstance for Runtime {148 type CrossAccountId = self::CrossAccountId;149 type TransactionConverter = self::TransactionConverter;150151 fn get_transaction_converter() -> TransactionConverter {152 TransactionConverter153 }154}155156/// The type for looking up accounts. We don't expect more than 4 billion of them, but you157/// never know...158pub type AccountIndex = u32;159160/// Balance of an account.161pub type Balance = u128;162163/// Index of a transaction in the chain.164pub type Index = u32;165166/// A hash of some data used by the chain.167pub type Hash = sp_core::H256;168169/// Digest item type.170pub type DigestItem = generic::DigestItem;171172/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know173/// the specifics of the runtime. They can then be made to be agnostic over specific formats174/// of data like extrinsics, allowing for them to continue syncing the network through upgrades175/// 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;180181 pub use unique_runtime_common::types::*;182183 impl_opaque_keys! {184 pub struct SessionKeys {185 pub aura: Aura,186 }187 }188}189190/// This runtime version.191pub const VERSION: RuntimeVersion = RuntimeVersion {192 spec_name: create_runtime_str!(RUNTIME_NAME),193 impl_name: create_runtime_str!(RUNTIME_NAME),194 authoring_version: 1,195 spec_version: 922080,196 impl_version: 0,197 apis: RUNTIME_API_VERSIONS,198 transaction_version: 1,199 state_version: 0,200};201202#[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}207208/// 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}216217type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;218219pub 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 treasury224 let mut split = fees.ration(100, 0);225 if let Some(tips) = fees_then_tips.next() {226 // for tips, if any, 100% to treasury227 tips.ration_merge_into(100, 0, &mut split);228 }229 Treasury::on_unbalanced(split.0);230 // Author::on_unbalanced(split.1);231 }232 }233}234235parameter_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 they252 // are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.253 weights.reserved = Some(254 MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT255 );256 })257 .avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)258 .build_or_panic();259 pub const Version: RuntimeVersion = VERSION;260 pub const SS58Prefix: u8 = 42;261}262263parameter_types! {264 pub const ChainId: u64 = 8882;265}266267pub struct FixedFee;268impl FeeCalculator for FixedFee {269 fn min_gas_price() -> (U256, u64) {270 (MIN_GAS_PRICE.into(), 0)271 }272}273274// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case275// (contract, which only writes a lot of data),276// approximating on top of our real store write weight277parameter_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}282283/// Limiting EVM execution to 50% of block for substrate users and management tasks284/// EVM transaction consumes more weight than substrate's, so we can't rely on them being285/// scheduled fairly286const 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}290291pub 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}300301impl 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}306307impl 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}332333impl pallet_evm_migration::Config for Runtime {334 type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;335}336337pub 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 where341 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 None348 }349}350351impl pallet_ethereum::Config for Runtime {352 type Event = Event;353 type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;354}355356impl pallet_randomness_collective_flip::Config for Runtime {}357358impl 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}406407parameter_types! {408 pub const MinimumPeriod: u64 = SLOT_DURATION / 2;409}410411impl 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}418419parameter_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}425426impl 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}439440pub const fn deposit(items: u32, bytes: u32) -> Balance {441 items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE442}443444/*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 Mb459 // 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 fifth463 // 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}470471impl 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*/493494parameter_types! {495 /// This value increases the priority of `Operational` transactions by adding496 /// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.497 pub const OperationalFeeMultiplier: u8 = 5;498}499500/// Linear implementor of `WeightToFeePolynomial`501pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);502503impl<T> WeightToFeePolynomial for LinearFee<T>504where505 T: BaseArithmetic + From<u32> + Copy + Unsigned,506{507 type Balance = T;508509 fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {510 smallvec!(WeightToFeeCoefficient {511 // Targeting 0.1 Unique per NFT transfer512 coeff_integer: WEIGHT_TO_FEE_COEFF.into(),513 coeff_frac: Perbill::zero(),514 negative: false,515 degree: 1,516 })517 }518}519520impl pallet_transaction_payment::Config for Runtime {521 type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;522 type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;523 type OperationalFeeMultiplier = OperationalFeeMultiplier;524 type WeightToFee = LinearFee<Balance>;525 type FeeMultiplierUpdate = ();526}527528parameter_types! {529 pub const ProposalBond: Permill = Permill::from_percent(5);530 pub const ProposalBondMinimum: Balance = 1 * UNIQUE;531 pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;532 pub const SpendPeriod: BlockNumber = 5 * MINUTES;533 pub const Burn: Permill = Permill::from_percent(0);534 pub const TipCountdown: BlockNumber = 1 * DAYS;535 pub const TipFindersFee: Percent = Percent::from_percent(20);536 pub const TipReportDepositBase: Balance = 1 * UNIQUE;537 pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;538 pub const BountyDepositBase: Balance = 1 * UNIQUE;539 pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;540 pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");541 pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;542 pub const MaximumReasonLength: u32 = 16384;543 pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);544 pub const BountyValueMinimum: Balance = 5 * UNIQUE;545 pub const MaxApprovals: u32 = 100;546}547548impl pallet_treasury::Config for Runtime {549 type PalletId = TreasuryModuleId;550 type Currency = Balances;551 type ApproveOrigin = EnsureRoot<AccountId>;552 type RejectOrigin = EnsureRoot<AccountId>;553 type Event = Event;554 type OnSlash = ();555 type ProposalBond = ProposalBond;556 type ProposalBondMinimum = ProposalBondMinimum;557 type ProposalBondMaximum = ProposalBondMaximum;558 type SpendPeriod = SpendPeriod;559 type Burn = Burn;560 type BurnDestination = ();561 type SpendFunds = ();562 type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;563 type MaxApprovals = MaxApprovals;564}565566impl pallet_sudo::Config for Runtime {567 type Event = Event;568 type Call = Call;569}570571pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);572573impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider574 for RelayChainBlockNumberProvider<T>575{576 type BlockNumber = BlockNumber;577578 fn current_block_number() -> Self::BlockNumber {579 cumulus_pallet_parachain_system::Pallet::<T>::validation_data()580 .map(|d| d.relay_parent_number)581 .unwrap_or_default()582 }583}584585parameter_types! {586 pub const MinVestedTransfer: Balance = 10 * UNIQUE;587 pub const MaxVestingSchedules: u32 = 28;588}589590impl orml_vesting::Config for Runtime {591 type Event = Event;592 type Currency = pallet_balances::Pallet<Runtime>;593 type MinVestedTransfer = MinVestedTransfer;594 type VestedTransferOrigin = EnsureSigned<AccountId>;595 type WeightInfo = ();596 type MaxVestingSchedules = MaxVestingSchedules;597 type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;598}599600parameter_types! {601 pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;602 pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;603}604605impl cumulus_pallet_parachain_system::Config for Runtime {606 type Event = Event;607 type SelfParaId = parachain_info::Pallet<Self>;608 type OnSystemEvent = ();609 // type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<610 // MaxDownwardMessageWeight,611 // XcmExecutor<XcmConfig>,612 // Call,613 // >;614 type OutboundXcmpMessageSource = XcmpQueue;615 type DmpMessageHandler = DmpQueue;616 type ReservedDmpWeight = ReservedDmpWeight;617 type ReservedXcmpWeight = ReservedXcmpWeight;618 type XcmpMessageHandler = XcmpQueue;619}620621impl parachain_info::Config for Runtime {}622623impl cumulus_pallet_aura_ext::Config for Runtime {}624625parameter_types! {626 pub const RelayLocation: MultiLocation = MultiLocation::parent();627 pub const RelayNetwork: NetworkId = NetworkId::Polkadot;628 pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();629 pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();630}631632/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used633/// when determining ownership of accounts for asset transacting and when attempting to use XCM634/// `Transact` in order to determine the dispatch Origin.635pub type LocationToAccountId = (636 // The parent (Relay-chain) origin converts to the default `AccountId`.637 ParentIsPreset<AccountId>,638 // Sibling parachain origins convert to AccountId via the `ParaId::into`.639 SiblingParachainConvertsVia<Sibling, AccountId>,640 // Straight up local `AccountId32` origins just alias directly to `AccountId`.641 AccountId32Aliases<RelayNetwork, AccountId>,642);643644pub struct OnlySelfCurrency;645impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {646 fn matches_fungible(a: &MultiAsset) -> Option<B> {647 match (&a.id, &a.fun) {648 (Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),649 _ => None,650 }651 }652}653654/// Means for transacting assets on this chain.655pub type LocalAssetTransactor = CurrencyAdapter<656 // Use this currency:657 Balances,658 // Use this currency when it is a fungible asset matching the given location or name:659 OnlySelfCurrency,660 // Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:661 LocationToAccountId,662 // Our chain's account ID type (we can't get away without mentioning it explicitly):663 AccountId,664 // We don't track any teleports.665 (),666>;667668/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,669/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can670/// biases the kind of local `Origin` it will become.671pub type XcmOriginToTransactDispatchOrigin = (672 // Sovereign account converter; this attempts to derive an `AccountId` from the origin location673 // using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for674 // foreign chains who want to have a local sovereign account on this chain which they control.675 SovereignSignedViaLocation<LocationToAccountId, Origin>,676 // Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when677 // recognised.678 RelayChainAsNative<RelayOrigin, Origin>,679 // Native converter for sibling Parachains; will convert to a `SiblingPara` origin when680 // recognised.681 SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,682 // Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a683 // transaction from the Root origin.684 ParentAsSuperuser<Origin>,685 // Native signed account converter; this just converts an `AccountId32` origin into a normal686 // `Origin::Signed` origin of the same 32-byte value.687 SignedAccountId32AsNative<RelayNetwork, Origin>,688 // Xcm origins can be represented natively under the Xcm pallet's Xcm origin.689 XcmPassthrough<Origin>,690);691692parameter_types! {693 // One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.694 pub UnitWeightCost: Weight = 1_000_000;695 // 1200 UNIQUEs buy 1 second of weight.696 pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);697 pub const MaxInstructions: u32 = 100;698 pub const MaxAuthorities: u32 = 100_000;699}700701match_types! {702 pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {703 MultiLocation { parents: 1, interior: Here } |704 MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }705 };706}707708pub type Barrier = (709 TakeWeightCredit,710 AllowTopLevelPaidExecutionFrom<Everything>,711 AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,712 // ^^^ Parent & its unit plurality gets free execution713);714715pub struct UsingOnlySelfCurrencyComponents<716 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,717 AssetId: Get<MultiLocation>,718 AccountId,719 Currency: CurrencyT<AccountId>,720 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,721>(722 Weight,723 Currency::Balance,724 PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,725);726impl<727 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,728 AssetId: Get<MultiLocation>,729 AccountId,730 Currency: CurrencyT<AccountId>,731 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,732 > WeightTrader733 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>734{735 fn new() -> Self {736 Self(0, Zero::zero(), PhantomData)737 }738739 fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {740 let amount = WeightToFee::calc(&weight);741 let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;742743 // location to this parachain through relay chain744 let option1: xcm::v1::AssetId = Concrete(MultiLocation {745 parents: 1,746 interior: X1(Parachain(ParachainInfo::parachain_id().into())),747 });748 // direct location749 let option2: xcm::v1::AssetId = Concrete(MultiLocation {750 parents: 0,751 interior: Here,752 });753754 let required = if payment.fungible.contains_key(&option1) {755 (option1, u128_amount).into()756 } else if payment.fungible.contains_key(&option2) {757 (option2, u128_amount).into()758 } else {759 (Concrete(MultiLocation::default()), u128_amount).into()760 };761762 let unused = payment763 .checked_sub(required)764 .map_err(|_| XcmError::TooExpensive)?;765 self.0 = self.0.saturating_add(weight);766 self.1 = self.1.saturating_add(amount);767 Ok(unused)768 }769770 fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {771 let weight = weight.min(self.0);772 let amount = WeightToFee::calc(&weight);773 self.0 -= weight;774 self.1 = self.1.saturating_sub(amount);775 let amount: u128 = amount.saturated_into();776 if amount > 0 {777 Some((AssetId::get(), amount).into())778 } else {779 None780 }781 }782}783impl<784 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,785 AssetId: Get<MultiLocation>,786 AccountId,787 Currency: CurrencyT<AccountId>,788 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,789 > Drop790 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>791{792 fn drop(&mut self) {793 OnUnbalanced::on_unbalanced(Currency::issue(self.1));794 }795}796797pub struct XcmConfig;798impl Config for XcmConfig {799 type Call = Call;800 type XcmSender = XcmRouter;801 // How to withdraw and deposit an asset.802 type AssetTransactor = LocalAssetTransactor;803 type OriginConverter = XcmOriginToTransactDispatchOrigin;804 type IsReserve = NativeAsset;805 type IsTeleporter = (); // Teleportation is disabled806 type LocationInverter = LocationInverter<Ancestry>;807 type Barrier = Barrier;808 type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;809 type Trader = UsingOnlySelfCurrencyComponents<810 IdentityFee<Balance>,811 RelayLocation,812 AccountId,813 Balances,814 (),815 >;816 type ResponseHandler = (); // Don't handle responses for now.817 type SubscriptionService = PolkadotXcm;818819 type AssetTrap = PolkadotXcm;820 type AssetClaims = PolkadotXcm;821}822823// parameter_types! {824// pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;825// }826827/// No local origins on this chain are allowed to dispatch XCM sends/executions.828pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);829830/// The means for routing XCM messages which are not for local execution into the right message831/// 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);838839impl pallet_evm_coder_substrate::Config for Runtime {}840841impl 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}857858impl cumulus_pallet_xcm::Config for Runtime {859 type Event = Event;860 type XcmExecutor = XcmExecutor<XcmConfig>;861}862863impl 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}873874impl cumulus_pallet_dmp_queue::Config for Runtime {875 type Event = Event;876 type XcmExecutor = XcmExecutor<XcmConfig>;877 type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;878}879880impl pallet_aura::Config for Runtime {881 type AuthorityId = AuraId;882 type DisabledValidators = ();883 type MaxAuthorities = MaxAuthorities;884}885886parameter_types! {887 pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();888 pub const CollectionCreationPrice: Balance = 2 * UNIQUE;889}890891impl 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>;898899 type EvmTokenAddressMapping = EvmTokenAddressMapping;900 type CrossTokenAddressMapping = CrossTokenAddressMapping<Self::AccountId>;901 type ContractAddress = EvmCollectionHelpersAddress;902}903904impl pallet_structure::Config for Runtime {905 type Event = Event;906 type Call = Call;907 type WeightInfo = pallet_structure::weights::SubstrateWeight<Self>;908}909910impl 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}919920impl pallet_proxy_rmrk_core::Config for Runtime {921 type WeightInfo = pallet_proxy_rmrk_core::weights::SubstrateWeight<Self>;922 type Event = Event;923}924925impl pallet_proxy_rmrk_equip::Config for Runtime {926 type WeightInfo = pallet_proxy_rmrk_equip::weights::SubstrateWeight<Self>;927 type Event = Event;928}929930impl pallet_unique::Config for Runtime {931 type Event = Event;932 type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;933 type CommonWeightInfo = CommonWeights<Self>;934}935936parameter_types! {937 pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied938}939940/// Used for the pallet inflation941impl pallet_inflation::Config for Runtime {942 type Currency = Balances;943 type TreasuryAccountId = TreasuryAccountId;944 type InflationBlockInterval = InflationBlockInterval;945 type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;946}947948parameter_types! {949 pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *950 RuntimeBlockWeights::get().max_block;951 pub const MaxScheduledPerBlock: u32 = 50;952}953954type ChargeTransactionPayment = pallet_charge_transaction::ChargeTransactionPayment<Runtime>;955use frame_support::traits::NamedReservableCurrency;956957fn get_signed_extras(from: <Runtime as frame_system::Config>::AccountId) -> SignedExtraScheduler {958 (959 frame_system::CheckSpecVersion::<Runtime>::new(),960 frame_system::CheckGenesis::<Runtime>::new(),961 frame_system::CheckEra::<Runtime>::from(Era::Immortal),962 frame_system::CheckNonce::<Runtime>::from(frame_system::Pallet::<Runtime>::account_nonce(963 from,964 )),965 frame_system::CheckWeight::<Runtime>::new(),966 // sponsoring transaction logic967 // pallet_charge_transaction::ChargeTransactionPayment::<Runtime>::new(0),968 )969}970971pub struct SchedulerPaymentExecutor;972impl<T: frame_system::Config + pallet_unique_scheduler::Config, SelfContainedSignedInfo>973 DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor974where975 <T as frame_system::Config>::Call: Member976 + Dispatchable<Origin = Origin, Info = DispatchInfo>977 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>978 + GetDispatchInfo979 + From<frame_system::Call<Runtime>>,980 SelfContainedSignedInfo: Send + Sync + 'static,981 Call: From<<T as frame_system::Config>::Call>982 + From<<T as pallet_unique_scheduler::Config>::Call>983 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,984 sp_runtime::AccountId32: From<<T as frame_system::Config>::AccountId>,985{986 fn dispatch_call(987 signer: <T as frame_system::Config>::AccountId,988 call: <T as pallet_unique_scheduler::Config>::Call,989 ) -> Result<990 Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,991 TransactionValidityError,992 > {993 let dispatch_info = call.get_dispatch_info();994 let extrinsic = fp_self_contained::CheckedExtrinsic::<995 AccountId,996 Call,997 SignedExtraScheduler,998 SelfContainedSignedInfo,999 > {1000 signed:1001 CheckedSignature::<AccountId, SignedExtraScheduler, SelfContainedSignedInfo>::Signed(1002 signer.clone().into(),1003 get_signed_extras(signer.into()),1004 ),1005 function: call.into(),1006 };10071008 extrinsic.apply::<Runtime>(&dispatch_info, 0)1009 }10101011 fn reserve_balance(1012 id: [u8; 16],1013 sponsor: <T as frame_system::Config>::AccountId,1014 call: <T as pallet_unique_scheduler::Config>::Call,1015 count: u32,1016 ) -> Result<(), DispatchError> {1017 let dispatch_info = call.get_dispatch_info();1018 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0)1019 .saturating_mul(count.into());10201021 <Balances as NamedReservableCurrency<AccountId>>::reserve_named(1022 &id,1023 &(sponsor.into()),1024 weight,1025 )1026 }10271028 fn pay_for_call(1029 id: [u8; 16],1030 sponsor: <T as frame_system::Config>::AccountId,1031 call: <T as pallet_unique_scheduler::Config>::Call,1032 ) -> Result<u128, DispatchError> {1033 let dispatch_info = call.get_dispatch_info();1034 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0);1035 Ok(1036 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1037 &id,1038 &(sponsor.into()),1039 weight,1040 ),1041 )1042 }10431044 fn cancel_reserve(1045 id: [u8; 16],1046 sponsor: <T as frame_system::Config>::AccountId,1047 ) -> Result<u128, DispatchError> {1048 Ok(1049 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1050 &id,1051 &(sponsor.into()),1052 u128::MAX,1053 ),1054 )1055 }1056}10571058parameter_types! {1059 pub const NoPreimagePostponement: Option<u32> = Some(10);1060 pub const Preimage: Option<u32> = Some(10);1061}10621063/// Used the compare the privilege of an origin inside the scheduler.1064pub struct OriginPrivilegeCmp;10651066impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {1067 fn cmp_privilege(_left: &OriginCaller, _right: &OriginCaller) -> Option<Ordering> {1068 Some(Ordering::Equal)1069 }1070}10711072impl pallet_unique_scheduler::Config for Runtime {1073 type Event = Event;1074 type Origin = Origin;1075 type Currency = Balances;1076 type PalletsOrigin = OriginCaller;1077 type Call = Call;1078 type MaximumWeight = MaximumSchedulerWeight;1079 type ScheduleOrigin = EnsureSigned<AccountId>;1080 type MaxScheduledPerBlock = MaxScheduledPerBlock;1081 type WeightInfo = ();1082 type CallExecutor = SchedulerPaymentExecutor;1083 type OriginPrivilegeCmp = OriginPrivilegeCmp;1084 type PreimageProvider = ();1085 type NoPreimagePostponement = NoPreimagePostponement;1086}10871088type EvmSponsorshipHandler = (1089 UniqueEthSponsorshipHandler<Runtime>,1090 pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,1091);10921093type SponsorshipHandler = (1094 UniqueSponsorshipHandler<Runtime>,1095 //pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1096 pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1097);10981099impl pallet_evm_transaction_payment::Config for Runtime {1100 type EvmSponsorshipHandler = EvmSponsorshipHandler;1101 type Currency = Balances;1102}11031104impl pallet_charge_transaction::Config for Runtime {1105 type SponsorshipHandler = SponsorshipHandler;1106}11071108// impl pallet_contract_helpers::Config for Runtime {1109// type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1110// }11111112parameter_types! {1113 // 0x842899ECF380553E8a4de75bF534cdf6fBF640491114 pub const HelpersContractAddress: H160 = H160([1115 0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1116 ]);11171118 // 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f1119 pub const EvmCollectionHelpersAddress: H160 = H160([1120 0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,1121 ]);1122}11231124impl pallet_evm_contract_helpers::Config for Runtime {1125 type ContractAddress = HelpersContractAddress;1126 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1127}11281129construct_runtime!(1130 pub enum Runtime where1131 Block = Block,1132 NodeBlock = opaque::Block,1133 UncheckedExtrinsic = UncheckedExtrinsic1134 {1135 ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1136 ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,11371138 Aura: pallet_aura::{Pallet, Config<T>} = 22,1139 AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,11401141 Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1142 RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1143 Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1144 TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1145 Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1146 Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1147 System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1148 Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1149 // Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1150 // Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,11511152 // XCM helpers.1153 XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1154 PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1155 CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1156 DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11571158 // Unique Pallets1159 Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1160 Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1161 Scheduler: pallet_unique_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1162 // free = 631163 Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1164 // ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1165 Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1166 Fungible: pallet_fungible::{Pallet, Storage} = 67,1167 Refungible: pallet_refungible::{Pallet, Storage} = 68,1168 Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1169 Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,1170 RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,1171 RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,11721173 // Frontier1174 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1175 Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11761177 EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1178 EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1179 EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1180 EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1181 }1182);11831184pub struct TransactionConverter;11851186impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1187 fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1188 UncheckedExtrinsic::new_unsigned(1189 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1190 )1191 }1192}11931194impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1195 fn convert_transaction(1196 &self,1197 transaction: pallet_ethereum::Transaction,1198 ) -> opaque::UncheckedExtrinsic {1199 let extrinsic = UncheckedExtrinsic::new_unsigned(1200 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1201 );1202 let encoded = extrinsic.encode();1203 opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1204 .expect("Encoded extrinsic is always valid")1205 }1206}12071208/// The address format for describing accounts.1209pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1210/// Block header type as expected by this runtime.1211pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1212/// Block type as expected by this runtime.1213pub type Block = generic::Block<Header, UncheckedExtrinsic>;1214/// A Block signed with a Justification1215pub type SignedBlock = generic::SignedBlock<Block>;1216/// BlockId type as expected by this runtime.1217pub type BlockId = generic::BlockId<Block>;1218/// The SignedExtension to the basic transaction logic.1219pub type SignedExtra = (1220 frame_system::CheckSpecVersion<Runtime>,1221 // system::CheckTxVersion<Runtime>,1222 frame_system::CheckGenesis<Runtime>,1223 frame_system::CheckEra<Runtime>,1224 frame_system::CheckNonce<Runtime>,1225 frame_system::CheckWeight<Runtime>,1226 ChargeTransactionPayment,1227 //pallet_contract_helpers::ContractHelpersExtension<Runtime>,1228 pallet_ethereum::FakeTransactionFinalizer<Runtime>,1229);1230pub type SignedExtraScheduler = (1231 frame_system::CheckSpecVersion<Runtime>,1232 frame_system::CheckGenesis<Runtime>,1233 frame_system::CheckEra<Runtime>,1234 frame_system::CheckNonce<Runtime>,1235 frame_system::CheckWeight<Runtime>,1236);1237/// Unchecked extrinsic type as expected by this runtime.1238pub type UncheckedExtrinsic =1239 fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1240/// Extrinsic type that has already been checked.1241pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1242/// Executive: handles dispatch to the various modules.1243pub type Executive = frame_executive::Executive<1244 Runtime,1245 Block,1246 frame_system::ChainContext<Runtime>,1247 Runtime,1248 AllPalletsReversedWithSystemFirst,1249>;12501251impl_opaque_keys! {1252 pub struct SessionKeys {1253 pub aura: Aura,1254 }1255}12561257impl fp_self_contained::SelfContainedCall for Call {1258 type SignedInfo = H160;12591260 fn is_self_contained(&self) -> bool {1261 match self {1262 Call::Ethereum(call) => call.is_self_contained(),1263 _ => false,1264 }1265 }12661267 fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1268 match self {1269 Call::Ethereum(call) => call.check_self_contained(),1270 _ => None,1271 }1272 }12731274 fn validate_self_contained(1275 &self,1276 info: &Self::SignedInfo,1277 dispatch_info: &DispatchInfoOf<Call>,1278 len: usize,1279 ) -> Option<TransactionValidity> {1280 match self {1281 Call::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),1282 _ => None,1283 }1284 }12851286 fn pre_dispatch_self_contained(1287 &self,1288 info: &Self::SignedInfo,1289 ) -> Option<Result<(), TransactionValidityError>> {1290 match self {1291 Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1292 _ => None,1293 }1294 }12951296 fn apply_self_contained(1297 self,1298 info: Self::SignedInfo,1299 ) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1300 match self {1301 call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1302 Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1303 )),1304 _ => None,1305 }1306 }1307}13081309macro_rules! dispatch_unique_runtime {1310 ($collection:ident.$method:ident($($name:ident),*)) => {{1311 let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1312 let dispatch = collection.as_dyn();13131314 Ok::<_, DispatchError>(dispatch.$method($($name),*))1315 }};1316}13171318impl_common_runtime_apis! {1319 #![custom_apis]13201321 impl rmrk_rpc::RmrkApi<1322 Block,1323 AccountId,1324 RmrkCollectionInfo<AccountId>,1325 RmrkInstanceInfo<AccountId>,1326 RmrkResourceInfo,1327 RmrkPropertyInfo,1328 RmrkBaseInfo<AccountId>,1329 RmrkPartType,1330 RmrkTheme1331 > for Runtime {1332 fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {1333 Ok(RmrkCore::last_collection_idx())1334 }13351336 fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {1337 use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};1338 use pallet_common::CommonCollectionOperations;13391340 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {1341 Ok(c) => c,1342 Err(_) => return Ok(None),1343 };13441345 let nfts_count = collection.total_supply();13461347 Ok(Some(RmrkCollectionInfo {1348 issuer: collection.owner.clone(),1349 metadata: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::Metadata)?,1350 max: collection.limits.token_limit,1351 symbol: RmrkCore::rebind(&collection.token_prefix)?,1352 nfts_count1353 }))1354 }13551356 fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {1357 use up_data_structs::mapping::TokenAddressMapping;1358 use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};1359 use pallet_common::CommonCollectionOperations;13601361 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {1362 Ok(c) => c,1363 Err(_) => return Ok(None),1364 };13651366 let nft_id = TokenId(nft_by_id);1367 if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }13681369 let owner = match collection.token_owner(nft_id) {1370 Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {1371 Some((col, tok)) => {1372 let rmrk_collection = RmrkCore::rmrk_collection_id(col)?;13731374 RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)1375 }1376 None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())1377 },1378 None => return Ok(None)1379 };13801381 Ok(Some(RmrkInstanceInfo {1382 owner: owner,1383 royalty: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::RoyaltyInfo)?,1384 metadata: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Metadata)?,1385 equipped: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Equipped)?,1386 pending: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::PendingNftAccept)?,1387 }))1388 }13891390 fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {1391 use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};1392 use pallet_common::CommonCollectionOperations;13931394 let cross_account_id = CrossAccountId::from_sub(account_id);13951396 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {1397 Ok(c) => c,1398 Err(_) => return Ok(Vec::new()),1399 };14001401 let tokens = collection.account_tokens(cross_account_id)1402 .into_iter()1403 .filter(|token| {1404 let is_pending = RmrkCore::get_nft_property_decoded(1405 collection_id,1406 *token,1407 RmrkProperty::PendingNftAccept1408 ).unwrap_or(true);14091410 !is_pending1411 })1412 .map(|token| token.0)1413 .collect();14141415 Ok(tokens)1416 }14171418 fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {1419 use pallet_proxy_rmrk_core::RmrkProperty;14201421 let collection_id = match RmrkCore::unique_collection_id(collection_id) {1422 Ok(id) => id,1423 Err(_) => return Ok(Vec::new())1424 };1425 let nft_id = TokenId(nft_id);1426 if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(Vec::new()); }14271428 Ok(1429 pallet_nonfungible::TokenChildren::<Runtime>::iter_prefix((collection_id, nft_id))1430 .filter_map(|((child_collection, child_token), _)| {1431 let is_pending = RmrkCore::get_nft_property_decoded(1432 child_collection,1433 child_token,1434 RmrkProperty::PendingNftAccept1435 ).ok()?;14361437 if is_pending {1438 return None;1439 }14401441 let rmrk_child_collection = RmrkCore::rmrk_collection_id(1442 child_collection1443 ).ok()?;14441445 Some(RmrkNftChild {1446 collection_id: rmrk_child_collection,1447 nft_id: child_token.0,1448 })1449 }).collect()1450 )1451 }14521453 fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {1454 use pallet_proxy_rmrk_core::misc::CollectionType;14551456 let collection_id = match RmrkCore::unique_collection_id(collection_id) {1457 Ok(id) => id,1458 Err(_) => return Ok(Vec::new())1459 };1460 if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() {1461 return Ok(Vec::new());1462 }14631464 let properties = RmrkCore::filter_user_properties(1465 collection_id,1466 /* token_id = */ None,1467 filter_keys,1468 |key, value| RmrkPropertyInfo {1469 key,1470 value1471 }1472 )?;14731474 Ok(properties)1475 }14761477 fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {1478 use pallet_proxy_rmrk_core::misc::NftType;14791480 let collection_id = match RmrkCore::unique_collection_id(collection_id) {1481 Ok(id) => id,1482 Err(_) => return Ok(Vec::new())1483 };1484 let token_id = TokenId(nft_id);14851486 if RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {1487 return Ok(Vec::new());1488 }14891490 let properties = RmrkCore::filter_user_properties(1491 collection_id,1492 Some(token_id),1493 filter_keys,1494 |key, value| RmrkPropertyInfo {1495 key,1496 value1497 }1498 )?;14991500 Ok(properties)1501 }15021503 fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {1504 use pallet_proxy_rmrk_core::misc::{CollectionType, NftType};1505 use up_data_structs::PropertyScope;15061507 let collection_id = match RmrkCore::unique_collection_id(collection_id) {1508 Ok(id) => id,1509 Err(_) => return Ok(Vec::new())1510 };1511 if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }15121513 let nft_id = TokenId(nft_id);1514 if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }15151516 let resources = <pallet_nonfungible::Pallet<Runtime>>::iterate_token_aux_properties(1517 collection_id, nft_id, PropertyScope::Rmrk1518 ).filter_map(|(_, value)| {1519 let resource_info: RmrkResourceInfo = RmrkCore::decode_property(&value).ok()?;15201521 Some(resource_info)1522 }).collect();15231524 Ok(resources)1525 }15261527 fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {1528 use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};15291530 let collection_id = match RmrkCore::unique_collection_id(collection_id) {1531 Ok(id) => id,1532 Err(_) => return Ok(None)1533 };1534 if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }15351536 let nft_id = TokenId(nft_id);1537 if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }15381539 let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;1540 Ok(1541 priorities.into_iter()1542 .enumerate()1543 .find(|(_, id)| *id == resource_id)1544 .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)1545 )1546 }15471548 fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {1549 use pallet_proxy_rmrk_core::{1550 RmrkProperty, misc::{CollectionType},1551 };15521553 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {1554 Ok(c) => c,1555 Err(_) => return Ok(None),1556 };15571558 Ok(Some(RmrkBaseInfo {1559 issuer: collection.owner.clone(),1560 base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,1561 symbol: RmrkCore::rebind(&collection.token_prefix)?,1562 }))1563 }15641565 fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {1566 use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};1567 use pallet_common::CommonCollectionOperations;15681569 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {1570 Ok(c) => c,1571 Err(_) => return Ok(Vec::new()),1572 };15731574 let parts = collection.collection_tokens()1575 .into_iter()1576 .filter_map(|token_id| {1577 let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;15781579 match nft_type {1580 NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {1581 id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,1582 src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,1583 z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,1584 })),1585 NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {1586 id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,1587 src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,1588 z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,1589 equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,1590 })),1591 _ => None1592 }1593 })1594 .collect();15951596 Ok(parts)1597 }15981599 fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {1600 use pallet_proxy_rmrk_core::{RmrkProperty, misc::{NftType, CollectionType}};1601 use pallet_common::CommonCollectionOperations;16021603 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {1604 Ok(c) => c,1605 Err(_) => return Ok(Vec::new()),1606 };16071608 let theme_names = collection.collection_tokens()1609 .iter()1610 .filter_map(|token_id| {1611 let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).ok()?;16121613 match nft_type {1614 NftType::Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),1615 _ => None1616 }1617 })1618 .collect();16191620 Ok(theme_names)1621 }16221623 fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {1624 use pallet_proxy_rmrk_core::{1625 RmrkProperty,1626 misc::{CollectionType, NftType}1627 };1628 use pallet_common::CommonCollectionOperations;16291630 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {1631 Ok(c) => c,1632 Err(_) => return Ok(None),1633 };16341635 let theme_info = collection.collection_tokens()1636 .into_iter()1637 .find_map(|token_id| {1638 RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;16391640 let name: RmrkString = RmrkCore::get_nft_property_decoded(1641 collection_id, token_id, RmrkProperty::ThemeName1642 ).ok()?;16431644 if name == theme_name {1645 Some((name, token_id))1646 } else {1647 None1648 }1649 });16501651 let (name, theme_id) = match theme_info {1652 Some((name, theme_id)) => (name, theme_id),1653 None => return Ok(None)1654 };16551656 let properties = RmrkCore::filter_user_properties(1657 collection_id,1658 Some(theme_id),1659 filter_keys,1660 |key, value| RmrkThemeProperty {1661 key,1662 value1663 }1664 )?;16651666 let inherit = RmrkCore::get_nft_property_decoded(1667 collection_id,1668 theme_id,1669 RmrkProperty::ThemeInherit1670 )?;16711672 let theme = RmrkTheme {1673 name,1674 properties,1675 inherit,1676 };16771678 Ok(Some(theme))1679 }1680 }1681}16821683struct CheckInherents;16841685impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1686 fn check_inherents(1687 block: &Block,1688 relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1689 ) -> sp_inherents::CheckInherentsResult {1690 let relay_chain_slot = relay_state_proof1691 .read_slot()1692 .expect("Could not read the relay chain slot from the proof");16931694 let inherent_data =1695 cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1696 relay_chain_slot,1697 sp_std::time::Duration::from_secs(6),1698 )1699 .create_inherent_data()1700 .expect("Could not create the timestamp inherent data");17011702 inherent_data.check_extrinsics(block)1703 }1704}17051706cumulus_pallet_parachain_system::register_validate_block!(1707 Runtime = Runtime,1708 BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1709 CheckInherents = CheckInherents,1710);1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! The Substrate Node Template runtime. This can be compiled with `#[no_std]`, ready for Wasm.1819#![cfg_attr(not(feature = "std"), no_std)]20// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.21#![recursion_limit = "1024"]22#![allow(clippy::from_over_into, clippy::identity_op)]23#![allow(clippy::fn_to_numeric_cast_with_truncation)]24// Make the WASM binary available.25#[cfg(feature = "std")]26include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));2728use sp_api::impl_runtime_apis;29use sp_core::{crypto::KeyTypeId, OpaqueMetadata, H256, U256, H160};30use sp_runtime::DispatchError;31use fp_self_contained::*;32// #[cfg(any(feature = "std", test))]33// pub use sp_runtime::BuildStorage;3435use sp_runtime::{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};4142use sp_std::prelude::*;4344#[cfg(feature = "std")]45use sp_version::NativeVersion;46use sp_version::RuntimeVersion;47pub use pallet_transaction_payment::{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 },70};71use pallet_unique_scheduler::DispatchCall;72use up_data_structs::{73 CollectionId, TokenId, TokenData, Property, PropertyKeyPermission, CollectionLimits,74 CollectionStats, RpcCollection,75 mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},76 TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,77 RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkCollectionId, RmrkNftId,78 RmrkNftChild, RmrkPropertyKey, RmrkResourceId, RmrkBaseId,79};8081// use pallet_contracts::weights::WeightInfo;82// #[cfg(any(feature = "std", test))]83use frame_system::{84 self as frame_system, EnsureRoot, EnsureSigned,85 limits::{BlockWeights, BlockLength},86};87use sp_arithmetic::{88 traits::{BaseArithmetic, Unsigned},89};90use smallvec::smallvec;91// use scale_info::TypeInfo;92use codec::{Encode, Decode};93use fp_rpc::TransactionStatus;94use sp_runtime::{95 traits::{96 Applyable, BlockNumberProvider, Dispatchable, PostDispatchInfoOf, DispatchInfoOf,97 Saturating, CheckedConversion,98 },99 generic::Era,100 transaction_validity::TransactionValidityError,101 DispatchErrorWithPostInfo, SaturatedConversion,102};103104// pub use pallet_timestamp::Call as TimestampCall;105pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;106107// Polkadot imports108use pallet_xcm::XcmPassthrough;109use polkadot_parachain::primitives::Sibling;110use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};111use xcm_builder::{112 AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,113 EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser,114 RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,115 SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,116 ParentIsPreset,117};118use xcm_executor::{Config, XcmExecutor, Assets};119use sp_std::{cmp::Ordering, marker::PhantomData};120121use xcm::latest::{122 // Xcm,123 AssetId::{Concrete},124 Fungibility::Fungible as XcmFungible,125 MultiAsset,126 Error as XcmError,127};128use xcm_executor::traits::{MatchesFungible, WeightTrader};129//use xcm_executor::traits::MatchesFungible;130131use unique_runtime_common::{132 impl_common_runtime_apis,133 types::*,134 constants::*,135 dispatch::{CollectionDispatchT, CollectionDispatch},136 sponsoring::UniqueSponsorshipHandler,137 eth_sponsoring::UniqueEthSponsorshipHandler,138 weights::CommonWeights,139};140141pub const RUNTIME_NAME: &str = "opal";142pub const TOKEN_SYMBOL: &str = "OPL";143144type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;145146impl RuntimeInstance for Runtime {147 type CrossAccountId = self::CrossAccountId;148 type TransactionConverter = self::TransactionConverter;149150 fn get_transaction_converter() -> TransactionConverter {151 TransactionConverter152 }153}154155/// The type for looking up accounts. We don't expect more than 4 billion of them, but you156/// never know...157pub type AccountIndex = u32;158159/// Balance of an account.160pub type Balance = u128;161162/// Index of a transaction in the chain.163pub type Index = u32;164165/// A hash of some data used by the chain.166pub type Hash = sp_core::H256;167168/// Digest item type.169pub type DigestItem = generic::DigestItem;170171/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know172/// the specifics of the runtime. They can then be made to be agnostic over specific formats173/// of data like extrinsics, allowing for them to continue syncing the network through upgrades174/// to even the core data structures.175pub mod opaque {176 use sp_std::prelude::*;177 use sp_runtime::impl_opaque_keys;178 use super::Aura;179180 pub use unique_runtime_common::types::*;181182 impl_opaque_keys! {183 pub struct SessionKeys {184 pub aura: Aura,185 }186 }187}188189/// This runtime version.190pub const VERSION: RuntimeVersion = RuntimeVersion {191 spec_name: create_runtime_str!(RUNTIME_NAME),192 impl_name: create_runtime_str!(RUNTIME_NAME),193 authoring_version: 1,194 spec_version: 922080,195 impl_version: 0,196 apis: RUNTIME_API_VERSIONS,197 transaction_version: 1,198 state_version: 0,199};200201#[derive(codec::Encode, codec::Decode)]202pub enum XCMPMessage<XAccountId, XBalance> {203 /// Transfer tokens to the given account from the Parachain account.204 TransferToken(XAccountId, XBalance),205}206207/// The version information used to identify this runtime when compiled natively.208#[cfg(feature = "std")]209pub fn native_version() -> NativeVersion {210 NativeVersion {211 runtime_version: VERSION,212 can_author_with: Default::default(),213 }214}215216type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;217218pub struct DealWithFees;219impl OnUnbalanced<NegativeImbalance> for DealWithFees {220 fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {221 if let Some(fees) = fees_then_tips.next() {222 // for fees, 100% to treasury223 let mut split = fees.ration(100, 0);224 if let Some(tips) = fees_then_tips.next() {225 // for tips, if any, 100% to treasury226 tips.ration_merge_into(100, 0, &mut split);227 }228 Treasury::on_unbalanced(split.0);229 // Author::on_unbalanced(split.1);230 }231 }232}233234parameter_types! {235 pub const BlockHashCount: BlockNumber = 2400;236 pub RuntimeBlockLength: BlockLength =237 BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);238 pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);239 pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;240 pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()241 .base_block(BlockExecutionWeight::get())242 .for_class(DispatchClass::all(), |weights| {243 weights.base_extrinsic = ExtrinsicBaseWeight::get();244 })245 .for_class(DispatchClass::Normal, |weights| {246 weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);247 })248 .for_class(DispatchClass::Operational, |weights| {249 weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);250 // Operational transactions have some extra reserved space, so that they251 // are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.252 weights.reserved = Some(253 MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT254 );255 })256 .avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)257 .build_or_panic();258 pub const Version: RuntimeVersion = VERSION;259 pub const SS58Prefix: u8 = 42;260}261262parameter_types! {263 pub const ChainId: u64 = 8882;264}265266pub struct FixedFee;267impl FeeCalculator for FixedFee {268 fn min_gas_price() -> (U256, u64) {269 (MIN_GAS_PRICE.into(), 0)270 }271}272273// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case274// (contract, which only writes a lot of data),275// approximating on top of our real store write weight276parameter_types! {277 pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;278 pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;279 pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();280}281282/// Limiting EVM execution to 50% of block for substrate users and management tasks283/// EVM transaction consumes more weight than substrate's, so we can't rely on them being284/// scheduled fairly285const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);286parameter_types! {287 pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());288}289290pub enum FixedGasWeightMapping {}291impl GasWeightMapping for FixedGasWeightMapping {292 fn gas_to_weight(gas: u64) -> Weight {293 gas.saturating_mul(WeightPerGas::get())294 }295 fn weight_to_gas(weight: Weight) -> u64 {296 weight / WeightPerGas::get()297 }298}299300impl pallet_evm::account::Config for Runtime {301 type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Self>;302 type EvmAddressMapping = pallet_evm::HashedAddressMapping<Self::Hashing>;303 type EvmBackwardsAddressMapping = fp_evm_mapping::MapBackwardsAddressTruncated;304}305306impl pallet_evm::Config for Runtime {307 type BlockGasLimit = BlockGasLimit;308 type FeeCalculator = FixedFee;309 type GasWeightMapping = FixedGasWeightMapping;310 type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;311 type CallOrigin = EnsureAddressTruncated<Self>;312 type WithdrawOrigin = EnsureAddressTruncated<Self>;313 type AddressMapping = HashedAddressMapping<Self::Hashing>;314 type PrecompilesType = ();315 type PrecompilesValue = ();316 type Currency = Balances;317 type Event = Event;318 type OnMethodCall = (319 pallet_evm_migration::OnMethodCall<Self>,320 pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,321 CollectionDispatchT<Self>,322 pallet_unique::eth::CollectionHelpersOnMethodCall<Self>,323 );324 type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;325 type ChainId = ChainId;326 type Runner = pallet_evm::runner::stack::Runner<Self>;327 type OnChargeTransaction = pallet_evm::EVMCurrencyAdapter<Balances, DealWithFees>;328 type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;329 type FindAuthor = EthereumFindAuthor<Aura>;330}331332impl pallet_evm_migration::Config for Runtime {333 type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;334}335336pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);337impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {338 fn find_author<'a, I>(digests: I) -> Option<H160>339 where340 I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,341 {342 if let Some(author_index) = F::find_author(digests) {343 let authority_id = Aura::authorities()[author_index as usize].clone();344 return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));345 }346 None347 }348}349350impl pallet_ethereum::Config for Runtime {351 type Event = Event;352 type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;353}354355impl pallet_randomness_collective_flip::Config for Runtime {}356357impl frame_system::Config for Runtime {358 /// The data to be stored in an account.359 type AccountData = pallet_balances::AccountData<Balance>;360 /// The identifier used to distinguish between accounts.361 type AccountId = AccountId;362 /// The basic call filter to use in dispatchable.363 type BaseCallFilter = Everything;364 /// Maximum number of block number to block hash mappings to keep (oldest pruned first).365 type BlockHashCount = BlockHashCount;366 /// The maximum length of a block (in bytes).367 type BlockLength = RuntimeBlockLength;368 /// The index type for blocks.369 type BlockNumber = BlockNumber;370 /// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.371 type BlockWeights = RuntimeBlockWeights;372 /// The aggregated dispatch type that is available for extrinsics.373 type Call = Call;374 /// The weight of database operations that the runtime can invoke.375 type DbWeight = RocksDbWeight;376 /// The ubiquitous event type.377 type Event = Event;378 /// The type for hashing blocks and tries.379 type Hash = Hash;380 /// The hashing algorithm used.381 type Hashing = BlakeTwo256;382 /// The header type.383 type Header = generic::Header<BlockNumber, BlakeTwo256>;384 /// The index type for storing how many extrinsics an account has signed.385 type Index = Index;386 /// The lookup mechanism to get account ID from whatever is passed in dispatchers.387 type Lookup = AccountIdLookup<AccountId, ()>;388 /// What to do if an account is fully reaped from the system.389 type OnKilledAccount = ();390 /// What to do if a new account is created.391 type OnNewAccount = ();392 type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;393 /// The ubiquitous origin type.394 type Origin = Origin;395 /// This type is being generated by `construct_runtime!`.396 type PalletInfo = PalletInfo;397 /// This is used as an identifier of the chain. 42 is the generic substrate prefix.398 type SS58Prefix = SS58Prefix;399 /// Weight information for the extrinsics of this pallet.400 type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;401 /// Version of the runtime.402 type Version = Version;403 type MaxConsumers = ConstU32<16>;404}405406parameter_types! {407 pub const MinimumPeriod: u64 = SLOT_DURATION / 2;408}409410impl pallet_timestamp::Config for Runtime {411 /// A timestamp: milliseconds since the unix epoch.412 type Moment = u64;413 type OnTimestampSet = ();414 type MinimumPeriod = MinimumPeriod;415 type WeightInfo = ();416}417418parameter_types! {419 // pub const ExistentialDeposit: u128 = 500;420 pub const ExistentialDeposit: u128 = 0;421 pub const MaxLocks: u32 = 50;422 pub const MaxReserves: u32 = 50;423}424425impl pallet_balances::Config for Runtime {426 type MaxLocks = MaxLocks;427 type MaxReserves = MaxReserves;428 type ReserveIdentifier = [u8; 16];429 /// The type for recording an account's balance.430 type Balance = Balance;431 /// The ubiquitous event type.432 type Event = Event;433 type DustRemoval = Treasury;434 type ExistentialDeposit = ExistentialDeposit;435 type AccountStore = System;436 type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;437}438439pub const fn deposit(items: u32, bytes: u32) -> Balance {440 items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE441}442443/*444parameter_types! {445 pub TombstoneDeposit: Balance = deposit(446 1,447 sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,448 );449 pub DepositPerContract: Balance = TombstoneDeposit::get();450 pub const DepositPerStorageByte: Balance = deposit(0, 1);451 pub const DepositPerStorageItem: Balance = deposit(1, 0);452 pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);453 pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;454 pub const SignedClaimHandicap: u32 = 2;455 pub const MaxDepth: u32 = 32;456 pub const MaxValueSize: u32 = 16 * 1024;457 pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb458 // The lazy deletion runs inside on_initialize.459 pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *460 RuntimeBlockWeights::get().max_block;461 // The weight needed for decoding the queue should be less or equal than a fifth462 // of the overall weight dedicated to the lazy deletion.463 pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (464 <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -465 <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)466 )) / 5) as u32;467 pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();468}469470impl pallet_contracts::Config for Runtime {471 type Time = Timestamp;472 type Randomness = RandomnessCollectiveFlip;473 type Currency = Balances;474 type Event = Event;475 type RentPayment = ();476 type SignedClaimHandicap = SignedClaimHandicap;477 type TombstoneDeposit = TombstoneDeposit;478 type DepositPerContract = DepositPerContract;479 type DepositPerStorageByte = DepositPerStorageByte;480 type DepositPerStorageItem = DepositPerStorageItem;481 type RentFraction = RentFraction;482 type SurchargeReward = SurchargeReward;483 type WeightPrice = pallet_transaction_payment::Pallet<Self>;484 type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;485 type ChainExtension = NFTExtension;486 type DeletionQueueDepth = DeletionQueueDepth;487 type DeletionWeightLimit = DeletionWeightLimit;488 type Schedule = Schedule;489 type CallStack = [pallet_contracts::Frame<Self>; 31];490}491*/492493parameter_types! {494 /// This value increases the priority of `Operational` transactions by adding495 /// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.496 pub const OperationalFeeMultiplier: u8 = 5;497}498499/// Linear implementor of `WeightToFeePolynomial`500pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);501502impl<T> WeightToFeePolynomial for LinearFee<T>503where504 T: BaseArithmetic + From<u32> + Copy + Unsigned,505{506 type Balance = T;507508 fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {509 smallvec!(WeightToFeeCoefficient {510 // Targeting 0.1 Unique per NFT transfer511 coeff_integer: WEIGHT_TO_FEE_COEFF.into(),512 coeff_frac: Perbill::zero(),513 negative: false,514 degree: 1,515 })516 }517}518519impl 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}526527parameter_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}546547impl 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}564565impl pallet_sudo::Config for Runtime {566 type Event = Event;567 type Call = Call;568}569570pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);571572impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider573 for RelayChainBlockNumberProvider<T>574{575 type BlockNumber = BlockNumber;576577 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}583584parameter_types! {585 pub const MinVestedTransfer: Balance = 10 * UNIQUE;586 pub const MaxVestingSchedules: u32 = 28;587}588589impl 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}598599parameter_types! {600 pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;601 pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;602}603604impl 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}619620impl parachain_info::Config for Runtime {}621622impl cumulus_pallet_aura_ext::Config for Runtime {}623624parameter_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}630631/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used632/// when determining ownership of accounts for asset transacting and when attempting to use XCM633/// `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);642643pub 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}652653/// 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>;666667/// 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 can669/// 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 location672 // using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for673 // 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 when676 // recognised.677 RelayChainAsNative<RelayOrigin, Origin>,678 // Native converter for sibling Parachains; will convert to a `SiblingPara` origin when679 // recognised.680 SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,681 // Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a682 // transaction from the Root origin.683 ParentAsSuperuser<Origin>,684 // Native signed account converter; this just converts an `AccountId32` origin into a normal685 // `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);690691parameter_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}699700match_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}706707pub type Barrier = (708 TakeWeightCredit,709 AllowTopLevelPaidExecutionFrom<Everything>,710 AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,711 // ^^^ Parent & its unit plurality gets free execution712);713714pub struct UsingOnlySelfCurrencyComponents<715 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,716 AssetId: Get<MultiLocation>,717 AccountId,718 Currency: CurrencyT<AccountId>,719 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,720>(721 Weight,722 Currency::Balance,723 PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,724);725impl<726 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,727 AssetId: Get<MultiLocation>,728 AccountId,729 Currency: CurrencyT<AccountId>,730 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,731 > WeightTrader732 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>733{734 fn new() -> Self {735 Self(0, Zero::zero(), PhantomData)736 }737738 fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {739 let amount = WeightToFee::calc(&weight);740 let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;741742 // location to this parachain through relay chain743 let option1: xcm::v1::AssetId = Concrete(MultiLocation {744 parents: 1,745 interior: X1(Parachain(ParachainInfo::parachain_id().into())),746 });747 // direct location748 let option2: xcm::v1::AssetId = Concrete(MultiLocation {749 parents: 0,750 interior: Here,751 });752753 let required = if payment.fungible.contains_key(&option1) {754 (option1, u128_amount).into()755 } else if payment.fungible.contains_key(&option2) {756 (option2, u128_amount).into()757 } else {758 (Concrete(MultiLocation::default()), u128_amount).into()759 };760761 let unused = payment762 .checked_sub(required)763 .map_err(|_| XcmError::TooExpensive)?;764 self.0 = self.0.saturating_add(weight);765 self.1 = self.1.saturating_add(amount);766 Ok(unused)767 }768769 fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {770 let weight = weight.min(self.0);771 let amount = WeightToFee::calc(&weight);772 self.0 -= weight;773 self.1 = self.1.saturating_sub(amount);774 let amount: u128 = amount.saturated_into();775 if amount > 0 {776 Some((AssetId::get(), amount).into())777 } else {778 None779 }780 }781}782impl<783 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,784 AssetId: Get<MultiLocation>,785 AccountId,786 Currency: CurrencyT<AccountId>,787 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,788 > Drop789 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>790{791 fn drop(&mut self) {792 OnUnbalanced::on_unbalanced(Currency::issue(self.1));793 }794}795796pub struct XcmConfig;797impl Config for XcmConfig {798 type Call = Call;799 type XcmSender = XcmRouter;800 // How to withdraw and deposit an asset.801 type AssetTransactor = LocalAssetTransactor;802 type OriginConverter = XcmOriginToTransactDispatchOrigin;803 type IsReserve = NativeAsset;804 type IsTeleporter = (); // Teleportation is disabled805 type LocationInverter = LocationInverter<Ancestry>;806 type Barrier = Barrier;807 type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;808 type Trader = UsingOnlySelfCurrencyComponents<809 IdentityFee<Balance>,810 RelayLocation,811 AccountId,812 Balances,813 (),814 >;815 type ResponseHandler = (); // Don't handle responses for now.816 type SubscriptionService = PolkadotXcm;817818 type AssetTrap = PolkadotXcm;819 type AssetClaims = PolkadotXcm;820}821822// parameter_types! {823// pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;824// }825826/// No local origins on this chain are allowed to dispatch XCM sends/executions.827pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);828829/// The means for routing XCM messages which are not for local execution into the right message830/// queues.831pub type XcmRouter = (832 // Two routers - use UMP to communicate with the relay chain:833 cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,834 // ..and XCMP to communicate with the sibling chains.835 XcmpQueue,836);837838impl pallet_evm_coder_substrate::Config for Runtime {}839840impl pallet_xcm::Config for Runtime {841 type Event = Event;842 type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;843 type XcmRouter = XcmRouter;844 type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;845 type XcmExecuteFilter = Everything;846 type XcmExecutor = XcmExecutor<XcmConfig>;847 type XcmTeleportFilter = Everything;848 type XcmReserveTransferFilter = Everything;849 type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;850 type LocationInverter = LocationInverter<Ancestry>;851 type Origin = Origin;852 type Call = Call;853 const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;854 type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;855}856857impl cumulus_pallet_xcm::Config for Runtime {858 type Event = Event;859 type XcmExecutor = XcmExecutor<XcmConfig>;860}861862impl cumulus_pallet_xcmp_queue::Config for Runtime {863 type WeightInfo = ();864 type Event = Event;865 type XcmExecutor = XcmExecutor<XcmConfig>;866 type ChannelInfo = ParachainSystem;867 type VersionWrapper = ();868 type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;869 type ControllerOrigin = EnsureRoot<AccountId>;870 type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;871}872873impl cumulus_pallet_dmp_queue::Config for Runtime {874 type Event = Event;875 type XcmExecutor = XcmExecutor<XcmConfig>;876 type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;877}878879impl pallet_aura::Config for Runtime {880 type AuthorityId = AuraId;881 type DisabledValidators = ();882 type MaxAuthorities = MaxAuthorities;883}884885parameter_types! {886 pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();887 pub const CollectionCreationPrice: Balance = 2 * UNIQUE;888}889890impl pallet_common::Config for Runtime {891 type WeightInfo = pallet_common::weights::SubstrateWeight<Self>;892 type Event = Event;893 type Currency = Balances;894 type CollectionCreationPrice = CollectionCreationPrice;895 type TreasuryAccountId = TreasuryAccountId;896 type CollectionDispatch = CollectionDispatchT<Self>;897898 type EvmTokenAddressMapping = EvmTokenAddressMapping;899 type CrossTokenAddressMapping = CrossTokenAddressMapping<Self::AccountId>;900 type ContractAddress = EvmCollectionHelpersAddress;901}902903impl pallet_structure::Config for Runtime {904 type Event = Event;905 type Call = Call;906 type WeightInfo = pallet_structure::weights::SubstrateWeight<Self>;907}908909impl pallet_fungible::Config for Runtime {910 type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;911}912impl pallet_refungible::Config for Runtime {913 type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;914}915impl pallet_nonfungible::Config for Runtime {916 type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;917}918919impl pallet_proxy_rmrk_core::Config for Runtime {920 type WeightInfo = pallet_proxy_rmrk_core::weights::SubstrateWeight<Self>;921 type Event = Event;922}923924impl pallet_proxy_rmrk_equip::Config for Runtime {925 type WeightInfo = pallet_proxy_rmrk_equip::weights::SubstrateWeight<Self>;926 type Event = Event;927}928929impl pallet_unique::Config for Runtime {930 type Event = Event;931 type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;932 type CommonWeightInfo = CommonWeights<Self>;933}934935parameter_types! {936 pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied937}938939/// Used for the pallet inflation940impl pallet_inflation::Config for Runtime {941 type Currency = Balances;942 type TreasuryAccountId = TreasuryAccountId;943 type InflationBlockInterval = InflationBlockInterval;944 type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;945}946947parameter_types! {948 pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *949 RuntimeBlockWeights::get().max_block;950 pub const MaxScheduledPerBlock: u32 = 50;951}952953type ChargeTransactionPayment = pallet_charge_transaction::ChargeTransactionPayment<Runtime>;954use frame_support::traits::NamedReservableCurrency;955956fn get_signed_extras(from: <Runtime as frame_system::Config>::AccountId) -> SignedExtraScheduler {957 (958 frame_system::CheckSpecVersion::<Runtime>::new(),959 frame_system::CheckGenesis::<Runtime>::new(),960 frame_system::CheckEra::<Runtime>::from(Era::Immortal),961 frame_system::CheckNonce::<Runtime>::from(frame_system::Pallet::<Runtime>::account_nonce(962 from,963 )),964 frame_system::CheckWeight::<Runtime>::new(),965 // sponsoring transaction logic966 // pallet_charge_transaction::ChargeTransactionPayment::<Runtime>::new(0),967 )968}969970pub struct SchedulerPaymentExecutor;971impl<T: frame_system::Config + pallet_unique_scheduler::Config, SelfContainedSignedInfo>972 DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor973where974 <T as frame_system::Config>::Call: Member975 + Dispatchable<Origin = Origin, Info = DispatchInfo>976 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>977 + GetDispatchInfo978 + From<frame_system::Call<Runtime>>,979 SelfContainedSignedInfo: Send + Sync + 'static,980 Call: From<<T as frame_system::Config>::Call>981 + From<<T as pallet_unique_scheduler::Config>::Call>982 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,983 sp_runtime::AccountId32: From<<T as frame_system::Config>::AccountId>,984{985 fn dispatch_call(986 signer: <T as frame_system::Config>::AccountId,987 call: <T as pallet_unique_scheduler::Config>::Call,988 ) -> Result<989 Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,990 TransactionValidityError,991 > {992 let dispatch_info = call.get_dispatch_info();993 let extrinsic = fp_self_contained::CheckedExtrinsic::<994 AccountId,995 Call,996 SignedExtraScheduler,997 SelfContainedSignedInfo,998 > {999 signed:1000 CheckedSignature::<AccountId, SignedExtraScheduler, SelfContainedSignedInfo>::Signed(1001 signer.clone().into(),1002 get_signed_extras(signer.into()),1003 ),1004 function: call.into(),1005 };10061007 extrinsic.apply::<Runtime>(&dispatch_info, 0)1008 }10091010 fn reserve_balance(1011 id: [u8; 16],1012 sponsor: <T as frame_system::Config>::AccountId,1013 call: <T as pallet_unique_scheduler::Config>::Call,1014 count: u32,1015 ) -> Result<(), DispatchError> {1016 let dispatch_info = call.get_dispatch_info();1017 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0)1018 .saturating_mul(count.into());10191020 <Balances as NamedReservableCurrency<AccountId>>::reserve_named(1021 &id,1022 &(sponsor.into()),1023 weight,1024 )1025 }10261027 fn pay_for_call(1028 id: [u8; 16],1029 sponsor: <T as frame_system::Config>::AccountId,1030 call: <T as pallet_unique_scheduler::Config>::Call,1031 ) -> Result<u128, DispatchError> {1032 let dispatch_info = call.get_dispatch_info();1033 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0);1034 Ok(1035 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1036 &id,1037 &(sponsor.into()),1038 weight,1039 ),1040 )1041 }10421043 fn cancel_reserve(1044 id: [u8; 16],1045 sponsor: <T as frame_system::Config>::AccountId,1046 ) -> Result<u128, DispatchError> {1047 Ok(1048 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1049 &id,1050 &(sponsor.into()),1051 u128::MAX,1052 ),1053 )1054 }1055}10561057parameter_types! {1058 pub const NoPreimagePostponement: Option<u32> = Some(10);1059 pub const Preimage: Option<u32> = Some(10);1060}10611062/// Used the compare the privilege of an origin inside the scheduler.1063pub struct OriginPrivilegeCmp;10641065impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {1066 fn cmp_privilege(_left: &OriginCaller, _right: &OriginCaller) -> Option<Ordering> {1067 Some(Ordering::Equal)1068 }1069}10701071impl pallet_unique_scheduler::Config for Runtime {1072 type Event = Event;1073 type Origin = Origin;1074 type Currency = Balances;1075 type PalletsOrigin = OriginCaller;1076 type Call = Call;1077 type MaximumWeight = MaximumSchedulerWeight;1078 type ScheduleOrigin = EnsureSigned<AccountId>;1079 type MaxScheduledPerBlock = MaxScheduledPerBlock;1080 type WeightInfo = ();1081 type CallExecutor = SchedulerPaymentExecutor;1082 type OriginPrivilegeCmp = OriginPrivilegeCmp;1083 type PreimageProvider = ();1084 type NoPreimagePostponement = NoPreimagePostponement;1085}10861087type EvmSponsorshipHandler = (1088 UniqueEthSponsorshipHandler<Runtime>,1089 pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,1090);10911092type SponsorshipHandler = (1093 UniqueSponsorshipHandler<Runtime>,1094 //pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1095 pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1096);10971098impl pallet_evm_transaction_payment::Config for Runtime {1099 type EvmSponsorshipHandler = EvmSponsorshipHandler;1100 type Currency = Balances;1101}11021103impl pallet_charge_transaction::Config for Runtime {1104 type SponsorshipHandler = SponsorshipHandler;1105}11061107// impl pallet_contract_helpers::Config for Runtime {1108// type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1109// }11101111parameter_types! {1112 // 0x842899ECF380553E8a4de75bF534cdf6fBF640491113 pub const HelpersContractAddress: H160 = H160([1114 0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1115 ]);11161117 // 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f1118 pub const EvmCollectionHelpersAddress: H160 = H160([1119 0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,1120 ]);1121}11221123impl pallet_evm_contract_helpers::Config for Runtime {1124 type ContractAddress = HelpersContractAddress;1125 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1126}11271128construct_runtime!(1129 pub enum Runtime where1130 Block = Block,1131 NodeBlock = opaque::Block,1132 UncheckedExtrinsic = UncheckedExtrinsic1133 {1134 ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1135 ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,11361137 Aura: pallet_aura::{Pallet, Config<T>} = 22,1138 AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,11391140 Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1141 RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1142 Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1143 TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1144 Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1145 Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1146 System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1147 Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1148 // Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1149 // Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,11501151 // XCM helpers.1152 XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1153 PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1154 CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1155 DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11561157 // Unique Pallets1158 Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1159 Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1160 Scheduler: pallet_unique_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1161 // free = 631162 Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1163 // ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1164 Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1165 Fungible: pallet_fungible::{Pallet, Storage} = 67,1166 Refungible: pallet_refungible::{Pallet, Storage} = 68,1167 Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1168 Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,1169 RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,1170 RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,11711172 // Frontier1173 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1174 Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11751176 EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1177 EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1178 EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1179 EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1180 }1181);11821183pub struct TransactionConverter;11841185impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1186 fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1187 UncheckedExtrinsic::new_unsigned(1188 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1189 )1190 }1191}11921193impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1194 fn convert_transaction(1195 &self,1196 transaction: pallet_ethereum::Transaction,1197 ) -> opaque::UncheckedExtrinsic {1198 let extrinsic = UncheckedExtrinsic::new_unsigned(1199 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1200 );1201 let encoded = extrinsic.encode();1202 opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1203 .expect("Encoded extrinsic is always valid")1204 }1205}12061207/// The address format for describing accounts.1208pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1209/// Block header type as expected by this runtime.1210pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1211/// Block type as expected by this runtime.1212pub type Block = generic::Block<Header, UncheckedExtrinsic>;1213/// A Block signed with a Justification1214pub type SignedBlock = generic::SignedBlock<Block>;1215/// BlockId type as expected by this runtime.1216pub type BlockId = generic::BlockId<Block>;1217/// The SignedExtension to the basic transaction logic.1218pub type SignedExtra = (1219 frame_system::CheckSpecVersion<Runtime>,1220 // system::CheckTxVersion<Runtime>,1221 frame_system::CheckGenesis<Runtime>,1222 frame_system::CheckEra<Runtime>,1223 frame_system::CheckNonce<Runtime>,1224 frame_system::CheckWeight<Runtime>,1225 ChargeTransactionPayment,1226 //pallet_contract_helpers::ContractHelpersExtension<Runtime>,1227 pallet_ethereum::FakeTransactionFinalizer<Runtime>,1228);1229pub type SignedExtraScheduler = (1230 frame_system::CheckSpecVersion<Runtime>,1231 frame_system::CheckGenesis<Runtime>,1232 frame_system::CheckEra<Runtime>,1233 frame_system::CheckNonce<Runtime>,1234 frame_system::CheckWeight<Runtime>,1235);1236/// Unchecked extrinsic type as expected by this runtime.1237pub type UncheckedExtrinsic =1238 fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1239/// Extrinsic type that has already been checked.1240pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1241/// Executive: handles dispatch to the various modules.1242pub type Executive = frame_executive::Executive<1243 Runtime,1244 Block,1245 frame_system::ChainContext<Runtime>,1246 Runtime,1247 AllPalletsReversedWithSystemFirst,1248>;12491250impl_opaque_keys! {1251 pub struct SessionKeys {1252 pub aura: Aura,1253 }1254}12551256impl fp_self_contained::SelfContainedCall for Call {1257 type SignedInfo = H160;12581259 fn is_self_contained(&self) -> bool {1260 match self {1261 Call::Ethereum(call) => call.is_self_contained(),1262 _ => false,1263 }1264 }12651266 fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1267 match self {1268 Call::Ethereum(call) => call.check_self_contained(),1269 _ => None,1270 }1271 }12721273 fn validate_self_contained(1274 &self,1275 info: &Self::SignedInfo,1276 dispatch_info: &DispatchInfoOf<Call>,1277 len: usize,1278 ) -> Option<TransactionValidity> {1279 match self {1280 Call::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),1281 _ => None,1282 }1283 }12841285 fn pre_dispatch_self_contained(1286 &self,1287 info: &Self::SignedInfo,1288 ) -> Option<Result<(), TransactionValidityError>> {1289 match self {1290 Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1291 _ => None,1292 }1293 }12941295 fn apply_self_contained(1296 self,1297 info: Self::SignedInfo,1298 ) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1299 match self {1300 call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1301 Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1302 )),1303 _ => None,1304 }1305 }1306}13071308macro_rules! dispatch_unique_runtime {1309 ($collection:ident.$method:ident($($name:ident),*)) => {{1310 let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1311 let dispatch = collection.as_dyn();13121313 Ok::<_, DispatchError>(dispatch.$method($($name),*))1314 }};1315}13161317impl_common_runtime_apis! {1318 #![custom_apis]13191320 impl rmrk_rpc::RmrkApi<1321 Block,1322 AccountId,1323 RmrkCollectionInfo<AccountId>,1324 RmrkInstanceInfo<AccountId>,1325 RmrkResourceInfo,1326 RmrkPropertyInfo,1327 RmrkBaseInfo<AccountId>,1328 RmrkPartType,1329 RmrkTheme1330 > for Runtime {1331 fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {1332 pallet_proxy_rmrk_core::rpc::last_collection_idx::<Runtime>()1333 }13341335 fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {1336 pallet_proxy_rmrk_core::rpc::collection_by_id::<Runtime>(collection_id)1337 }13381339 fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {1340 pallet_proxy_rmrk_core::rpc::nft_by_id::<Runtime>(collection_id, nft_by_id)1341 }13421343 fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {1344 pallet_proxy_rmrk_core::rpc::account_tokens::<Runtime>(account_id, collection_id)1345 }13461347 fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {1348 pallet_proxy_rmrk_core::rpc::nft_children::<Runtime>(collection_id, nft_id)1349 }13501351 fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {1352 pallet_proxy_rmrk_core::rpc::collection_properties::<Runtime>(collection_id, filter_keys)1353 }13541355 fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {1356 pallet_proxy_rmrk_core::rpc::nft_properties::<Runtime>(collection_id, nft_id, filter_keys)1357 }13581359 fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {1360 pallet_proxy_rmrk_core::rpc::nft_resources::<Runtime>(collection_id, nft_id)1361 }13621363 fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {1364 pallet_proxy_rmrk_core::rpc::nft_resource_priority::<Runtime>(collection_id, nft_id, resource_id)1365 }13661367 fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {1368 pallet_proxy_rmrk_equip::rpc::base::<Runtime>(base_id)1369 }13701371 fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {1372 pallet_proxy_rmrk_equip::rpc::base_parts::<Runtime>(base_id)1373 }13741375 fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {1376 pallet_proxy_rmrk_equip::rpc::theme_names::<Runtime>(base_id)1377 }13781379 fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {1380 pallet_proxy_rmrk_equip::rpc::theme::<Runtime>(base_id, theme_name, filter_keys)1381 }1382 }1383}13841385struct CheckInherents;13861387impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1388 fn check_inherents(1389 block: &Block,1390 relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1391 ) -> sp_inherents::CheckInherentsResult {1392 let relay_chain_slot = relay_state_proof1393 .read_slot()1394 .expect("Could not read the relay chain slot from the proof");13951396 let inherent_data =1397 cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1398 relay_chain_slot,1399 sp_std::time::Duration::from_secs(6),1400 )1401 .create_inherent_data()1402 .expect("Could not create the timestamp inherent data");14031404 inherent_data.check_extrinsics(block)1405 }1406}14071408cumulus_pallet_parachain_system::register_validate_block!(1409 Runtime = Runtime,1410 BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1411 CheckInherents = CheckInherents,1412);runtime/quartz/src/lib.rsdiffbeforeafterboth--- a/runtime/quartz/src/lib.rs
+++ b/runtime/quartz/src/lib.rs
@@ -74,9 +74,8 @@
CollectionStats, RpcCollection,
mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},
TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,
- RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkThemeProperty, RmrkCollectionId,
- RmrkNftId, RmrkAccountIdOrCollectionNftTuple, RmrkNftChild, RmrkPropertyKey, RmrkResourceId,
- RmrkBaseId, RmrkFixedPart, RmrkSlotPart, RmrkString,
+ RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkCollectionId, RmrkNftId,
+ RmrkNftChild, RmrkPropertyKey, RmrkResourceId, RmrkBaseId,
};
// use pallet_contracts::weights::WeightInfo;
@@ -1330,352 +1329,55 @@
RmrkTheme
> for Runtime {
fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
- Ok(RmrkCore::last_collection_idx())
+ pallet_proxy_rmrk_core::rpc::last_collection_idx::<Runtime>()
}
fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let nfts_count = collection.total_supply();
-
- Ok(Some(RmrkCollectionInfo {
- issuer: collection.owner.clone(),
- metadata: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::Metadata)?,
- max: collection.limits.token_limit,
- symbol: RmrkCore::rebind(&collection.token_prefix)?,
- nfts_count
- }))
+ pallet_proxy_rmrk_core::rpc::collection_by_id::<Runtime>(collection_id)
}
fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {
- use up_data_structs::mapping::TokenAddressMapping;
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let nft_id = TokenId(nft_by_id);
- if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }
-
- let owner = match collection.token_owner(nft_id) {
- Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {
- Some((col, tok)) => {
- let rmrk_collection = RmrkCore::rmrk_collection_id(col)?;
-
- RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)
- }
- None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())
- },
- None => return Ok(None)
- };
-
- Ok(Some(RmrkInstanceInfo {
- owner: owner,
- royalty: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::RoyaltyInfo)?,
- metadata: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Metadata)?,
- equipped: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Equipped)?,
- pending: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::PendingNftAccept)?,
- }))
+ pallet_proxy_rmrk_core::rpc::nft_by_id::<Runtime>(collection_id, nft_by_id)
}
fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let cross_account_id = CrossAccountId::from_sub(account_id);
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let tokens = collection.account_tokens(cross_account_id)
- .into_iter()
- .filter(|token| {
- let is_pending = RmrkCore::get_nft_property_decoded(
- collection_id,
- *token,
- RmrkProperty::PendingNftAccept
- ).unwrap_or(true);
-
- !is_pending
- })
- .map(|token| token.0)
- .collect();
-
- Ok(tokens)
+ pallet_proxy_rmrk_core::rpc::account_tokens::<Runtime>(account_id, collection_id)
}
fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {
- use pallet_proxy_rmrk_core::RmrkProperty;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- let nft_id = TokenId(nft_id);
- if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(Vec::new()); }
-
- Ok(
- pallet_nonfungible::TokenChildren::<Runtime>::iter_prefix((collection_id, nft_id))
- .filter_map(|((child_collection, child_token), _)| {
- let is_pending = RmrkCore::get_nft_property_decoded(
- child_collection,
- child_token,
- RmrkProperty::PendingNftAccept
- ).ok()?;
-
- if is_pending {
- return None;
- }
-
- let rmrk_child_collection = RmrkCore::rmrk_collection_id(
- child_collection
- ).ok()?;
-
- Some(RmrkNftChild {
- collection_id: rmrk_child_collection,
- nft_id: child_token.0,
- })
- }).collect()
- )
+ pallet_proxy_rmrk_core::rpc::nft_children::<Runtime>(collection_id, nft_id)
}
fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::CollectionType;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() {
- return Ok(Vec::new());
- }
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- /* token_id = */ None,
- filter_keys,
- |key, value| RmrkPropertyInfo {
- key,
- value
- }
- )?;
-
- Ok(properties)
+ pallet_proxy_rmrk_core::rpc::collection_properties::<Runtime>(collection_id, filter_keys)
}
fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::NftType;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- let token_id = TokenId(nft_id);
-
- if RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {
- return Ok(Vec::new());
- }
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- Some(token_id),
- filter_keys,
- |key, value| RmrkPropertyInfo {
- key,
- value
- }
- )?;
-
- Ok(properties)
+ pallet_proxy_rmrk_core::rpc::nft_properties::<Runtime>(collection_id, nft_id, filter_keys)
}
fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::{CollectionType, NftType};
- use up_data_structs::PropertyScope;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }
-
- let nft_id = TokenId(nft_id);
- if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }
-
- let resources = <pallet_nonfungible::Pallet<Runtime>>::iterate_token_aux_properties(
- collection_id, nft_id, PropertyScope::Rmrk
- ).filter_map(|(_, value)| {
- let resource_info: RmrkResourceInfo = RmrkCore::decode_property(&value).ok()?;
-
- Some(resource_info)
- }).collect();
-
- Ok(resources)
+ pallet_proxy_rmrk_core::rpc::nft_resources::<Runtime>(collection_id, nft_id)
}
fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(None)
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }
-
- let nft_id = TokenId(nft_id);
- if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }
-
- let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;
- Ok(
- priorities.into_iter()
- .enumerate()
- .find(|(_, id)| *id == resource_id)
- .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)
- )
+ pallet_proxy_rmrk_core::rpc::nft_resource_priority::<Runtime>(collection_id, nft_id, resource_id)
}
fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {
- use pallet_proxy_rmrk_core::{
- RmrkProperty, misc::{CollectionType},
- };
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- Ok(Some(RmrkBaseInfo {
- issuer: collection.owner.clone(),
- base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,
- symbol: RmrkCore::rebind(&collection.token_prefix)?,
- }))
+ pallet_proxy_rmrk_equip::rpc::base::<Runtime>(base_id)
}
fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let parts = collection.collection_tokens()
- .into_iter()
- .filter_map(|token_id| {
- let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;
-
- match nft_type {
- NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {
- id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
- src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
- z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
- })),
- NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {
- id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
- src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
- z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
- equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,
- })),
- _ => None
- }
- })
- .collect();
-
- Ok(parts)
+ pallet_proxy_rmrk_equip::rpc::base_parts::<Runtime>(base_id)
}
fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{NftType, CollectionType}};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let theme_names = collection.collection_tokens()
- .iter()
- .filter_map(|token_id| {
- let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).ok()?;
-
- match nft_type {
- NftType::Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),
- _ => None
- }
- })
- .collect();
-
- Ok(theme_names)
+ pallet_proxy_rmrk_equip::rpc::theme_names::<Runtime>(base_id)
}
fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {
- use pallet_proxy_rmrk_core::{
- RmrkProperty,
- misc::{CollectionType, NftType}
- };
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let theme_info = collection.collection_tokens()
- .into_iter()
- .find_map(|token_id| {
- RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;
-
- let name: RmrkString = RmrkCore::get_nft_property_decoded(
- collection_id, token_id, RmrkProperty::ThemeName
- ).ok()?;
-
- if name == theme_name {
- Some((name, token_id))
- } else {
- None
- }
- });
-
- let (name, theme_id) = match theme_info {
- Some((name, theme_id)) => (name, theme_id),
- None => return Ok(None)
- };
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- Some(theme_id),
- filter_keys,
- |key, value| RmrkThemeProperty {
- key,
- value
- }
- )?;
-
- let inherit = RmrkCore::get_nft_property_decoded(
- collection_id,
- theme_id,
- RmrkProperty::ThemeInherit
- )?;
-
- let theme = RmrkTheme {
- name,
- properties,
- inherit,
- };
-
- Ok(Some(theme))
+ pallet_proxy_rmrk_equip::rpc::theme::<Runtime>(base_id, theme_name, filter_keys)
}
}
}