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.rsdiffbeforeafterboth--- a/runtime/opal/src/lib.rs
+++ b/runtime/opal/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)
}
}
}
runtime/quartz/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;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};129130use unique_runtime_common::{131 impl_common_runtime_apis,132 types::*,133 constants::*,134 dispatch::{CollectionDispatchT, CollectionDispatch},135 sponsoring::UniqueSponsorshipHandler,136 eth_sponsoring::UniqueEthSponsorshipHandler,137 weights::CommonWeights,138};139140pub const RUNTIME_NAME: &str = "quartz";141pub const TOKEN_SYMBOL: &str = "QTZ";142143type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;144145impl RuntimeInstance for Runtime {146 type CrossAccountId = self::CrossAccountId;147148 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 = 255;260}261262parameter_types! {263 pub const ChainId: u64 = 8881;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 = 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.into(),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.into(),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);1091type SponsorshipHandler = (1092 UniqueSponsorshipHandler<Runtime>,1093 //pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1094 pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1095);10961097impl pallet_evm_transaction_payment::Config for Runtime {1098 type EvmSponsorshipHandler = EvmSponsorshipHandler;1099 type Currency = Balances;1100}11011102impl pallet_charge_transaction::Config for Runtime {1103 type SponsorshipHandler = SponsorshipHandler;1104}11051106// impl pallet_contract_helpers::Config for Runtime {1107// type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1108// }11091110parameter_types! {1111 // 0x842899ECF380553E8a4de75bF534cdf6fBF640491112 pub const HelpersContractAddress: H160 = H160([1113 0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1114 ]);11151116 // 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f1117 pub const EvmCollectionHelpersAddress: H160 = H160([1118 0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,1119 ]);1120}11211122impl pallet_evm_contract_helpers::Config for Runtime {1123 type ContractAddress = HelpersContractAddress;1124 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1125}11261127construct_runtime!(1128 pub enum Runtime where1129 Block = Block,1130 NodeBlock = opaque::Block,1131 UncheckedExtrinsic = UncheckedExtrinsic1132 {1133 ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1134 ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,11351136 Aura: pallet_aura::{Pallet, Config<T>} = 22,1137 AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,11381139 Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1140 RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1141 Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1142 TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1143 Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1144 Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1145 System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1146 Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1147 // Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1148 // Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,11491150 // XCM helpers.1151 XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1152 PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1153 CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1154 DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11551156 // Unique Pallets1157 Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1158 Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1159 Scheduler: pallet_unique_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1160 // free = 631161 Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1162 // ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1163 Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1164 Fungible: pallet_fungible::{Pallet, Storage} = 67,1165 Refungible: pallet_refungible::{Pallet, Storage} = 68,1166 Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1167 Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,1168 RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,1169 RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,11701171 // Frontier1172 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1173 Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11741175 EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1176 EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1177 EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1178 EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1179 }1180);11811182pub struct TransactionConverter;11831184impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1185 fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1186 UncheckedExtrinsic::new_unsigned(1187 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1188 )1189 }1190}11911192impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1193 fn convert_transaction(1194 &self,1195 transaction: pallet_ethereum::Transaction,1196 ) -> opaque::UncheckedExtrinsic {1197 let extrinsic = UncheckedExtrinsic::new_unsigned(1198 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1199 );1200 let encoded = extrinsic.encode();1201 opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1202 .expect("Encoded extrinsic is always valid")1203 }1204}12051206/// The address format for describing accounts.1207pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1208/// Block header type as expected by this runtime.1209pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1210/// Block type as expected by this runtime.1211pub type Block = generic::Block<Header, UncheckedExtrinsic>;1212/// A Block signed with a Justification1213pub type SignedBlock = generic::SignedBlock<Block>;1214/// BlockId type as expected by this runtime.1215pub type BlockId = generic::BlockId<Block>;1216/// The SignedExtension to the basic transaction logic.1217pub type SignedExtra = (1218 frame_system::CheckSpecVersion<Runtime>,1219 // system::CheckTxVersion<Runtime>,1220 frame_system::CheckGenesis<Runtime>,1221 frame_system::CheckEra<Runtime>,1222 frame_system::CheckNonce<Runtime>,1223 frame_system::CheckWeight<Runtime>,1224 ChargeTransactionPayment,1225 //pallet_contract_helpers::ContractHelpersExtension<Runtime>,1226 pallet_ethereum::FakeTransactionFinalizer<Runtime>,1227);12281229pub 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 // pallet_charge_transaction::ChargeTransactionPayment<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;91use codec::{Encode, Decode};92use fp_rpc::TransactionStatus;93use sp_runtime::{94 traits::{95 Applyable, BlockNumberProvider, Dispatchable, PostDispatchInfoOf, DispatchInfoOf,96 Saturating, CheckedConversion,97 },98 generic::Era,99 transaction_validity::TransactionValidityError,100 DispatchErrorWithPostInfo, SaturatedConversion,101};102103// pub use pallet_timestamp::Call as TimestampCall;104pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;105106// Polkadot imports107use pallet_xcm::XcmPassthrough;108use polkadot_parachain::primitives::Sibling;109use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};110use xcm_builder::{111 AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,112 EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser,113 RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,114 SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,115 ParentIsPreset,116};117use xcm_executor::{Config, XcmExecutor, Assets};118use sp_std::{cmp::Ordering, marker::PhantomData};119120use xcm::latest::{121 // Xcm,122 AssetId::{Concrete},123 Fungibility::Fungible as XcmFungible,124 MultiAsset,125 Error as XcmError,126};127use xcm_executor::traits::{MatchesFungible, WeightTrader};128129use unique_runtime_common::{130 impl_common_runtime_apis,131 types::*,132 constants::*,133 dispatch::{CollectionDispatchT, CollectionDispatch},134 sponsoring::UniqueSponsorshipHandler,135 eth_sponsoring::UniqueEthSponsorshipHandler,136 weights::CommonWeights,137};138139pub const RUNTIME_NAME: &str = "quartz";140pub const TOKEN_SYMBOL: &str = "QTZ";141142type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;143144impl RuntimeInstance for Runtime {145 type CrossAccountId = self::CrossAccountId;146147 type TransactionConverter = self::TransactionConverter;148149 fn get_transaction_converter() -> TransactionConverter {150 TransactionConverter151 }152}153154/// The type for looking up accounts. We don't expect more than 4 billion of them, but you155/// never know...156pub type AccountIndex = u32;157158/// Balance of an account.159pub type Balance = u128;160161/// Index of a transaction in the chain.162pub type Index = u32;163164/// A hash of some data used by the chain.165pub type Hash = sp_core::H256;166167/// Digest item type.168pub type DigestItem = generic::DigestItem;169170/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know171/// the specifics of the runtime. They can then be made to be agnostic over specific formats172/// of data like extrinsics, allowing for them to continue syncing the network through upgrades173/// to even the core data structures.174pub mod opaque {175 use sp_std::prelude::*;176 use sp_runtime::impl_opaque_keys;177 use super::Aura;178179 pub use unique_runtime_common::types::*;180181 impl_opaque_keys! {182 pub struct SessionKeys {183 pub aura: Aura,184 }185 }186}187188/// This runtime version.189pub const VERSION: RuntimeVersion = RuntimeVersion {190 spec_name: create_runtime_str!(RUNTIME_NAME),191 impl_name: create_runtime_str!(RUNTIME_NAME),192 authoring_version: 1,193 spec_version: 922080,194 impl_version: 0,195 apis: RUNTIME_API_VERSIONS,196 transaction_version: 1,197 state_version: 0,198};199200#[derive(codec::Encode, codec::Decode)]201pub enum XCMPMessage<XAccountId, XBalance> {202 /// Transfer tokens to the given account from the Parachain account.203 TransferToken(XAccountId, XBalance),204}205206/// The version information used to identify this runtime when compiled natively.207#[cfg(feature = "std")]208pub fn native_version() -> NativeVersion {209 NativeVersion {210 runtime_version: VERSION,211 can_author_with: Default::default(),212 }213}214215type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;216217pub struct DealWithFees;218impl OnUnbalanced<NegativeImbalance> for DealWithFees {219 fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {220 if let Some(fees) = fees_then_tips.next() {221 // for fees, 100% to treasury222 let mut split = fees.ration(100, 0);223 if let Some(tips) = fees_then_tips.next() {224 // for tips, if any, 100% to treasury225 tips.ration_merge_into(100, 0, &mut split);226 }227 Treasury::on_unbalanced(split.0);228 // Author::on_unbalanced(split.1);229 }230 }231}232233parameter_types! {234 pub const BlockHashCount: BlockNumber = 2400;235 pub RuntimeBlockLength: BlockLength =236 BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);237 pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);238 pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;239 pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()240 .base_block(BlockExecutionWeight::get())241 .for_class(DispatchClass::all(), |weights| {242 weights.base_extrinsic = ExtrinsicBaseWeight::get();243 })244 .for_class(DispatchClass::Normal, |weights| {245 weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);246 })247 .for_class(DispatchClass::Operational, |weights| {248 weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);249 // Operational transactions have some extra reserved space, so that they250 // are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.251 weights.reserved = Some(252 MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT253 );254 })255 .avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)256 .build_or_panic();257 pub const Version: RuntimeVersion = VERSION;258 pub const SS58Prefix: u8 = 255;259}260261parameter_types! {262 pub const ChainId: u64 = 8881;263}264265pub struct FixedFee;266impl FeeCalculator for FixedFee {267 fn min_gas_price() -> (U256, u64) {268 (MIN_GAS_PRICE.into(), 0)269 }270}271272// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case273// (contract, which only writes a lot of data),274// approximating on top of our real store write weight275parameter_types! {276 pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;277 pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;278 pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();279}280281/// Limiting EVM execution to 50% of block for substrate users and management tasks282/// EVM transaction consumes more weight than substrate's, so we can't rely on them being283/// scheduled fairly284const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);285parameter_types! {286 pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());287}288289pub enum FixedGasWeightMapping {}290impl GasWeightMapping for FixedGasWeightMapping {291 fn gas_to_weight(gas: u64) -> Weight {292 gas.saturating_mul(WeightPerGas::get())293 }294 fn weight_to_gas(weight: Weight) -> u64 {295 weight / WeightPerGas::get()296 }297}298299impl pallet_evm::account::Config for Runtime {300 type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Self>;301 type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;302 type EvmBackwardsAddressMapping = fp_evm_mapping::MapBackwardsAddressTruncated;303}304305impl pallet_evm::Config for Runtime {306 type BlockGasLimit = BlockGasLimit;307 type FeeCalculator = FixedFee;308 type GasWeightMapping = FixedGasWeightMapping;309 type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;310 type CallOrigin = EnsureAddressTruncated<Self>;311 type WithdrawOrigin = EnsureAddressTruncated<Self>;312 type AddressMapping = HashedAddressMapping<Self::Hashing>;313 type PrecompilesType = ();314 type PrecompilesValue = ();315 type Currency = Balances;316 type Event = Event;317 type OnMethodCall = (318 pallet_evm_migration::OnMethodCall<Self>,319 pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,320 CollectionDispatchT<Self>,321 pallet_unique::eth::CollectionHelpersOnMethodCall<Self>,322 );323 type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;324 type ChainId = ChainId;325 type Runner = pallet_evm::runner::stack::Runner<Self>;326 type OnChargeTransaction = pallet_evm::EVMCurrencyAdapter<Balances, DealWithFees>;327 type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;328 type FindAuthor = EthereumFindAuthor<Aura>;329}330331impl pallet_evm_migration::Config for Runtime {332 type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;333}334335pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);336impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {337 fn find_author<'a, I>(digests: I) -> Option<H160>338 where339 I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,340 {341 if let Some(author_index) = F::find_author(digests) {342 let authority_id = Aura::authorities()[author_index as usize].clone();343 return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));344 }345 None346 }347}348349impl pallet_ethereum::Config for Runtime {350 type Event = Event;351 type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;352}353354impl pallet_randomness_collective_flip::Config for Runtime {}355356impl frame_system::Config for Runtime {357 /// The data to be stored in an account.358 type AccountData = pallet_balances::AccountData<Balance>;359 /// The identifier used to distinguish between accounts.360 type AccountId = AccountId;361 /// The basic call filter to use in dispatchable.362 type BaseCallFilter = Everything;363 /// Maximum number of block number to block hash mappings to keep (oldest pruned first).364 type BlockHashCount = BlockHashCount;365 /// The maximum length of a block (in bytes).366 type BlockLength = RuntimeBlockLength;367 /// The index type for blocks.368 type BlockNumber = BlockNumber;369 /// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.370 type BlockWeights = RuntimeBlockWeights;371 /// The aggregated dispatch type that is available for extrinsics.372 type Call = Call;373 /// The weight of database operations that the runtime can invoke.374 type DbWeight = RocksDbWeight;375 /// The ubiquitous event type.376 type Event = Event;377 /// The type for hashing blocks and tries.378 type Hash = Hash;379 /// The hashing algorithm used.380 type Hashing = BlakeTwo256;381 /// The header type.382 type Header = generic::Header<BlockNumber, BlakeTwo256>;383 /// The index type for storing how many extrinsics an account has signed.384 type Index = Index;385 /// The lookup mechanism to get account ID from whatever is passed in dispatchers.386 type Lookup = AccountIdLookup<AccountId, ()>;387 /// What to do if an account is fully reaped from the system.388 type OnKilledAccount = ();389 /// What to do if a new account is created.390 type OnNewAccount = ();391 type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;392 /// The ubiquitous origin type.393 type Origin = Origin;394 /// This type is being generated by `construct_runtime!`.395 type PalletInfo = PalletInfo;396 /// This is used as an identifier of the chain. 42 is the generic substrate prefix.397 type SS58Prefix = SS58Prefix;398 /// Weight information for the extrinsics of this pallet.399 type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;400 /// Version of the runtime.401 type Version = Version;402 type MaxConsumers = ConstU32<16>;403}404405parameter_types! {406 pub const MinimumPeriod: u64 = SLOT_DURATION / 2;407}408409impl pallet_timestamp::Config for Runtime {410 /// A timestamp: milliseconds since the unix epoch.411 type Moment = u64;412 type OnTimestampSet = ();413 type MinimumPeriod = MinimumPeriod;414 type WeightInfo = ();415}416417parameter_types! {418 // pub const ExistentialDeposit: u128 = 500;419 pub const ExistentialDeposit: u128 = 0;420 pub const MaxLocks: u32 = 50;421 pub const MaxReserves: u32 = 50;422}423424impl pallet_balances::Config for Runtime {425 type MaxLocks = MaxLocks;426 type MaxReserves = MaxReserves;427 type ReserveIdentifier = [u8; 16];428 /// The type for recording an account's balance.429 type Balance = Balance;430 /// The ubiquitous event type.431 type Event = Event;432 type DustRemoval = Treasury;433 type ExistentialDeposit = ExistentialDeposit;434 type AccountStore = System;435 type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;436}437438pub const fn deposit(items: u32, bytes: u32) -> Balance {439 items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE440}441442/*443parameter_types! {444 pub TombstoneDeposit: Balance = deposit(445 1,446 sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,447 );448 pub DepositPerContract: Balance = TombstoneDeposit::get();449 pub const DepositPerStorageByte: Balance = deposit(0, 1);450 pub const DepositPerStorageItem: Balance = deposit(1, 0);451 pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);452 pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;453 pub const SignedClaimHandicap: u32 = 2;454 pub const MaxDepth: u32 = 32;455 pub const MaxValueSize: u32 = 16 * 1024;456 pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb457 // The lazy deletion runs inside on_initialize.458 pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *459 RuntimeBlockWeights::get().max_block;460 // The weight needed for decoding the queue should be less or equal than a fifth461 // of the overall weight dedicated to the lazy deletion.462 pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (463 <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -464 <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)465 )) / 5) as u32;466 pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();467}468469impl pallet_contracts::Config for Runtime {470 type Time = Timestamp;471 type Randomness = RandomnessCollectiveFlip;472 type Currency = Balances;473 type Event = Event;474 type RentPayment = ();475 type SignedClaimHandicap = SignedClaimHandicap;476 type TombstoneDeposit = TombstoneDeposit;477 type DepositPerContract = DepositPerContract;478 type DepositPerStorageByte = DepositPerStorageByte;479 type DepositPerStorageItem = DepositPerStorageItem;480 type RentFraction = RentFraction;481 type SurchargeReward = SurchargeReward;482 type WeightPrice = pallet_transaction_payment::Pallet<Self>;483 type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;484 type ChainExtension = NFTExtension;485 type DeletionQueueDepth = DeletionQueueDepth;486 type DeletionWeightLimit = DeletionWeightLimit;487 type Schedule = Schedule;488 type CallStack = [pallet_contracts::Frame<Self>; 31];489}490*/491492parameter_types! {493 /// This value increases the priority of `Operational` transactions by adding494 /// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.495 pub const OperationalFeeMultiplier: u8 = 5;496}497498/// Linear implementor of `WeightToFeePolynomial`499pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);500501impl<T> WeightToFeePolynomial for LinearFee<T>502where503 T: BaseArithmetic + From<u32> + Copy + Unsigned,504{505 type Balance = T;506507 fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {508 smallvec!(WeightToFeeCoefficient {509 // Targeting 0.1 Unique per NFT transfer510 coeff_integer: WEIGHT_TO_FEE_COEFF.into(),511 coeff_frac: Perbill::zero(),512 negative: false,513 degree: 1,514 })515 }516}517518impl pallet_transaction_payment::Config for Runtime {519 type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;520 type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;521 type OperationalFeeMultiplier = OperationalFeeMultiplier;522 type WeightToFee = LinearFee<Balance>;523 type FeeMultiplierUpdate = ();524}525526parameter_types! {527 pub const ProposalBond: Permill = Permill::from_percent(5);528 pub const ProposalBondMinimum: Balance = 1 * UNIQUE;529 pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;530 pub const SpendPeriod: BlockNumber = 5 * MINUTES;531 pub const Burn: Permill = Permill::from_percent(0);532 pub const TipCountdown: BlockNumber = 1 * DAYS;533 pub const TipFindersFee: Percent = Percent::from_percent(20);534 pub const TipReportDepositBase: Balance = 1 * UNIQUE;535 pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;536 pub const BountyDepositBase: Balance = 1 * UNIQUE;537 pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;538 pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");539 pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;540 pub const MaximumReasonLength: u32 = 16384;541 pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);542 pub const BountyValueMinimum: Balance = 5 * UNIQUE;543 pub const MaxApprovals: u32 = 100;544}545546impl pallet_treasury::Config for Runtime {547 type PalletId = TreasuryModuleId;548 type Currency = Balances;549 type ApproveOrigin = EnsureRoot<AccountId>;550 type RejectOrigin = EnsureRoot<AccountId>;551 type Event = Event;552 type OnSlash = ();553 type ProposalBond = ProposalBond;554 type ProposalBondMinimum = ProposalBondMinimum;555 type ProposalBondMaximum = ProposalBondMaximum;556 type SpendPeriod = SpendPeriod;557 type Burn = Burn;558 type BurnDestination = ();559 type SpendFunds = ();560 type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;561 type MaxApprovals = MaxApprovals;562}563564impl pallet_sudo::Config for Runtime {565 type Event = Event;566 type Call = Call;567}568569pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);570571impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider572 for RelayChainBlockNumberProvider<T>573{574 type BlockNumber = BlockNumber;575576 fn current_block_number() -> Self::BlockNumber {577 cumulus_pallet_parachain_system::Pallet::<T>::validation_data()578 .map(|d| d.relay_parent_number)579 .unwrap_or_default()580 }581}582583parameter_types! {584 pub const MinVestedTransfer: Balance = 10 * UNIQUE;585 pub const MaxVestingSchedules: u32 = 28;586}587588impl orml_vesting::Config for Runtime {589 type Event = Event;590 type Currency = pallet_balances::Pallet<Runtime>;591 type MinVestedTransfer = MinVestedTransfer;592 type VestedTransferOrigin = EnsureSigned<AccountId>;593 type WeightInfo = ();594 type MaxVestingSchedules = MaxVestingSchedules;595 type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;596}597598parameter_types! {599 pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;600 pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;601}602603impl cumulus_pallet_parachain_system::Config for Runtime {604 type Event = Event;605 type SelfParaId = parachain_info::Pallet<Self>;606 type OnSystemEvent = ();607 // type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<608 // MaxDownwardMessageWeight,609 // XcmExecutor<XcmConfig>,610 // Call,611 // >;612 type OutboundXcmpMessageSource = XcmpQueue;613 type DmpMessageHandler = DmpQueue;614 type ReservedDmpWeight = ReservedDmpWeight;615 type ReservedXcmpWeight = ReservedXcmpWeight;616 type XcmpMessageHandler = XcmpQueue;617}618619impl parachain_info::Config for Runtime {}620621impl cumulus_pallet_aura_ext::Config for Runtime {}622623parameter_types! {624 pub const RelayLocation: MultiLocation = MultiLocation::parent();625 pub const RelayNetwork: NetworkId = NetworkId::Polkadot;626 pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();627 pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();628}629630/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used631/// when determining ownership of accounts for asset transacting and when attempting to use XCM632/// `Transact` in order to determine the dispatch Origin.633pub type LocationToAccountId = (634 // The parent (Relay-chain) origin converts to the default `AccountId`.635 ParentIsPreset<AccountId>,636 // Sibling parachain origins convert to AccountId via the `ParaId::into`.637 SiblingParachainConvertsVia<Sibling, AccountId>,638 // Straight up local `AccountId32` origins just alias directly to `AccountId`.639 AccountId32Aliases<RelayNetwork, AccountId>,640);641642pub struct OnlySelfCurrency;643impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {644 fn matches_fungible(a: &MultiAsset) -> Option<B> {645 match (&a.id, &a.fun) {646 (Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),647 _ => None,648 }649 }650}651652/// Means for transacting assets on this chain.653pub type LocalAssetTransactor = CurrencyAdapter<654 // Use this currency:655 Balances,656 // Use this currency when it is a fungible asset matching the given location or name:657 OnlySelfCurrency,658 // Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:659 LocationToAccountId,660 // Our chain's account ID type (we can't get away without mentioning it explicitly):661 AccountId,662 // We don't track any teleports.663 (),664>;665666/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,667/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can668/// biases the kind of local `Origin` it will become.669pub type XcmOriginToTransactDispatchOrigin = (670 // Sovereign account converter; this attempts to derive an `AccountId` from the origin location671 // using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for672 // foreign chains who want to have a local sovereign account on this chain which they control.673 SovereignSignedViaLocation<LocationToAccountId, Origin>,674 // Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when675 // recognised.676 RelayChainAsNative<RelayOrigin, Origin>,677 // Native converter for sibling Parachains; will convert to a `SiblingPara` origin when678 // recognised.679 SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,680 // Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a681 // transaction from the Root origin.682 ParentAsSuperuser<Origin>,683 // Native signed account converter; this just converts an `AccountId32` origin into a normal684 // `Origin::Signed` origin of the same 32-byte value.685 SignedAccountId32AsNative<RelayNetwork, Origin>,686 // Xcm origins can be represented natively under the Xcm pallet's Xcm origin.687 XcmPassthrough<Origin>,688);689690parameter_types! {691 // One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.692 pub UnitWeightCost: Weight = 1_000_000;693 // 1200 UNIQUEs buy 1 second of weight.694 pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);695 pub const MaxInstructions: u32 = 100;696 pub const MaxAuthorities: u32 = 100_000;697}698699match_types! {700 pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {701 MultiLocation { parents: 1, interior: Here } |702 MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }703 };704}705706pub type Barrier = (707 TakeWeightCredit,708 AllowTopLevelPaidExecutionFrom<Everything>,709 AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,710 // ^^^ Parent & its unit plurality gets free execution711);712713pub struct UsingOnlySelfCurrencyComponents<714 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,715 AssetId: Get<MultiLocation>,716 AccountId,717 Currency: CurrencyT<AccountId>,718 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,719>(720 Weight,721 Currency::Balance,722 PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,723);724impl<725 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,726 AssetId: Get<MultiLocation>,727 AccountId,728 Currency: CurrencyT<AccountId>,729 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,730 > WeightTrader731 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>732{733 fn new() -> Self {734 Self(0, Zero::zero(), PhantomData)735 }736737 fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {738 let amount = WeightToFee::calc(&weight);739 let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;740741 // location to this parachain through relay chain742 let option1: xcm::v1::AssetId = Concrete(MultiLocation {743 parents: 1,744 interior: X1(Parachain(ParachainInfo::parachain_id().into())),745 });746 // direct location747 let option2: xcm::v1::AssetId = Concrete(MultiLocation {748 parents: 0,749 interior: Here,750 });751752 let required = if payment.fungible.contains_key(&option1) {753 (option1, u128_amount).into()754 } else if payment.fungible.contains_key(&option2) {755 (option2, u128_amount).into()756 } else {757 (Concrete(MultiLocation::default()), u128_amount).into()758 };759760 let unused = payment761 .checked_sub(required)762 .map_err(|_| XcmError::TooExpensive)?;763 self.0 = self.0.saturating_add(weight);764 self.1 = self.1.saturating_add(amount);765 Ok(unused)766 }767768 fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {769 let weight = weight.min(self.0);770 let amount = WeightToFee::calc(&weight);771 self.0 -= weight;772 self.1 = self.1.saturating_sub(amount);773 let amount: u128 = amount.saturated_into();774 if amount > 0 {775 Some((AssetId::get(), amount).into())776 } else {777 None778 }779 }780}781impl<782 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,783 AssetId: Get<MultiLocation>,784 AccountId,785 Currency: CurrencyT<AccountId>,786 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,787 > Drop788 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>789{790 fn drop(&mut self) {791 OnUnbalanced::on_unbalanced(Currency::issue(self.1));792 }793}794795pub struct XcmConfig;796impl Config for XcmConfig {797 type Call = Call;798 type XcmSender = XcmRouter;799 // How to withdraw and deposit an asset.800 type AssetTransactor = LocalAssetTransactor;801 type OriginConverter = XcmOriginToTransactDispatchOrigin;802 type IsReserve = NativeAsset;803 type IsTeleporter = (); // Teleportation is disabled804 type LocationInverter = LocationInverter<Ancestry>;805 type Barrier = Barrier;806 type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;807 type Trader = UsingOnlySelfCurrencyComponents<808 IdentityFee<Balance>,809 RelayLocation,810 AccountId,811 Balances,812 (),813 >;814 type ResponseHandler = (); // Don't handle responses for now.815 type SubscriptionService = PolkadotXcm;816817 type AssetTrap = PolkadotXcm;818 type AssetClaims = PolkadotXcm;819}820821// parameter_types! {822// pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;823// }824825/// No local origins on this chain are allowed to dispatch XCM sends/executions.826pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);827828/// The means for routing XCM messages which are not for local execution into the right message829/// queues.830pub type XcmRouter = (831 // Two routers - use UMP to communicate with the relay chain:832 cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,833 // ..and XCMP to communicate with the sibling chains.834 XcmpQueue,835);836837impl pallet_evm_coder_substrate::Config for Runtime {}838839impl pallet_xcm::Config for Runtime {840 type Event = Event;841 type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;842 type XcmRouter = XcmRouter;843 type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;844 type XcmExecuteFilter = Everything;845 type XcmExecutor = XcmExecutor<XcmConfig>;846 type XcmTeleportFilter = Everything;847 type XcmReserveTransferFilter = Everything;848 type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;849 type LocationInverter = LocationInverter<Ancestry>;850 type Origin = Origin;851 type Call = Call;852 const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;853 type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;854}855856impl cumulus_pallet_xcm::Config for Runtime {857 type Event = Event;858 type XcmExecutor = XcmExecutor<XcmConfig>;859}860861impl cumulus_pallet_xcmp_queue::Config for Runtime {862 type WeightInfo = ();863 type Event = Event;864 type XcmExecutor = XcmExecutor<XcmConfig>;865 type ChannelInfo = ParachainSystem;866 type VersionWrapper = ();867 type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;868 type ControllerOrigin = EnsureRoot<AccountId>;869 type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;870}871872impl cumulus_pallet_dmp_queue::Config for Runtime {873 type Event = Event;874 type XcmExecutor = XcmExecutor<XcmConfig>;875 type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;876}877878impl pallet_aura::Config for Runtime {879 type AuthorityId = AuraId;880 type DisabledValidators = ();881 type MaxAuthorities = MaxAuthorities;882}883884parameter_types! {885 pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();886 pub const CollectionCreationPrice: Balance = 2 * UNIQUE;887}888889impl pallet_common::Config for Runtime {890 type WeightInfo = pallet_common::weights::SubstrateWeight<Self>;891 type Event = Event;892 type Currency = Balances;893 type CollectionCreationPrice = CollectionCreationPrice;894 type TreasuryAccountId = TreasuryAccountId;895 type CollectionDispatch = CollectionDispatchT<Self>;896897 type EvmTokenAddressMapping = EvmTokenAddressMapping;898 type CrossTokenAddressMapping = CrossTokenAddressMapping<Self::AccountId>;899 type ContractAddress = EvmCollectionHelpersAddress;900}901902impl pallet_structure::Config for Runtime {903 type Event = Event;904 type Call = Call;905 type WeightInfo = pallet_structure::weights::SubstrateWeight<Self>;906}907908impl pallet_fungible::Config for Runtime {909 type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;910}911impl pallet_refungible::Config for Runtime {912 type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;913}914impl pallet_nonfungible::Config for Runtime {915 type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;916}917918impl pallet_proxy_rmrk_core::Config for Runtime {919 type WeightInfo = pallet_proxy_rmrk_core::weights::SubstrateWeight<Self>;920 type Event = Event;921}922923impl pallet_proxy_rmrk_equip::Config for Runtime {924 type WeightInfo = pallet_proxy_rmrk_equip::weights::SubstrateWeight<Self>;925 type Event = Event;926}927928impl pallet_unique::Config for Runtime {929 type Event = Event;930 type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;931 type CommonWeightInfo = CommonWeights<Self>;932}933934parameter_types! {935 pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied936}937938/// Used for the pallet inflation939impl pallet_inflation::Config for Runtime {940 type Currency = Balances;941 type TreasuryAccountId = TreasuryAccountId;942 type InflationBlockInterval = InflationBlockInterval;943 type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;944}945946parameter_types! {947 pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *948 RuntimeBlockWeights::get().max_block;949 pub const MaxScheduledPerBlock: u32 = 50;950}951952type ChargeTransactionPayment = pallet_charge_transaction::ChargeTransactionPayment<Runtime>;953use frame_support::traits::NamedReservableCurrency;954955fn get_signed_extras(from: <Runtime as frame_system::Config>::AccountId) -> SignedExtraScheduler {956 (957 frame_system::CheckSpecVersion::<Runtime>::new(),958 frame_system::CheckGenesis::<Runtime>::new(),959 frame_system::CheckEra::<Runtime>::from(Era::Immortal),960 frame_system::CheckNonce::<Runtime>::from(frame_system::Pallet::<Runtime>::account_nonce(961 from,962 )),963 frame_system::CheckWeight::<Runtime>::new(),964 // sponsoring transaction logic965 // pallet_charge_transaction::ChargeTransactionPayment::<Runtime>::new(0),966 )967}968969pub struct SchedulerPaymentExecutor;970impl<T: frame_system::Config + pallet_unique_scheduler::Config, SelfContainedSignedInfo>971 DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor972where973 <T as frame_system::Config>::Call: Member974 + Dispatchable<Origin = Origin, Info = DispatchInfo>975 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>976 + GetDispatchInfo977 + From<frame_system::Call<Runtime>>,978 SelfContainedSignedInfo: Send + Sync + 'static,979 Call: From<<T as frame_system::Config>::Call>980 + From<<T as pallet_unique_scheduler::Config>::Call>981 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,982 sp_runtime::AccountId32: From<<T as frame_system::Config>::AccountId>,983{984 fn dispatch_call(985 signer: <T as frame_system::Config>::AccountId,986 call: <T as pallet_unique_scheduler::Config>::Call,987 ) -> Result<988 Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,989 TransactionValidityError,990 > {991 let dispatch_info = call.get_dispatch_info();992 let extrinsic = fp_self_contained::CheckedExtrinsic::<993 AccountId,994 Call,995 SignedExtraScheduler,996 SelfContainedSignedInfo,997 > {998 signed:999 CheckedSignature::<AccountId, SignedExtraScheduler, SelfContainedSignedInfo>::Signed(1000 signer.clone().into(),1001 get_signed_extras(signer.into()),1002 ),1003 function: call.into(),1004 };10051006 extrinsic.apply::<Runtime>(&dispatch_info, 0)1007 }10081009 fn reserve_balance(1010 id: [u8; 16],1011 sponsor: <T as frame_system::Config>::AccountId,1012 call: <T as pallet_unique_scheduler::Config>::Call,1013 count: u32,1014 ) -> Result<(), DispatchError> {1015 let dispatch_info = call.get_dispatch_info();1016 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0)1017 .saturating_mul(count.into());10181019 <Balances as NamedReservableCurrency<AccountId>>::reserve_named(1020 &id,1021 &(sponsor.into()),1022 weight.into(),1023 )1024 }10251026 fn pay_for_call(1027 id: [u8; 16],1028 sponsor: <T as frame_system::Config>::AccountId,1029 call: <T as pallet_unique_scheduler::Config>::Call,1030 ) -> Result<u128, DispatchError> {1031 let dispatch_info = call.get_dispatch_info();1032 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0);1033 Ok(1034 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1035 &id,1036 &(sponsor.into()),1037 weight.into(),1038 ),1039 )1040 }10411042 fn cancel_reserve(1043 id: [u8; 16],1044 sponsor: <T as frame_system::Config>::AccountId,1045 ) -> Result<u128, DispatchError> {1046 Ok(1047 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1048 &id,1049 &(sponsor.into()),1050 u128::MAX,1051 ),1052 )1053 }1054}10551056parameter_types! {1057 pub const NoPreimagePostponement: Option<u32> = Some(10);1058 pub const Preimage: Option<u32> = Some(10);1059}10601061/// Used the compare the privilege of an origin inside the scheduler.1062pub struct OriginPrivilegeCmp;10631064impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {1065 fn cmp_privilege(_left: &OriginCaller, _right: &OriginCaller) -> Option<Ordering> {1066 Some(Ordering::Equal)1067 }1068}10691070impl pallet_unique_scheduler::Config for Runtime {1071 type Event = Event;1072 type Origin = Origin;1073 type Currency = Balances;1074 type PalletsOrigin = OriginCaller;1075 type Call = Call;1076 type MaximumWeight = MaximumSchedulerWeight;1077 type ScheduleOrigin = EnsureSigned<AccountId>;1078 type MaxScheduledPerBlock = MaxScheduledPerBlock;1079 type WeightInfo = ();1080 type CallExecutor = SchedulerPaymentExecutor;1081 type OriginPrivilegeCmp = OriginPrivilegeCmp;1082 type PreimageProvider = ();1083 type NoPreimagePostponement = NoPreimagePostponement;1084}10851086type EvmSponsorshipHandler = (1087 UniqueEthSponsorshipHandler<Runtime>,1088 pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,1089);1090type SponsorshipHandler = (1091 UniqueSponsorshipHandler<Runtime>,1092 //pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1093 pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1094);10951096impl pallet_evm_transaction_payment::Config for Runtime {1097 type EvmSponsorshipHandler = EvmSponsorshipHandler;1098 type Currency = Balances;1099}11001101impl pallet_charge_transaction::Config for Runtime {1102 type SponsorshipHandler = SponsorshipHandler;1103}11041105// impl pallet_contract_helpers::Config for Runtime {1106// type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1107// }11081109parameter_types! {1110 // 0x842899ECF380553E8a4de75bF534cdf6fBF640491111 pub const HelpersContractAddress: H160 = H160([1112 0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1113 ]);11141115 // 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f1116 pub const EvmCollectionHelpersAddress: H160 = H160([1117 0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,1118 ]);1119}11201121impl pallet_evm_contract_helpers::Config for Runtime {1122 type ContractAddress = HelpersContractAddress;1123 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1124}11251126construct_runtime!(1127 pub enum Runtime where1128 Block = Block,1129 NodeBlock = opaque::Block,1130 UncheckedExtrinsic = UncheckedExtrinsic1131 {1132 ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1133 ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,11341135 Aura: pallet_aura::{Pallet, Config<T>} = 22,1136 AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,11371138 Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1139 RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1140 Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1141 TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1142 Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1143 Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1144 System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1145 Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1146 // Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1147 // Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,11481149 // XCM helpers.1150 XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1151 PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1152 CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1153 DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11541155 // Unique Pallets1156 Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1157 Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1158 Scheduler: pallet_unique_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1159 // free = 631160 Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1161 // ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1162 Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1163 Fungible: pallet_fungible::{Pallet, Storage} = 67,1164 Refungible: pallet_refungible::{Pallet, Storage} = 68,1165 Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1166 Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,1167 RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,1168 RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,11691170 // Frontier1171 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1172 Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11731174 EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1175 EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1176 EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1177 EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1178 }1179);11801181pub struct TransactionConverter;11821183impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1184 fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1185 UncheckedExtrinsic::new_unsigned(1186 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1187 )1188 }1189}11901191impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1192 fn convert_transaction(1193 &self,1194 transaction: pallet_ethereum::Transaction,1195 ) -> opaque::UncheckedExtrinsic {1196 let extrinsic = UncheckedExtrinsic::new_unsigned(1197 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1198 );1199 let encoded = extrinsic.encode();1200 opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1201 .expect("Encoded extrinsic is always valid")1202 }1203}12041205/// The address format for describing accounts.1206pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1207/// Block header type as expected by this runtime.1208pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1209/// Block type as expected by this runtime.1210pub type Block = generic::Block<Header, UncheckedExtrinsic>;1211/// A Block signed with a Justification1212pub type SignedBlock = generic::SignedBlock<Block>;1213/// BlockId type as expected by this runtime.1214pub type BlockId = generic::BlockId<Block>;1215/// The SignedExtension to the basic transaction logic.1216pub type SignedExtra = (1217 frame_system::CheckSpecVersion<Runtime>,1218 // system::CheckTxVersion<Runtime>,1219 frame_system::CheckGenesis<Runtime>,1220 frame_system::CheckEra<Runtime>,1221 frame_system::CheckNonce<Runtime>,1222 frame_system::CheckWeight<Runtime>,1223 ChargeTransactionPayment,1224 //pallet_contract_helpers::ContractHelpersExtension<Runtime>,1225 pallet_ethereum::FakeTransactionFinalizer<Runtime>,1226);12271228pub type SignedExtraScheduler = (1229 frame_system::CheckSpecVersion<Runtime>,1230 frame_system::CheckGenesis<Runtime>,1231 frame_system::CheckEra<Runtime>,1232 frame_system::CheckNonce<Runtime>,1233 frame_system::CheckWeight<Runtime>,1234 // pallet_charge_transaction::ChargeTransactionPayment<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);