difftreelog
Merge pull request #385 from UniqueNetwork/feature/conditional-rmrk
in: master
feat(rmrk): remove RMRK proxy from unique runtime
10 files changed
node/rpc/Cargo.tomldiffbeforeafterboth--- a/node/rpc/Cargo.toml
+++ b/node/rpc/Cargo.toml
@@ -63,3 +63,4 @@
[features]
default = []
std = []
+unique-runtime = []
node/rpc/src/lib.rsdiffbeforeafterboth--- a/node/rpc/src/lib.rs
+++ b/node/rpc/src/lib.rs
@@ -169,7 +169,11 @@
Eth, EthApiServer, EthDevSigner, EthFilter, EthFilterApiServer, EthPubSub,
EthPubSubApiServer, EthSigner, Net, NetApiServer, Web3, Web3ApiServer,
};
- use uc_rpc::{UniqueApiServer, Unique, RmrkApiServer, Rmrk};
+ use uc_rpc::{UniqueApiServer, Unique};
+
+ #[cfg(not(feature = "unique-runtime"))]
+ use uc_rpc::{RmrkApiServer, Rmrk};
+
// use pallet_contracts_rpc::{Contracts, ContractsApi};
use pallet_transaction_payment_rpc::{TransactionPaymentRpc, TransactionPaymentApiServer};
use substrate_frame_rpc_system::{SystemRpc, SystemApiServer};
@@ -223,6 +227,8 @@
)?;
io.merge(Unique::new(client.clone()).into_rpc())?;
+
+ #[cfg(not(feature = "unique-runtime"))]
io.merge(Rmrk::new(client.clone()).into_rpc())?;
if let Some(filter_pool) = filter_pool {
runtime/common/src/runtime_apis.rsdiffbeforeafterboth--- a/runtime/common/src/runtime_apis.rs
+++ b/runtime/common/src/runtime_apis.rs
@@ -144,402 +144,6 @@
}
}
- impl rmrk_rpc::RmrkApi<
- Block,
- AccountId,
- RmrkCollectionInfo<AccountId>,
- RmrkInstanceInfo<AccountId>,
- RmrkResourceInfo,
- RmrkPropertyInfo,
- RmrkBaseInfo<AccountId>,
- RmrkPartType,
- RmrkTheme
- > for Runtime {
- fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
- Ok(RmrkCore::last_collection_idx())
- }
-
- 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
- }))
- }
-
- 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)?,
- }))
- }
-
- 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)
- }
-
- 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()
- )
- }
-
- 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)
- }
-
- 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)
- }
-
- fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType}};
- use pallet_common::CommonCollectionOperations;
-
- 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 res_collection_id: Option<CollectionId> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)?;
-
- let res_collection_id = match res_collection_id {
- Some(id) => id,
- None => return Ok(Vec::new())
- };
-
- let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;
-
- let resources = resource_collection
- .collection_tokens()
- .iter()
- .filter_map(|(res_id)| Some(RmrkResourceInfo {
- id: res_id.0,
- pending: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).ok()?,
- pending_removal: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).ok()?,
- resource: match RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::ResourceType).ok()? {
- ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {
- src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
- metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
- license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
- thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
- }),
- ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {
- parts: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Parts).ok()?,
- base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
- src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
- metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
- license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
- thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
- }),
- ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {
- base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
- src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
- metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
- slot: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Slot).ok()?,
- license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
- thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
- }),
- },
- }))
- .collect();
-
- Ok(resources)
- }
-
- 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)
- )
- }
-
- 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)?,
- }))
- }
-
- 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)
- }
-
- fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::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 {
- Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),
- _ => None
- }
- })
- .collect();
-
- Ok(theme_names)
- }
-
- 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))
- }
- }
-
impl sp_api::Core<Block> for Runtime {
fn version() -> RuntimeVersion {
VERSION
runtime/opal/src/lib.rsdiffbeforeafterboth--- a/runtime/opal/src/lib.rs
+++ b/runtime/opal/src/lib.rs
@@ -1315,7 +1315,405 @@
}};
}
-impl_common_runtime_apis!();
+impl_common_runtime_apis! {
+ #![custom_apis]
+
+ impl rmrk_rpc::RmrkApi<
+ Block,
+ AccountId,
+ RmrkCollectionInfo<AccountId>,
+ RmrkInstanceInfo<AccountId>,
+ RmrkResourceInfo,
+ RmrkPropertyInfo,
+ RmrkBaseInfo<AccountId>,
+ RmrkPartType,
+ RmrkTheme
+ > for Runtime {
+ fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
+ Ok(RmrkCore::last_collection_idx())
+ }
+
+ 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
+ }))
+ }
+
+ 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)?,
+ }))
+ }
+
+ 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)
+ }
+
+ 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()
+ )
+ }
+
+ 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)
+ }
+
+ 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)
+ }
+
+ fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
+ use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType}};
+ use pallet_common::CommonCollectionOperations;
+
+ 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 res_collection_id: Option<CollectionId> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)?;
+
+ let res_collection_id = match res_collection_id {
+ Some(id) => id,
+ None => return Ok(Vec::new())
+ };
+
+ let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;
+
+ let resources = resource_collection
+ .collection_tokens()
+ .iter()
+ .filter_map(|res_id| Some(RmrkResourceInfo {
+ id: res_id.0,
+ pending: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).ok()?,
+ pending_removal: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).ok()?,
+ resource: match RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::ResourceType).ok()? {
+ ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {
+ src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
+ metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
+ license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
+ thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
+ }),
+ ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {
+ parts: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Parts).ok()?,
+ base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
+ src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
+ metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
+ license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
+ thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
+ }),
+ ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {
+ base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
+ src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
+ metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
+ slot: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Slot).ok()?,
+ license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
+ thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
+ }),
+ },
+ }))
+ .collect();
+
+ Ok(resources)
+ }
+
+ 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)
+ )
+ }
+
+ 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)?,
+ }))
+ }
+
+ 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)
+ }
+
+ 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)
+ }
+
+ 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))
+ }
+ }
+}
struct CheckInherents;
runtime/quartz/src/lib.rsdiffbeforeafterboth--- a/runtime/quartz/src/lib.rs
+++ b/runtime/quartz/src/lib.rs
@@ -1315,7 +1315,405 @@
}};
}
-impl_common_runtime_apis!();
+impl_common_runtime_apis! {
+ #![custom_apis]
+
+ impl rmrk_rpc::RmrkApi<
+ Block,
+ AccountId,
+ RmrkCollectionInfo<AccountId>,
+ RmrkInstanceInfo<AccountId>,
+ RmrkResourceInfo,
+ RmrkPropertyInfo,
+ RmrkBaseInfo<AccountId>,
+ RmrkPartType,
+ RmrkTheme
+ > for Runtime {
+ fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
+ Ok(RmrkCore::last_collection_idx())
+ }
+
+ 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
+ }))
+ }
+
+ 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)?,
+ }))
+ }
+
+ 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)
+ }
+
+ 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()
+ )
+ }
+
+ 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)
+ }
+
+ 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)
+ }
+
+ fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
+ use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType}};
+ use pallet_common::CommonCollectionOperations;
+
+ 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 res_collection_id: Option<CollectionId> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)?;
+
+ let res_collection_id = match res_collection_id {
+ Some(id) => id,
+ None => return Ok(Vec::new())
+ };
+
+ let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;
+
+ let resources = resource_collection
+ .collection_tokens()
+ .iter()
+ .filter_map(|res_id| Some(RmrkResourceInfo {
+ id: res_id.0,
+ pending: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).ok()?,
+ pending_removal: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).ok()?,
+ resource: match RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::ResourceType).ok()? {
+ ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {
+ src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
+ metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
+ license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
+ thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
+ }),
+ ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {
+ parts: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Parts).ok()?,
+ base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
+ src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
+ metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
+ license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
+ thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
+ }),
+ ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {
+ base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
+ src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
+ metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
+ slot: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Slot).ok()?,
+ license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
+ thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
+ }),
+ },
+ }))
+ .collect();
+
+ Ok(resources)
+ }
+
+ 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)
+ )
+ }
+
+ 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)?,
+ }))
+ }
+
+ 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)
+ }
+
+ 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)
+ }
+
+ 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))
+ }
+ }
+}
struct CheckInherents;
runtime/unique/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, RmrkResourceTypes,79 RmrkBasicResource, RmrkComposableResource, RmrkSlotResource, RmrkResourceId, RmrkBaseId,80 RmrkFixedPart, RmrkSlotPart, RmrkString,81};8283// use pallet_contracts::weights::WeightInfo;84// #[cfg(any(feature = "std", test))]85use frame_system::{86 self as frame_system, EnsureRoot, EnsureSigned,87 limits::{BlockWeights, BlockLength},88};89use sp_arithmetic::{90 traits::{BaseArithmetic, Unsigned},91};92use smallvec::smallvec;93use codec::{Encode, Decode};94use fp_rpc::TransactionStatus;95use sp_runtime::{96 traits::{97 Applyable, BlockNumberProvider, Dispatchable, PostDispatchInfoOf, DispatchInfoOf,98 Saturating, CheckedConversion,99 },100 generic::Era,101 transaction_validity::TransactionValidityError,102 DispatchErrorWithPostInfo, SaturatedConversion,103};104105// pub use pallet_timestamp::Call as TimestampCall;106pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;107108// Polkadot imports109use pallet_xcm::XcmPassthrough;110use polkadot_parachain::primitives::Sibling;111use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};112use xcm_builder::{113 AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,114 EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser,115 RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,116 SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,117 ParentIsPreset,118};119use xcm_executor::{Config, XcmExecutor, Assets};120use sp_std::{cmp::Ordering, marker::PhantomData};121122use xcm::latest::{123 // Xcm,124 AssetId::{Concrete},125 Fungibility::Fungible as XcmFungible,126 MultiAsset,127 Error as XcmError,128};129use xcm_executor::traits::{MatchesFungible, WeightTrader};130131use unique_runtime_common::{132 impl_common_runtime_apis,133 types::*,134 constants::*,135 dispatch::{CollectionDispatchT, CollectionDispatch},136 sponsoring::UniqueSponsorshipHandler,137 eth_sponsoring::UniqueEthSponsorshipHandler,138 weights::CommonWeights,139};140141pub const RUNTIME_NAME: &str = "unique";142pub const TOKEN_SYMBOL: &str = "UNQ";143144type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;145146impl RuntimeInstance for Runtime {147 type CrossAccountId = self::CrossAccountId;148 type TransactionConverter = self::TransactionConverter;149150 fn get_transaction_converter() -> TransactionConverter {151 TransactionConverter152 }153}154155/// The type for looking up accounts. We don't expect more than 4 billion of them, but you156/// never know...157pub type AccountIndex = u32;158159/// Balance of an account.160pub type Balance = u128;161162/// Index of a transaction in the chain.163pub type Index = u32;164165/// A hash of some data used by the chain.166pub type Hash = sp_core::H256;167168/// Digest item type.169pub type DigestItem = generic::DigestItem;170171/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know172/// the specifics of the runtime. They can then be made to be agnostic over specific formats173/// of data like extrinsics, allowing for them to continue syncing the network through upgrades174/// to even the core data structures.175pub mod opaque {176 use sp_std::prelude::*;177 use sp_runtime::impl_opaque_keys;178 use super::Aura;179180 pub use unique_runtime_common::types::*;181182 impl_opaque_keys! {183 pub struct SessionKeys {184 pub aura: Aura,185 }186 }187}188189/// This runtime version.190pub const VERSION: RuntimeVersion = RuntimeVersion {191 spec_name: create_runtime_str!(RUNTIME_NAME),192 impl_name: create_runtime_str!(RUNTIME_NAME),193 authoring_version: 1,194 spec_version: 922000,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: u16 = 7391;260}261262parameter_types! {263 pub const ChainId: u64 = 8880;264}265266pub struct FixedFee;267impl FeeCalculator for FixedFee {268 fn min_gas_price() -> (U256, u64) {269 (MIN_GAS_PRICE.into(), 0)270 }271}272273// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case274// (contract, which only writes a lot of data),275// approximating on top of our real store write weight276parameter_types! {277 pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;278 pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;279 pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();280}281282/// Limiting EVM execution to 50% of block for substrate users and management tasks283/// EVM transaction consumes more weight than substrate's, so we can't rely on them being284/// scheduled fairly285const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);286parameter_types! {287 pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());288}289290pub enum FixedGasWeightMapping {}291impl GasWeightMapping for FixedGasWeightMapping {292 fn gas_to_weight(gas: u64) -> Weight {293 gas.saturating_mul(WeightPerGas::get())294 }295 fn weight_to_gas(weight: Weight) -> u64 {296 weight / WeightPerGas::get()297 }298}299300impl pallet_evm::account::Config for Runtime {301 type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Self>;302 type EvmAddressMapping = pallet_evm::HashedAddressMapping<Self::Hashing>;303 type EvmBackwardsAddressMapping = fp_evm_mapping::MapBackwardsAddressTruncated;304}305306impl pallet_evm::Config for Runtime {307 type BlockGasLimit = BlockGasLimit;308 type FeeCalculator = FixedFee;309 type GasWeightMapping = FixedGasWeightMapping;310 type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;311 type CallOrigin = EnsureAddressTruncated<Self>;312 type WithdrawOrigin = EnsureAddressTruncated<Self>;313 type AddressMapping = HashedAddressMapping<Self::Hashing>;314 type PrecompilesType = ();315 type PrecompilesValue = ();316 type Currency = Balances;317 type Event = Event;318 type OnMethodCall = (319 pallet_evm_migration::OnMethodCall<Self>,320 pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,321 CollectionDispatchT<Self>,322 pallet_unique::eth::CollectionHelpersOnMethodCall<Self>,323 );324 type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;325 type ChainId = ChainId;326 type Runner = pallet_evm::runner::stack::Runner<Self>;327 type OnChargeTransaction = pallet_evm::EVMCurrencyAdapter<Balances, DealWithFees>;328 type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;329 type FindAuthor = EthereumFindAuthor<Aura>;330}331332impl pallet_evm_migration::Config for Runtime {333 type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;334}335336pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);337impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {338 fn find_author<'a, I>(digests: I) -> Option<H160>339 where340 I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,341 {342 if let Some(author_index) = F::find_author(digests) {343 let authority_id = Aura::authorities()[author_index as usize].clone();344 return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));345 }346 None347 }348}349350impl pallet_ethereum::Config for Runtime {351 type Event = Event;352 type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;353}354355impl pallet_randomness_collective_flip::Config for Runtime {}356357impl frame_system::Config for Runtime {358 /// The data to be stored in an account.359 type AccountData = pallet_balances::AccountData<Balance>;360 /// The identifier used to distinguish between accounts.361 type AccountId = AccountId;362 /// The basic call filter to use in dispatchable.363 type BaseCallFilter = Everything;364 /// Maximum number of block number to block hash mappings to keep (oldest pruned first).365 type BlockHashCount = BlockHashCount;366 /// The maximum length of a block (in bytes).367 type BlockLength = RuntimeBlockLength;368 /// The index type for blocks.369 type BlockNumber = BlockNumber;370 /// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.371 type BlockWeights = RuntimeBlockWeights;372 /// The aggregated dispatch type that is available for extrinsics.373 type Call = Call;374 /// The weight of database operations that the runtime can invoke.375 type DbWeight = RocksDbWeight;376 /// The ubiquitous event type.377 type Event = Event;378 /// The type for hashing blocks and tries.379 type Hash = Hash;380 /// The hashing algorithm used.381 type Hashing = BlakeTwo256;382 /// The header type.383 type Header = generic::Header<BlockNumber, BlakeTwo256>;384 /// The index type for storing how many extrinsics an account has signed.385 type Index = Index;386 /// The lookup mechanism to get account ID from whatever is passed in dispatchers.387 type Lookup = AccountIdLookup<AccountId, ()>;388 /// What to do if an account is fully reaped from the system.389 type OnKilledAccount = ();390 /// What to do if a new account is created.391 type OnNewAccount = ();392 type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;393 /// The ubiquitous origin type.394 type Origin = Origin;395 /// This type is being generated by `construct_runtime!`.396 type PalletInfo = PalletInfo;397 /// This is used as an identifier of the chain. 42 is the generic substrate prefix.398 type SS58Prefix = SS58Prefix;399 /// Weight information for the extrinsics of this pallet.400 type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;401 /// Version of the runtime.402 type Version = Version;403 type MaxConsumers = ConstU32<16>;404}405406parameter_types! {407 pub const MinimumPeriod: u64 = SLOT_DURATION / 2;408}409410impl pallet_timestamp::Config for Runtime {411 /// A timestamp: milliseconds since the unix epoch.412 type Moment = u64;413 type OnTimestampSet = ();414 type MinimumPeriod = MinimumPeriod;415 type WeightInfo = ();416}417418parameter_types! {419 // pub const ExistentialDeposit: u128 = 500;420 pub const ExistentialDeposit: u128 = 0;421 pub const MaxLocks: u32 = 50;422 pub const MaxReserves: u32 = 50;423}424425impl pallet_balances::Config for Runtime {426 type MaxLocks = MaxLocks;427 type MaxReserves = MaxReserves;428 type ReserveIdentifier = [u8; 16];429 /// The type for recording an account's balance.430 type Balance = Balance;431 /// The ubiquitous event type.432 type Event = Event;433 type DustRemoval = Treasury;434 type ExistentialDeposit = ExistentialDeposit;435 type AccountStore = System;436 type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;437}438439pub const fn deposit(items: u32, bytes: u32) -> Balance {440 items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE441}442443/*444parameter_types! {445 pub TombstoneDeposit: Balance = deposit(446 1,447 sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,448 );449 pub DepositPerContract: Balance = TombstoneDeposit::get();450 pub const DepositPerStorageByte: Balance = deposit(0, 1);451 pub const DepositPerStorageItem: Balance = deposit(1, 0);452 pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);453 pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;454 pub const SignedClaimHandicap: u32 = 2;455 pub const MaxDepth: u32 = 32;456 pub const MaxValueSize: u32 = 16 * 1024;457 pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb458 // The lazy deletion runs inside on_initialize.459 pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *460 RuntimeBlockWeights::get().max_block;461 // The weight needed for decoding the queue should be less or equal than a fifth462 // of the overall weight dedicated to the lazy deletion.463 pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (464 <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -465 <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)466 )) / 5) as u32;467 pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();468}469470impl pallet_contracts::Config for Runtime {471 type Time = Timestamp;472 type Randomness = RandomnessCollectiveFlip;473 type Currency = Balances;474 type Event = Event;475 type RentPayment = ();476 type SignedClaimHandicap = SignedClaimHandicap;477 type TombstoneDeposit = TombstoneDeposit;478 type DepositPerContract = DepositPerContract;479 type DepositPerStorageByte = DepositPerStorageByte;480 type DepositPerStorageItem = DepositPerStorageItem;481 type RentFraction = RentFraction;482 type SurchargeReward = SurchargeReward;483 type WeightPrice = pallet_transaction_payment::Pallet<Self>;484 type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;485 type ChainExtension = NFTExtension;486 type DeletionQueueDepth = DeletionQueueDepth;487 type DeletionWeightLimit = DeletionWeightLimit;488 type Schedule = Schedule;489 type CallStack = [pallet_contracts::Frame<Self>; 31];490}491*/492493parameter_types! {494 /// This value increases the priority of `Operational` transactions by adding495 /// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.496 pub const OperationalFeeMultiplier: u8 = 5;497}498499/// Linear implementor of `WeightToFeePolynomial`500pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);501502impl<T> WeightToFeePolynomial for LinearFee<T>503where504 T: BaseArithmetic + From<u32> + Copy + Unsigned,505{506 type Balance = T;507508 fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {509 smallvec!(WeightToFeeCoefficient {510 // Targeting 0.1 Unique per NFT transfer511 coeff_integer: WEIGHT_TO_FEE_COEFF.into(),512 coeff_frac: Perbill::zero(),513 negative: false,514 degree: 1,515 })516 }517}518519impl pallet_transaction_payment::Config for Runtime {520 type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;521 type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;522 type OperationalFeeMultiplier = OperationalFeeMultiplier;523 type WeightToFee = LinearFee<Balance>;524 type FeeMultiplierUpdate = ();525}526527parameter_types! {528 pub const ProposalBond: Permill = Permill::from_percent(5);529 pub const ProposalBondMinimum: Balance = 1 * UNIQUE;530 pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;531 pub const SpendPeriod: BlockNumber = 5 * MINUTES;532 pub const Burn: Permill = Permill::from_percent(0);533 pub const TipCountdown: BlockNumber = 1 * DAYS;534 pub const TipFindersFee: Percent = Percent::from_percent(20);535 pub const TipReportDepositBase: Balance = 1 * UNIQUE;536 pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;537 pub const BountyDepositBase: Balance = 1 * UNIQUE;538 pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;539 pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");540 pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;541 pub const MaximumReasonLength: u32 = 16384;542 pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);543 pub const BountyValueMinimum: Balance = 5 * UNIQUE;544 pub const MaxApprovals: u32 = 100;545}546547impl pallet_treasury::Config for Runtime {548 type PalletId = TreasuryModuleId;549 type Currency = Balances;550 type ApproveOrigin = EnsureRoot<AccountId>;551 type RejectOrigin = EnsureRoot<AccountId>;552 type Event = Event;553 type OnSlash = ();554 type ProposalBond = ProposalBond;555 type ProposalBondMinimum = ProposalBondMinimum;556 type ProposalBondMaximum = ProposalBondMaximum;557 type SpendPeriod = SpendPeriod;558 type Burn = Burn;559 type BurnDestination = ();560 type SpendFunds = ();561 type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;562 type MaxApprovals = MaxApprovals;563}564565impl pallet_sudo::Config for Runtime {566 type Event = Event;567 type Call = Call;568}569570pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);571572impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider573 for RelayChainBlockNumberProvider<T>574{575 type BlockNumber = BlockNumber;576577 fn current_block_number() -> Self::BlockNumber {578 cumulus_pallet_parachain_system::Pallet::<T>::validation_data()579 .map(|d| d.relay_parent_number)580 .unwrap_or_default()581 }582}583584parameter_types! {585 pub const MinVestedTransfer: Balance = 10 * UNIQUE;586 pub const MaxVestingSchedules: u32 = 28;587}588589impl orml_vesting::Config for Runtime {590 type Event = Event;591 type Currency = pallet_balances::Pallet<Runtime>;592 type MinVestedTransfer = MinVestedTransfer;593 type VestedTransferOrigin = EnsureSigned<AccountId>;594 type WeightInfo = ();595 type MaxVestingSchedules = MaxVestingSchedules;596 type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;597}598599parameter_types! {600 pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;601 pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;602}603604impl cumulus_pallet_parachain_system::Config for Runtime {605 type Event = Event;606 type SelfParaId = parachain_info::Pallet<Self>;607 type OnSystemEvent = ();608 // type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<609 // MaxDownwardMessageWeight,610 // XcmExecutor<XcmConfig>,611 // Call,612 // >;613 type OutboundXcmpMessageSource = XcmpQueue;614 type DmpMessageHandler = DmpQueue;615 type ReservedDmpWeight = ReservedDmpWeight;616 type ReservedXcmpWeight = ReservedXcmpWeight;617 type XcmpMessageHandler = XcmpQueue;618}619620impl parachain_info::Config for Runtime {}621622impl cumulus_pallet_aura_ext::Config for Runtime {}623624parameter_types! {625 pub const RelayLocation: MultiLocation = MultiLocation::parent();626 pub const RelayNetwork: NetworkId = NetworkId::Polkadot;627 pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();628 pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();629}630631/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used632/// when determining ownership of accounts for asset transacting and when attempting to use XCM633/// `Transact` in order to determine the dispatch Origin.634pub type LocationToAccountId = (635 // The parent (Relay-chain) origin converts to the default `AccountId`.636 ParentIsPreset<AccountId>,637 // Sibling parachain origins convert to AccountId via the `ParaId::into`.638 SiblingParachainConvertsVia<Sibling, AccountId>,639 // Straight up local `AccountId32` origins just alias directly to `AccountId`.640 AccountId32Aliases<RelayNetwork, AccountId>,641);642643pub struct OnlySelfCurrency;644impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {645 fn matches_fungible(a: &MultiAsset) -> Option<B> {646 match (&a.id, &a.fun) {647 (Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),648 _ => None,649 }650 }651}652653/// Means for transacting assets on this chain.654pub type LocalAssetTransactor = CurrencyAdapter<655 // Use this currency:656 Balances,657 // Use this currency when it is a fungible asset matching the given location or name:658 OnlySelfCurrency,659 // Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:660 LocationToAccountId,661 // Our chain's account ID type (we can't get away without mentioning it explicitly):662 AccountId,663 // We don't track any teleports.664 (),665>;666667/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,668/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can669/// biases the kind of local `Origin` it will become.670pub type XcmOriginToTransactDispatchOrigin = (671 // Sovereign account converter; this attempts to derive an `AccountId` from the origin location672 // using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for673 // foreign chains who want to have a local sovereign account on this chain which they control.674 SovereignSignedViaLocation<LocationToAccountId, Origin>,675 // Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when676 // recognised.677 RelayChainAsNative<RelayOrigin, Origin>,678 // Native converter for sibling Parachains; will convert to a `SiblingPara` origin when679 // recognised.680 SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,681 // Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a682 // transaction from the Root origin.683 ParentAsSuperuser<Origin>,684 // Native signed account converter; this just converts an `AccountId32` origin into a normal685 // `Origin::Signed` origin of the same 32-byte value.686 SignedAccountId32AsNative<RelayNetwork, Origin>,687 // Xcm origins can be represented natively under the Xcm pallet's Xcm origin.688 XcmPassthrough<Origin>,689);690691parameter_types! {692 // One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.693 pub UnitWeightCost: Weight = 1_000_000;694 // 1200 UNIQUEs buy 1 second of weight.695 pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);696 pub const MaxInstructions: u32 = 100;697 pub const MaxAuthorities: u32 = 100_000;698}699700match_types! {701 pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {702 MultiLocation { parents: 1, interior: Here } |703 MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }704 };705}706707pub type Barrier = (708 TakeWeightCredit,709 AllowTopLevelPaidExecutionFrom<Everything>,710 AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,711 // ^^^ Parent & its unit plurality gets free execution712);713714pub struct UsingOnlySelfCurrencyComponents<715 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,716 AssetId: Get<MultiLocation>,717 AccountId,718 Currency: CurrencyT<AccountId>,719 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,720>(721 Weight,722 Currency::Balance,723 PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,724);725impl<726 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,727 AssetId: Get<MultiLocation>,728 AccountId,729 Currency: CurrencyT<AccountId>,730 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,731 > WeightTrader732 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>733{734 fn new() -> Self {735 Self(0, Zero::zero(), PhantomData)736 }737738 fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {739 let amount = WeightToFee::calc(&weight);740 let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;741742 // location to this parachain through relay chain743 let option1: xcm::v1::AssetId = Concrete(MultiLocation {744 parents: 1,745 interior: X1(Parachain(ParachainInfo::parachain_id().into())),746 });747 // direct location748 let option2: xcm::v1::AssetId = Concrete(MultiLocation {749 parents: 0,750 interior: Here,751 });752753 let required = if payment.fungible.contains_key(&option1) {754 (option1, u128_amount).into()755 } else if payment.fungible.contains_key(&option2) {756 (option2, u128_amount).into()757 } else {758 (Concrete(MultiLocation::default()), u128_amount).into()759 };760761 let unused = payment762 .checked_sub(required)763 .map_err(|_| XcmError::TooExpensive)?;764 self.0 = self.0.saturating_add(weight);765 self.1 = self.1.saturating_add(amount);766 Ok(unused)767 }768769 fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {770 let weight = weight.min(self.0);771 let amount = WeightToFee::calc(&weight);772 self.0 -= weight;773 self.1 = self.1.saturating_sub(amount);774 let amount: u128 = amount.saturated_into();775 if amount > 0 {776 Some((AssetId::get(), amount).into())777 } else {778 None779 }780 }781}782impl<783 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,784 AssetId: Get<MultiLocation>,785 AccountId,786 Currency: CurrencyT<AccountId>,787 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,788 > Drop789 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>790{791 fn drop(&mut self) {792 OnUnbalanced::on_unbalanced(Currency::issue(self.1));793 }794}795796pub struct XcmConfig;797impl Config for XcmConfig {798 type Call = Call;799 type XcmSender = XcmRouter;800 // How to withdraw and deposit an asset.801 type AssetTransactor = LocalAssetTransactor;802 type OriginConverter = XcmOriginToTransactDispatchOrigin;803 type IsReserve = NativeAsset;804 type IsTeleporter = (); // Teleportation is disabled805 type LocationInverter = LocationInverter<Ancestry>;806 type Barrier = Barrier;807 type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;808 type Trader = UsingOnlySelfCurrencyComponents<809 IdentityFee<Balance>,810 RelayLocation,811 AccountId,812 Balances,813 (),814 >;815 type ResponseHandler = (); // Don't handle responses for now.816 type SubscriptionService = PolkadotXcm;817818 type AssetTrap = PolkadotXcm;819 type AssetClaims = PolkadotXcm;820}821822// parameter_types! {823// pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;824// }825826/// No local origins on this chain are allowed to dispatch XCM sends/executions.827pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);828829/// The means for routing XCM messages which are not for local execution into the right message830/// queues.831pub type XcmRouter = (832 // Two routers - use UMP to communicate with the relay chain:833 cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,834 // ..and XCMP to communicate with the sibling chains.835 XcmpQueue,836);837838impl pallet_evm_coder_substrate::Config for Runtime {}839840impl pallet_xcm::Config for Runtime {841 type Event = Event;842 type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;843 type XcmRouter = XcmRouter;844 type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;845 type XcmExecuteFilter = Everything;846 type XcmExecutor = XcmExecutor<XcmConfig>;847 type XcmTeleportFilter = Everything;848 type XcmReserveTransferFilter = Everything;849 type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;850 type LocationInverter = LocationInverter<Ancestry>;851 type Origin = Origin;852 type Call = Call;853 const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;854 type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;855}856857impl cumulus_pallet_xcm::Config for Runtime {858 type Event = Event;859 type XcmExecutor = XcmExecutor<XcmConfig>;860}861862impl cumulus_pallet_xcmp_queue::Config for Runtime {863 type WeightInfo = ();864 type Event = Event;865 type XcmExecutor = XcmExecutor<XcmConfig>;866 type ChannelInfo = ParachainSystem;867 type VersionWrapper = ();868 type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;869 type ControllerOrigin = EnsureRoot<AccountId>;870 type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;871}872873impl cumulus_pallet_dmp_queue::Config for Runtime {874 type Event = Event;875 type XcmExecutor = XcmExecutor<XcmConfig>;876 type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;877}878879impl pallet_aura::Config for Runtime {880 type AuthorityId = AuraId;881 type DisabledValidators = ();882 type MaxAuthorities = MaxAuthorities;883}884885parameter_types! {886 pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();887 pub const CollectionCreationPrice: Balance = 2 * UNIQUE;888}889890impl pallet_common::Config for Runtime {891 type WeightInfo = pallet_common::weights::SubstrateWeight<Self>;892 type Event = Event;893 type Currency = Balances;894 type CollectionCreationPrice = CollectionCreationPrice;895 type TreasuryAccountId = TreasuryAccountId;896 type CollectionDispatch = CollectionDispatchT<Self>;897898 type EvmTokenAddressMapping = EvmTokenAddressMapping;899 type CrossTokenAddressMapping = CrossTokenAddressMapping<Self::AccountId>;900 type ContractAddress = EvmCollectionHelpersAddress;901}902903impl pallet_structure::Config for Runtime {904 type Event = Event;905 type Call = Call;906 type WeightInfo = pallet_structure::weights::SubstrateWeight<Self>;907}908909impl pallet_fungible::Config for Runtime {910 type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;911}912impl pallet_refungible::Config for Runtime {913 type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;914}915impl pallet_nonfungible::Config for Runtime {916 type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;917}918919impl pallet_proxy_rmrk_core::Config for Runtime {920 type WeightInfo = pallet_proxy_rmrk_core::weights::SubstrateWeight<Self>;921 type Event = Event;922}923924impl pallet_proxy_rmrk_equip::Config for Runtime {925 type 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,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,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 pallet_charge_transaction::ChargeTransactionPayment<Runtime>,1224 //pallet_contract_helpers::ContractHelpersExtension<Runtime>,1225 pallet_ethereum::FakeTransactionFinalizer<Runtime>,1226);1227pub type SignedExtraScheduler = (1228 frame_system::CheckSpecVersion<Runtime>,1229 frame_system::CheckGenesis<Runtime>,1230 frame_system::CheckEra<Runtime>,1231 frame_system::CheckNonce<Runtime>,1232 frame_system::CheckWeight<Runtime>,1233 // pallet_charge_transaction::ChargeTransactionPayment<Runtime>,1234);1235/// Unchecked extrinsic type as expected by this runtime.1236pub type UncheckedExtrinsic =1237 fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1238/// Extrinsic type that has already been checked.1239pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1240/// Executive: handles dispatch to the various modules.1241pub type Executive = frame_executive::Executive<1242 Runtime,1243 Block,1244 frame_system::ChainContext<Runtime>,1245 Runtime,1246 AllPalletsReversedWithSystemFirst,1247>;12481249impl_opaque_keys! {1250 pub struct SessionKeys {1251 pub aura: Aura,1252 }1253}12541255impl fp_self_contained::SelfContainedCall for Call {1256 type SignedInfo = H160;12571258 fn is_self_contained(&self) -> bool {1259 match self {1260 Call::Ethereum(call) => call.is_self_contained(),1261 _ => false,1262 }1263 }12641265 fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1266 match self {1267 Call::Ethereum(call) => call.check_self_contained(),1268 _ => None,1269 }1270 }12711272 fn validate_self_contained(1273 &self,1274 info: &Self::SignedInfo,1275 dispatch_info: &DispatchInfoOf<Call>,1276 len: usize,1277 ) -> Option<TransactionValidity> {1278 match self {1279 Call::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),1280 _ => None,1281 }1282 }12831284 fn pre_dispatch_self_contained(1285 &self,1286 info: &Self::SignedInfo,1287 ) -> Option<Result<(), TransactionValidityError>> {1288 match self {1289 Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1290 _ => None,1291 }1292 }12931294 fn apply_self_contained(1295 self,1296 info: Self::SignedInfo,1297 ) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1298 match self {1299 call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1300 Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1301 )),1302 _ => None,1303 }1304 }1305}13061307macro_rules! dispatch_unique_runtime {1308 ($collection:ident.$method:ident($($name:ident),*)) => {{1309 let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1310 let dispatch = collection.as_dyn();13111312 Ok::<_, DispatchError>(dispatch.$method($($name),*))1313 }};1314}13151316impl_common_runtime_apis!();13171318struct CheckInherents;13191320impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1321 fn check_inherents(1322 block: &Block,1323 relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1324 ) -> sp_inherents::CheckInherentsResult {1325 let relay_chain_slot = relay_state_proof1326 .read_slot()1327 .expect("Could not read the relay chain slot from the proof");13281329 let inherent_data =1330 cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1331 relay_chain_slot,1332 sp_std::time::Duration::from_secs(6),1333 )1334 .create_inherent_data()1335 .expect("Could not create the timestamp inherent data");13361337 inherent_data.check_extrinsics(block)1338 }1339}13401341cumulus_pallet_parachain_system::register_validate_block!(1342 Runtime = Runtime,1343 BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1344 CheckInherents = CheckInherents,1345);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,78 RmrkNftId, RmrkNftChild, RmrkPropertyKey,79 RmrkResourceId, RmrkBaseId,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 = "unique";141pub const TOKEN_SYMBOL: &str = "UNQ";142143type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;144145impl RuntimeInstance for Runtime {146 type CrossAccountId = self::CrossAccountId;147 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: 922000,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: u16 = 7391;259}260261parameter_types! {262 pub const ChainId: u64 = 8880;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 = pallet_evm::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_unique::Config for Runtime {919 type Event = Event;920 type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;921 type CommonWeightInfo = CommonWeights<Self>;922}923924parameter_types! {925 pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied926}927928/// Used for the pallet inflation929impl pallet_inflation::Config for Runtime {930 type Currency = Balances;931 type TreasuryAccountId = TreasuryAccountId;932 type InflationBlockInterval = InflationBlockInterval;933 type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;934}935936parameter_types! {937 pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *938 RuntimeBlockWeights::get().max_block;939 pub const MaxScheduledPerBlock: u32 = 50;940}941942type ChargeTransactionPayment = pallet_charge_transaction::ChargeTransactionPayment<Runtime>;943use frame_support::traits::NamedReservableCurrency;944945fn get_signed_extras(from: <Runtime as frame_system::Config>::AccountId) -> SignedExtraScheduler {946 (947 frame_system::CheckSpecVersion::<Runtime>::new(),948 frame_system::CheckGenesis::<Runtime>::new(),949 frame_system::CheckEra::<Runtime>::from(Era::Immortal),950 frame_system::CheckNonce::<Runtime>::from(frame_system::Pallet::<Runtime>::account_nonce(951 from,952 )),953 frame_system::CheckWeight::<Runtime>::new(),954 // sponsoring transaction logic955 // pallet_charge_transaction::ChargeTransactionPayment::<Runtime>::new(0),956 )957}958959pub struct SchedulerPaymentExecutor;960impl<T: frame_system::Config + pallet_unique_scheduler::Config, SelfContainedSignedInfo>961 DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor962where963 <T as frame_system::Config>::Call: Member964 + Dispatchable<Origin = Origin, Info = DispatchInfo>965 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>966 + GetDispatchInfo967 + From<frame_system::Call<Runtime>>,968 SelfContainedSignedInfo: Send + Sync + 'static,969 Call: From<<T as frame_system::Config>::Call>970 + From<<T as pallet_unique_scheduler::Config>::Call>971 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,972 sp_runtime::AccountId32: From<<T as frame_system::Config>::AccountId>,973{974 fn dispatch_call(975 signer: <T as frame_system::Config>::AccountId,976 call: <T as pallet_unique_scheduler::Config>::Call,977 ) -> Result<978 Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,979 TransactionValidityError,980 > {981 let dispatch_info = call.get_dispatch_info();982 let extrinsic = fp_self_contained::CheckedExtrinsic::<983 AccountId,984 Call,985 SignedExtraScheduler,986 SelfContainedSignedInfo,987 > {988 signed:989 CheckedSignature::<AccountId, SignedExtraScheduler, SelfContainedSignedInfo>::Signed(990 signer.clone().into(),991 get_signed_extras(signer.into()),992 ),993 function: call.into(),994 };995996 extrinsic.apply::<Runtime>(&dispatch_info, 0)997 }998999 fn reserve_balance(1000 id: [u8; 16],1001 sponsor: <T as frame_system::Config>::AccountId,1002 call: <T as pallet_unique_scheduler::Config>::Call,1003 count: u32,1004 ) -> Result<(), DispatchError> {1005 let dispatch_info = call.get_dispatch_info();1006 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0)1007 .saturating_mul(count.into());10081009 <Balances as NamedReservableCurrency<AccountId>>::reserve_named(1010 &id,1011 &(sponsor.into()),1012 weight,1013 )1014 }10151016 fn pay_for_call(1017 id: [u8; 16],1018 sponsor: <T as frame_system::Config>::AccountId,1019 call: <T as pallet_unique_scheduler::Config>::Call,1020 ) -> Result<u128, DispatchError> {1021 let dispatch_info = call.get_dispatch_info();1022 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0);1023 Ok(1024 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1025 &id,1026 &(sponsor.into()),1027 weight,1028 ),1029 )1030 }10311032 fn cancel_reserve(1033 id: [u8; 16],1034 sponsor: <T as frame_system::Config>::AccountId,1035 ) -> Result<u128, DispatchError> {1036 Ok(1037 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1038 &id,1039 &(sponsor.into()),1040 u128::MAX,1041 ),1042 )1043 }1044}10451046parameter_types! {1047 pub const NoPreimagePostponement: Option<u32> = Some(10);1048 pub const Preimage: Option<u32> = Some(10);1049}10501051/// Used the compare the privilege of an origin inside the scheduler.1052pub struct OriginPrivilegeCmp;10531054impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {1055 fn cmp_privilege(_left: &OriginCaller, _right: &OriginCaller) -> Option<Ordering> {1056 Some(Ordering::Equal)1057 }1058}10591060impl pallet_unique_scheduler::Config for Runtime {1061 type Event = Event;1062 type Origin = Origin;1063 type Currency = Balances;1064 type PalletsOrigin = OriginCaller;1065 type Call = Call;1066 type MaximumWeight = MaximumSchedulerWeight;1067 type ScheduleOrigin = EnsureSigned<AccountId>;1068 type MaxScheduledPerBlock = MaxScheduledPerBlock;1069 type WeightInfo = ();1070 type CallExecutor = SchedulerPaymentExecutor;1071 type OriginPrivilegeCmp = OriginPrivilegeCmp;1072 type PreimageProvider = ();1073 type NoPreimagePostponement = NoPreimagePostponement;1074}10751076type EvmSponsorshipHandler = (1077 UniqueEthSponsorshipHandler<Runtime>,1078 pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,1079);1080type SponsorshipHandler = (1081 UniqueSponsorshipHandler<Runtime>,1082 //pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1083 pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1084);10851086impl pallet_evm_transaction_payment::Config for Runtime {1087 type EvmSponsorshipHandler = EvmSponsorshipHandler;1088 type Currency = Balances;1089}10901091impl pallet_charge_transaction::Config for Runtime {1092 type SponsorshipHandler = SponsorshipHandler;1093}10941095// impl pallet_contract_helpers::Config for Runtime {1096// type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1097// }10981099parameter_types! {1100 // 0x842899ECF380553E8a4de75bF534cdf6fBF640491101 pub const HelpersContractAddress: H160 = H160([1102 0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1103 ]);11041105 // 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f1106 pub const EvmCollectionHelpersAddress: H160 = H160([1107 0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,1108 ]);1109}11101111impl pallet_evm_contract_helpers::Config for Runtime {1112 type ContractAddress = HelpersContractAddress;1113 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1114}11151116construct_runtime!(1117 pub enum Runtime where1118 Block = Block,1119 NodeBlock = opaque::Block,1120 UncheckedExtrinsic = UncheckedExtrinsic1121 {1122 ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1123 ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,11241125 Aura: pallet_aura::{Pallet, Config<T>} = 22,1126 AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,11271128 Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1129 RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1130 Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1131 TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1132 Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1133 Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1134 System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1135 Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1136 // Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1137 // Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,11381139 // XCM helpers.1140 XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1141 PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1142 CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1143 DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11441145 // Unique Pallets1146 Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1147 Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1148 Scheduler: pallet_unique_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1149 // free = 631150 Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1151 // ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1152 Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1153 Fungible: pallet_fungible::{Pallet, Storage} = 67,1154 Refungible: pallet_refungible::{Pallet, Storage} = 68,1155 Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1156 Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,11571158 // Frontier1159 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1160 Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11611162 EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1163 EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1164 EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1165 EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1166 }1167);11681169pub struct TransactionConverter;11701171impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1172 fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1173 UncheckedExtrinsic::new_unsigned(1174 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1175 )1176 }1177}11781179impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1180 fn convert_transaction(1181 &self,1182 transaction: pallet_ethereum::Transaction,1183 ) -> opaque::UncheckedExtrinsic {1184 let extrinsic = UncheckedExtrinsic::new_unsigned(1185 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1186 );1187 let encoded = extrinsic.encode();1188 opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1189 .expect("Encoded extrinsic is always valid")1190 }1191}11921193/// The address format for describing accounts.1194pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1195/// Block header type as expected by this runtime.1196pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1197/// Block type as expected by this runtime.1198pub type Block = generic::Block<Header, UncheckedExtrinsic>;1199/// A Block signed with a Justification1200pub type SignedBlock = generic::SignedBlock<Block>;1201/// BlockId type as expected by this runtime.1202pub type BlockId = generic::BlockId<Block>;1203/// The SignedExtension to the basic transaction logic.1204pub type SignedExtra = (1205 frame_system::CheckSpecVersion<Runtime>,1206 // system::CheckTxVersion<Runtime>,1207 frame_system::CheckGenesis<Runtime>,1208 frame_system::CheckEra<Runtime>,1209 frame_system::CheckNonce<Runtime>,1210 frame_system::CheckWeight<Runtime>,1211 pallet_charge_transaction::ChargeTransactionPayment<Runtime>,1212 //pallet_contract_helpers::ContractHelpersExtension<Runtime>,1213 pallet_ethereum::FakeTransactionFinalizer<Runtime>,1214);1215pub type SignedExtraScheduler = (1216 frame_system::CheckSpecVersion<Runtime>,1217 frame_system::CheckGenesis<Runtime>,1218 frame_system::CheckEra<Runtime>,1219 frame_system::CheckNonce<Runtime>,1220 frame_system::CheckWeight<Runtime>,1221 // pallet_charge_transaction::ChargeTransactionPayment<Runtime>,1222);1223/// Unchecked extrinsic type as expected by this runtime.1224pub type UncheckedExtrinsic =1225 fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1226/// Extrinsic type that has already been checked.1227pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1228/// Executive: handles dispatch to the various modules.1229pub type Executive = frame_executive::Executive<1230 Runtime,1231 Block,1232 frame_system::ChainContext<Runtime>,1233 Runtime,1234 AllPalletsReversedWithSystemFirst,1235>;12361237impl_opaque_keys! {1238 pub struct SessionKeys {1239 pub aura: Aura,1240 }1241}12421243impl fp_self_contained::SelfContainedCall for Call {1244 type SignedInfo = H160;12451246 fn is_self_contained(&self) -> bool {1247 match self {1248 Call::Ethereum(call) => call.is_self_contained(),1249 _ => false,1250 }1251 }12521253 fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1254 match self {1255 Call::Ethereum(call) => call.check_self_contained(),1256 _ => None,1257 }1258 }12591260 fn validate_self_contained(1261 &self,1262 info: &Self::SignedInfo,1263 dispatch_info: &DispatchInfoOf<Call>,1264 len: usize,1265 ) -> Option<TransactionValidity> {1266 match self {1267 Call::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),1268 _ => None,1269 }1270 }12711272 fn pre_dispatch_self_contained(1273 &self,1274 info: &Self::SignedInfo,1275 ) -> Option<Result<(), TransactionValidityError>> {1276 match self {1277 Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1278 _ => None,1279 }1280 }12811282 fn apply_self_contained(1283 self,1284 info: Self::SignedInfo,1285 ) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1286 match self {1287 call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1288 Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1289 )),1290 _ => None,1291 }1292 }1293}12941295macro_rules! dispatch_unique_runtime {1296 ($collection:ident.$method:ident($($name:ident),*)) => {{1297 let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1298 let dispatch = collection.as_dyn();12991300 Ok::<_, DispatchError>(dispatch.$method($($name),*))1301 }};1302}13031304impl_common_runtime_apis! {1305 #![custom_apis]13061307 impl rmrk_rpc::RmrkApi<1308 Block,1309 AccountId,1310 RmrkCollectionInfo<AccountId>,1311 RmrkInstanceInfo<AccountId>,1312 RmrkResourceInfo,1313 RmrkPropertyInfo,1314 RmrkBaseInfo<AccountId>,1315 RmrkPartType,1316 RmrkTheme1317 > for Runtime {1318 fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {1319 Ok(Default::default())1320 }13211322 fn collection_by_id(_collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {1323 Ok(Default::default())1324 }13251326 fn nft_by_id(_collection_id: RmrkCollectionId, _nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {1327 Ok(Default::default())1328 }13291330 fn account_tokens(_account_id: AccountId, _collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {1331 Ok(Default::default())1332 }13331334 fn nft_children(_collection_id: RmrkCollectionId, _nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {1335 Ok(Default::default())1336 }13371338 fn collection_properties(_collection_id: RmrkCollectionId, _filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {1339 Ok(Default::default())1340 }13411342 fn nft_properties(_collection_id: RmrkCollectionId, _nft_id: RmrkNftId, _filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {1343 Ok(Default::default())1344 }13451346 fn nft_resources(_collection_id: RmrkCollectionId, _nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {1347 Ok(Default::default())1348 }13491350 fn nft_resource_priority(_collection_id: RmrkCollectionId, _nft_id: RmrkNftId, _resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {1351 Ok(Default::default())1352 }13531354 fn base(_base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {1355 Ok(Default::default())1356 }13571358 fn base_parts(_base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {1359 Ok(Default::default())1360 }13611362 fn theme_names(_base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {1363 Ok(Default::default())1364 }13651366 fn theme(_base_id: RmrkBaseId, _theme_name: RmrkThemeName, _filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {1367 Ok(Default::default())1368 }1369 }1370}13711372struct CheckInherents;13731374impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1375 fn check_inherents(1376 block: &Block,1377 relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1378 ) -> sp_inherents::CheckInherentsResult {1379 let relay_chain_slot = relay_state_proof1380 .read_slot()1381 .expect("Could not read the relay chain slot from the proof");13821383 let inherent_data =1384 cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1385 relay_chain_slot,1386 sp_std::time::Duration::from_secs(6),1387 )1388 .create_inherent_data()1389 .expect("Could not create the timestamp inherent data");13901391 inherent_data.check_extrinsics(block)1392 }1393}13941395cumulus_pallet_parachain_system::register_validate_block!(1396 Runtime = Runtime,1397 BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1398 CheckInherents = CheckInherents,1399);tests/src/eth/nesting/nest.test.tsdiffbeforeafterboth--- a/tests/src/eth/nesting/nest.test.ts
+++ b/tests/src/eth/nesting/nest.test.ts
@@ -29,34 +29,37 @@
const {collectionId, contract} = await createNestingCollection(api, web3, owner);
// Create a token to be nested
- const nftTokenId = await contract.methods.nextTokenId().call();
+ const targetNFTTokenId = await contract.methods.nextTokenId().call();
await contract.methods.mint(
owner,
- nftTokenId,
+ targetNFTTokenId,
).send({from: owner});
- // Nest into a token
- const firstTargetNftTokenId = await contract.methods.nextTokenId().call();
+ const targetNftTokenAddress = tokenIdToAddress(collectionId, targetNFTTokenId);
+
+ // Create a nested token
+ const firstTokenId = await contract.methods.nextTokenId().call();
await contract.methods.mint(
- owner,
- firstTargetNftTokenId,
+ targetNftTokenAddress,
+ firstTokenId,
).send({from: owner});
-
- const targetNftTokenAddress = tokenIdToAddress(collectionId, firstTargetNftTokenId);
- await contract.methods.transfer(targetNftTokenAddress, nftTokenId).send({from: owner});
- expect(await contract.methods.ownerOf(nftTokenId).call()).to.be.equal(targetNftTokenAddress);
+ expect(await contract.methods.ownerOf(firstTokenId).call()).to.be.equal(targetNftTokenAddress);
- // Re-nest into another
- const secondTargetNftTokenId = await contract.methods.nextTokenId().call();
+ // Create a token to be nested and nest
+ const secondTokenId = await contract.methods.nextTokenId().call();
await contract.methods.mint(
owner,
- secondTargetNftTokenId,
+ secondTokenId,
).send({from: owner});
- const nextNftTokenAddress = tokenIdToAddress(collectionId, secondTargetNftTokenId);
- await contract.methods.transfer(nextNftTokenAddress, nftTokenId).send({from: owner});
- expect(await contract.methods.ownerOf(nftTokenId).call()).to.be.equal(nextNftTokenAddress);
+ await contract.methods.transfer(targetNftTokenAddress, secondTokenId).send({from: owner});
+
+ expect(await contract.methods.ownerOf(secondTokenId).call()).to.be.equal(targetNftTokenAddress);
+
+ // Unnest token back
+ await contract.methods.transferFrom(targetNftTokenAddress, owner, secondTokenId).send({from: owner});
+ expect(await contract.methods.ownerOf(secondTokenId).call()).to.be.equal(owner);
});
itWeb3('NFT: allows an Owner to nest/unnest their token (Restricted nesting)', async ({api, web3, privateKeyWrapper}) => {
@@ -125,7 +128,7 @@
.transfer(targetNftTokenAddress, nftTokenId)
.call({from: owner})).to.be.rejectedWith('UserIsNotAllowedToNest');
});
-
+
itWeb3('NFT: disallows a non-Owner to nest someone else\'s token', async ({api, web3, privateKeyWrapper}) => {
const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
const malignant = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
@@ -139,20 +142,20 @@
targetTokenId,
).send({from: owner});
const targetTokenAddress = tokenIdToAddress(collectionId, targetTokenId);
-
+
// Mint a token belonging to a different account
const tokenId = await contract.methods.nextTokenId().call();
await contract.methods.mint(
malignant,
tokenId,
).send({from: owner});
-
+
// Try to nest one token in another as a non-owner account
await expect(contract.methods
.transfer(targetTokenAddress, tokenId)
.call({from: malignant})).to.be.rejectedWith('UserIsNotAllowedToNest');
});
-
+
itWeb3('NFT: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async ({api, web3, privateKeyWrapper}) => {
const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
const malignant = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
@@ -182,7 +185,7 @@
.transfer(nftTokenAddressA, nftTokenIdB)
.call({from: malignant})).to.be.rejectedWith('UserIsNotAllowedToNest');
});
-
+
itWeb3('NFT: disallows to nest token in an unlisted collection', async ({api, web3, privateKeyWrapper}) => {
const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
tests/src/nesting/nest.test.tsdiffbeforeafterboth--- a/tests/src/nesting/nest.test.ts
+++ b/tests/src/nesting/nest.test.ts
@@ -454,6 +454,7 @@
it('Admin (NFT): disallows an Admin to nest and unnest someone else\'s token', async () => {
await usingApi(async api => {
const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
+ await setCollectionLimitsExpectSuccess(alice, collection, {ownerCanTransfer: true});
await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
await addToAllowListExpectSuccess(alice, collection, bob.address);
tests/src/pallet-presence.test.tsdiffbeforeafterboth--- a/tests/src/pallet-presence.test.ts
+++ b/tests/src/pallet-presence.test.ts
@@ -50,8 +50,6 @@
'unique',
'nonfungible',
'refungible',
- 'rmrkcore',
- 'rmrkequip',
'scheduler',
'charging',
];
@@ -64,6 +62,16 @@
];
describe('Pallet presence', () => {
+ before(async () => {
+ await usingApi(async api => {
+ const chain = await api.rpc.system.chain();
+
+ if (!chain.eq('UNIQUE')) {
+ requiredPallets.push(...['rmrkcore', 'rmrkequip']);
+ }
+ });
+ });
+
it('Required pallets are present', async () => {
await usingApi(async api => {
for (let i=0; i<requiredPallets.length; i++) {
tests/src/rmrk/rmrk.test.tsdiffbeforeafterboth--- a/tests/src/rmrk/rmrk.test.ts
+++ b/tests/src/rmrk/rmrk.test.ts
@@ -11,6 +11,7 @@
} from '../util/helpers';
import {IKeyringPair} from '@polkadot/types/types';
import {ApiPromise} from '@polkadot/api';
+import {it} from 'mocha';
let alice: IKeyringPair;
let bob: IKeyringPair;
@@ -48,14 +49,26 @@
return result.data!;
}
-describe('RMRK External Integration Test', () => {
+async function isUnique(): Promise<boolean> {
+ return usingApi(async api => {
+ const chain = await api.rpc.system.chain();
+
+ return chain.eq('UNIQUE');
+ });
+}
+
+describe('RMRK External Integration Test', async () => {
+ const it_rmrk = (await isUnique() ? it : it.skip);
+
before(async () => {
await usingApi(async (api, privateKeyWrapper) => {
alice = privateKeyWrapper('//Alice');
+
+
});
});
- it('Creates a new RMRK collection that is mapped to a different ID and is tagged as external', async () => {
+ it_rmrk('Creates a new RMRK collection that is mapped to a different ID and is tagged as external', async () => {
await usingApi(async api => {
// throwaway collection to bump last Unique collection ID to test ID mapping
await createCollectionExpectSuccess();
@@ -70,11 +83,13 @@
});
});
-describe('Negative Integration Test: External Collections, Internal Ops', () => {
+describe('Negative Integration Test: External Collections, Internal Ops', async () => {
let uniqueCollectionId: number;
let rmrkCollectionId: number;
let rmrkNftId: number;
+ const it_rmrk = (await isUnique() ? it : it.skip);
+
before(async () => {
await usingApi(async (api, privateKeyWrapper) => {
alice = privateKeyWrapper('//Alice');
@@ -88,7 +103,7 @@
});
});
- it('[Negative] Forbids Unique operations with an external collection, handled by dispatch_call', async () => {
+ it_rmrk('[Negative] Forbids Unique operations with an external collection, handled by dispatch_call', async () => {
await usingApi(async api => {
// Collection item creation
@@ -147,7 +162,7 @@
});
});
- it('[Negative] Forbids Unique collection operations with an external collection', async () => {
+ it_rmrk('[Negative] Forbids Unique collection operations with an external collection', async () => {
await usingApi(async api => {
const txDestroyCollection = api.tx.unique.destroyCollection(uniqueCollectionId);
await expect(executeTransaction(api, alice, txDestroyCollection), 'destroying collection')
@@ -206,10 +221,12 @@
});
});
-describe('Negative Integration Test: Internal Collections, External Ops', () => {
+describe('Negative Integration Test: Internal Collections, External Ops', async () => {
let collectionId: number;
let nftId: number;
+ const it_rmrk = (await isUnique() ? it : it.skip);
+
before(async () => {
await usingApi(async (api, privateKeyWrapper) => {
alice = privateKeyWrapper('//Alice');
@@ -220,7 +237,7 @@
});
});
- it('[Negative] Forbids RMRK operations with the internal collection and NFT (due to the lack of mapping)', async () => {
+ it_rmrk('[Negative] Forbids RMRK operations with the internal collection and NFT (due to the lack of mapping)', async () => {
await usingApi(async api => {
const txChangeOwner = api.tx.rmrkCore.changeCollectionIssuer(collectionId, bob.address);
await expect(executeTransaction(api, alice, txChangeOwner), 'changing collection issuer')