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.rsdiffbeforeafterboth74 CollectionStats, RpcCollection,74 CollectionStats, RpcCollection,75 mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},75 mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},76 TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,76 TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,77 RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkThemeProperty, RmrkCollectionId,77 RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkCollectionId,78 RmrkNftId, RmrkAccountIdOrCollectionNftTuple, RmrkNftChild, RmrkPropertyKey, RmrkResourceTypes,78 RmrkNftId, RmrkNftChild, RmrkPropertyKey,79 RmrkBasicResource, RmrkComposableResource, RmrkSlotResource, RmrkResourceId, RmrkBaseId,79 RmrkResourceId, RmrkBaseId,80 RmrkFixedPart, RmrkSlotPart, RmrkString,81};80};828183// use pallet_contracts::weights::WeightInfo;82// use pallet_contracts::weights::WeightInfo;916 type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;915 type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;917}916}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}927917928impl pallet_unique::Config for Runtime {918impl pallet_unique::Config for Runtime {929 type Event = Event;919 type Event = Event;1164 Refungible: pallet_refungible::{Pallet, Storage} = 68,1154 Refungible: pallet_refungible::{Pallet, Storage} = 68,1165 Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1155 Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1166 Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,1156 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,116911571170 // Frontier1158 // Frontier1171 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1159 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1313 }};1301 }};1314}1302}131513031316impl_common_runtime_apis!();1304impl_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}131713711318struct CheckInherents;1372struct CheckInherents;13191373tests/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')