git.delta.rocks / unique-network / refs/commits / 04f74d7ff1f6

difftreelog

feat(rmrk) remove RMRK proxy from unique runtime

Daniel Shiposha2022-06-14parent: #681a5b7.patch.diff
in: master

7 files changed

modifiedCargo.lockdiffbeforeafterboth
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8998,6 +8998,15 @@
 ]
 
 [[package]]
+name = "rmrk-api-opt"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "rmrk-rpc"
 version = "0.0.1"
 dependencies = [
modifiednode/rpc/Cargo.tomldiffbeforeafterboth
--- a/node/rpc/Cargo.toml
+++ b/node/rpc/Cargo.toml
@@ -63,3 +63,4 @@
 [features]
 default = []
 std = []
+unique-runtime = []
modifiednode/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 {
modifiedruntime/common/src/runtime_apis.rsdiffbeforeafterboth
144                }144                }
145            }145            }
146
147            impl rmrk_rpc::RmrkApi<
148                Block,
149                AccountId,
150                RmrkCollectionInfo<AccountId>,
151                RmrkInstanceInfo<AccountId>,
152                RmrkResourceInfo,
153                RmrkPropertyInfo,
154                RmrkBaseInfo<AccountId>,
155                RmrkPartType,
156                RmrkTheme
157            > for Runtime {
158                fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
159                    Ok(RmrkCore::last_collection_idx())
160                }
161
162                fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {
163                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
164                    use pallet_common::CommonCollectionOperations;
165
166                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
167                        Ok(c) => c,
168                        Err(_) => return Ok(None),
169                    };
170
171                    let nfts_count = collection.total_supply();
172
173                    Ok(Some(RmrkCollectionInfo {
174                        issuer: collection.owner.clone(),
175                        metadata: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::Metadata)?,
176                        max: collection.limits.token_limit,
177                        symbol: RmrkCore::rebind(&collection.token_prefix)?,
178                        nfts_count
179                    }))
180                }
181
182                fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {
183                    use up_data_structs::mapping::TokenAddressMapping;
184                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
185                    use pallet_common::CommonCollectionOperations;
186
187                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
188                        Ok(c) => c,
189                        Err(_) => return Ok(None),
190                    };
191
192                    let nft_id = TokenId(nft_by_id);
193                    if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }
194
195                    let owner = match collection.token_owner(nft_id) {
196                        Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {
197                            Some((col, tok)) => {
198                                let rmrk_collection = RmrkCore::rmrk_collection_id(col)?;
199
200                                RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)
201                            }
202                            None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())
203                        },
204                        None => return Ok(None)
205                    };
206
207                    Ok(Some(RmrkInstanceInfo {
208                        owner: owner,
209                        royalty: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::RoyaltyInfo)?,
210                        metadata: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Metadata)?,
211                        equipped: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Equipped)?,
212                        pending: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::PendingNftAccept)?,
213                    }))
214                }
215
216                fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {
217                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
218                    use pallet_common::CommonCollectionOperations;
219
220                    let cross_account_id = CrossAccountId::from_sub(account_id);
221
222                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
223                        Ok(c) => c,
224                        Err(_) => return Ok(Vec::new()),
225                    };
226
227                    let tokens = collection.account_tokens(cross_account_id)
228                        .into_iter()
229                        .filter(|token| {
230                            let is_pending = RmrkCore::get_nft_property_decoded(
231                                collection_id,
232                                *token,
233                                RmrkProperty::PendingNftAccept
234                            ).unwrap_or(true);
235
236                            !is_pending
237                        })
238                        .map(|token| token.0)
239                        .collect();
240
241                    Ok(tokens)
242                }
243
244                fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {
245                    use pallet_proxy_rmrk_core::RmrkProperty;
246
247                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {
248                        Ok(id) => id,
249                        Err(_) => return Ok(Vec::new())
250                    };
251                    let nft_id = TokenId(nft_id);
252                    if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(Vec::new()); }
253
254                    Ok(
255                        pallet_nonfungible::TokenChildren::<Runtime>::iter_prefix((collection_id, nft_id))
256                            .filter_map(|((child_collection, child_token), _)| {
257                                let is_pending = RmrkCore::get_nft_property_decoded(
258                                    child_collection,
259                                    child_token,
260                                    RmrkProperty::PendingNftAccept
261                                ).ok()?;
262
263                                if is_pending {
264                                    return None;
265                                }
266
267                                let rmrk_child_collection = RmrkCore::rmrk_collection_id(
268                                    child_collection
269                                ).ok()?;
270
271                                Some(RmrkNftChild {
272                                    collection_id: rmrk_child_collection,
273                                    nft_id: child_token.0,
274                                })
275                            }).collect()
276                    )
277                }
278
279                fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
280                    use pallet_proxy_rmrk_core::misc::CollectionType;
281
282                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {
283                        Ok(id) => id,
284                        Err(_) => return Ok(Vec::new())
285                    };
286                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() {
287                        return Ok(Vec::new());
288                    }
289
290                    let properties = RmrkCore::filter_user_properties(
291                        collection_id,
292                        /* token_id = */ None,
293                        filter_keys,
294                        |key, value| RmrkPropertyInfo {
295                            key,
296                            value
297                        }
298                    )?;
299
300                    Ok(properties)
301                }
302
303                fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
304                    use pallet_proxy_rmrk_core::misc::NftType;
305
306                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {
307                        Ok(id) => id,
308                        Err(_) => return Ok(Vec::new())
309                    };
310                    let token_id = TokenId(nft_id);
311
312                    if RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {
313                        return Ok(Vec::new());
314                    }
315
316		            let properties = RmrkCore::filter_user_properties(
317                        collection_id,
318                        Some(token_id),
319                        filter_keys,
320                        |key, value| RmrkPropertyInfo {
321                            key,
322                            value
323                        }
324                    )?;
325
326                    Ok(properties)
327                }
328
329                fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
330                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType}};
331                    use pallet_common::CommonCollectionOperations;
332
333                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {
334                        Ok(id) => id,
335                        Err(_) => return Ok(Vec::new())
336                    };
337                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }
338
339                    let nft_id = TokenId(nft_id);
340                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }
341
342                    let res_collection_id: Option<CollectionId> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)?;
343
344                    let res_collection_id = match res_collection_id {
345                        Some(id) => id,
346                        None => return Ok(Vec::new())
347                    };
348
349                    let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;
350
351                    let resources = resource_collection
352                        .collection_tokens()
353                        .iter()
354                        .filter_map(|(res_id)| Some(RmrkResourceInfo {
355                            id: res_id.0,
356                            pending: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).ok()?,
357                            pending_removal: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).ok()?,
358                            resource: match RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::ResourceType).ok()? {
359                                ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {
360                                    src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
361                                    metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
362                                    license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
363                                    thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
364                                }),
365                                ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {
366                                    parts: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Parts).ok()?,
367                                    base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
368                                    src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
369                                    metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
370                                    license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
371                                    thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
372                                }),
373                                ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {
374                                    base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
375                                    src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
376                                    metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
377                                    slot: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Slot).ok()?,
378                                    license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
379                                    thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
380                                }),
381                            },
382                        }))
383                        .collect();
384
385                    Ok(resources)
386                }
387
388                fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {
389                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
390
391                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {
392                        Ok(id) => id,
393                        Err(_) => return Ok(None)
394                    };
395                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }
396
397                    let nft_id = TokenId(nft_id);
398                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }
399
400                    let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;
401                    Ok(
402                        priorities.into_iter()
403                            .enumerate()
404                            .find(|(_, id)| *id == resource_id)
405                            .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)
406                    )
407                }
408
409                fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {
410                    use pallet_proxy_rmrk_core::{
411                        RmrkProperty, misc::{CollectionType},
412                    };
413
414                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
415                        Ok(c) => c,
416                        Err(_) => return Ok(None),
417                    };
418
419                    Ok(Some(RmrkBaseInfo {
420                        issuer: collection.owner.clone(),
421                        base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,
422                        symbol: RmrkCore::rebind(&collection.token_prefix)?,
423                    }))
424                }
425
426                fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
427                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
428                    use pallet_common::CommonCollectionOperations;
429
430                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
431                        Ok(c) => c,
432                        Err(_) => return Ok(Vec::new()),
433                    };
434
435                    let parts = collection.collection_tokens()
436                        .into_iter()
437                        .filter_map(|token_id| {
438                            let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;
439
440                            match nft_type {
441                                NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {
442                                    id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
443                                    src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
444                                    z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
445                                })),
446                                NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {
447                                    id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
448                                    src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
449                                    z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
450                                    equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,
451                                })),
452                                _ => None
453                            }
454                        })
455                        .collect();
456
457                    Ok(parts)
458                }
459
460                fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
461                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
462                    use pallet_common::CommonCollectionOperations;
463
464                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
465                        Ok(c) => c,
466                        Err(_) => return Ok(Vec::new()),
467                    };
468
469                    let theme_names = collection.collection_tokens()
470                        .iter()
471                        .filter_map(|token_id| {
472                            let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).ok()?;
473
474                            match nft_type {
475                                Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),
476                                _ => None
477                            }
478                        })
479                        .collect();
480
481                    Ok(theme_names)
482                }
483
484                fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {
485                    use pallet_proxy_rmrk_core::{
486                        RmrkProperty,
487                        misc::{CollectionType, NftType}
488                    };
489                    use pallet_common::CommonCollectionOperations;
490
491                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
492                        Ok(c) => c,
493                        Err(_) => return Ok(None),
494                    };
495
496                    let theme_info = collection.collection_tokens()
497                        .into_iter()
498                        .find_map(|token_id| {
499                            RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;
500
501                            let name: RmrkString = RmrkCore::get_nft_property_decoded(
502                                collection_id, token_id, RmrkProperty::ThemeName
503                            ).ok()?;
504
505                            if name == theme_name {
506                                Some((name, token_id))
507                            } else {
508                                None
509                            }
510                        });
511
512                    let (name, theme_id) = match theme_info {
513                        Some((name, theme_id)) => (name, theme_id),
514                        None => return Ok(None)
515                    };
516
517                    let properties = RmrkCore::filter_user_properties(
518                        collection_id,
519                        Some(theme_id),
520                        filter_keys,
521                        |key, value| RmrkThemeProperty {
522                            key,
523                            value
524                        }
525                    )?;
526
527                    let inherit = RmrkCore::get_nft_property_decoded(
528                        collection_id,
529                        theme_id,
530                        RmrkProperty::ThemeInherit
531                    )?;
532
533                    let theme = RmrkTheme {
534                        name,
535                        properties,
536                        inherit,
537                    };
538
539                    Ok(Some(theme))
540                }
541            }
542146
543            impl sp_api::Core<Block> for Runtime {147            impl sp_api::Core<Block> for Runtime {
544                fn version() -> RuntimeVersion {148                fn version() -> RuntimeVersion {
modifiedruntime/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;
modifiedruntime/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;
modifiedruntime/unique/src/lib.rsdiffbeforeafterboth
--- a/runtime/unique/src/lib.rs
+++ b/runtime/unique/src/lib.rs
@@ -916,15 +916,6 @@
 	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;
 }
 
-impl pallet_proxy_rmrk_core::Config for Runtime {
-	type WeightInfo = pallet_proxy_rmrk_core::weights::SubstrateWeight<Self>;
-	type Event = Event;
-}
-
-impl pallet_proxy_rmrk_equip::Config for Runtime {
-	type Event = Event;
-}
-
 impl pallet_unique::Config for Runtime {
 	type Event = Event;
 	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;
@@ -1164,8 +1155,6 @@
 		Refungible: pallet_refungible::{Pallet, Storage} = 68,
 		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,
 		Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,
-		RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,
-		RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,
 
 		// Frontier
 		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,
@@ -1313,7 +1302,73 @@
 	}};
 }
 
-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(Default::default())
+		}
+
+		fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
+			Ok(Default::default())
+		}
+
+		fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {
+			Ok(Default::default())
+		}
+	}
+}
 
 struct CheckInherents;