difftreelog
refactor move RMRK rpc impl to proxy pallets
in: master
6 files changed
pallets/proxy-rmrk-core/src/lib.rsdiffbeforeafterboth--- a/pallets/proxy-rmrk-core/src/lib.rs
+++ b/pallets/proxy-rmrk-core/src/lib.rs
@@ -35,6 +35,7 @@
pub mod benchmarking;
pub mod misc;
pub mod property;
+pub mod rpc;
pub mod weights;
pub type SelfWeightOf<T> = <T as Config>::WeightInfo;
pallets/proxy-rmrk-core/src/rpc.rsdiffbeforeafterboth--- /dev/null
+++ b/pallets/proxy-rmrk-core/src/rpc.rs
@@ -0,0 +1,265 @@
+use super::*;
+
+pub fn last_collection_idx<T: Config>() -> Result<RmrkCollectionId, DispatchError> {
+ Ok(<Pallet<T>>::last_collection_idx())
+}
+
+pub fn collection_by_id<T: Config>(
+ collection_id: RmrkCollectionId,
+) -> Result<Option<RmrkCollectionInfo<T::AccountId>>, DispatchError> {
+ let (collection, collection_id) = match <Pallet<T>>::get_typed_nft_collection_mapped(
+ collection_id,
+ misc::CollectionType::Regular,
+ ) {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ let nfts_count = collection.total_supply();
+
+ Ok(Some(RmrkCollectionInfo {
+ issuer: collection.owner.clone(),
+ metadata: <Pallet<T>>::get_collection_property_decoded(
+ collection_id,
+ RmrkProperty::Metadata,
+ )?,
+ max: collection.limits.token_limit,
+ symbol: <Pallet<T>>::rebind(&collection.token_prefix)?,
+ nfts_count,
+ }))
+}
+
+pub fn nft_by_id<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_by_id: RmrkNftId,
+) -> Result<Option<RmrkInstanceInfo<T::AccountId>>, DispatchError> {
+ let (collection, collection_id) = match <Pallet<T>>::get_typed_nft_collection_mapped(
+ collection_id,
+ misc::CollectionType::Regular,
+ ) {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ let nft_id = TokenId(nft_by_id);
+ if !<Pallet<T>>::nft_exists(collection_id, nft_id) {
+ return Ok(None);
+ }
+
+ let owner = match collection.token_owner(nft_id) {
+ Some(owner) => match T::CrossTokenAddressMapping::address_to_token(&owner) {
+ Some((col, tok)) => {
+ let rmrk_collection = <Pallet<T>>::rmrk_collection_id(col)?;
+
+ RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)
+ }
+ None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone()),
+ },
+ None => return Ok(None),
+ };
+
+ Ok(Some(RmrkInstanceInfo {
+ owner: owner,
+ royalty: <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::RoyaltyInfo,
+ )?,
+ metadata: <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::Metadata,
+ )?,
+ equipped: <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::Equipped,
+ )?,
+ pending: <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::PendingNftAccept,
+ )?,
+ }))
+}
+
+pub fn account_tokens<T: Config>(
+ account_id: T::AccountId,
+ collection_id: RmrkCollectionId,
+) -> Result<Vec<RmrkNftId>, DispatchError> {
+ let cross_account_id = CrossAccountId::from_sub(account_id);
+
+ let (collection, collection_id) = match <Pallet<T>>::get_typed_nft_collection_mapped(
+ collection_id,
+ misc::CollectionType::Regular,
+ ) {
+ Ok(c) => c,
+ Err(_) => return Ok(Vec::new()),
+ };
+
+ let tokens = collection
+ .account_tokens(cross_account_id)
+ .into_iter()
+ .filter(|token| {
+ let is_pending = <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ *token,
+ RmrkProperty::PendingNftAccept,
+ )
+ .unwrap_or(true);
+
+ !is_pending
+ })
+ .map(|token| token.0)
+ .collect();
+
+ Ok(tokens)
+}
+
+pub fn nft_children<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_id: RmrkNftId,
+) -> Result<Vec<RmrkNftChild>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new()),
+ };
+ let nft_id = TokenId(nft_id);
+ if !<Pallet<T>>::nft_exists(collection_id, nft_id) {
+ return Ok(Vec::new());
+ }
+
+ Ok(
+ pallet_nonfungible::TokenChildren::<T>::iter_prefix((collection_id, nft_id))
+ .filter_map(|((child_collection, child_token), _)| {
+ let is_pending = <Pallet<T>>::get_nft_property_decoded(
+ child_collection,
+ child_token,
+ RmrkProperty::PendingNftAccept,
+ )
+ .ok()?;
+
+ if is_pending {
+ return None;
+ }
+
+ let rmrk_child_collection =
+ <Pallet<T>>::rmrk_collection_id(child_collection).ok()?;
+
+ Some(RmrkNftChild {
+ collection_id: rmrk_child_collection,
+ nft_id: child_token.0,
+ })
+ })
+ .collect(),
+ )
+}
+
+pub fn collection_properties<T: Config>(
+ collection_id: RmrkCollectionId,
+ filter_keys: Option<Vec<RmrkPropertyKey>>,
+) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new()),
+ };
+ if <Pallet<T>>::ensure_collection_type(collection_id, misc::CollectionType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let properties = <Pallet<T>>::filter_user_properties(
+ collection_id,
+ /* token_id = */ None,
+ filter_keys,
+ |key, value| RmrkPropertyInfo { key, value },
+ )?;
+
+ Ok(properties)
+}
+
+pub fn nft_properties<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_id: RmrkNftId,
+ filter_keys: Option<Vec<RmrkPropertyKey>>,
+) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new()),
+ };
+ let token_id = TokenId(nft_id);
+
+ if <Pallet<T>>::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let properties = <Pallet<T>>::filter_user_properties(
+ collection_id,
+ Some(token_id),
+ filter_keys,
+ |key, value| RmrkPropertyInfo { key, value },
+ )?;
+
+ Ok(properties)
+}
+
+pub fn nft_resources<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_id: RmrkNftId,
+) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new()),
+ };
+ if <Pallet<T>>::ensure_collection_type(collection_id, misc::CollectionType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let nft_id = TokenId(nft_id);
+ if <Pallet<T>>::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let resources = <pallet_nonfungible::Pallet<T>>::iterate_token_aux_properties(
+ collection_id,
+ nft_id,
+ PropertyScope::Rmrk,
+ )
+ .filter_map(|(_, value)| {
+ let resource_info: RmrkResourceInfo = <Pallet<T>>::decode_property(&value).ok()?;
+
+ Some(resource_info)
+ })
+ .collect();
+
+ Ok(resources)
+}
+
+pub fn nft_resource_priority<T: Config>(
+ collection_id: RmrkCollectionId,
+ nft_id: RmrkNftId,
+ resource_id: RmrkResourceId,
+) -> Result<Option<u32>, DispatchError> {
+ let collection_id = match <Pallet<T>>::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(None),
+ };
+ if <Pallet<T>>::ensure_collection_type(collection_id, misc::CollectionType::Regular).is_err() {
+ return Ok(None);
+ }
+
+ let nft_id = TokenId(nft_id);
+ if <Pallet<T>>::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() {
+ return Ok(None);
+ }
+
+ let priorities: Vec<_> = <Pallet<T>>::get_nft_property_decoded(
+ collection_id,
+ nft_id,
+ RmrkProperty::ResourcePriorities,
+ )?;
+ Ok(priorities
+ .into_iter()
+ .enumerate()
+ .find(|(_, id)| *id == resource_id)
+ .map(|(priority, _): (usize, RmrkResourceId)| priority as u32))
+}
pallets/proxy-rmrk-equip/src/lib.rsdiffbeforeafterboth--- a/pallets/proxy-rmrk-equip/src/lib.rs
+++ b/pallets/proxy-rmrk-equip/src/lib.rs
@@ -34,6 +34,7 @@
#[cfg(feature = "runtime-benchmarks")]
pub mod benchmarking;
+pub mod rpc;
pub mod weights;
pub type SelfWeightOf<T> = <T as Config>::WeightInfo;
pallets/proxy-rmrk-equip/src/rpc.rsdiffbeforeafterbothno changes
runtime/opal/src/lib.rsdiffbeforeafterboth--- a/runtime/opal/src/lib.rs
+++ b/runtime/opal/src/lib.rs
@@ -74,9 +74,8 @@
CollectionStats, RpcCollection,
mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},
TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,
- RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkThemeProperty, RmrkCollectionId,
- RmrkNftId, RmrkAccountIdOrCollectionNftTuple, RmrkNftChild, RmrkPropertyKey, RmrkResourceId,
- RmrkBaseId, RmrkFixedPart, RmrkSlotPart, RmrkString,
+ RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkCollectionId, RmrkNftId,
+ RmrkNftChild, RmrkPropertyKey, RmrkResourceId, RmrkBaseId,
};
// use pallet_contracts::weights::WeightInfo;
@@ -1330,352 +1329,55 @@
RmrkTheme
> for Runtime {
fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
- Ok(RmrkCore::last_collection_idx())
+ pallet_proxy_rmrk_core::rpc::last_collection_idx::<Runtime>()
}
fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let nfts_count = collection.total_supply();
-
- Ok(Some(RmrkCollectionInfo {
- issuer: collection.owner.clone(),
- metadata: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::Metadata)?,
- max: collection.limits.token_limit,
- symbol: RmrkCore::rebind(&collection.token_prefix)?,
- nfts_count
- }))
+ pallet_proxy_rmrk_core::rpc::collection_by_id::<Runtime>(collection_id)
}
fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {
- use up_data_structs::mapping::TokenAddressMapping;
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let nft_id = TokenId(nft_by_id);
- if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }
-
- let owner = match collection.token_owner(nft_id) {
- Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {
- Some((col, tok)) => {
- let rmrk_collection = RmrkCore::rmrk_collection_id(col)?;
-
- RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)
- }
- None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())
- },
- None => return Ok(None)
- };
-
- Ok(Some(RmrkInstanceInfo {
- owner: owner,
- royalty: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::RoyaltyInfo)?,
- metadata: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Metadata)?,
- equipped: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Equipped)?,
- pending: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::PendingNftAccept)?,
- }))
+ pallet_proxy_rmrk_core::rpc::nft_by_id::<Runtime>(collection_id, nft_by_id)
}
fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let cross_account_id = CrossAccountId::from_sub(account_id);
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let tokens = collection.account_tokens(cross_account_id)
- .into_iter()
- .filter(|token| {
- let is_pending = RmrkCore::get_nft_property_decoded(
- collection_id,
- *token,
- RmrkProperty::PendingNftAccept
- ).unwrap_or(true);
-
- !is_pending
- })
- .map(|token| token.0)
- .collect();
-
- Ok(tokens)
+ pallet_proxy_rmrk_core::rpc::account_tokens::<Runtime>(account_id, collection_id)
}
fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {
- use pallet_proxy_rmrk_core::RmrkProperty;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- let nft_id = TokenId(nft_id);
- if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(Vec::new()); }
-
- Ok(
- pallet_nonfungible::TokenChildren::<Runtime>::iter_prefix((collection_id, nft_id))
- .filter_map(|((child_collection, child_token), _)| {
- let is_pending = RmrkCore::get_nft_property_decoded(
- child_collection,
- child_token,
- RmrkProperty::PendingNftAccept
- ).ok()?;
-
- if is_pending {
- return None;
- }
-
- let rmrk_child_collection = RmrkCore::rmrk_collection_id(
- child_collection
- ).ok()?;
-
- Some(RmrkNftChild {
- collection_id: rmrk_child_collection,
- nft_id: child_token.0,
- })
- }).collect()
- )
+ pallet_proxy_rmrk_core::rpc::nft_children::<Runtime>(collection_id, nft_id)
}
fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::CollectionType;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() {
- return Ok(Vec::new());
- }
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- /* token_id = */ None,
- filter_keys,
- |key, value| RmrkPropertyInfo {
- key,
- value
- }
- )?;
-
- Ok(properties)
+ pallet_proxy_rmrk_core::rpc::collection_properties::<Runtime>(collection_id, filter_keys)
}
fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::NftType;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- let token_id = TokenId(nft_id);
-
- if RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {
- return Ok(Vec::new());
- }
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- Some(token_id),
- filter_keys,
- |key, value| RmrkPropertyInfo {
- key,
- value
- }
- )?;
-
- Ok(properties)
+ pallet_proxy_rmrk_core::rpc::nft_properties::<Runtime>(collection_id, nft_id, filter_keys)
}
fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::{CollectionType, NftType};
- use up_data_structs::PropertyScope;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }
-
- let nft_id = TokenId(nft_id);
- if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }
-
- let resources = <pallet_nonfungible::Pallet<Runtime>>::iterate_token_aux_properties(
- collection_id, nft_id, PropertyScope::Rmrk
- ).filter_map(|(_, value)| {
- let resource_info: RmrkResourceInfo = RmrkCore::decode_property(&value).ok()?;
-
- Some(resource_info)
- }).collect();
-
- Ok(resources)
+ pallet_proxy_rmrk_core::rpc::nft_resources::<Runtime>(collection_id, nft_id)
}
fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(None)
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }
-
- let nft_id = TokenId(nft_id);
- if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }
-
- let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;
- Ok(
- priorities.into_iter()
- .enumerate()
- .find(|(_, id)| *id == resource_id)
- .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)
- )
+ pallet_proxy_rmrk_core::rpc::nft_resource_priority::<Runtime>(collection_id, nft_id, resource_id)
}
fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {
- use pallet_proxy_rmrk_core::{
- RmrkProperty, misc::{CollectionType},
- };
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- Ok(Some(RmrkBaseInfo {
- issuer: collection.owner.clone(),
- base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,
- symbol: RmrkCore::rebind(&collection.token_prefix)?,
- }))
+ pallet_proxy_rmrk_equip::rpc::base::<Runtime>(base_id)
}
fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let parts = collection.collection_tokens()
- .into_iter()
- .filter_map(|token_id| {
- let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;
-
- match nft_type {
- NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {
- id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
- src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
- z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
- })),
- NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {
- id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
- src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
- z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
- equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,
- })),
- _ => None
- }
- })
- .collect();
-
- Ok(parts)
+ pallet_proxy_rmrk_equip::rpc::base_parts::<Runtime>(base_id)
}
fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{NftType, CollectionType}};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let theme_names = collection.collection_tokens()
- .iter()
- .filter_map(|token_id| {
- let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).ok()?;
-
- match nft_type {
- NftType::Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),
- _ => None
- }
- })
- .collect();
-
- Ok(theme_names)
+ pallet_proxy_rmrk_equip::rpc::theme_names::<Runtime>(base_id)
}
fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {
- use pallet_proxy_rmrk_core::{
- RmrkProperty,
- misc::{CollectionType, NftType}
- };
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let theme_info = collection.collection_tokens()
- .into_iter()
- .find_map(|token_id| {
- RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;
-
- let name: RmrkString = RmrkCore::get_nft_property_decoded(
- collection_id, token_id, RmrkProperty::ThemeName
- ).ok()?;
-
- if name == theme_name {
- Some((name, token_id))
- } else {
- None
- }
- });
-
- let (name, theme_id) = match theme_info {
- Some((name, theme_id)) => (name, theme_id),
- None => return Ok(None)
- };
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- Some(theme_id),
- filter_keys,
- |key, value| RmrkThemeProperty {
- key,
- value
- }
- )?;
-
- let inherit = RmrkCore::get_nft_property_decoded(
- collection_id,
- theme_id,
- RmrkProperty::ThemeInherit
- )?;
-
- let theme = RmrkTheme {
- name,
- properties,
- inherit,
- };
-
- Ok(Some(theme))
+ pallet_proxy_rmrk_equip::rpc::theme::<Runtime>(base_id, theme_name, filter_keys)
}
}
}
runtime/quartz/src/lib.rsdiffbeforeafterboth--- a/runtime/quartz/src/lib.rs
+++ b/runtime/quartz/src/lib.rs
@@ -74,9 +74,8 @@
CollectionStats, RpcCollection,
mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},
TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,
- RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkThemeProperty, RmrkCollectionId,
- RmrkNftId, RmrkAccountIdOrCollectionNftTuple, RmrkNftChild, RmrkPropertyKey, RmrkResourceId,
- RmrkBaseId, RmrkFixedPart, RmrkSlotPart, RmrkString,
+ RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkCollectionId, RmrkNftId,
+ RmrkNftChild, RmrkPropertyKey, RmrkResourceId, RmrkBaseId,
};
// use pallet_contracts::weights::WeightInfo;
@@ -1330,352 +1329,55 @@
RmrkTheme
> for Runtime {
fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
- Ok(RmrkCore::last_collection_idx())
+ pallet_proxy_rmrk_core::rpc::last_collection_idx::<Runtime>()
}
fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let nfts_count = collection.total_supply();
-
- Ok(Some(RmrkCollectionInfo {
- issuer: collection.owner.clone(),
- metadata: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::Metadata)?,
- max: collection.limits.token_limit,
- symbol: RmrkCore::rebind(&collection.token_prefix)?,
- nfts_count
- }))
+ pallet_proxy_rmrk_core::rpc::collection_by_id::<Runtime>(collection_id)
}
fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {
- use up_data_structs::mapping::TokenAddressMapping;
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let nft_id = TokenId(nft_by_id);
- if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }
-
- let owner = match collection.token_owner(nft_id) {
- Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {
- Some((col, tok)) => {
- let rmrk_collection = RmrkCore::rmrk_collection_id(col)?;
-
- RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)
- }
- None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())
- },
- None => return Ok(None)
- };
-
- Ok(Some(RmrkInstanceInfo {
- owner: owner,
- royalty: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::RoyaltyInfo)?,
- metadata: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Metadata)?,
- equipped: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Equipped)?,
- pending: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::PendingNftAccept)?,
- }))
+ pallet_proxy_rmrk_core::rpc::nft_by_id::<Runtime>(collection_id, nft_by_id)
}
fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let cross_account_id = CrossAccountId::from_sub(account_id);
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let tokens = collection.account_tokens(cross_account_id)
- .into_iter()
- .filter(|token| {
- let is_pending = RmrkCore::get_nft_property_decoded(
- collection_id,
- *token,
- RmrkProperty::PendingNftAccept
- ).unwrap_or(true);
-
- !is_pending
- })
- .map(|token| token.0)
- .collect();
-
- Ok(tokens)
+ pallet_proxy_rmrk_core::rpc::account_tokens::<Runtime>(account_id, collection_id)
}
fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {
- use pallet_proxy_rmrk_core::RmrkProperty;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- let nft_id = TokenId(nft_id);
- if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(Vec::new()); }
-
- Ok(
- pallet_nonfungible::TokenChildren::<Runtime>::iter_prefix((collection_id, nft_id))
- .filter_map(|((child_collection, child_token), _)| {
- let is_pending = RmrkCore::get_nft_property_decoded(
- child_collection,
- child_token,
- RmrkProperty::PendingNftAccept
- ).ok()?;
-
- if is_pending {
- return None;
- }
-
- let rmrk_child_collection = RmrkCore::rmrk_collection_id(
- child_collection
- ).ok()?;
-
- Some(RmrkNftChild {
- collection_id: rmrk_child_collection,
- nft_id: child_token.0,
- })
- }).collect()
- )
+ pallet_proxy_rmrk_core::rpc::nft_children::<Runtime>(collection_id, nft_id)
}
fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::CollectionType;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() {
- return Ok(Vec::new());
- }
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- /* token_id = */ None,
- filter_keys,
- |key, value| RmrkPropertyInfo {
- key,
- value
- }
- )?;
-
- Ok(properties)
+ pallet_proxy_rmrk_core::rpc::collection_properties::<Runtime>(collection_id, filter_keys)
}
fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::NftType;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- let token_id = TokenId(nft_id);
-
- if RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {
- return Ok(Vec::new());
- }
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- Some(token_id),
- filter_keys,
- |key, value| RmrkPropertyInfo {
- key,
- value
- }
- )?;
-
- Ok(properties)
+ pallet_proxy_rmrk_core::rpc::nft_properties::<Runtime>(collection_id, nft_id, filter_keys)
}
fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::{CollectionType, NftType};
- use up_data_structs::PropertyScope;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }
-
- let nft_id = TokenId(nft_id);
- if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }
-
- let resources = <pallet_nonfungible::Pallet<Runtime>>::iterate_token_aux_properties(
- collection_id, nft_id, PropertyScope::Rmrk
- ).filter_map(|(_, value)| {
- let resource_info: RmrkResourceInfo = RmrkCore::decode_property(&value).ok()?;
-
- Some(resource_info)
- }).collect();
-
- Ok(resources)
+ pallet_proxy_rmrk_core::rpc::nft_resources::<Runtime>(collection_id, nft_id)
}
fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(None)
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }
-
- let nft_id = TokenId(nft_id);
- if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }
-
- let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;
- Ok(
- priorities.into_iter()
- .enumerate()
- .find(|(_, id)| *id == resource_id)
- .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)
- )
+ pallet_proxy_rmrk_core::rpc::nft_resource_priority::<Runtime>(collection_id, nft_id, resource_id)
}
fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {
- use pallet_proxy_rmrk_core::{
- RmrkProperty, misc::{CollectionType},
- };
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- Ok(Some(RmrkBaseInfo {
- issuer: collection.owner.clone(),
- base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,
- symbol: RmrkCore::rebind(&collection.token_prefix)?,
- }))
+ pallet_proxy_rmrk_equip::rpc::base::<Runtime>(base_id)
}
fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let parts = collection.collection_tokens()
- .into_iter()
- .filter_map(|token_id| {
- let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;
-
- match nft_type {
- NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {
- id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
- src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
- z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
- })),
- NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {
- id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
- src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
- z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
- equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,
- })),
- _ => None
- }
- })
- .collect();
-
- Ok(parts)
+ pallet_proxy_rmrk_equip::rpc::base_parts::<Runtime>(base_id)
}
fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{NftType, CollectionType}};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let theme_names = collection.collection_tokens()
- .iter()
- .filter_map(|token_id| {
- let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).ok()?;
-
- match nft_type {
- NftType::Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),
- _ => None
- }
- })
- .collect();
-
- Ok(theme_names)
+ pallet_proxy_rmrk_equip::rpc::theme_names::<Runtime>(base_id)
}
fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {
- use pallet_proxy_rmrk_core::{
- RmrkProperty,
- misc::{CollectionType, NftType}
- };
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let theme_info = collection.collection_tokens()
- .into_iter()
- .find_map(|token_id| {
- RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;
-
- let name: RmrkString = RmrkCore::get_nft_property_decoded(
- collection_id, token_id, RmrkProperty::ThemeName
- ).ok()?;
-
- if name == theme_name {
- Some((name, token_id))
- } else {
- None
- }
- });
-
- let (name, theme_id) = match theme_info {
- Some((name, theme_id)) => (name, theme_id),
- None => return Ok(None)
- };
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- Some(theme_id),
- filter_keys,
- |key, value| RmrkThemeProperty {
- key,
- value
- }
- )?;
-
- let inherit = RmrkCore::get_nft_property_decoded(
- collection_id,
- theme_id,
- RmrkProperty::ThemeInherit
- )?;
-
- let theme = RmrkTheme {
- name,
- properties,
- inherit,
- };
-
- Ok(Some(theme))
+ pallet_proxy_rmrk_equip::rpc::theme::<Runtime>(base_id, theme_name, filter_keys)
}
}
}