From 960c1089697d2401949db63a99186e47d488f23b Mon Sep 17 00:00:00 2001
From: Daniel Shiposha <dshiposha@usetech.com>
Date: Fri, 17 Jun 2022 14:35:21 +0000
Subject: [PATCH] refactor: move RMRK rpc impl to proxy pallets


---
--- 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;
--- /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))
+}
--- 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;
--- /dev/null
+++ b/pallets/proxy-rmrk-equip/src/rpc.rs
@@ -0,0 +1,186 @@
+use super::*;
+use pallet_rmrk_core::{misc, property::*};
+use sp_std::vec::Vec;
+
+pub fn base<T: Config>(
+	base_id: RmrkBaseId,
+) -> Result<Option<RmrkBaseInfo<T::AccountId>>, DispatchError> {
+	let (collection, collection_id) =
+		match <PalletCore<T>>::get_typed_nft_collection_mapped(base_id, misc::CollectionType::Base)
+		{
+			Ok(c) => c,
+			Err(_) => return Ok(None),
+		};
+
+	Ok(Some(RmrkBaseInfo {
+		issuer: collection.owner.clone(),
+		base_type: <PalletCore<T>>::get_collection_property_decoded(
+			collection_id,
+			RmrkProperty::BaseType,
+		)?,
+		symbol: <PalletCore<T>>::rebind(&collection.token_prefix)?,
+	}))
+}
+
+pub fn base_parts<T: Config>(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
+	use pallet_common::CommonCollectionOperations;
+
+	let (collection, collection_id) =
+		match <PalletCore<T>>::get_typed_nft_collection_mapped(base_id, misc::CollectionType::Base)
+		{
+			Ok(c) => c,
+			Err(_) => return Ok(Vec::new()),
+		};
+
+	let parts = collection
+		.collection_tokens()
+		.into_iter()
+		.filter_map(|token_id| {
+			let nft_type = <PalletCore<T>>::get_nft_type(collection_id, token_id).ok()?;
+
+			match nft_type {
+				NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {
+					id: <PalletCore<T>>::get_nft_property_decoded(
+						collection_id,
+						token_id,
+						RmrkProperty::ExternalPartId,
+					)
+					.ok()?,
+					src: <PalletCore<T>>::get_nft_property_decoded(
+						collection_id,
+						token_id,
+						RmrkProperty::Src,
+					)
+					.ok()?,
+					z: <PalletCore<T>>::get_nft_property_decoded(
+						collection_id,
+						token_id,
+						RmrkProperty::ZIndex,
+					)
+					.ok()?,
+				})),
+				NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {
+					id: <PalletCore<T>>::get_nft_property_decoded(
+						collection_id,
+						token_id,
+						RmrkProperty::ExternalPartId,
+					)
+					.ok()?,
+					src: <PalletCore<T>>::get_nft_property_decoded(
+						collection_id,
+						token_id,
+						RmrkProperty::Src,
+					)
+					.ok()?,
+					z: <PalletCore<T>>::get_nft_property_decoded(
+						collection_id,
+						token_id,
+						RmrkProperty::ZIndex,
+					)
+					.ok()?,
+					equippable: <PalletCore<T>>::get_nft_property_decoded(
+						collection_id,
+						token_id,
+						RmrkProperty::EquippableList,
+					)
+					.ok()?,
+				})),
+				_ => None,
+			}
+		})
+		.collect();
+
+	Ok(parts)
+}
+
+pub fn theme_names<T: Config>(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
+	use pallet_common::CommonCollectionOperations;
+
+	let (collection, collection_id) =
+		match <PalletCore<T>>::get_typed_nft_collection_mapped(base_id, misc::CollectionType::Base)
+		{
+			Ok(c) => c,
+			Err(_) => return Ok(Vec::new()),
+		};
+
+	let theme_names = collection
+		.collection_tokens()
+		.iter()
+		.filter_map(|token_id| {
+			let nft_type = <PalletCore<T>>::get_nft_type(collection_id, *token_id).ok()?;
+
+			match nft_type {
+				NftType::Theme => <PalletCore<T>>::get_nft_property_decoded(
+					collection_id,
+					*token_id,
+					RmrkProperty::ThemeName,
+				)
+				.ok(),
+				_ => None,
+			}
+		})
+		.collect();
+
+	Ok(theme_names)
+}
+
+pub fn theme<T: Config>(
+	base_id: RmrkBaseId,
+	theme_name: RmrkThemeName,
+	filter_keys: Option<Vec<RmrkPropertyKey>>,
+) -> Result<Option<RmrkTheme>, DispatchError> {
+	use pallet_common::CommonCollectionOperations;
+
+	let (collection, collection_id) =
+		match <PalletCore<T>>::get_typed_nft_collection_mapped(base_id, misc::CollectionType::Base)
+		{
+			Ok(c) => c,
+			Err(_) => return Ok(None),
+		};
+
+	let theme_info = collection
+		.collection_tokens()
+		.into_iter()
+		.find_map(|token_id| {
+			<PalletCore<T>>::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;
+
+			let name: RmrkString = <PalletCore<T>>::get_nft_property_decoded(
+				collection_id,
+				token_id,
+				RmrkProperty::ThemeName,
+			)
+			.ok()?;
+
+			if name == theme_name {
+				Some((name, token_id))
+			} else {
+				None
+			}
+		});
+
+	let (name, theme_id) = match theme_info {
+		Some((name, theme_id)) => (name, theme_id),
+		None => return Ok(None),
+	};
+
+	let properties = <PalletCore<T>>::filter_user_properties(
+		collection_id,
+		Some(theme_id),
+		filter_keys,
+		|key, value| RmrkThemeProperty { key, value },
+	)?;
+
+	let inherit = <PalletCore<T>>::get_nft_property_decoded(
+		collection_id,
+		theme_id,
+		RmrkProperty::ThemeInherit,
+	)?;
+
+	let theme = RmrkTheme {
+		name,
+		properties,
+		inherit,
+	};
+
+	Ok(Some(theme))
+}
--- 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)
 		}
 	}
 }
--- 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)
 		}
 	}
 }

-- 
gitstuff