git.delta.rocks / unique-network / refs/commits / e90158d94962

--- a/pallets/proxy-rmrk-core/CHANGELOG.md
+++ /dev/null
@@ -1,17 +0,0 @@
-<!-- bureaucrate goes here -->
-## [v0.1.2] 2022-08-16
-
-### Other changes
-
-- build: Upgrade polkadot to v0.9.27 2c498572636f2b34d53b1c51b7283a761a7dc90a
-
-- build: Upgrade polkadot to v0.9.26 85515e54c4ca1b82a2630034e55dcc804c643bf8
-
-- refactor: Remove `#[transactional]` from extrinsics 7fd36cea2f6e00c02c67ccc1de9649ae404efd31
-
-Every extrinsic now runs in transaction implicitly, and
-`#[transactional]` on pallet dispatchable is now meaningless
-
-Upstream-Change: https://github.com/paritytech/substrate/issues/10806
-
-- build: Upgrade polkadot to v0.9.25 cdfb9bdc7b205ff1b5134f034ef9973d769e5e6b
\ No newline at end of file

--- a/pallets/proxy-rmrk-core/Cargo.toml
+++ /dev/null
@@ -1,41 +0,0 @@
-[package]
-edition = "2021"
-license = "GPLv3"
-name = "pallet-rmrk-core"
-version = "0.1.2"
-
-[dependencies]
-# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.
-codec = { workspace = true, package = "parity-scale-codec" }
-
-scale-info = { workspace = true }
-
-frame-benchmarking = { workspace = true, optional = true }
-frame-support = { workspace = true }
-frame-system = { workspace = true }
-pallet-common = { workspace = true }
-pallet-evm = { workspace = true }
-pallet-nonfungible = { workspace = true }
-pallet-structure = { workspace = true }
-rmrk-traits = { workspace = true }
-sp-runtime = { workspace = true }
-sp-std = { workspace = true }
-up-data-structs = { workspace = true }
-
-[features]
-default = ["std"]
-runtime-benchmarks = ['frame-benchmarking', 'frame-support/runtime-benchmarks', 'frame-system/runtime-benchmarks']
-std = [
-	"frame-support/std",
-	"frame-system/std",
-	"pallet-common/std",
-	"pallet-evm/std",
-	"pallet-nonfungible/std",
-	"pallet-structure/std",
-	"rmrk-traits/std",
-	"sp-runtime/std",
-	"sp-std/std",
-	"up-data-structs/std",
-	'frame-benchmarking/std',
-]
-try-runtime = ["frame-support/try-runtime"]

--- a/pallets/proxy-rmrk-core/src/benchmarking.rs
+++ /dev/null
@@ -1,544 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-use sp_std::vec;
-
-use frame_benchmarking::{benchmarks, account};
-use frame_system::RawOrigin;
-use frame_support::{
-	traits::{Currency, Get},
-	BoundedVec,
-};
-use sp_runtime::Permill;
-
-use up_data_structs::*;
-
-use super::*;
-
-const SEED: u32 = 1;
-
-fn create_data<S: Get<u32>>() -> BoundedVec<u8, S> {
-	vec![b'A'; S::get() as usize].try_into().expect("size == S")
-}
-
-fn create_u32_array<S: Get<u32>>() -> BoundedVec<u32, S> {
-	vec![0; S::get() as usize].try_into().expect("size == S")
-}
-
-fn create_basic_resource() -> RmrkBasicResource {
-	RmrkBasicResource {
-		src: Some(create_data()),
-		metadata: Some(create_data()),
-		license: Some(create_data()),
-		thumb: Some(create_data()),
-	}
-}
-
-fn create_composable_resource() -> RmrkComposableResource {
-	RmrkComposableResource {
-		parts: create_u32_array(),
-		base: 100,
-		src: Some(create_data()),
-		metadata: Some(create_data()),
-		license: Some(create_data()),
-		thumb: Some(create_data()),
-	}
-}
-
-fn create_slot_resource() -> RmrkSlotResource {
-	RmrkSlotResource {
-		base: 100,
-		slot: 200,
-		src: Some(create_data()),
-		metadata: Some(create_data()),
-		license: Some(create_data()),
-		thumb: Some(create_data()),
-	}
-}
-
-fn create_max_resource_types_array<S: Get<u32>>(num: usize) -> BoundedVec<RmrkResourceTypes, S> {
-	vec![RmrkResourceTypes::Composable(create_composable_resource()); num]
-		.try_into()
-		.expect("num <= S")
-}
-
-fn create_max_collection<T: Config>(owner: &T::AccountId) -> DispatchResult {
-	<T as pallet_common::Config>::Currency::deposit_creating(
-		owner,
-		T::CollectionCreationPrice::get(),
-	);
-
-	let metadata = create_data();
-	let max = None;
-	let symbol = create_data();
-
-	<Pallet<T>>::create_collection(
-		RawOrigin::Signed(owner.clone()).into(),
-		metadata,
-		max,
-		symbol,
-	)
-}
-
-fn create_nft<T: Config>(owner: &T::AccountId, collection_id: RmrkCollectionId) -> DispatchResult {
-	let royalty_recipient = Some(owner.clone());
-	let royalty_amount = Some(Permill::from_percent(25));
-	let metadata = create_data();
-	let transferable = true;
-
-	<Pallet<T>>::mint_nft(
-		RawOrigin::Signed(owner.clone()).into(),
-		None,
-		collection_id,
-		royalty_recipient,
-		royalty_amount,
-		metadata,
-		transferable,
-		None,
-	)
-}
-
-struct NftBuilder {
-	collection_id: RmrkCollectionId,
-	current_nft_id: RmrkNftId,
-}
-
-impl NftBuilder {
-	fn new(collection_id: RmrkCollectionId) -> Self {
-		Self {
-			collection_id,
-			current_nft_id: 0,
-		}
-	}
-
-	fn build<T: Config>(&mut self, owner: &T::AccountId) -> Result<RmrkNftId, DispatchError> {
-		create_nft::<T>(owner, self.collection_id)?;
-		self.current_nft_id += 1;
-
-		Ok(self.current_nft_id)
-	}
-
-	fn build_tower<T: Config>(
-		&mut self,
-		owner: &T::AccountId,
-		height: u32,
-	) -> Result<(RmrkNftId, RmrkNftId), DispatchError> {
-		self.build::<T>(owner)?;
-
-		let root_nft_id = self.current_nft_id;
-		let mut prev_nft_id = root_nft_id;
-
-		for _ in 0..height {
-			self.build::<T>(owner)?;
-
-			let new_owner =
-				<RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::CollectionAndNftTuple(
-					self.collection_id,
-					prev_nft_id,
-				);
-
-			<Pallet<T>>::send(
-				RawOrigin::Signed(owner.clone()).into(),
-				self.collection_id,
-				self.current_nft_id,
-				new_owner,
-			)?;
-
-			prev_nft_id = self.current_nft_id;
-		}
-
-		let deepest_nft_id = self.current_nft_id;
-
-		Ok((root_nft_id, deepest_nft_id))
-	}
-
-	fn build_wide_tree<T: Config>(
-		&mut self,
-		owner: &T::AccountId,
-		width: u32,
-	) -> Result<RmrkNftId, DispatchError> {
-		self.build::<T>(owner)?;
-
-		let root_nft_id = self.current_nft_id;
-
-		let root_owner = <RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::CollectionAndNftTuple(
-			self.collection_id,
-			root_nft_id,
-		);
-
-		for _ in 0..width {
-			self.build::<T>(owner)?;
-
-			<Pallet<T>>::send(
-				RawOrigin::Signed(owner.clone()).into(),
-				self.collection_id,
-				self.current_nft_id,
-				root_owner.clone(),
-			)?;
-		}
-
-		Ok(root_nft_id)
-	}
-}
-
-benchmarks! {
-	create_collection {
-		let caller = account("caller", 0, SEED);
-		<T as pallet_common::Config>::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
-		let metadata = create_data();
-		let max = None;
-		let symbol = create_data();
-	}: _(RawOrigin::Signed(caller), metadata, max, symbol)
-
-	destroy_collection {
-		let caller = account("caller", 0, SEED);
-
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-	}: _(RawOrigin::Signed(caller), collection_id)
-
-	change_collection_issuer {
-		let caller: T::AccountId = account("caller", 0, SEED);
-
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-
-		let new_owner: T::AccountId = account("new_owner", 0, SEED);
-
-		let new_owner_source = T::Lookup::unlookup(new_owner);
-	}: _(RawOrigin::Signed(caller), collection_id, new_owner_source)
-
-	lock_collection {
-		let caller: T::AccountId = account("caller", 0, SEED);
-
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-	}: _(RawOrigin::Signed(caller), collection_id)
-
-	mint_nft {
-		let b in 0..100;
-
-		let caller: T::AccountId = account("caller", 0, SEED);
-
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-		let owner = caller.clone();
-
-		let royalty_recipient = Some(caller.clone());
-		let royalty_amount = Some(Permill::from_percent(25));
-		let metadata = create_data();
-		let transferable = true;
-	}:  _(
-		RawOrigin::Signed(caller),
-		None,
-		collection_id,
-		royalty_recipient,
-		royalty_amount,
-		metadata,
-		transferable,
-		Some(create_max_resource_types_array(b as usize))
-	)
-
-	burn_nft {
-		let b in 0..200;
-
-		let caller: T::AccountId = account("caller", 0, SEED);
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let root_nft_id  = nft_builder.build_wide_tree::<T>(&caller, b)?;
-		let max_burns = b + 1;
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		root_nft_id,
-		max_burns
-	)
-
-	send {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let src_nft_id = nft_builder.build::<T>(&caller)?;
-		let (_, target_nft_id) = nft_builder.build_tower::<T>(&caller, NESTING_BUDGET - 2)?;
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		src_nft_id,
-		<RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::CollectionAndNftTuple(collection_id, target_nft_id)
-	)
-
-	accept_nft {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let sender: T::AccountId = account("sender", 0, SEED);
-
-		create_max_collection::<T>(&sender)?;
-		let src_collection_id = 0;
-
-		create_max_collection::<T>(&caller)?;
-		let target_collection_id = 1;
-
-		let mut src_nft_builder = NftBuilder::new(src_collection_id);
-		let src_nft_id = src_nft_builder.build::<T>(&sender)?;
-
-		let mut target_nft_builder = NftBuilder::new(target_collection_id);
-		let fake_target_nft_id = target_nft_builder.build::<T>(&caller)?;
-		let (_, target_nft_id) = target_nft_builder.build_tower::<T>(&caller, NESTING_BUDGET - 1)?;
-
-		let new_owner = <RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::CollectionAndNftTuple(
-			target_collection_id,
-			fake_target_nft_id
-		);
-
-		let actual_new_owner = <RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::CollectionAndNftTuple(
-			target_collection_id,
-			target_nft_id
-		);
-
-		<Pallet<T>>::send(
-			RawOrigin::Signed(sender.clone()).into(),
-			src_collection_id,
-			src_nft_id,
-			new_owner,
-		)?;
-	}: _(
-		RawOrigin::Signed(caller),
-		src_collection_id,
-		src_nft_id,
-		actual_new_owner
-	)
-
-	reject_nft {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let sender: T::AccountId = account("sender", 0, SEED);
-
-		create_max_collection::<T>(&sender)?;
-		let src_collection_id = 0;
-
-		create_max_collection::<T>(&caller)?;
-		let target_collection_id = 1;
-
-		let mut src_nft_builder = NftBuilder::new(src_collection_id);
-		let (src_root_nft_id, _) = src_nft_builder.build_tower::<T>(&sender, NESTING_BUDGET - 1)?;
-
-		let mut target_nft_builder = NftBuilder::new(target_collection_id);
-		let target_nft_id = target_nft_builder.build::<T>(&caller)?;
-
-		let new_owner = <RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::CollectionAndNftTuple(
-			target_collection_id,
-			target_nft_id
-		);
-
-		<Pallet<T>>::send(
-			RawOrigin::Signed(sender.clone()).into(),
-			src_collection_id,
-			src_root_nft_id,
-			new_owner,
-		)?;
-	}: _(
-		RawOrigin::Signed(caller),
-		src_collection_id,
-		src_root_nft_id
-	)
-
-	set_property {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let (_, nft_id) = nft_builder.build_tower::<T>(&caller, NESTING_BUDGET - 1)?;
-
-		let key = create_data();
-		let value = create_data();
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		Some(nft_id),
-		key,
-		value
-	)
-
-	set_priority {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let (_, nft_id) = nft_builder.build_tower::<T>(&caller, NESTING_BUDGET - 1)?;
-		let priorities = create_u32_array();
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		nft_id,
-		priorities
-	)
-
-	add_basic_resource {
-		let caller: T::AccountId = account("caller", 0, SEED);
-
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let (_, nft_id) = nft_builder.build_tower::<T>(&caller, NESTING_BUDGET - 1)?;
-		let resource = create_basic_resource();
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		nft_id,
-		resource
-	)
-
-	add_composable_resource {
-		let caller: T::AccountId = account("caller", 0, SEED);
-
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let (_, nft_id) = nft_builder.build_tower::<T>(&caller, NESTING_BUDGET - 1)?;
-		let resource = create_composable_resource();
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		nft_id,
-		resource
-	)
-
-	add_slot_resource {
-		let caller: T::AccountId = account("caller", 0, SEED);
-
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let (_, nft_id) = nft_builder.build_tower::<T>(&caller, NESTING_BUDGET - 1)?;
-		let resource = create_slot_resource();
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		nft_id,
-		resource
-	)
-
-	remove_resource {
-		let caller: T::AccountId = account("caller", 0, SEED);
-
-		create_max_collection::<T>(&caller)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let (_, nft_id) = nft_builder.build_tower::<T>(&caller, NESTING_BUDGET - 1)?;
-		let resource = create_basic_resource();
-
-		<Pallet<T>>::add_basic_resource(
-			RawOrigin::Signed(caller.clone()).into(),
-			collection_id,
-			nft_id,
-			resource
-		)?;
-
-		let resource_id = 0;
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		nft_id,
-		resource_id
-	)
-
-	accept_resource {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let admin: T::AccountId = account("admin", 0, SEED);
-
-		create_max_collection::<T>(&admin)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let root_nft_id = 1;
-		let (_, nested_nft_id) = nft_builder.build_tower::<T>(&admin, NESTING_BUDGET - 1)?;
-		let resource = create_basic_resource();
-
-		let new_owner = <RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::AccountId(caller.clone());
-
-		<Pallet<T>>::send(
-			RawOrigin::Signed(admin.clone()).into(),
-			collection_id,
-			root_nft_id,
-			new_owner,
-		)?;
-
-		<Pallet<T>>::add_basic_resource(
-			RawOrigin::Signed(admin.clone()).into(),
-			collection_id,
-			nested_nft_id,
-			resource
-		)?;
-
-		let resource_id = 0;
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		nested_nft_id,
-		resource_id
-	)
-
-	accept_resource_removal {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let admin: T::AccountId = account("admin", 0, SEED);
-
-		create_max_collection::<T>(&admin)?;
-		let collection_id = 0;
-
-		let mut nft_builder = NftBuilder::new(collection_id);
-		let root_nft_id = 1;
-		let (_, nested_nft_id) = nft_builder.build_tower::<T>(&admin, NESTING_BUDGET - 1)?;
-		let resource = create_basic_resource();
-
-		<Pallet<T>>::add_basic_resource(
-			RawOrigin::Signed(admin.clone()).into(),
-			collection_id,
-			nested_nft_id,
-			resource
-		)?;
-
-		let resource_id = 0;
-
-		let new_owner = <RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::AccountId(caller.clone());
-
-		<Pallet<T>>::send(
-			RawOrigin::Signed(admin.clone()).into(),
-			collection_id,
-			root_nft_id,
-			new_owner,
-		)?;
-
-		<Pallet<T>>::remove_resource(
-			RawOrigin::Signed(admin).into(),
-			collection_id,
-			nested_nft_id,
-			resource_id
-		)?;
-	}: _(
-		RawOrigin::Signed(caller),
-		collection_id,
-		nested_nft_id,
-		resource_id
-	)
-}

--- a/pallets/proxy-rmrk-core/src/lib.rs
+++ /dev/null
@@ -1,2119 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-//! # RMRK Core Proxy Pallet
-//!
-//! A pallet used as proxy for RMRK Core (<https://rmrk-team.github.io/rmrk-substrate/#/pallets/rmrk-core>).
-//!
-//! - [`Config`]
-//! - [`Call`]
-//! - [`Pallet`]
-//!
-//! ## Overview
-//!
-//! The RMRK Core Proxy pallet mirrors the functionality of RMRK Core,
-//! binding its externalities to Unique's own underlying structure.
-//! It is purposed to mimic RMRK Core exactly, allowing seamless integrations
-//! of solutions based on RMRK.
-//!
-//! RMRK Core itself contains essential functionality for RMRK's nested and
-//! multi-resourced NFTs.
-//!
-//! *Note*, that while RMRK itself is subject to active development and restructuring,
-//! the proxy may be caught temporarily out of date.
-//!
-//! ### What is RMRK?
-//!
-//! RMRK is a set of NFT standards which compose several "NFT 2.0 lego" primitives.
-//! Putting these legos together allows a user to create NFT systems of arbitrary complexity.
-//!
-//! Meaning, RMRK NFTs are dynamic, able to nest into each other and form a hierarchy,
-//! make use of specific changeable and partially shared metadata in the form of resources,
-//! and more.
-//!
-//! Visit RMRK documentation and repositories to learn more:
-//! - Docs: <https://docs.rmrk.app/getting-started/>
-//! - FAQ: <https://coda.io/@rmrk/faq>
-//! - Substrate code repository: <https://github.com/rmrk-team/rmrk-substrate>
-//! - RMRK specification repository: <https://github.com/rmrk-team/rmrk-spec>
-//!
-//! ## Terminology
-//!
-//! For more information on RMRK, see RMRK's own documentation.
-//!
-//! ### Intro to RMRK
-//!
-//! - **Resource:** Additional piece of metadata of an NFT usually serving to add
-//! a piece of media on top of the root metadata (NFT's own), be it a different wing
-//! on the root template bird or something entirely unrelated.
-//!
-//! - **Base:** A list of possible "components" - Parts, a combination of which can
-//! be appended/equipped to/on an NFT.
-//!
-//! - **Part:** Something that, together with other Parts, can constitute an NFT.
-//! Parts are defined in the Base to which they belong. Parts can be either
-//! of the `slot` type or `fixed` type. Slots are intended for equippables.
-//! Note that "part of something" and "Part of a Base" can be easily confused,
-//! and so in this documentation these words are distinguished by the capital letter.
-//!
-//! - **Theme:** Named objects of variable => value pairs which get interpolated into
-//! the Base's `themable` Parts. Themes can hold any value, but are often represented
-//! in RMRK's examples as colors applied to visible Parts.
-//!
-//! ### Peculiarities in Unique
-//!
-//! - **Scoped properties:** Properties that are normally obscured from users.
-//! Their purpose is to contain structured metadata that was not included in the Unique standard
-//! for collections and tokens, meant to be operated on by proxies and other outliers.
-//! Scoped property keys are prefixed with `some-scope:`, where `some-scope` is
-//! an arbitrary keyword, like "rmrk". `:` is considered an unacceptable symbol in user-defined
-//! properties, which, along with other safeguards, makes scoped ones impossible to tamper with.
-//!
-//! - **Auxiliary properties:** A slightly different structure of properties,
-//! trading universality of use for more convenient storage, writes and access.
-//! Meant to be inaccessible to end users.
-//!
-//! ## Proxy Implementation
-//!
-//! An external user is supposed to be able to utilize this proxy as they would
-//! utilize RMRK, and get exactly the same results. Normally, Unique transactions
-//! are off-limits to RMRK collections and tokens, and vice versa. However,
-//! the information stored on chain can be freely interpreted by storage reads and Unique RPCs.
-//!
-//! ### ID Mapping
-//!
-//! RMRK's collections' IDs are counted independently of Unique's and start at 0.
-//! Note that tokens' IDs still start at 1.
-//! The collections themselves, as well as tokens, are stored as Unique collections,
-//! and thus RMRK IDs are mapped to Unique IDs (but not vice versa).
-//!
-//! ### External/Internal Collection Insulation
-//!
-//! A Unique transaction cannot target collections purposed for RMRK,
-//! and they are flagged as `external` to specify that. On the other hand,
-//! due to the mapping, RMRK transactions and RPCs simply cannot reach Unique collections.
-//!
-//! ### Native Properties
-//!
-//! Many of RMRK's native parameters are stored as scoped properties of a collection
-//! or an NFT on the chain. Scoped properties are prefixed with `rmrk:`, where `:`
-//! is an unacceptable symbol in user-defined properties, which, along with other safeguards,
-//! makes them impossible to tamper with.
-//!
-//! ### Collection and NFT Types, or Base, Parts and Themes Handling
-//!
-//! RMRK introduces the concept of a Base, which is a catalogue of Parts,
-//! possible components of an NFT. Due to its similarity with the functionality
-//! of a token collection, a Base is stored and handled as one, and the Base's Parts and Themes
-//! are this collection's NFTs. See [`CollectionType`] and [`NftType`].
-//!
-//! ## Interface
-//!
-//! ### Dispatchables
-//!
-//! - `create_collection` - Create a new collection of NFTs.
-//! - `destroy_collection` - Destroy a collection.
-//! - `change_collection_issuer` - Change the issuer of a collection.
-//! Analogous to Unique's collection's [`owner`](up_data_structs::Collection).
-//! - `lock_collection` - "Lock" the collection and prevent new token creation. **Cannot be undone.**
-//! - `mint_nft` - Mint an NFT in a specified collection.
-//! - `burn_nft` - Burn an NFT, destroying it and its nested tokens.
-//! - `send` - Transfer an NFT from an account/NFT A to another account/NFT B.
-//! - `accept_nft` - Accept an NFT sent from another account to self or an owned NFT.
-//! - `reject_nft` - Reject an NFT sent from another account to self or owned NFT and **burn it**.
-//! - `accept_resource` - Accept the addition of a newly created pending resource to an existing NFT.
-//! - `accept_resource_removal` - Accept the removal of a removal-pending resource from an NFT.
-//! - `set_property` - Add or edit a custom user property of a token or a collection.
-//! - `set_priority` - Set a different order of resource priorities for an NFT.
-//! - `add_basic_resource` - Create and set/propose a basic resource for an NFT.
-//! - `add_composable_resource` - Create and set/propose a composable resource for an NFT.
-//! - `add_slot_resource` - Create and set/propose a slot resource for an NFT.
-//! - `remove_resource` - Remove and erase a resource from an NFT.
-
-#![cfg_attr(not(feature = "std"), no_std)]
-
-use frame_support::{pallet_prelude::*, BoundedVec, dispatch::DispatchResult};
-use frame_system::{pallet_prelude::*, ensure_signed};
-use sp_runtime::{DispatchError, Permill, traits::StaticLookup};
-use sp_std::{
-	vec::Vec,
-	collections::{btree_set::BTreeSet, btree_map::BTreeMap},
-};
-use up_data_structs::{*, mapping::TokenAddressMapping};
-use pallet_common::{
-	Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations,
-};
-use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData};
-use pallet_structure::{Pallet as PalletStructure, Error as StructureError};
-use pallet_evm::account::CrossAccountId;
-use core::convert::AsRef;
-
-pub use pallet::*;
-
-#[cfg(feature = "runtime-benchmarks")]
-pub mod benchmarking;
-pub mod misc;
-pub mod property;
-pub mod rpc;
-pub mod weights;
-
-pub type SelfWeightOf<T> = <T as Config>::WeightInfo;
-
-use weights::WeightInfo;
-use misc::*;
-pub use property::*;
-
-use RmrkProperty::*;
-
-/// A maximum number of levels of depth in the token nesting tree.
-pub const NESTING_BUDGET: u32 = 5;
-
-type PendingTarget = (CollectionId, TokenId);
-type PendingChild = (RmrkCollectionId, RmrkNftId);
-type PendingChildrenSet = BTreeSet<PendingChild>;
-
-type BasesMap = BTreeMap<RmrkBaseId, u32>;
-
-#[frame_support::pallet]
-pub mod pallet {
-	use super::*;
-
-	#[pallet::config]
-	pub trait Config:
-		frame_system::Config
-		+ pallet_common::Config
-		+ pallet_nonfungible::Config
-		+ pallet_evm::Config
-	{
-		/// Overarching event type.
-		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
-
-		/// The weight information of this pallet.
-		type WeightInfo: WeightInfo;
-	}
-
-	/// Latest yet-unused collection ID.
-	#[pallet::storage]
-	#[pallet::getter(fn collection_index)]
-	pub type CollectionIndex<T: Config> = StorageValue<_, RmrkCollectionId, ValueQuery>;
-
-	/// Mapping from RMRK collection ID to Unique's.
-	#[pallet::storage]
-	pub type UniqueCollectionId<T: Config> =
-		StorageMap<_, Twox64Concat, RmrkCollectionId, CollectionId, ValueQuery>;
-
-	#[pallet::pallet]
-	#[pallet::generate_store(pub(super) trait Store)]
-	pub struct Pallet<T>(_);
-
-	#[pallet::event]
-	#[pallet::generate_deposit(pub(super) fn deposit_event)]
-	pub enum Event<T: Config> {
-		CollectionCreated {
-			issuer: T::AccountId,
-			collection_id: RmrkCollectionId,
-		},
-		CollectionDestroyed {
-			issuer: T::AccountId,
-			collection_id: RmrkCollectionId,
-		},
-		IssuerChanged {
-			old_issuer: T::AccountId,
-			new_issuer: T::AccountId,
-			collection_id: RmrkCollectionId,
-		},
-		CollectionLocked {
-			issuer: T::AccountId,
-			collection_id: RmrkCollectionId,
-		},
-		NftMinted {
-			owner: T::AccountId,
-			collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-		},
-		NFTBurned {
-			owner: T::AccountId,
-			nft_id: RmrkNftId,
-		},
-		NFTSent {
-			sender: T::AccountId,
-			recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,
-			collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-			approval_required: bool,
-		},
-		NFTAccepted {
-			sender: T::AccountId,
-			recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,
-			collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-		},
-		NFTRejected {
-			sender: T::AccountId,
-			collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-		},
-		PropertySet {
-			collection_id: RmrkCollectionId,
-			maybe_nft_id: Option<RmrkNftId>,
-			key: RmrkKeyString,
-			value: RmrkValueString,
-		},
-		ResourceAdded {
-			nft_id: RmrkNftId,
-			resource_id: RmrkResourceId,
-		},
-		ResourceRemoval {
-			nft_id: RmrkNftId,
-			resource_id: RmrkResourceId,
-		},
-		ResourceAccepted {
-			nft_id: RmrkNftId,
-			resource_id: RmrkResourceId,
-		},
-		ResourceRemovalAccepted {
-			nft_id: RmrkNftId,
-			resource_id: RmrkResourceId,
-		},
-		PrioritySet {
-			collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-		},
-	}
-
-	#[pallet::error]
-	pub enum Error<T> {
-		/* Unique proxy-specific events */
-		/// Property of the type of RMRK collection could not be read successfully.
-		CorruptedCollectionType,
-		// NftTypeEncodeError,
-		/// Too many symbols supplied as the property key. The maximum is [256](up_data_structs::MAX_PROPERTY_KEY_LENGTH).
-		RmrkPropertyKeyIsTooLong,
-		/// Too many bytes supplied as the property value. The maximum is [32768](up_data_structs::MAX_PROPERTY_VALUE_LENGTH).
-		RmrkPropertyValueIsTooLong,
-		/// Could not find a property by the supplied key.
-		RmrkPropertyIsNotFound,
-		/// Something went wrong when decoding encoded data from the storage.
-		/// Perhaps, there was a wrong key supplied for the type, or the data was improperly stored.
-		UnableToDecodeRmrkData,
-
-		/* RMRK compatible events */
-		/// Only destroying collections without tokens is allowed.
-		CollectionNotEmpty,
-		/// Could not find an ID for a collection. It is likely there were too many collections created on the chain, causing an overflow.
-		NoAvailableCollectionId,
-		/// Token does not exist, or there is no suitable ID for it, likely too many tokens were created in a collection, causing an overflow.
-		NoAvailableNftId,
-		/// Collection does not exist, has a wrong type, or does not map to a Unique ID.
-		CollectionUnknown,
-		/// No permission to perform action.
-		NoPermission,
-		/// Token is marked as non-transferable, and thus cannot be transferred.
-		NonTransferable,
-		/// Too many tokens created in the collection, no new ones are allowed.
-		CollectionFullOrLocked,
-		/// No such resource found.
-		ResourceDoesntExist,
-		/// If an NFT is sent to a descendant, that would form a nesting loop, an ouroboros.
-		/// Sending to self is redundant.
-		CannotSendToDescendentOrSelf,
-		/// Not the target owner of the sent NFT.
-		CannotAcceptNonOwnedNft,
-		/// Not the target owner of the sent NFT.
-		CannotRejectNonOwnedNft,
-		/// NFT was not sent and is not pending.
-		CannotRejectNonPendingNft,
-		/// Resource is not pending for the operation.
-		ResourceNotPending,
-		/// Could not find an ID for the resource. It is likely there were too many resources created on an NFT, causing an overflow.
-		NoAvailableResourceId,
-	}
-
-	#[pallet::call]
-	impl<T: Config> Pallet<T> {
-		// todo :refactor replace every collection_id with rmrk_collection_id (and nft_id) in arguments for uniformity?
-
-		/// Create a new collection of NFTs.
-		///
-		/// # Permissions:
-		/// * Anyone - will be assigned as the issuer of the collection.
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.
-		/// - `max`: Optional maximum number of tokens.
-		/// - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.
-		/// Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.
-		#[pallet::call_index(0)]
-		#[pallet::weight(<SelfWeightOf<T>>::create_collection())]
-		pub fn create_collection(
-			origin: OriginFor<T>,
-			metadata: RmrkString,
-			max: Option<u32>,
-			symbol: RmrkCollectionSymbol,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-
-			let limits = CollectionLimits {
-				owner_can_transfer: Some(false),
-				token_limit: max,
-				..Default::default()
-			};
-
-			let data = CreateCollectionData {
-				limits: Some(limits),
-				token_prefix: symbol
-					.into_inner()
-					.try_into()
-					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,
-				permissions: Some(CollectionPermissions {
-					nesting: Some(NestingPermissions {
-						token_owner: true,
-						collection_admin: false,
-						restricted: None,
-						#[cfg(feature = "runtime-benchmarks")]
-						permissive: false,
-					}),
-					..Default::default()
-				}),
-				..Default::default()
-			};
-
-			let unique_collection_id = Self::init_collection(
-				T::CrossAccountId::from_sub(sender.clone()),
-				data,
-				[
-					Self::encode_rmrk_property(Metadata, &metadata)?,
-					Self::encode_rmrk_property(CollectionType, &misc::CollectionType::Regular)?,
-				]
-				.into_iter(),
-			)?;
-			let rmrk_collection_id = <CollectionIndex<T>>::get();
-
-			<UniqueCollectionId<T>>::insert(rmrk_collection_id, unique_collection_id);
-
-			<PalletCommon<T>>::set_scoped_collection_property(
-				unique_collection_id,
-				RMRK_SCOPE,
-				Self::encode_rmrk_property(RmrkInternalCollectionId, &rmrk_collection_id)?,
-			)?;
-
-			<CollectionIndex<T>>::mutate(|n| *n += 1);
-
-			Self::deposit_event(Event::CollectionCreated {
-				issuer: sender,
-				collection_id: rmrk_collection_id,
-			});
-
-			Ok(())
-		}
-
-		/// Destroy a collection.
-		///
-		/// Only empty collections can be destroyed. If it has any tokens, they must be burned first.
-		///
-		/// # Permissions:
-		/// * Collection issuer
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `collection_id`: RMRK ID of the collection to destroy.
-		#[pallet::call_index(1)]
-		#[pallet::weight(<SelfWeightOf<T>>::destroy_collection())]
-		pub fn destroy_collection(
-			origin: OriginFor<T>,
-			collection_id: RmrkCollectionId,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
-
-			let collection = Self::get_typed_nft_collection(
-				Self::unique_collection_id(collection_id)?,
-				misc::CollectionType::Regular,
-			)?;
-			collection.check_is_external()?;
-
-			<PalletNft<T>>::destroy_collection(collection, &cross_sender)
-				.map_err(Self::map_unique_err_to_proxy)?;
-
-			Self::deposit_event(Event::CollectionDestroyed {
-				issuer: sender,
-				collection_id,
-			});
-
-			Ok(())
-		}
-
-		/// Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).
-		///
-		/// # Permissions:
-		/// * Collection issuer
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `collection_id`: RMRK collection ID to change the issuer of.
-		/// - `new_issuer`: Collection's new issuer.
-		#[pallet::call_index(2)]
-		#[pallet::weight(<SelfWeightOf<T>>::change_collection_issuer())]
-		pub fn change_collection_issuer(
-			origin: OriginFor<T>,
-			collection_id: RmrkCollectionId,
-			new_issuer: <T::Lookup as StaticLookup>::Source,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-
-			let collection = Self::get_nft_collection(Self::unique_collection_id(collection_id)?)?;
-			collection.check_is_external()?;
-
-			let new_issuer = T::Lookup::lookup(new_issuer)?;
-
-			Self::change_collection_owner(
-				Self::unique_collection_id(collection_id)?,
-				misc::CollectionType::Regular,
-				sender.clone(),
-				new_issuer.clone(),
-			)?;
-
-			Self::deposit_event(Event::IssuerChanged {
-				old_issuer: sender,
-				new_issuer,
-				collection_id,
-			});
-
-			Ok(())
-		}
-
-		/// "Lock" the collection and prevent new token creation. Cannot be undone.
-		///
-		/// # Permissions:
-		/// * Collection issuer
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `collection_id`: RMRK ID of the collection to lock.
-		#[pallet::call_index(3)]
-		#[pallet::weight(<SelfWeightOf<T>>::lock_collection())]
-		pub fn lock_collection(
-			origin: OriginFor<T>,
-			collection_id: RmrkCollectionId,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
-
-			let collection = Self::get_typed_nft_collection(
-				Self::unique_collection_id(collection_id)?,
-				misc::CollectionType::Regular,
-			)?;
-			collection.check_is_external()?;
-
-			Self::check_collection_owner(&collection, &cross_sender)?;
-
-			let token_count = collection.total_supply();
-
-			let mut collection = collection.into_inner();
-			collection.limits.token_limit = Some(token_count);
-			collection.save()?;
-
-			Self::deposit_event(Event::CollectionLocked {
-				issuer: sender,
-				collection_id,
-			});
-
-			Ok(())
-		}
-
-		/// Mint an NFT in a specified collection.
-		///
-		/// # Permissions:
-		/// * Collection issuer
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).
-		/// - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.
-		/// - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.
-		/// - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.
-		/// - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.
-		/// - `transferable`: Can this NFT be transferred? Cannot be changed.
-		/// - `resources`: Resource data to be added to the NFT immediately after minting.
-		#[pallet::call_index(4)]
-		#[pallet::weight(<SelfWeightOf<T>>::mint_nft(resources.as_ref().map(|r| r.len() as u32).unwrap_or(0)))]
-		pub fn mint_nft(
-			origin: OriginFor<T>,
-			owner: Option<T::AccountId>,
-			collection_id: RmrkCollectionId,
-			recipient: Option<T::AccountId>,
-			royalty_amount: Option<Permill>,
-			metadata: RmrkString,
-			transferable: bool,
-			resources: Option<BoundedVec<RmrkResourceTypes, MaxResourcesOnMint>>,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
-
-			let owner = owner.unwrap_or(sender.clone());
-			let cross_owner = T::CrossAccountId::from_sub(owner.clone());
-
-			let collection = Self::get_typed_nft_collection(
-				Self::unique_collection_id(collection_id)?,
-				misc::CollectionType::Regular,
-			)?;
-			collection.check_is_external()?;
-
-			let royalty_info = royalty_amount.map(|amount| rmrk_traits::RoyaltyInfo {
-				recipient: recipient.unwrap_or_else(|| owner.clone()),
-				amount,
-			});
-
-			let nft_id = Self::create_nft(
-				&cross_sender,
-				&cross_owner,
-				&collection,
-				[
-					Self::encode_rmrk_property(TokenType, &NftType::Regular)?,
-					Self::encode_rmrk_property(Transferable, &transferable)?,
-					Self::encode_rmrk_property(PendingNftAccept, &None::<PendingTarget>)?,
-					Self::encode_rmrk_property(RoyaltyInfo, &royalty_info)?,
-					Self::encode_rmrk_property(Metadata, &metadata)?,
-					Self::encode_rmrk_property(Equipped, &false)?,
-					Self::encode_rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,
-					Self::encode_rmrk_property(NextResourceId, &(0 as RmrkResourceId))?,
-					Self::encode_rmrk_property(PendingChildren, &PendingChildrenSet::new())?,
-					Self::encode_rmrk_property(AssociatedBases, &BasesMap::new())?,
-				]
-				.into_iter(),
-			)
-			.map_err(|err| match err {
-				DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),
-				err => Self::map_unique_err_to_proxy(err),
-			})?;
-
-			if let Some(resources) = resources {
-				for resource in resources {
-					Self::resource_add(sender.clone(), collection.id, nft_id, resource)?;
-				}
-			}
-
-			Self::deposit_event(Event::NftMinted {
-				owner,
-				collection_id,
-				nft_id: nft_id.0,
-			});
-
-			Ok(())
-		}
-
-		/// Burn an NFT, destroying it and its nested tokens up to the specified limit.
-		/// If the burning budget is exceeded, the transaction is reverted.
-		///
-		/// This is the way to burn a nested token as well.
-		///
-		/// For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).
-		///
-		/// # Permissions:
-		/// * Token owner
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.
-		/// - `nft_id`: ID of the NFT to be destroyed.
-		/// - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction
-		/// is reverted if there are more tokens to burn in the nesting tree than this number.
-		/// This is primarily a mechanism of transaction weight control.
-		#[pallet::call_index(5)]
-		#[pallet::weight(<SelfWeightOf<T>>::burn_nft(*max_burns))]
-		pub fn burn_nft(
-			origin: OriginFor<T>,
-			collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-			max_burns: u32,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
-
-			let collection = Self::get_typed_nft_collection(
-				Self::unique_collection_id(collection_id)?,
-				misc::CollectionType::Regular,
-			)?;
-			collection.check_is_external()?;
-
-			Self::destroy_nft(
-				cross_sender,
-				Self::unique_collection_id(collection_id)?,
-				nft_id.into(),
-				max_burns,
-				<Error<T>>::NoPermission,
-			)
-			.map_err(|err| Self::map_unique_err_to_proxy(err.error))?;
-
-			Self::deposit_event(Event::NFTBurned {
-				owner: sender,
-				nft_id,
-			});
-
-			Ok(())
-		}
-
-		/// Transfer an NFT from an account/NFT A to another account/NFT B.
-		/// The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].
-		///
-		/// If the target owner is an NFT owned by another account, then the NFT will enter
-		/// the pending state and will have to be accepted by the other account.
-		///
-		/// # Permissions:
-		/// - Token owner
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.
-		/// - `rmrk_nft_id`: ID of the NFT to be transferred.
-		/// - `new_owner`: New owner of the nft which can be either an account or a NFT.
-		#[pallet::call_index(6)]
-		#[pallet::weight(<SelfWeightOf<T>>::send())]
-		pub fn send(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			rmrk_nft_id: RmrkNftId,
-			new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin.clone())?;
-			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
-			let nft_id = rmrk_nft_id.into();
-
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			let token_data =
-				<TokenData<T>>::get((collection_id, nft_id)).ok_or(<Error<T>>::NoAvailableNftId)?;
-
-			let from = token_data.owner;
-
-			ensure!(
-				Self::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Transferable)?,
-				<Error<T>>::NonTransferable
-			);
-
-			ensure!(
-				Self::get_nft_property_decoded::<Option<PendingTarget>>(
-					collection_id,
-					nft_id,
-					RmrkProperty::PendingNftAccept
-				)?
-				.is_none(),
-				<Error<T>>::NoPermission
-			);
-
-			let target_owner;
-			let approval_required;
-
-			match new_owner {
-				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {
-					target_owner = T::CrossAccountId::from_sub(account_id.clone());
-					approval_required = false;
-				}
-				RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(
-					target_collection_id,
-					target_nft_id,
-				) => {
-					let target_collection_id = Self::unique_collection_id(target_collection_id)?;
-
-					let target_nft_budget = budget::Value::new(NESTING_BUDGET);
-
-					let target_nft_owner = <PalletStructure<T>>::get_checked_topmost_owner(
-						target_collection_id,
-						target_nft_id.into(),
-						Some((collection_id, nft_id)),
-						&target_nft_budget,
-					)
-					.map_err(Self::map_unique_err_to_proxy)?
-					.ok_or::<DispatchError>(<Error<T>>::NoPermission.into())?;
-
-					approval_required = cross_sender != target_nft_owner;
-
-					if approval_required {
-						target_owner = target_nft_owner;
-
-						<PalletNft<T>>::set_scoped_token_property(
-							collection.id,
-							nft_id,
-							RMRK_SCOPE,
-							Self::encode_rmrk_property::<Option<PendingTarget>>(
-								PendingNftAccept,
-								&Some((target_collection_id, target_nft_id.into())),
-							)?,
-						)?;
-
-						Self::insert_pending_child(
-							(target_collection_id, target_nft_id.into()),
-							(rmrk_collection_id, rmrk_nft_id),
-						)?;
-					} else {
-						target_owner = T::CrossTokenAddressMapping::token_to_address(
-							target_collection_id,
-							target_nft_id.into(),
-						);
-					}
-				}
-			}
-
-			let src_nft_budget = budget::Value::new(NESTING_BUDGET);
-
-			<PalletNft<T>>::transfer_from(
-				&collection,
-				&cross_sender,
-				&from,
-				&target_owner,
-				nft_id,
-				&src_nft_budget,
-			)
-			.map_err(Self::map_unique_err_to_proxy)?;
-
-			Self::deposit_event(Event::NFTSent {
-				sender,
-				recipient: new_owner,
-				collection_id: rmrk_collection_id,
-				nft_id: rmrk_nft_id,
-				approval_required,
-			});
-
-			Ok(())
-		}
-
-		/// Accept an NFT sent from another account to self or an owned NFT.
-		///
-		/// The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.
-		///
-		/// # Permissions:
-		/// - Token-owner-to-be
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.
-		/// - `rmrk_nft_id`: ID of the NFT to be accepted.
-		/// - `new_owner`: Either the sender's account ID or a sender-owned NFT,
-		/// whichever the accepted NFT was sent to.
-		#[pallet::call_index(7)]
-		#[pallet::weight(<SelfWeightOf<T>>::accept_nft())]
-		pub fn accept_nft(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			rmrk_nft_id: RmrkNftId,
-			new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin.clone())?;
-			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
-			let nft_id = rmrk_nft_id.into();
-
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			let new_cross_owner = match new_owner {
-				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {
-					T::CrossAccountId::from_sub(account_id.clone())
-				}
-				RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(
-					target_collection_id,
-					target_nft_id,
-				) => {
-					let target_collection_id = Self::unique_collection_id(target_collection_id)?;
-
-					T::CrossTokenAddressMapping::token_to_address(
-						target_collection_id,
-						TokenId(target_nft_id),
-					)
-				}
-			};
-
-			let budget = budget::Value::new(NESTING_BUDGET);
-
-			<PalletNft<T>>::transfer(
-				&collection,
-				&cross_sender,
-				&new_cross_owner,
-				nft_id,
-				&budget,
-			)
-			.map_err(|err| {
-				if err == <CommonError<T>>::UserIsNotAllowedToNest.into() {
-					<Error<T>>::CannotAcceptNonOwnedNft.into()
-				} else {
-					Self::map_unique_err_to_proxy(err)
-				}
-			})?;
-
-			let pending_target = Self::get_nft_property_decoded::<Option<PendingTarget>>(
-				collection_id,
-				nft_id,
-				RmrkProperty::PendingNftAccept,
-			)?;
-
-			if let Some(pending_target) = pending_target {
-				Self::remove_pending_child(pending_target, (rmrk_collection_id, rmrk_nft_id))?;
-
-				<PalletNft<T>>::set_scoped_token_property(
-					collection.id,
-					nft_id,
-					RMRK_SCOPE,
-					Self::encode_rmrk_property(PendingNftAccept, &None::<PendingTarget>)?,
-				)?;
-			}
-
-			Self::deposit_event(Event::NFTAccepted {
-				sender,
-				recipient: new_owner,
-				collection_id: rmrk_collection_id,
-				nft_id: rmrk_nft_id,
-			});
-
-			Ok(())
-		}
-
-		/// Reject an NFT sent from another account to self or owned NFT.
-		/// The NFT in question will not be sent back and burnt instead.
-		///
-		/// The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.
-		///
-		/// # Permissions:
-		/// - Token-owner-to-be-not
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.
-		/// - `rmrk_nft_id`: ID of the NFT to be rejected.
-		#[pallet::call_index(8)]
-		#[pallet::weight(<SelfWeightOf<T>>::reject_nft())]
-		pub fn reject_nft(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			rmrk_nft_id: RmrkNftId,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
-			let nft_id = rmrk_nft_id.into();
-
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			ensure!(
-				<TokenData<T>>::get((collection_id, nft_id)).is_some(),
-				<Error<T>>::NoAvailableNftId
-			);
-
-			let pending_target = Self::get_nft_property_decoded::<Option<PendingTarget>>(
-				collection_id,
-				nft_id,
-				RmrkProperty::PendingNftAccept,
-			)?;
-
-			match pending_target {
-				Some(pending_target) => {
-					Self::remove_pending_child(pending_target, (rmrk_collection_id, rmrk_nft_id))?
-				}
-				None => return Err(<Error<T>>::CannotRejectNonPendingNft.into()),
-			}
-
-			Self::destroy_nft(
-				cross_sender,
-				collection_id,
-				nft_id,
-				NESTING_BUDGET,
-				<Error<T>>::CannotRejectNonOwnedNft,
-			)
-			.map_err(|err| Self::map_unique_err_to_proxy(err.error))?;
-
-			Self::deposit_event(Event::NFTRejected {
-				sender,
-				collection_id: rmrk_collection_id,
-				nft_id: rmrk_nft_id,
-			});
-
-			Ok(())
-		}
-
-		/// Accept the addition of a newly created pending resource to an existing NFT.
-		///
-		/// This transaction is needed when a resource is created and assigned to an NFT
-		/// by a non-owner, i.e. the collection issuer, with one of the
-		/// [`add_...` transactions](Pallet::add_basic_resource).
-		///
-		/// # Permissions:
-		/// - Token owner
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK collection ID of the NFT.
-		/// - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.
-		/// - `resource_id`: ID of the newly created pending resource.
-		/// accept the addition of a new resource to an existing NFT
-		#[pallet::call_index(9)]
-		#[pallet::weight(<SelfWeightOf<T>>::accept_resource())]
-		pub fn accept_resource(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			rmrk_nft_id: RmrkNftId,
-			resource_id: RmrkResourceId,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let cross_sender = T::CrossAccountId::from_sub(sender);
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)
-				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			let nft_id = rmrk_nft_id.into();
-
-			let budget = budget::Value::new(NESTING_BUDGET);
-
-			let nft_owner =
-				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)
-					.map_err(|_| <Error<T>>::ResourceDoesntExist)?
-					.ok_or::<DispatchError>(<Error<T>>::NoPermission.into())?;
-
-			Self::try_mutate_resource_info(collection_id, nft_id, resource_id, |res| {
-				ensure!(res.pending, <Error<T>>::ResourceNotPending);
-				ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);
-
-				res.pending = false;
-
-				Ok(())
-			})?;
-
-			Self::deposit_event(Event::<T>::ResourceAccepted {
-				nft_id: rmrk_nft_id,
-				resource_id,
-			});
-
-			Ok(())
-		}
-
-		/// Accept the removal of a removal-pending resource from an NFT.
-		///
-		/// This transaction is needed when a non-owner, i.e. the collection issuer,
-		/// requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.
-		///
-		/// # Permissions:
-		/// - Token owner
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK collection ID of the NFT.
-		/// - `rmrk_nft_id`: ID of the NFT with a resource to be removed.
-		/// - `resource_id`: ID of the removal-pending resource.
-		#[pallet::call_index(10)]
-		#[pallet::weight(<SelfWeightOf<T>>::accept_resource_removal())]
-		pub fn accept_resource_removal(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			rmrk_nft_id: RmrkNftId,
-			resource_id: RmrkResourceId,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let cross_sender = T::CrossAccountId::from_sub(sender);
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)
-				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			let nft_id = rmrk_nft_id.into();
-
-			let budget = budget::Value::new(NESTING_BUDGET);
-
-			let nft_owner =
-				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)
-					.map_err(|_| <Error<T>>::ResourceDoesntExist)?
-					.ok_or::<DispatchError>(<Error<T>>::NoPermission.into())?;
-
-			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);
-
-			let resource_id_key = Self::get_scoped_property_key(ResourceId(resource_id))?;
-
-			let resource_info = <PalletNft<T>>::token_aux_property((
-				collection_id,
-				nft_id,
-				RMRK_SCOPE,
-				resource_id_key.clone(),
-			))
-			.ok_or(<Error<T>>::ResourceDoesntExist)?;
-
-			let resource_info: RmrkResourceInfo = Self::decode_property_value(&resource_info)?;
-
-			ensure!(
-				resource_info.pending_removal,
-				<Error<T>>::ResourceNotPending
-			);
-
-			<PalletNft<T>>::remove_token_aux_property(
-				collection_id,
-				nft_id,
-				RMRK_SCOPE,
-				resource_id_key,
-			);
-
-			if let RmrkResourceTypes::Composable(resource) = resource_info.resource {
-				let base_id = resource.base;
-
-				Self::remove_associated_base_id(collection_id, nft_id, base_id)?;
-			}
-
-			Self::deposit_event(Event::<T>::ResourceRemovalAccepted {
-				nft_id: rmrk_nft_id,
-				resource_id,
-			});
-
-			Ok(())
-		}
-
-		/// Add or edit a custom user property, a key-value pair, describing the metadata
-		/// of a token or a collection, on either one of these.
-		///
-		/// Note that in this proxy implementation many details regarding RMRK are stored
-		/// as scoped properties prefixed with "rmrk:", normally inaccessible
-		/// to external transactions and RPCs.
-		///
-		/// # Permissions:
-		/// - Collection issuer - in case of collection property
-		/// - Token owner - in case of NFT property
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK collection ID.
-		/// - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.
-		/// - `key`: Key of the custom property to be referenced by.
-		/// - `value`: Value of the custom property to be stored.
-		#[pallet::call_index(11)]
-		#[pallet::weight(<SelfWeightOf<T>>::set_property())]
-		pub fn set_property(
-			origin: OriginFor<T>,
-			#[pallet::compact] rmrk_collection_id: RmrkCollectionId,
-			maybe_nft_id: Option<RmrkNftId>,
-			key: RmrkKeyString,
-			value: RmrkValueString,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let sender = T::CrossAccountId::from_sub(sender);
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			let budget = budget::Value::new(NESTING_BUDGET);
-
-			match maybe_nft_id {
-				Some(nft_id) => {
-					let token_id: TokenId = nft_id.into();
-
-					Self::ensure_nft_type(collection_id, token_id, NftType::Regular)?;
-					Self::ensure_nft_owner(collection_id, token_id, &sender, &budget)?;
-
-					<PalletNft<T>>::set_scoped_token_property(
-						collection_id,
-						token_id,
-						RMRK_SCOPE,
-						Self::encode_rmrk_property(UserProperty(key.as_slice()), &value)?,
-					)?;
-				}
-				None => {
-					let collection = Self::get_typed_nft_collection(
-						collection_id,
-						misc::CollectionType::Regular,
-					)?;
-
-					Self::check_collection_owner(&collection, &sender)?;
-
-					<PalletCommon<T>>::set_scoped_collection_property(
-						collection_id,
-						RMRK_SCOPE,
-						Self::encode_rmrk_property(UserProperty(key.as_slice()), &value)?,
-					)?;
-				}
-			}
-
-			Self::deposit_event(Event::PropertySet {
-				collection_id: rmrk_collection_id,
-				maybe_nft_id,
-				key,
-				value,
-			});
-
-			Ok(())
-		}
-
-		/// Set a different order of resource priorities for an NFT. Priorities can be used,
-		/// for example, for order of rendering.
-		///
-		/// Note that the priorities are not updated automatically, and are an empty vector
-		/// by default. There is no pre-set definition for the order to be particular,
-		/// it can be interpreted arbitrarily use-case by use-case.
-		///
-		/// # Permissions:
-		/// - Token owner
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK collection ID of the NFT.
-		/// - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.
-		/// - `priorities`: Ordered vector of resource IDs.
-		#[pallet::call_index(12)]
-		#[pallet::weight(<SelfWeightOf<T>>::set_priority())]
-		pub fn set_priority(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			rmrk_nft_id: RmrkNftId,
-			priorities: BoundedVec<RmrkResourceId, RmrkMaxPriorities>,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let sender = T::CrossAccountId::from_sub(sender);
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
-			let nft_id = rmrk_nft_id.into();
-
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			let budget = budget::Value::new(NESTING_BUDGET);
-
-			Self::ensure_nft_type(collection_id, nft_id, NftType::Regular)?;
-			Self::ensure_nft_owner(collection_id, nft_id, &sender, &budget)?;
-
-			<PalletNft<T>>::set_scoped_token_property(
-				collection_id,
-				nft_id,
-				RMRK_SCOPE,
-				Self::encode_rmrk_property(ResourcePriorities, &priorities.into_inner())?,
-			)?;
-
-			Self::deposit_event(Event::<T>::PrioritySet {
-				collection_id: rmrk_collection_id,
-				nft_id: rmrk_nft_id,
-			});
-
-			Ok(())
-		}
-
-		/// Create and set/propose a basic resource for an NFT.
-		///
-		/// A basic resource is the simplest, lacking a Base and anything that comes with it.
-		/// See RMRK docs for more information and examples.
-		///
-		/// # Permissions:
-		/// - Collection issuer - if not the token owner, adding the resource will warrant
-		/// the owner's [acceptance](Pallet::accept_resource).
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK collection ID of the NFT.
-		/// - `nft_id`: ID of the NFT to assign a resource to.
-		/// - `resource`: Data of the resource to be created.
-		#[pallet::call_index(13)]
-		#[pallet::weight(<SelfWeightOf<T>>::add_basic_resource())]
-		pub fn add_basic_resource(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-			resource: RmrkBasicResource,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin.clone())?;
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			let resource_id = Self::resource_add(
-				sender,
-				collection_id,
-				nft_id.into(),
-				RmrkResourceTypes::Basic(resource),
-			)?;
-
-			Self::deposit_event(Event::ResourceAdded {
-				nft_id,
-				resource_id,
-			});
-			Ok(())
-		}
-
-		/// Create and set/propose a composable resource for an NFT.
-		///
-		/// A composable resource links to a Base and has a subset of its Parts it is composed of.
-		/// See RMRK docs for more information and examples.
-		///
-		/// # Permissions:
-		/// - Collection issuer - if not the token owner, adding the resource will warrant
-		/// the owner's [acceptance](Pallet::accept_resource).
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK collection ID of the NFT.
-		/// - `nft_id`: ID of the NFT to assign a resource to.
-		/// - `resource`: Data of the resource to be created.
-		#[pallet::call_index(14)]
-		#[pallet::weight(<SelfWeightOf<T>>::add_composable_resource())]
-		pub fn add_composable_resource(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-			resource: RmrkComposableResource,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin.clone())?;
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			let base_id = resource.base;
-
-			let resource_id = Self::resource_add(
-				sender,
-				collection_id,
-				nft_id.into(),
-				RmrkResourceTypes::Composable(resource),
-			)?;
-
-			<PalletNft<T>>::try_mutate_token_aux_property(
-				collection_id,
-				nft_id.into(),
-				RMRK_SCOPE,
-				Self::get_scoped_property_key(AssociatedBases)?,
-				|value| -> DispatchResult {
-					let mut bases: BasesMap = match value {
-						Some(value) => Self::decode_property_value(value)?,
-						None => BasesMap::new(),
-					};
-
-					*bases.entry(base_id).or_insert(0) += 1;
-
-					*value = Some(Self::encode_property_value(&bases)?);
-					Ok(())
-				},
-			)?;
-
-			Self::deposit_event(Event::ResourceAdded {
-				nft_id,
-				resource_id,
-			});
-			Ok(())
-		}
-
-		/// Create and set/propose a slot resource for an NFT.
-		///
-		/// A slot resource links to a Base and a slot ID in it which it can fit into.
-		/// See RMRK docs for more information and examples.
-		///
-		/// # Permissions:
-		/// - Collection issuer - if not the token owner, adding the resource will warrant
-		/// the owner's [acceptance](Pallet::accept_resource).
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK collection ID of the NFT.
-		/// - `nft_id`: ID of the NFT to assign a resource to.
-		/// - `resource`: Data of the resource to be created.
-		#[pallet::call_index(15)]
-		#[pallet::weight(<SelfWeightOf<T>>::add_slot_resource())]
-		pub fn add_slot_resource(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-			resource: RmrkSlotResource,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin.clone())?;
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			let resource_id = Self::resource_add(
-				sender,
-				collection_id,
-				nft_id.into(),
-				RmrkResourceTypes::Slot(resource),
-			)?;
-
-			Self::deposit_event(Event::ResourceAdded {
-				nft_id,
-				resource_id,
-			});
-			Ok(())
-		}
-
-		/// Remove and erase a resource from an NFT.
-		///
-		/// If the sender does not own the NFT, then it will be pending confirmation,
-		/// and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.
-		///
-		/// # Permissions
-		/// - Collection issuer
-		///
-		/// # Arguments
-		/// - `origin`: sender of the transaction
-		/// - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.
-		/// - `nft_id`: ID of the NFT with a resource to be removed.
-		/// - `resource_id`: ID of the resource to be removed.
-		#[pallet::call_index(16)]
-		#[pallet::weight(<SelfWeightOf<T>>::remove_resource())]
-		pub fn remove_resource(
-			origin: OriginFor<T>,
-			rmrk_collection_id: RmrkCollectionId,
-			nft_id: RmrkNftId,
-			resource_id: RmrkResourceId,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin.clone())?;
-
-			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
-			let collection =
-				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-			collection.check_is_external()?;
-
-			Self::resource_remove(sender, collection_id, nft_id.into(), resource_id)?;
-
-			Self::deposit_event(Event::ResourceRemoval {
-				nft_id,
-				resource_id,
-			});
-			Ok(())
-		}
-	}
-}
-
-impl<T: Config> Pallet<T> {
-	/// Transform one of possible RMRK keys into a byte key with a RMRK scope.
-	pub fn get_scoped_property_key(rmrk_key: RmrkProperty) -> Result<PropertyKey, DispatchError> {
-		let key = rmrk_key.to_key::<T>()?;
-
-		let scoped_key = RMRK_SCOPE
-			.apply(key)
-			.map_err(|_| <Error<T>>::RmrkPropertyKeyIsTooLong)?;
-
-		Ok(scoped_key)
-	}
-
-	/// Form a Unique property, transforming a RMRK key into bytes (without assigning the scope yet)
-	/// and encoding the value from an arbitrary type into bytes.
-	pub fn encode_rmrk_property<E: Encode>(
-		rmrk_key: RmrkProperty,
-		value: &E,
-	) -> Result<Property, DispatchError> {
-		let key = rmrk_key.to_key::<T>()?;
-
-		let value = Self::encode_property_value(value)?;
-
-		let property = Property { key, value };
-
-		Ok(property)
-	}
-
-	/// Encode property value from an arbitrary type into bytes for storage.
-	pub fn encode_property_value<E: Encode, S: Get<u32>>(
-		value: &E,
-	) -> Result<BoundedBytes<S>, DispatchError> {
-		let value = value
-			.encode()
-			.try_into()
-			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong)?;
-
-		Ok(value)
-	}
-
-	/// Decode property value from bytes into an arbitrary type.
-	pub fn decode_property_value<D: Decode, S: Get<u32>>(
-		vec: &BoundedBytes<S>,
-	) -> Result<D, DispatchError> {
-		vec.decode()
-			.map_err(|_| <Error<T>>::UnableToDecodeRmrkData.into())
-	}
-
-	/// Change the limit of a property value byte vector.
-	pub fn rebind<L, S>(vec: &BoundedVec<u8, L>) -> Result<BoundedVec<u8, S>, DispatchError>
-	where
-		BoundedVec<u8, S>: TryFrom<Vec<u8>>,
-	{
-		vec.rebind()
-			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong.into())
-	}
-
-	/// Initialize a new NFT collection with certain RMRK-scoped properties.
-	///
-	/// See [`init_collection`](pallet_nonfungible::pallet::Pallet::init_collection) for more details.
-	fn init_collection(
-		sender: T::CrossAccountId,
-		data: CreateCollectionData<T::AccountId>,
-		properties: impl Iterator<Item = Property>,
-	) -> Result<CollectionId, DispatchError> {
-		let collection_id = <PalletNft<T>>::init_collection(
-			sender.clone(),
-			sender,
-			data,
-			up_data_structs::CollectionFlags {
-				external: true,
-				..Default::default()
-			},
-		);
-
-		if let Err(DispatchError::Arithmetic(_)) = &collection_id {
-			return Err(<Error<T>>::NoAvailableCollectionId.into());
-		}
-
-		<PalletCommon<T>>::set_scoped_collection_properties(
-			collection_id?,
-			RMRK_SCOPE,
-			properties,
-		)?;
-
-		collection_id
-	}
-
-	/// Mint a new NFT with certain RMRK-scoped properties. Sender must be the collection owner.
-	///
-	/// See [`create_item`](pallet_nonfungible::pallet::Pallet::create_item) for more details.
-	pub fn create_nft(
-		sender: &T::CrossAccountId,
-		owner: &T::CrossAccountId,
-		collection: &NonfungibleHandle<T>,
-		properties: impl Iterator<Item = Property>,
-	) -> Result<TokenId, DispatchError> {
-		let data = CreateNftExData {
-			properties: BoundedVec::default(),
-			owner: owner.clone(),
-		};
-
-		let budget = budget::Value::new(NESTING_BUDGET);
-
-		<PalletNft<T>>::create_item(collection, sender, data, &budget)?;
-
-		let nft_id = <PalletNft<T>>::current_token_id(collection.id);
-
-		<PalletNft<T>>::set_scoped_token_properties(collection.id, nft_id, RMRK_SCOPE, properties)?;
-
-		Ok(nft_id)
-	}
-
-	/// Burn an NFT, along with its nested children, limited by `max_burns`. The sender must be the token owner.
-	///
-	/// See [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively) for more details.
-	fn destroy_nft(
-		sender: T::CrossAccountId,
-		collection_id: CollectionId,
-		token_id: TokenId,
-		max_burns: u32,
-		error_if_not_owned: Error<T>,
-	) -> DispatchResultWithPostInfo {
-		let collection =
-			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-
-		let token_data =
-			<TokenData<T>>::get((collection_id, token_id)).ok_or(<Error<T>>::NoAvailableNftId)?;
-
-		let from = token_data.owner;
-
-		let owner_check_budget = budget::Value::new(NESTING_BUDGET);
-
-		ensure!(
-			<PalletStructure<T>>::check_indirectly_owned(
-				sender.clone(),
-				collection_id,
-				token_id,
-				None,
-				&owner_check_budget
-			)?,
-			error_if_not_owned,
-		);
-
-		let burns_budget = budget::Value::new(max_burns);
-		let breadth_budget = budget::Value::new(max_burns);
-
-		<PalletNft<T>>::burn_recursively(
-			&collection,
-			&from,
-			token_id,
-			&burns_budget,
-			&breadth_budget,
-		)
-	}
-
-	/// Add a sent token pending acceptance to the target owning token as a property.
-	fn insert_pending_child(
-		target: (CollectionId, TokenId),
-		child: (RmrkCollectionId, RmrkNftId),
-	) -> DispatchResult {
-		Self::mutate_pending_children(target, |pending_children| {
-			pending_children.insert(child);
-		})
-	}
-
-	/// Remove a sent token pending acceptance from the target token's properties.
-	fn remove_pending_child(
-		target: (CollectionId, TokenId),
-		child: (RmrkCollectionId, RmrkNftId),
-	) -> DispatchResult {
-		Self::mutate_pending_children(target, |pending_children| {
-			pending_children.remove(&child);
-		})
-	}
-
-	/// Apply a mutation to the property of a token containing sent tokens
-	/// that are currently pending acceptance.
-	fn mutate_pending_children(
-		(target_collection_id, target_nft_id): (CollectionId, TokenId),
-		f: impl FnOnce(&mut PendingChildrenSet),
-	) -> DispatchResult {
-		<PalletNft<T>>::try_mutate_token_aux_property(
-			target_collection_id,
-			target_nft_id,
-			RMRK_SCOPE,
-			Self::get_scoped_property_key(PendingChildren)?,
-			|pending_children| -> DispatchResult {
-				let mut map = match pending_children {
-					Some(map) => Self::decode_property_value(map)?,
-					None => PendingChildrenSet::new(),
-				};
-
-				f(&mut map);
-
-				*pending_children = Some(Self::encode_property_value(&map)?);
-
-				Ok(())
-			},
-		)
-	}
-
-	/// Get an iterator from a token's property containing tokens sent to it
-	/// that are currently pending acceptance.
-	fn iterate_pending_children(
-		collection_id: CollectionId,
-		nft_id: TokenId,
-	) -> Result<impl Iterator<Item = PendingChild>, DispatchError> {
-		let property = <PalletNft<T>>::token_aux_property((
-			collection_id,
-			nft_id,
-			RMRK_SCOPE,
-			Self::get_scoped_property_key(PendingChildren)?,
-		));
-
-		let pending_children = match property {
-			Some(map) => Self::decode_property_value(&map)?,
-			None => PendingChildrenSet::new(),
-		};
-
-		Ok(pending_children.into_iter())
-	}
-
-	/// Get incremented resource ID from within an NFT's properties and store the new latest ID.
-	/// Thus, the returned resource ID should be used.
-	///
-	/// Resource IDs are unique only across an NFT.
-	fn acquire_next_resource_id(
-		collection_id: CollectionId,
-		nft_id: TokenId,
-	) -> Result<RmrkResourceId, DispatchError> {
-		let resource_id: RmrkResourceId =
-			Self::get_nft_property_decoded(collection_id, nft_id, NextResourceId)?;
-
-		let next_id = resource_id
-			.checked_add(1)
-			.ok_or(<Error<T>>::NoAvailableResourceId)?;
-
-		<PalletNft<T>>::set_scoped_token_property(
-			collection_id,
-			nft_id,
-			RMRK_SCOPE,
-			Self::encode_rmrk_property(NextResourceId, &next_id)?,
-		)?;
-
-		Ok(resource_id)
-	}
-
-	/// Create and add a resource for a regular NFT, mark it as pending if the sender
-	/// is not the token owner. The sender must be the collection owner.
-	fn resource_add(
-		sender: T::AccountId,
-		collection_id: CollectionId,
-		nft_id: TokenId,
-		resource: RmrkResourceTypes,
-	) -> Result<RmrkResourceId, DispatchError> {
-		let collection =
-			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-		ensure!(collection.owner == sender, Error::<T>::NoPermission);
-
-		let sender = T::CrossAccountId::from_sub(sender);
-		let budget = budget::Value::new(NESTING_BUDGET);
-
-		let nft_owner = <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)
-			.map_err(Self::map_unique_err_to_proxy)?
-			.ok_or::<DispatchError>(<Error<T>>::NoPermission.into())?;
-
-		let pending = sender != nft_owner;
-
-		let id = Self::acquire_next_resource_id(collection_id, nft_id)?;
-
-		let resource_info = RmrkResourceInfo {
-			id,
-			resource,
-			pending,
-			pending_removal: false,
-		};
-
-		<PalletNft<T>>::try_mutate_token_aux_property(
-			collection_id,
-			nft_id,
-			RMRK_SCOPE,
-			Self::get_scoped_property_key(ResourceId(id))?,
-			|value| -> DispatchResult {
-				*value = Some(Self::encode_property_value(&resource_info)?);
-
-				Ok(())
-			},
-		)?;
-
-		Ok(id)
-	}
-
-	/// Designate a resource for erasure from an NFT, and remove it if the sender is the token owner.
-	/// The sender must be the collection owner.
-	fn resource_remove(
-		sender: T::AccountId,
-		collection_id: CollectionId,
-		nft_id: TokenId,
-		resource_id: RmrkResourceId,
-	) -> DispatchResult {
-		let collection =
-			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
-		ensure!(collection.owner == sender, Error::<T>::NoPermission);
-
-		let resource_id_key = Self::get_scoped_property_key(ResourceId(resource_id))?;
-
-		let resource = <PalletNft<T>>::token_aux_property((
-			collection_id,
-			nft_id,
-			RMRK_SCOPE,
-			resource_id_key.clone(),
-		))
-		.ok_or(<Error<T>>::ResourceDoesntExist)?;
-
-		let resource_info: RmrkResourceInfo = Self::decode_property_value(&resource)?;
-
-		let budget = up_data_structs::budget::Value::new(NESTING_BUDGET);
-		let topmost_owner =
-			<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)?
-				.ok_or::<DispatchError>(<Error<T>>::NoPermission.into())?;
-
-		let sender = T::CrossAccountId::from_sub(sender);
-		if topmost_owner == sender {
-			<PalletNft<T>>::remove_token_aux_property(
-				collection_id,
-				nft_id,
-				RMRK_SCOPE,
-				Self::get_scoped_property_key(ResourceId(resource_id))?,
-			);
-
-			if let RmrkResourceTypes::Composable(resource) = resource_info.resource {
-				let base_id = resource.base;
-
-				Self::remove_associated_base_id(collection_id, nft_id, base_id)?;
-			}
-		} else {
-			Self::try_mutate_resource_info(collection_id, nft_id, resource_id, |res| {
-				res.pending_removal = true;
-
-				Ok(())
-			})?;
-		}
-
-		Ok(())
-	}
-
-	/// Remove a Base ID from an NFT if they are associated.
-	/// The Base itself is deleted if the number of associated NFTs reaches 0.
-	fn remove_associated_base_id(
-		collection_id: CollectionId,
-		nft_id: TokenId,
-		base_id: RmrkBaseId,
-	) -> DispatchResult {
-		<PalletNft<T>>::try_mutate_token_aux_property(
-			collection_id,
-			nft_id,
-			RMRK_SCOPE,
-			Self::get_scoped_property_key(AssociatedBases)?,
-			|value| -> DispatchResult {
-				let mut bases: BasesMap = match value {
-					Some(value) => Self::decode_property_value(value)?,
-					None => BasesMap::new(),
-				};
-
-				let remaining = bases.get(&base_id);
-
-				if let Some(remaining) = remaining {
-					if let Some(0) | None = remaining.checked_sub(1) {
-						bases.remove(&base_id);
-					}
-				}
-
-				*value = Some(Self::encode_property_value(&bases)?);
-				Ok(())
-			},
-		)
-	}
-
-	/// Apply a mutation to a resource stored in the token properties of an NFT.
-	fn try_mutate_resource_info(
-		collection_id: CollectionId,
-		nft_id: TokenId,
-		resource_id: RmrkResourceId,
-		f: impl FnOnce(&mut RmrkResourceInfo) -> DispatchResult,
-	) -> DispatchResult {
-		<PalletNft<T>>::try_mutate_token_aux_property(
-			collection_id,
-			nft_id,
-			RMRK_SCOPE,
-			Self::get_scoped_property_key(ResourceId(resource_id))?,
-			|value| match value {
-				Some(value) => {
-					let mut resource_info: RmrkResourceInfo = Self::decode_property_value(value)?;
-
-					f(&mut resource_info)?;
-
-					*value = Self::encode_property_value(&resource_info)?;
-
-					Ok(())
-				}
-				None => Err(<Error<T>>::ResourceDoesntExist.into()),
-			},
-		)
-	}
-
-	/// Change the owner of an NFT collection, ensuring that the sender is the current owner.
-	fn change_collection_owner(
-		collection_id: CollectionId,
-		collection_type: misc::CollectionType,
-		sender: T::AccountId,
-		new_owner: T::AccountId,
-	) -> DispatchResult {
-		let collection = Self::get_typed_nft_collection(collection_id, collection_type)?;
-		Self::check_collection_owner(&collection, &T::CrossAccountId::from_sub(sender))?;
-
-		let mut collection = collection.into_inner();
-
-		collection.owner = new_owner;
-		collection.save()
-	}
-
-	/// Ensure that an account is the collection owner/issuer, return an error if not.
-	pub fn check_collection_owner(
-		collection: &NonfungibleHandle<T>,
-		account: &T::CrossAccountId,
-	) -> DispatchResult {
-		collection
-			.check_is_owner(account)
-			.map_err(Self::map_unique_err_to_proxy)
-	}
-
-	/// Get the latest yet-unused RMRK collection index from the storage.
-	pub fn last_collection_idx() -> RmrkCollectionId {
-		<CollectionIndex<T>>::get()
-	}
-
-	/// Get a mapping from a RMRK collection ID to its corresponding Unique collection ID.
-	pub fn unique_collection_id(
-		rmrk_collection_id: RmrkCollectionId,
-	) -> Result<CollectionId, DispatchError> {
-		<UniqueCollectionId<T>>::try_get(rmrk_collection_id)
-			.map_err(|_| <Error<T>>::CollectionUnknown.into())
-	}
-
-	/// Get a mapping from a Unique collection ID to its RMRK collection ID counterpart, if it exists.
-	pub fn rmrk_collection_id(
-		unique_collection_id: CollectionId,
-	) -> Result<RmrkCollectionId, DispatchError> {
-		Self::get_collection_property_decoded(unique_collection_id, RmrkInternalCollectionId)
-	}
-
-	/// Fetch a Unique NFT collection.
-	pub fn get_nft_collection(
-		collection_id: CollectionId,
-	) -> Result<NonfungibleHandle<T>, DispatchError> {
-		let collection = <CollectionHandle<T>>::try_get(collection_id)
-			.map_err(|_| <Error<T>>::CollectionUnknown)?;
-
-		match collection.mode {
-			CollectionMode::NFT => Ok(NonfungibleHandle::cast(collection)),
-			_ => Err(<Error<T>>::CollectionUnknown.into()),
-		}
-	}
-
-	/// Check if an NFT collection with such an ID exists.
-	pub fn collection_exists(collection_id: CollectionId) -> bool {
-		<CollectionHandle<T>>::try_get(collection_id).is_ok()
-	}
-
-	/// Fetch and decode a RMRK-scoped collection property value in bytes.
-	pub fn get_collection_property(
-		collection_id: CollectionId,
-		key: RmrkProperty,
-	) -> Result<PropertyValue, DispatchError> {
-		let collection_property = <PalletCommon<T>>::collection_properties(collection_id)
-			.get(&Self::get_scoped_property_key(key)?)
-			.ok_or(<Error<T>>::CollectionUnknown)?
-			.clone();
-
-		Ok(collection_property)
-	}
-
-	/// Fetch a RMRK-scoped collection property and decode it from bytes into an appropriate type.
-	pub fn get_collection_property_decoded<V: Decode>(
-		collection_id: CollectionId,
-		key: RmrkProperty,
-	) -> Result<V, DispatchError> {
-		Self::decode_property_value(&Self::get_collection_property(collection_id, key)?)
-	}
-
-	/// Get the type of a collection stored as a scoped property.
-	///
-	/// RMRK Core proxy differentiates between regular collections as well as RMRK Bases as collections.
-	pub fn get_collection_type(
-		collection_id: CollectionId,
-	) -> Result<misc::CollectionType, DispatchError> {
-		Self::get_collection_property_decoded(collection_id, CollectionType).map_err(|err| {
-			if err != <Error<T>>::CollectionUnknown.into() {
-				<Error<T>>::CorruptedCollectionType.into()
-			} else {
-				err
-			}
-		})
-	}
-
-	/// Ensure that the type of the collection equals the provided type,
-	/// otherwise return an error.
-	pub fn ensure_collection_type(
-		collection_id: CollectionId,
-		collection_type: misc::CollectionType,
-	) -> DispatchResult {
-		let actual_type = Self::get_collection_type(collection_id)?;
-		ensure!(
-			actual_type == collection_type,
-			<CommonError<T>>::NoPermission
-		);
-
-		Ok(())
-	}
-
-	/// Fetch an NFT collection, but make sure it has the appropriate type.
-	pub fn get_typed_nft_collection(
-		collection_id: CollectionId,
-		collection_type: misc::CollectionType,
-	) -> Result<NonfungibleHandle<T>, DispatchError> {
-		Self::ensure_collection_type(collection_id, collection_type)?;
-
-		Self::get_nft_collection(collection_id)
-	}
-
-	/// Same as [`get_typed_nft_collection`](crate::pallet::Pallet::get_typed_nft_collection),
-	/// but also return the Unique collection ID.
-	pub fn get_typed_nft_collection_mapped(
-		rmrk_collection_id: RmrkCollectionId,
-		collection_type: misc::CollectionType,
-	) -> Result<(NonfungibleHandle<T>, CollectionId), DispatchError> {
-		let unique_collection_id = match collection_type {
-			misc::CollectionType::Regular => Self::unique_collection_id(rmrk_collection_id)?,
-			_ => rmrk_collection_id.into(),
-		};
-
-		let collection = Self::get_typed_nft_collection(unique_collection_id, collection_type)?;
-
-		Ok((collection, unique_collection_id))
-	}
-
-	/// Fetch and decode a RMRK-scoped NFT property value in bytes.
-	pub fn get_nft_property(
-		collection_id: CollectionId,
-		nft_id: TokenId,
-		key: RmrkProperty,
-	) -> Result<PropertyValue, DispatchError> {
-		let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))
-			.get(&Self::get_scoped_property_key(key)?)
-			.ok_or(<Error<T>>::RmrkPropertyIsNotFound)?
-			.clone();
-
-		Ok(nft_property)
-	}
-
-	/// Fetch a RMRK-scoped NFT property and decode it from bytes into an appropriate type.
-	pub fn get_nft_property_decoded<V: Decode>(
-		collection_id: CollectionId,
-		nft_id: TokenId,
-		key: RmrkProperty,
-	) -> Result<V, DispatchError> {
-		Self::decode_property_value(&Self::get_nft_property(collection_id, nft_id, key)?)
-	}
-
-	/// Check that an NFT exists.
-	pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {
-		<TokenData<T>>::contains_key((collection_id, nft_id))
-	}
-
-	/// Get the type of an NFT stored as a scoped property.
-	///
-	/// RMRK Core proxy differentiates between regular NFTs, and RMRK Parts and Themes.
-	pub fn get_nft_type(
-		collection_id: CollectionId,
-		token_id: TokenId,
-	) -> Result<NftType, DispatchError> {
-		Self::get_nft_property_decoded(collection_id, token_id, TokenType)
-			.map_err(|_| <Error<T>>::NoAvailableNftId.into())
-	}
-
-	/// Ensure that the type of the NFT equals the provided type, otherwise return an error.
-	pub fn ensure_nft_type(
-		collection_id: CollectionId,
-		token_id: TokenId,
-		nft_type: NftType,
-	) -> DispatchResult {
-		let actual_type = Self::get_nft_type(collection_id, token_id)?;
-		ensure!(actual_type == nft_type, <Error<T>>::NoPermission);
-
-		Ok(())
-	}
-
-	/// Ensure that an account is the owner of the token, either directly
-	/// or at the top of the nesting hierarchy; return an error if it is not.
-	pub fn ensure_nft_owner(
-		collection_id: CollectionId,
-		token_id: TokenId,
-		possible_owner: &T::CrossAccountId,
-		nesting_budget: &dyn budget::Budget,
-	) -> DispatchResult {
-		let is_owned = <PalletStructure<T>>::check_indirectly_owned(
-			possible_owner.clone(),
-			collection_id,
-			token_id,
-			None,
-			nesting_budget,
-		)
-		.map_err(Self::map_unique_err_to_proxy)?;
-
-		ensure!(is_owned, <Error<T>>::NoPermission);
-
-		Ok(())
-	}
-
-	/// Fetch non-scoped properties of a collection or a token that match the filter keys supplied,
-	/// or, if None are provided, return all non-scoped properties.
-	pub fn filter_user_properties<Key, Value, R, Mapper>(
-		collection_id: CollectionId,
-		token_id: Option<TokenId>,
-		filter_keys: Option<Vec<RmrkPropertyKey>>,
-		mapper: Mapper,
-	) -> Result<Vec<R>, DispatchError>
-	where
-		Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,
-		Value: Decode + Default,
-		Mapper: Fn(Key, Value) -> R,
-	{
-		filter_keys
-			.map(|keys| {
-				let properties = keys
-					.into_iter()
-					.filter_map(|key| {
-						let key: Key = key.try_into().ok()?;
-
-						let value = match token_id {
-							Some(token_id) => Self::get_nft_property_decoded(
-								collection_id,
-								token_id,
-								UserProperty(key.as_ref()),
-							),
-							None => Self::get_collection_property_decoded(
-								collection_id,
-								UserProperty(key.as_ref()),
-							),
-						}
-						.ok()?;
-
-						Some(mapper(key, value))
-					})
-					.collect();
-
-				Ok(properties)
-			})
-			.unwrap_or_else(|| {
-				let properties =
-					Self::iterate_user_properties(collection_id, token_id, mapper)?.collect();
-
-				Ok(properties)
-			})
-	}
-
-	/// Get all non-scoped properties from a collection or a token, and apply some transformation,
-	/// supplied by `mapper`, to each key-value pair.
-	pub fn iterate_user_properties<Key, Value, R, Mapper>(
-		collection_id: CollectionId,
-		token_id: Option<TokenId>,
-		mapper: Mapper,
-	) -> Result<impl Iterator<Item = R>, DispatchError>
-	where
-		Key: TryFrom<RmrkPropertyKey> + AsRef<[u8]>,
-		Value: Decode + Default,
-		Mapper: Fn(Key, Value) -> R,
-	{
-		let properties = match token_id {
-			Some(token_id) => <PalletNft<T>>::token_properties((collection_id, token_id)),
-			None => <PalletCommon<T>>::collection_properties(collection_id),
-		};
-
-		let properties = properties.into_iter().filter_map(move |(key, value)| {
-			let key = strip_key_prefix(&key, USER_PROPERTY_PREFIX)?;
-
-			let key: Key = key.to_vec().try_into().ok()?;
-			let value: Value = value.decode().ok()?;
-
-			Some(mapper(key, value))
-		});
-
-		Ok(properties)
-	}
-
-	/// Match Unique errors to RMRK's own and return the RMRK error if a match is successful.
-	fn map_unique_err_to_proxy(err: DispatchError) -> DispatchError {
-		map_unique_err_to_proxy! {
-			match err {
-				CommonError::NoPermission => NoPermission,
-				CommonError::CollectionTokenLimitExceeded => CollectionFullOrLocked,
-				CommonError::PublicMintingNotAllowed => NoPermission,
-				CommonError::TokenNotFound => NoAvailableNftId,
-				CommonError::ApprovedValueTooLow => NoPermission,
-				CommonError::CantDestroyNotEmptyCollection => CollectionNotEmpty,
-				StructureError::TokenNotFound => NoAvailableNftId,
-				StructureError::OuroborosDetected => CannotSendToDescendentOrSelf,
-			}
-		}
-	}
-}

--- a/pallets/proxy-rmrk-core/src/misc.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-//! Miscellaneous helpers and utilities used by the proxy pallet.
-
-use super::*;
-use codec::{Encode, Decode, Error};
-
-/// Match an error to a provided pattern matcher and get
-/// the corresponding error of another type if a match is successful.
-#[macro_export]
-macro_rules! map_unique_err_to_proxy {
-    (match $err:ident { $($unique_err_ty:ident :: $unique_err:ident => $proxy_err:ident),+ $(,)? }) => {
-        $(
-            if $err == <$unique_err_ty<T>>::$unique_err.into() {
-                return <Error<T>>::$proxy_err.into()
-            } else
-        )+ {
-            $err
-        }
-    };
-}
-
-/// Interface to decode some serialized bytes into an arbitrary type `T`,
-/// preferably if these bytes were originally encoded from `T`.
-pub trait RmrkDecode<T: Decode, S> {
-	/// Try to decode self into an arbitrary type `T`.
-	fn decode(&self) -> Result<T, Error>;
-}
-
-impl<T: Decode, S> RmrkDecode<T, S> for BoundedVec<u8, S> {
-	fn decode(&self) -> Result<T, Error> {
-		let mut value = self.as_slice();
-
-		T::decode(&mut value)
-	}
-}
-
-/// Interface to "rebind" - change the limit of a bounded byte vector.
-pub trait RmrkRebind<T, S> {
-	/// Try to change the limit of a bounded byte vector.
-	fn rebind(&self) -> Result<BoundedVec<u8, S>, Error>;
-}
-
-impl<T, S> RmrkRebind<T, S> for BoundedVec<u8, T>
-where
-	BoundedVec<u8, S>: TryFrom<Vec<u8>>,
-{
-	fn rebind(&self) -> Result<BoundedVec<u8, S>, Error> {
-		BoundedVec::<u8, S>::try_from(self.clone().into_inner())
-			.map_err(|_| "BoundedVec exceeds its limit".into())
-	}
-}
-
-/// RMRK Base shares functionality with a regular collection, and is thus
-/// stored as one, but they are used for different purposes and need to be differentiated.
-#[derive(Encode, Decode, PartialEq, Eq)]
-pub enum CollectionType {
-	Regular,
-	Base,
-}
-
-/// RMRK Base, being stored as a collection, can have different kinds of tokens,
-/// all except the `Regular` type, which is attributed to `Regular` collection.
-#[derive(Encode, Decode, PartialEq, Eq)]
-pub enum NftType {
-	Regular,
-	FixedPart,
-	SlotPart,
-	Theme,
-}

--- a/pallets/proxy-rmrk-core/src/property.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-//! Details of storing and handling RMRK properties.
-
-use super::*;
-use up_data_structs::PropertyScope;
-use core::convert::AsRef;
-
-/// Property prefix for storing resources.
-pub const RESOURCE_ID_PREFIX: &str = "rsid-";
-/// Property prefix for storing custom user-defined properties.
-pub const USER_PROPERTY_PREFIX: &str = "userprop-";
-/// Property scope for RMRK, used to signify that this property
-/// was created and is used by RMRK.
-pub const RMRK_SCOPE: PropertyScope = PropertyScope::Rmrk;
-
-/// Predefined RMRK property keys for storage of RMRK data format on the Unique chain.
-pub enum RmrkProperty<'r> {
-	Metadata,
-	CollectionType,
-	RmrkInternalCollectionId,
-	TokenType,
-	Transferable,
-	RoyaltyInfo,
-	Equipped,
-	ResourcePriorities,
-	NextResourceId,
-	ResourceId(RmrkResourceId),
-	PendingNftAccept,
-	PendingChildren,
-	AssociatedBases,
-	Parts,
-	Base,
-	Src,
-	EquippedNft,
-	BaseType,
-	ExternalPartId,
-	EquippableList,
-	ZIndex,
-	ThemeName,
-	ThemeInherit,
-	UserProperty(&'r [u8]),
-}
-
-impl<'r> RmrkProperty<'r> {
-	/// Convert a predefined RMRK property key enum into string bytes.
-	pub fn to_key<T: Config>(self) -> Result<PropertyKey, Error<T>> {
-		fn get_bytes<T: AsRef<[u8]>>(container: &T) -> &[u8] {
-			container.as_ref()
-		}
-
-		macro_rules! key {
-            ($($component:expr),+) => {
-                PropertyKey::try_from([$(key!(@ &$component)),+].concat())
-                    .map_err(|_| <Error<T>>::RmrkPropertyKeyIsTooLong)
-            };
-
-            (@ $key:expr) => {
-                get_bytes($key)
-            };
-        }
-
-		match self {
-			Self::Metadata => key!("metadata"),
-			Self::CollectionType => key!("collection-type"),
-			Self::RmrkInternalCollectionId => key!("internal-id"),
-			Self::TokenType => key!("token-type"),
-			Self::Transferable => key!("transferable"),
-			Self::RoyaltyInfo => key!("royalty-info"),
-			Self::Equipped => key!("equipped"),
-			Self::ResourcePriorities => key!("resource-priorities"),
-			Self::NextResourceId => key!("next-resource-id"),
-			Self::ResourceId(id) => key!(RESOURCE_ID_PREFIX, id.to_le_bytes()),
-			Self::PendingNftAccept => key!("pending-nft-accept"),
-			Self::PendingChildren => key!("pending-children"),
-			Self::AssociatedBases => key!("assoc-bases"),
-			Self::Parts => key!("parts"),
-			Self::Base => key!("base"),
-			Self::Src => key!("src"),
-			Self::EquippedNft => key!("equipped-nft"),
-			Self::BaseType => key!("base-type"),
-			Self::ExternalPartId => key!("ext-part-id"),
-			Self::EquippableList => key!("equippable-list"),
-			Self::ZIndex => key!("z-index"),
-			Self::ThemeName => key!("theme-name"),
-			Self::ThemeInherit => key!("theme-inherit"),
-			Self::UserProperty(name) => key!(USER_PROPERTY_PREFIX, name),
-		}
-	}
-}
-
-/// Strip a property key of its prefix and RMRK scope.
-pub fn strip_key_prefix(key: &PropertyKey, prefix: &str) -> Option<PropertyKey> {
-	let key_prefix = PropertyKey::try_from(prefix.as_bytes().to_vec()).ok()?;
-	let key_prefix = RMRK_SCOPE.apply(key_prefix).ok()?;
-
-	key.as_slice()
-		.strip_prefix(key_prefix.as_slice())?
-		.to_vec()
-		.try_into()
-		.ok()
-}
-
-/// Check that the key has the prefix.
-pub fn is_valid_key_prefix(key: &PropertyKey, prefix: &str) -> bool {
-	strip_key_prefix(key, prefix).is_some()
-}

--- a/pallets/proxy-rmrk-core/src/rpc.rs
+++ /dev/null
@@ -1,293 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-//! Realizations of RMRK RPCs (remote procedure calls) related to the Core pallet.
-
-use super::*;
-
-/// Get the latest created collection ID.
-pub fn last_collection_idx<T: Config>() -> Result<RmrkCollectionId, DispatchError> {
-	Ok(<Pallet<T>>::last_collection_idx())
-}
-
-/// Get collection info by ID.
-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,
-	}))
-}
-
-/// Get NFT info by collection and NFT IDs.
-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) {
-		Ok(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()),
-		},
-		_ => 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,
-		)?,
-	}))
-}
-
-/// Get tokens owned by an account in a collection.
-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)
-}
-
-/// Get tokens nested in an NFT - its direct children (not the children's children).
-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 rmrk_child_collection =
-					<Pallet<T>>::rmrk_collection_id(child_collection).ok()?;
-
-				Some(RmrkNftChild {
-					collection_id: rmrk_child_collection,
-					nft_id: child_token.0,
-				})
-			})
-			.chain(
-				<Pallet<T>>::iterate_pending_children(collection_id, nft_id)?.map(
-					|(child_collection, child_nft_id)| RmrkNftChild {
-						collection_id: child_collection,
-						nft_id: child_nft_id,
-					},
-				),
-			)
-			.collect(),
-	)
-}
-
-/// Get collection properties, created by the user - not the proxy-specific properties.
-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)
-}
-
-/// Get NFT properties, created by the user - not the proxy-specific 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)
-}
-
-/// Get full information on each resource of an NFT, including pending.
-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(|(key, value)| {
-		if !is_valid_key_prefix(&key, RESOURCE_ID_PREFIX) {
-			return None;
-		}
-
-		let resource_info: RmrkResourceInfo = <Pallet<T>>::decode_property_value(&value).ok()?;
-
-		Some(resource_info)
-	})
-	.collect();
-
-	Ok(resources)
-}
-
-/// Get the priority of a resource in an NFT.
-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-core/src/weights.rs
+++ /dev/null
@@ -1,480 +0,0 @@
-// Template adopted from https://github.com/paritytech/substrate/blob/master/.maintain/frame-weight-template.hbs
-
-//! Autogenerated weights for pallet_proxy_rmrk_core
-//!
-//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2022-08-15, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
-//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
-
-// Executed Command:
-// target/release/unique-collator
-// benchmark
-// pallet
-// --pallet
-// pallet-proxy-rmrk-core
-// --wasm-execution
-// compiled
-// --extrinsic
-// *
-// --template
-// .maintain/frame-weight-template.hbs
-// --steps=50
-// --repeat=80
-// --heap-pages=4096
-// --output=./pallets/proxy-rmrk-core/src/weights.rs
-
-#![cfg_attr(rustfmt, rustfmt_skip)]
-#![allow(unused_parens)]
-#![allow(unused_imports)]
-#![allow(clippy::unnecessary_cast)]
-
-use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
-use sp_std::marker::PhantomData;
-
-/// Weight functions needed for pallet_proxy_rmrk_core.
-pub trait WeightInfo {
-	fn create_collection() -> Weight;
-	fn destroy_collection() -> Weight;
-	fn change_collection_issuer() -> Weight;
-	fn lock_collection() -> Weight;
-	fn mint_nft(b: u32, ) -> Weight;
-	fn burn_nft(b: u32, ) -> Weight;
-	fn send() -> Weight;
-	fn accept_nft() -> Weight;
-	fn reject_nft() -> Weight;
-	fn set_property() -> Weight;
-	fn set_priority() -> Weight;
-	fn add_basic_resource() -> Weight;
-	fn add_composable_resource() -> Weight;
-	fn add_slot_resource() -> Weight;
-	fn remove_resource() -> Weight;
-	fn accept_resource() -> Weight;
-	fn accept_resource_removal() -> Weight;
-}
-
-/// Weights for pallet_proxy_rmrk_core using the Substrate node and recommended hardware.
-pub struct SubstrateWeight<T>(PhantomData<T>);
-impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
-	// Storage: Common CreatedCollectionCount (r:1 w:1)
-	// Storage: Common DestroyedCollectionCount (r:1 w:0)
-	// Storage: System Account (r:2 w:2)
-	// Storage: RmrkCore CollectionIndex (r:1 w:1)
-	// Storage: Common CollectionPropertyPermissions (r:0 w:1)
-	// Storage: Common CollectionProperties (r:0 w:1)
-	// Storage: Common CollectionById (r:0 w:1)
-	// Storage: RmrkCore UniqueCollectionId (r:0 w:1)
-	fn create_collection() -> Weight {
-		Weight::from_ref_time(49_754_000)
-			.saturating_add(T::DbWeight::get().reads(5 as u64))
-			.saturating_add(T::DbWeight::get().writes(8 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:1)
-	// Storage: Common CollectionById (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:1 w:0)
-	// Storage: Common DestroyedCollectionCount (r:1 w:1)
-	// Storage: Nonfungible TokensMinted (r:0 w:1)
-	// Storage: Nonfungible TokensBurnt (r:0 w:1)
-	// Storage: Common AdminAmount (r:0 w:1)
-	fn destroy_collection() -> Weight {
-		Weight::from_ref_time(48_588_000)
-			.saturating_add(T::DbWeight::get().reads(5 as u64))
-			.saturating_add(T::DbWeight::get().writes(6 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:1)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	fn change_collection_issuer() -> Weight {
-		Weight::from_ref_time(25_054_000)
-			.saturating_add(T::DbWeight::get().reads(3 as u64))
-			.saturating_add(T::DbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:1)
-	// Storage: Nonfungible TokensMinted (r:1 w:0)
-	// Storage: Nonfungible TokensBurnt (r:1 w:0)
-	fn lock_collection() -> Weight {
-		Weight::from_ref_time(26_483_000)
-			.saturating_add(T::DbWeight::get().reads(5 as u64))
-			.saturating_add(T::DbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokensMinted (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:1 w:1)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:2 w:2)
-	fn mint_nft(b: u32, ) -> Weight {
-		Weight::from_ref_time(62_419_000)
-			// Standard Error: 7_000
-			.saturating_add(Weight::from_ref_time(12_325_000).saturating_mul(b as u64))
-			.saturating_add(T::DbWeight::get().reads(6 as u64))
-			.saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(b as u64)))
-			.saturating_add(T::DbWeight::get().writes(5 as u64))
-			.saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(b as u64)))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:1 w:1)
-	// Storage: Nonfungible TokenChildren (r:1 w:0)
-	// Storage: Nonfungible TokensBurnt (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:1 w:1)
-	// Storage: Nonfungible Allowance (r:1 w:0)
-	// Storage: Nonfungible Owned (r:0 w:1)
-	// Storage: Nonfungible TokenProperties (r:0 w:1)
-	fn burn_nft(b: u32, ) -> Weight {
-		(Weight::from_ref_time(0))
-			// Standard Error: 1_488_000
-			.saturating_add(Weight::from_ref_time(298_367_000).saturating_mul(b as u64))
-			.saturating_add(T::DbWeight::get().reads(9 as u64))
-			.saturating_add(T::DbWeight::get().reads((4 as u64).saturating_mul(b as u64)))
-			.saturating_add(T::DbWeight::get().writes(6 as u64))
-			.saturating_add(T::DbWeight::get().writes((4 as u64).saturating_mul(b as u64)))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:1)
-	// Storage: Nonfungible TokenProperties (r:1 w:0)
-	// Storage: Nonfungible AccountBalance (r:2 w:2)
-	// Storage: Nonfungible Allowance (r:1 w:0)
-	// Storage: Nonfungible TokenChildren (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:2)
-	fn send() -> Weight {
-		Weight::from_ref_time(81_942_000)
-			.saturating_add(T::DbWeight::get().reads(12 as u64))
-			.saturating_add(T::DbWeight::get().writes(6 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:2 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:2 w:0)
-	// Storage: Nonfungible TokenData (r:6 w:1)
-	// Storage: Nonfungible AccountBalance (r:2 w:2)
-	// Storage: Nonfungible Allowance (r:1 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	// Storage: Nonfungible TokenChildren (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:2)
-	fn accept_nft() -> Weight {
-		Weight::from_ref_time(97_925_000)
-			.saturating_add(T::DbWeight::get().reads(16 as u64))
-			.saturating_add(T::DbWeight::get().writes(8 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:5)
-	// Storage: Nonfungible TokenProperties (r:1 w:5)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	// Storage: Nonfungible TokenChildren (r:9 w:4)
-	// Storage: Nonfungible TokensBurnt (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:5 w:5)
-	// Storage: Nonfungible Allowance (r:5 w:0)
-	// Storage: Nonfungible Owned (r:0 w:5)
-	fn reject_nft() -> Weight {
-		Weight::from_ref_time(277_794_000)
-			.saturating_add(T::DbWeight::get().reads(30 as u64))
-			.saturating_add(T::DbWeight::get().writes(26 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	fn set_property() -> Weight {
-		Weight::from_ref_time(54_657_000)
-			.saturating_add(T::DbWeight::get().reads(9 as u64))
-			.saturating_add(T::DbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	fn set_priority() -> Weight {
-		Weight::from_ref_time(55_056_000)
-			.saturating_add(T::DbWeight::get().reads(9 as u64))
-			.saturating_add(T::DbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	fn add_basic_resource() -> Weight {
-		Weight::from_ref_time(61_673_000)
-			.saturating_add(T::DbWeight::get().reads(10 as u64))
-			.saturating_add(T::DbWeight::get().writes(2 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:2 w:2)
-	fn add_composable_resource() -> Weight {
-		Weight::from_ref_time(67_125_000)
-			.saturating_add(T::DbWeight::get().reads(11 as u64))
-			.saturating_add(T::DbWeight::get().writes(3 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	fn add_slot_resource() -> Weight {
-		Weight::from_ref_time(69_058_000)
-			.saturating_add(T::DbWeight::get().reads(10 as u64))
-			.saturating_add(T::DbWeight::get().writes(2 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	fn remove_resource() -> Weight {
-		Weight::from_ref_time(53_427_000)
-			.saturating_add(T::DbWeight::get().reads(9 as u64))
-			.saturating_add(T::DbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	fn accept_resource() -> Weight {
-		Weight::from_ref_time(50_623_000)
-			.saturating_add(T::DbWeight::get().reads(9 as u64))
-			.saturating_add(T::DbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	fn accept_resource_removal() -> Weight {
-		Weight::from_ref_time(50_917_000)
-			.saturating_add(T::DbWeight::get().reads(9 as u64))
-			.saturating_add(T::DbWeight::get().writes(1 as u64))
-	}
-}
-
-// For backwards compatibility and tests
-impl WeightInfo for () {
-	// Storage: Common CreatedCollectionCount (r:1 w:1)
-	// Storage: Common DestroyedCollectionCount (r:1 w:0)
-	// Storage: System Account (r:2 w:2)
-	// Storage: RmrkCore CollectionIndex (r:1 w:1)
-	// Storage: Common CollectionPropertyPermissions (r:0 w:1)
-	// Storage: Common CollectionProperties (r:0 w:1)
-	// Storage: Common CollectionById (r:0 w:1)
-	// Storage: RmrkCore UniqueCollectionId (r:0 w:1)
-	fn create_collection() -> Weight {
-		Weight::from_ref_time(49_754_000)
-			.saturating_add(RocksDbWeight::get().reads(5 as u64))
-			.saturating_add(RocksDbWeight::get().writes(8 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:1)
-	// Storage: Common CollectionById (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:1 w:0)
-	// Storage: Common DestroyedCollectionCount (r:1 w:1)
-	// Storage: Nonfungible TokensMinted (r:0 w:1)
-	// Storage: Nonfungible TokensBurnt (r:0 w:1)
-	// Storage: Common AdminAmount (r:0 w:1)
-	fn destroy_collection() -> Weight {
-		Weight::from_ref_time(48_588_000)
-			.saturating_add(RocksDbWeight::get().reads(5 as u64))
-			.saturating_add(RocksDbWeight::get().writes(6 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:1)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	fn change_collection_issuer() -> Weight {
-		Weight::from_ref_time(25_054_000)
-			.saturating_add(RocksDbWeight::get().reads(3 as u64))
-			.saturating_add(RocksDbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:1)
-	// Storage: Nonfungible TokensMinted (r:1 w:0)
-	// Storage: Nonfungible TokensBurnt (r:1 w:0)
-	fn lock_collection() -> Weight {
-		Weight::from_ref_time(26_483_000)
-			.saturating_add(RocksDbWeight::get().reads(5 as u64))
-			.saturating_add(RocksDbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokensMinted (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:1 w:1)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:2 w:2)
-	fn mint_nft(b: u32, ) -> Weight {
-		Weight::from_ref_time(62_419_000)
-			// Standard Error: 7_000
-			.saturating_add(Weight::from_ref_time(12_325_000).saturating_mul(b as u64))
-			.saturating_add(RocksDbWeight::get().reads(6 as u64))
-			.saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(b as u64)))
-			.saturating_add(RocksDbWeight::get().writes(5 as u64))
-			.saturating_add(RocksDbWeight::get().writes((1 as u64).saturating_mul(b as u64)))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:1 w:1)
-	// Storage: Nonfungible TokenChildren (r:1 w:0)
-	// Storage: Nonfungible TokensBurnt (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:1 w:1)
-	// Storage: Nonfungible Allowance (r:1 w:0)
-	// Storage: Nonfungible Owned (r:0 w:1)
-	// Storage: Nonfungible TokenProperties (r:0 w:1)
-	fn burn_nft(b: u32, ) -> Weight {
-		(Weight::from_ref_time(0))
-			// Standard Error: 1_488_000
-			.saturating_add(Weight::from_ref_time(298_367_000).saturating_mul(b as u64))
-			.saturating_add(RocksDbWeight::get().reads(9 as u64))
-			.saturating_add(RocksDbWeight::get().reads((4 as u64).saturating_mul(b as u64)))
-			.saturating_add(RocksDbWeight::get().writes(6 as u64))
-			.saturating_add(RocksDbWeight::get().writes((4 as u64).saturating_mul(b as u64)))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:1)
-	// Storage: Nonfungible TokenProperties (r:1 w:0)
-	// Storage: Nonfungible AccountBalance (r:2 w:2)
-	// Storage: Nonfungible Allowance (r:1 w:0)
-	// Storage: Nonfungible TokenChildren (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:2)
-	fn send() -> Weight {
-		Weight::from_ref_time(81_942_000)
-			.saturating_add(RocksDbWeight::get().reads(12 as u64))
-			.saturating_add(RocksDbWeight::get().writes(6 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:2 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:2 w:0)
-	// Storage: Nonfungible TokenData (r:6 w:1)
-	// Storage: Nonfungible AccountBalance (r:2 w:2)
-	// Storage: Nonfungible Allowance (r:1 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	// Storage: Nonfungible TokenChildren (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:2)
-	fn accept_nft() -> Weight {
-		Weight::from_ref_time(97_925_000)
-			.saturating_add(RocksDbWeight::get().reads(16 as u64))
-			.saturating_add(RocksDbWeight::get().writes(8 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:5)
-	// Storage: Nonfungible TokenProperties (r:1 w:5)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	// Storage: Nonfungible TokenChildren (r:9 w:4)
-	// Storage: Nonfungible TokensBurnt (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:5 w:5)
-	// Storage: Nonfungible Allowance (r:5 w:0)
-	// Storage: Nonfungible Owned (r:0 w:5)
-	fn reject_nft() -> Weight {
-		Weight::from_ref_time(277_794_000)
-			.saturating_add(RocksDbWeight::get().reads(30 as u64))
-			.saturating_add(RocksDbWeight::get().writes(26 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	fn set_property() -> Weight {
-		Weight::from_ref_time(54_657_000)
-			.saturating_add(RocksDbWeight::get().reads(9 as u64))
-			.saturating_add(RocksDbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	fn set_priority() -> Weight {
-		Weight::from_ref_time(55_056_000)
-			.saturating_add(RocksDbWeight::get().reads(9 as u64))
-			.saturating_add(RocksDbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	fn add_basic_resource() -> Weight {
-		Weight::from_ref_time(61_673_000)
-			.saturating_add(RocksDbWeight::get().reads(10 as u64))
-			.saturating_add(RocksDbWeight::get().writes(2 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:2 w:2)
-	fn add_composable_resource() -> Weight {
-		Weight::from_ref_time(67_125_000)
-			.saturating_add(RocksDbWeight::get().reads(11 as u64))
-			.saturating_add(RocksDbWeight::get().writes(3 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	fn add_slot_resource() -> Weight {
-		Weight::from_ref_time(69_058_000)
-			.saturating_add(RocksDbWeight::get().reads(10 as u64))
-			.saturating_add(RocksDbWeight::get().writes(2 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	fn remove_resource() -> Weight {
-		Weight::from_ref_time(53_427_000)
-			.saturating_add(RocksDbWeight::get().reads(9 as u64))
-			.saturating_add(RocksDbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	fn accept_resource() -> Weight {
-		Weight::from_ref_time(50_623_000)
-			.saturating_add(RocksDbWeight::get().reads(9 as u64))
-			.saturating_add(RocksDbWeight::get().writes(1 as u64))
-	}
-	// Storage: RmrkCore UniqueCollectionId (r:1 w:0)
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: Nonfungible TokenData (r:5 w:0)
-	// Storage: Nonfungible TokenAuxProperties (r:1 w:1)
-	fn accept_resource_removal() -> Weight {
-		Weight::from_ref_time(50_917_000)
-			.saturating_add(RocksDbWeight::get().reads(9 as u64))
-			.saturating_add(RocksDbWeight::get().writes(1 as u64))
-	}
-}

--- a/pallets/proxy-rmrk-equip/CHANGELOG.md
+++ /dev/null
@@ -1,17 +0,0 @@
-<!-- bureaucrate goes here -->
-## [v0.1.2] 2022-08-16
-
-### Other changes
-
-- build: Upgrade polkadot to v0.9.27 2c498572636f2b34d53b1c51b7283a761a7dc90a
-
-- build: Upgrade polkadot to v0.9.26 85515e54c4ca1b82a2630034e55dcc804c643bf8
-
-- refactor: Remove `#[transactional]` from extrinsics 7fd36cea2f6e00c02c67ccc1de9649ae404efd31
-
-Every extrinsic now runs in transaction implicitly, and
-`#[transactional]` on pallet dispatchable is now meaningless
-
-Upstream-Change: https://github.com/paritytech/substrate/issues/10806
-
-- build: Upgrade polkadot to v0.9.25 cdfb9bdc7b205ff1b5134f034ef9973d769e5e6b
\ No newline at end of file

--- a/pallets/proxy-rmrk-equip/Cargo.toml
+++ /dev/null
@@ -1,39 +0,0 @@
-[package]
-edition = "2021"
-license = "GPLv3"
-name = "pallet-rmrk-equip"
-version = "0.1.2"
-
-[dependencies]
-# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.
-codec = { workspace = true, package = "parity-scale-codec" }
-
-scale-info = { workspace = true }
-
-frame-benchmarking = {workspace = true, optional = true }
-frame-support = { workspace = true }
-frame-system = { workspace = true }
-pallet-common = { workspace = true }
-pallet-evm = { workspace = true }
-pallet-nonfungible = { workspace = true }
-pallet-proxy-rmrk-core = { workspace = true }
-sp-runtime = { workspace = true }
-sp-std = { workspace = true }
-up-data-structs = { workspace = true }
-
-[features]
-default = ["std"]
-runtime-benchmarks = ['frame-benchmarking', 'frame-support/runtime-benchmarks', 'frame-system/runtime-benchmarks']
-std = [
-	"frame-support/std",
-	"frame-system/std",
-	"pallet-common/std",
-	"pallet-evm/std",
-	"pallet-nonfungible/std",
-	"pallet-proxy-rmrk-core/std",
-	"sp-runtime/std",
-	"sp-std/std",
-	"up-data-structs/std",
-	'frame-benchmarking/std',
-]
-try-runtime = ["frame-support/try-runtime"]

--- a/pallets/proxy-rmrk-equip/src/benchmarking.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-use sp_std::vec;
-
-use frame_benchmarking::{benchmarks, account};
-use frame_system::RawOrigin;
-use frame_support::{
-	traits::{Currency, Get},
-	BoundedVec,
-};
-
-use up_data_structs::*;
-
-use super::*;
-
-const SEED: u32 = 1;
-
-fn create_data<S: Get<u32>>() -> BoundedVec<u8, S> {
-	vec![b'A'; S::get() as usize].try_into().expect("size == S")
-}
-
-fn create_u32_array<S: Get<u32>>() -> BoundedVec<u32, S> {
-	vec![0; S::get() as usize].try_into().expect("size == S")
-}
-
-fn create_max_part(id: RmrkSlotId) -> RmrkPartType {
-	RmrkPartType::SlotPart(RmrkSlotPart {
-		id,
-		equippable: RmrkEquippableList::Custom(create_u32_array()),
-		src: create_data(),
-		z: 1,
-	})
-}
-
-fn create_parts_array<S: Get<u32>>(num: u32) -> BoundedVec<RmrkPartType, S> {
-	let mut parts: BoundedVec<RmrkPartType, S> = vec![].try_into().expect("0 <= S");
-
-	for i in 0..num {
-		parts.try_push(create_max_part(i)).expect("num <= S");
-	}
-
-	parts
-}
-
-fn create_max_theme_property() -> RmrkThemeProperty {
-	RmrkThemeProperty {
-		key: create_data(),
-		value: create_data(),
-	}
-}
-
-fn create_theme_properties_array<S: Get<u32>>(num: u32) -> BoundedVec<RmrkThemeProperty, S> {
-	vec![create_max_theme_property(); num as usize]
-		.try_into()
-		.expect("num <= S")
-}
-
-fn create_max_theme(name: RmrkString, props_num: u32) -> RmrkBoundedTheme {
-	RmrkBoundedTheme {
-		name,
-		properties: create_theme_properties_array(props_num),
-		inherit: false,
-	}
-}
-
-benchmarks! {
-	create_base {
-		let b in 0..RmrkPartsLimit::get();
-
-		let caller = account("caller", 0, SEED);
-		<T as pallet_common::Config>::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
-
-		let base_type = create_data();
-		let symbol = create_data();
-		let parts = create_parts_array(b);
-	}: _(RawOrigin::Signed(caller), base_type, symbol, parts)
-
-	theme_add {
-		let b in 0..MaxPropertiesPerTheme::get();
-
-		let caller = account("caller", 0, SEED);
-		<T as pallet_common::Config>::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
-
-		let base_type = create_data();
-		let symbol = create_data();
-		let parts = create_parts_array(0);
-
-		<Pallet<T>>::create_base(RawOrigin::Signed(caller.clone()).into(), base_type, symbol, parts)?;
-		let base_id = 1;
-
-
-		let default_theme_name = b"default".to_vec().try_into().expect("default is a valid name; qed");
-		let default_theme = create_max_theme(default_theme_name, 0);
-
-		<Pallet<T>>::theme_add(RawOrigin::Signed(caller.clone()).into(), base_id, default_theme)?;
-
-		let theme = create_max_theme(create_data(), b);
-	}: _(RawOrigin::Signed(caller), base_id, theme)
-
-	equippable {
-		let caller = account("caller", 0, SEED);
-		<T as pallet_common::Config>::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
-
-		let base_id = 1;
-		let slot_id = 42;
-
-		let base_type = create_data();
-		let symbol = create_data();
-		let parts = vec! {
-			RmrkPartType::SlotPart(RmrkSlotPart {
-				id: slot_id,
-				equippable: RmrkEquippableList::All,
-				src: create_data(),
-				z: 1,
-			})
-		}.try_into().expect("1 <= RmrkPartsLimit");
-
-		<Pallet<T>>::create_base(RawOrigin::Signed(caller.clone()).into(), base_type, symbol, parts)?;
-
-		let equippables = RmrkEquippableList::Custom(create_u32_array());
-	}: _(RawOrigin::Signed(caller), base_id, slot_id, equippables)
-}

--- a/pallets/proxy-rmrk-equip/src/lib.rs
+++ /dev/null
@@ -1,508 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-//! # RMRK Core Proxy Pallet
-//!
-//! A pallet used as proxy for RMRK Core (<https://rmrk-team.github.io/rmrk-substrate/#/pallets/rmrk-core>).
-//!
-//! - [`Config`]
-//! - [`Call`]
-//! - [`Pallet`]
-//!
-//! ## Overview
-//!
-//! The RMRK Equip Proxy pallet mirrors the functionality of RMRK Equip,
-//! binding its externalities to Unique's own underlying structure.
-//! It is purposed to mimic RMRK Equip exactly, allowing seamless integrations
-//! of solutions based on RMRK.
-//!
-//! RMRK Equip itself contains functionality to equip NFTs, and work with Bases,
-//! Parts, and Themes. See [Proxy Implementation](#proxy-implementation) for details.
-//!
-//! Equip Proxy is responsible for a more specific area of RMRK, and heavily relies on the Core.
-//! For a more foundational description of proxy implementation, please refer to [`pallet_rmrk_core`].
-//!
-//! *Note*, that while RMRK itself is subject to active development and restructuring,
-//! the proxy may be caught temporarily out of date.
-//!
-//! ### What is RMRK?
-//!
-//! RMRK is a set of NFT standards which compose several "NFT 2.0 lego" primitives.
-//! Putting these legos together allows a user to create NFT systems of arbitrary complexity.
-//!
-//! Meaning, RMRK NFTs are dynamic, able to nest into each other and form a hierarchy,
-//! make use of specific changeable and partially shared metadata in the form of resources,
-//! and more.
-//!
-//! Visit RMRK documentation and repositories to learn more:
-//! - Docs: <https://docs.rmrk.app/getting-started/>
-//! - FAQ: <https://coda.io/@rmrk/faq>
-//! - Substrate code repository: <https://github.com/rmrk-team/rmrk-substrate>
-//! - RMRK spec repository: <https://github.com/rmrk-team/rmrk-spec>
-//!
-//! ## Terminology
-//!
-//! For more information on RMRK, see RMRK's own documentation.
-//!
-//! ### Intro to RMRK
-//!
-//! - **Resource:** Additional piece of metadata of an NFT usually serving to add
-//! a piece of media on top of the root metadata (NFT's own), be it a different wing
-//! on the root template bird or something entirely unrelated.
-//!
-//! - **Base:** A list of possible "components" - Parts, a combination of which can
-//! be appended/equipped to/on an NFT.
-//!
-//! - **Part:** Something that, together with other Parts, can constitute an NFT.
-//! Parts are defined in the Base to which they belong. Parts can be either
-//! of the `slot` type or `fixed` type. Slots are intended for equippables.
-//! Note that "part of something" and "Part of a Base" can be easily confused,
-//! and so in this documentation these words are distinguished by the capital letter.
-//!
-//! - **Theme:** Named objects of variable => value pairs which get interpolated into
-//! the Base's `themable` Parts. Themes can hold any value, but are often represented
-//! in RMRK's examples as colors applied to visible Parts.
-//!
-//! ### Peculiarities in Unique
-//!
-//! - **Scoped properties:** Properties that are normally obscured from users.
-//! Their purpose is to contain structured metadata that was not included in the Unique standard
-//! for collections and tokens, meant to be operated on by proxies and other outliers.
-//! Scoped property keys are prefixed with `some-scope:`, where `some-scope` is
-//! an arbitrary keyword, like "rmrk". `:` is considered an unacceptable symbol in user-defined
-//! properties, which, along with other safeguards, makes scoped ones impossible to tamper with.
-//!
-//! - **Auxiliary properties:** A slightly different structure of properties,
-//! trading universality of use for more convenient storage, writes and access.
-//! Meant to be inaccessible to end users.
-//!
-//! ## Proxy Implementation
-//!
-//! An external user is supposed to be able to utilize this proxy as they would
-//! utilize RMRK, and get exactly the same results. Normally, Unique transactions
-//! are off-limits to RMRK collections and tokens, and vice versa. However,
-//! the information stored on chain can be freely interpreted by storage reads and Unique RPCs.
-//!
-//! ### ID Mapping
-//!
-//! RMRK's collections' IDs are counted independently of Unique's and start at 0.
-//! Note that tokens' IDs still start at 1.
-//! The collections themselves, as well as tokens, are stored as Unique collections,
-//! and thus RMRK IDs are mapped to Unique IDs (but not vice versa).
-//!
-//! ### External/Internal Collection Insulation
-//!
-//! A Unique transaction cannot target collections purposed for RMRK,
-//! and they are flagged as `external` to specify that. On the other hand,
-//! due to the mapping, RMRK transactions and RPCs simply cannot reach Unique collections.
-//!
-//! ### Native Properties
-//!
-//! Many of RMRK's native parameters are stored as scoped properties of a collection
-//! or an NFT on the chain. Scoped properties are prefixed with `rmrk:`, where `:`
-//! is an unacceptable symbol in user-defined properties, which, along with other safeguards,
-//! makes them impossible to tamper with.
-//!
-//! ### Collection and NFT Types, or Base, Parts and Themes Handling
-//!
-//! RMRK introduces the concept of a Base, which is a catalogue of Parts,
-//! possible components of an NFT. Due to its similarity with the functionality
-//! of a token collection, a Base is stored and handled as one, and the Base's Parts and Themes
-//! are this collection's NFTs. See [`CollectionType`] and [`NftType`].
-//!
-//! ## Interface
-//!
-//! ### Dispatchables
-//!
-//! - `create_base` - Create a new Base.
-//! - `theme_add` - Add a Theme to a Base.
-//! - `equippable` - Update the array of Collections allowed to be equipped to a Base's specified Slot Part.
-
-#![cfg_attr(not(feature = "std"), no_std)]
-
-use frame_support::{pallet_prelude::*, BoundedVec, dispatch::DispatchResult};
-use frame_system::{pallet_prelude::*, ensure_signed};
-use sp_runtime::DispatchError;
-use up_data_structs::*;
-use pallet_common::{Pallet as PalletCommon, Error as CommonError};
-use pallet_proxy_rmrk_core::{
-	Pallet as PalletCore, Error as CoreError,
-	misc::{self, *},
-	property::RmrkProperty::*,
-};
-use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle};
-use pallet_evm::account::CrossAccountId;
-use weights::WeightInfo;
-
-pub use pallet::*;
-
-#[cfg(feature = "runtime-benchmarks")]
-pub mod benchmarking;
-pub mod rpc;
-pub mod weights;
-
-pub type SelfWeightOf<T> = <T as Config>::WeightInfo;
-
-#[frame_support::pallet]
-pub mod pallet {
-	use super::*;
-
-	#[pallet::config]
-	pub trait Config: frame_system::Config + pallet_proxy_rmrk_core::Config {
-		/// Overarching event type.
-		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
-
-		/// The weight information of this pallet.
-		type WeightInfo: WeightInfo;
-	}
-
-	/// Map of a Base ID and a Part ID to an NFT in the Base collection serving as the Part.
-	#[pallet::storage]
-	#[pallet::getter(fn internal_part_id)]
-	pub type InernalPartId<T: Config> =
-		StorageDoubleMap<_, Twox64Concat, CollectionId, Twox64Concat, RmrkPartId, TokenId>;
-
-	/// Checkmark that a Base has a Theme NFT named "default".
-	#[pallet::storage]
-	#[pallet::getter(fn base_has_default_theme)]
-	pub type BaseHasDefaultTheme<T: Config> =
-		StorageMap<_, Twox64Concat, CollectionId, bool, ValueQuery>;
-
-	#[pallet::pallet]
-	#[pallet::generate_store(pub(super) trait Store)]
-	pub struct Pallet<T>(_);
-
-	#[pallet::event]
-	#[pallet::generate_deposit(pub(super) fn deposit_event)]
-	pub enum Event<T: Config> {
-		BaseCreated {
-			issuer: T::AccountId,
-			base_id: RmrkBaseId,
-		},
-		EquippablesUpdated {
-			base_id: RmrkBaseId,
-			slot_id: RmrkSlotId,
-		},
-	}
-
-	#[pallet::error]
-	pub enum Error<T> {
-		/// No permission to perform action.
-		PermissionError,
-		/// Could not find an ID for a Base collection. It is likely there were too many collections created on the chain, causing an overflow.
-		NoAvailableBaseId,
-		/// Could not find a suitable ID for a Part, likely too many Part tokens were created in the Base, causing an overflow
-		NoAvailablePartId,
-		/// Base collection linked to this ID does not exist.
-		BaseDoesntExist,
-		/// No Theme named "default" is associated with the Base.
-		NeedsDefaultThemeFirst,
-		/// Part linked to this ID does not exist.
-		PartDoesntExist,
-		/// Cannot assign equippables to a fixed Part.
-		NoEquippableOnFixedPart,
-	}
-
-	#[pallet::call]
-	impl<T: Config> Pallet<T> {
-		/// Create a new Base.
-		///
-		/// Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)
-		///
-		/// # Permissions
-		/// - Anyone - will be assigned as the issuer of the Base.
-		///
-		/// # Arguments:
-		/// - `origin`: Caller, will be assigned as the issuer of the Base
-		/// - `base_type`: Arbitrary media type, e.g. "svg".
-		/// - `symbol`: Arbitrary client-chosen symbol.
-		/// - `parts`: Array of Fixed and Slot Parts composing the Base,
-		/// confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).
-		#[pallet::call_index(0)]
-		#[pallet::weight(<SelfWeightOf<T>>::create_base(parts.len() as u32))]
-		pub fn create_base(
-			origin: OriginFor<T>,
-			base_type: RmrkString,
-			symbol: RmrkBaseSymbol,
-			parts: BoundedVec<RmrkPartType, RmrkPartsLimit>,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
-
-			let data = CreateCollectionData {
-				limits: None,
-				token_prefix: symbol
-					.into_inner()
-					.try_into()
-					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,
-				..Default::default()
-			};
-
-			let collection_id_res = <PalletNft<T>>::init_collection(
-				cross_sender.clone(),
-				cross_sender.clone(),
-				data,
-				up_data_structs::CollectionFlags {
-					external: true,
-					..Default::default()
-				},
-			);
-
-			if let Err(DispatchError::Arithmetic(_)) = &collection_id_res {
-				return Err(<Error<T>>::NoAvailableBaseId.into());
-			}
-
-			let collection_id = collection_id_res?;
-
-			<PalletCommon<T>>::set_scoped_collection_properties(
-				collection_id,
-				PropertyScope::Rmrk,
-				[
-					<PalletCore<T>>::encode_rmrk_property(
-						CollectionType,
-						&misc::CollectionType::Base,
-					)?,
-					<PalletCore<T>>::encode_rmrk_property(BaseType, &base_type)?,
-				]
-				.into_iter(),
-			)?;
-
-			let collection = <PalletCore<T>>::get_nft_collection(collection_id)?;
-
-			for part in parts {
-				Self::create_part(&cross_sender, &collection, part)?;
-			}
-
-			Self::deposit_event(Event::BaseCreated {
-				issuer: sender,
-				base_id: collection_id.0,
-			});
-
-			Ok(())
-		}
-
-		/// Add a Theme to a Base.
-		/// A Theme named "default" is required prior to adding other Themes.
-		///
-		/// Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).
-		///
-		/// # Permissions:
-		/// - Base issuer
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `base_id`: Base ID containing the Theme to be updated.
-		/// - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an
-		///   array of [key, value, inherit].
-		///   - `key`: Arbitrary BoundedString, defined by client.
-		///   - `value`: Arbitrary BoundedString, defined by client.
-		///   - `inherit`: Optional bool.
-		#[pallet::call_index(1)]
-		#[pallet::weight(<SelfWeightOf<T>>::theme_add(theme.properties.len() as u32))]
-		pub fn theme_add(
-			origin: OriginFor<T>,
-			base_id: RmrkBaseId,
-			theme: RmrkBoundedTheme,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-
-			let sender = T::CrossAccountId::from_sub(sender);
-			let owner = &sender;
-
-			let collection_id: CollectionId = base_id.into();
-
-			let collection = Self::get_base(collection_id)?;
-
-			if theme.name.as_slice() == b"default" {
-				<BaseHasDefaultTheme<T>>::insert(collection_id, true);
-			} else if !Self::base_has_default_theme(collection_id) {
-				return Err(<Error<T>>::NeedsDefaultThemeFirst.into());
-			}
-
-			let token_id = <PalletCore<T>>::create_nft(
-				&sender,
-				owner,
-				&collection,
-				[
-					<PalletCore<T>>::encode_rmrk_property(TokenType, &NftType::Theme)?,
-					<PalletCore<T>>::encode_rmrk_property(ThemeName, &theme.name)?,
-					<PalletCore<T>>::encode_rmrk_property(ThemeInherit, &theme.inherit)?,
-				]
-				.into_iter(),
-			)
-			.map_err(|_| <Error<T>>::PermissionError)?;
-
-			for property in theme.properties {
-				<PalletNft<T>>::set_scoped_token_property(
-					collection_id,
-					token_id,
-					PropertyScope::Rmrk,
-					<PalletCore<T>>::encode_rmrk_property(
-						UserProperty(property.key.as_slice()),
-						&property.value,
-					)?,
-				)?;
-			}
-
-			Ok(())
-		}
-
-		/// Update the array of Collections allowed to be equipped to a Base's specified Slot Part.
-		///
-		/// Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).
-		///
-		/// # Permissions:
-		/// - Base issuer
-		///
-		/// # Arguments:
-		/// - `origin`: sender of the transaction
-		/// - `base_id`: Base containing the Slot Part to be updated.
-		/// - `slot_id`: Slot Part whose Equippable List is being updated .
-		/// - `equippables`: List of equippables that will override the current Equippables list.
-		#[pallet::call_index(2)]
-		#[pallet::weight(<SelfWeightOf<T>>::equippable())]
-		pub fn equippable(
-			origin: OriginFor<T>,
-			base_id: RmrkBaseId,
-			slot_id: RmrkSlotId,
-			equippables: RmrkEquippableList,
-		) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-
-			let base_collection_id = base_id.into();
-			let collection = Self::get_base(base_collection_id)?;
-
-			<PalletCore<T>>::check_collection_owner(
-				&collection,
-				&T::CrossAccountId::from_sub(sender),
-			)
-			.map_err(|err| {
-				if err == <CoreError<T>>::NoPermission.into() {
-					<Error<T>>::PermissionError.into()
-				} else {
-					err
-				}
-			})?;
-
-			let part_id = Self::internal_part_id(base_collection_id, slot_id)
-				.ok_or(<Error<T>>::PartDoesntExist)?;
-
-			let nft_type = <PalletCore<T>>::get_nft_type(base_collection_id, part_id)
-				.map_err(|_| <Error<T>>::PartDoesntExist)?;
-
-			match nft_type {
-				NftType::Regular | NftType::Theme => return Err(<Error<T>>::PermissionError.into()),
-				NftType::FixedPart => return Err(<Error<T>>::NoEquippableOnFixedPart.into()),
-				NftType::SlotPart => {
-					<PalletNft<T>>::set_scoped_token_property(
-						base_collection_id,
-						part_id,
-						PropertyScope::Rmrk,
-						<PalletCore<T>>::encode_rmrk_property(EquippableList, &equippables)?,
-					)?;
-				}
-			}
-
-			Self::deposit_event(Event::EquippablesUpdated { base_id, slot_id });
-
-			Ok(())
-		}
-	}
-}
-
-impl<T: Config> Pallet<T> {
-	/// Create (or overwrite) a Part in a Base.
-	/// The Part and the Base are represented as an NFT and a Collection.
-	fn create_part(
-		sender: &T::CrossAccountId,
-		collection: &NonfungibleHandle<T>,
-		part: RmrkPartType,
-	) -> DispatchResult {
-		let owner = sender;
-
-		let part_id = part.id();
-		let src = part.src();
-		let z_index = part.z_index();
-
-		let nft_type = match part {
-			RmrkPartType::FixedPart(_) => NftType::FixedPart,
-			RmrkPartType::SlotPart(_) => NftType::SlotPart,
-		};
-
-		let token_id = match Self::internal_part_id(collection.id, part_id) {
-			Some(token_id) => token_id,
-			None => {
-				let token_id =
-					<PalletCore<T>>::create_nft(sender, owner, collection, [].into_iter())
-						.map_err(|err| match err {
-							DispatchError::Arithmetic(_) => <Error<T>>::NoAvailablePartId.into(),
-							err => err,
-						})?;
-
-				<InernalPartId<T>>::insert(collection.id, part_id, token_id);
-
-				<PalletNft<T>>::set_scoped_token_property(
-					collection.id,
-					token_id,
-					PropertyScope::Rmrk,
-					<PalletCore<T>>::encode_rmrk_property(ExternalPartId, &part_id)?,
-				)?;
-
-				token_id
-			}
-		};
-
-		<PalletNft<T>>::set_scoped_token_properties(
-			collection.id,
-			token_id,
-			PropertyScope::Rmrk,
-			[
-				<PalletCore<T>>::encode_rmrk_property(TokenType, &nft_type)?,
-				<PalletCore<T>>::encode_rmrk_property(Src, &src)?,
-				<PalletCore<T>>::encode_rmrk_property(ZIndex, &z_index)?,
-			]
-			.into_iter(),
-		)?;
-
-		if let RmrkPartType::SlotPart(part) = part {
-			<PalletNft<T>>::set_scoped_token_property(
-				collection.id,
-				token_id,
-				PropertyScope::Rmrk,
-				<PalletCore<T>>::encode_rmrk_property(EquippableList, &part.equippable)?,
-			)?;
-		}
-
-		Ok(())
-	}
-
-	/// Ensure that the collection under the Base ID is a Base collection,
-	/// and fetch it.
-	fn get_base(base_id: CollectionId) -> Result<NonfungibleHandle<T>, DispatchError> {
-		let collection =
-			<PalletCore<T>>::get_typed_nft_collection(base_id, misc::CollectionType::Base)
-				.map_err(|err| {
-					if err == <CoreError<T>>::CollectionUnknown.into() {
-						<Error<T>>::BaseDoesntExist.into()
-					} else {
-						err
-					}
-				})?;
-		collection.check_is_external()?;
-
-		Ok(collection)
-	}
-}

--- a/pallets/proxy-rmrk-equip/src/rpc.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-//! Realizations of RMRK RPCs (remote procedure calls) related to the Equip pallet.
-
-use super::*;
-use pallet_proxy_rmrk_core::{misc, property::*};
-use sp_std::vec::Vec;
-
-/// Get base info by its ID.
-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)?,
-	}))
-}
-
-/// Get all parts of a base.
-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)
-}
-
-/// Get the theme names belonging to a base.
-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)
-}
-
-/// Get theme info, including properties, optionally limited to the provided keys.
-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/pallets/proxy-rmrk-equip/src/weights.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-// Template adopted from https://github.com/paritytech/substrate/blob/master/.maintain/frame-weight-template.hbs
-
-//! Autogenerated weights for pallet_proxy_rmrk_equip
-//!
-//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2022-08-15, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
-//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
-
-// Executed Command:
-// target/release/unique-collator
-// benchmark
-// pallet
-// --pallet
-// pallet-proxy-rmrk-equip
-// --wasm-execution
-// compiled
-// --extrinsic
-// *
-// --template
-// .maintain/frame-weight-template.hbs
-// --steps=50
-// --repeat=80
-// --heap-pages=4096
-// --output=./pallets/proxy-rmrk-equip/src/weights.rs
-
-#![cfg_attr(rustfmt, rustfmt_skip)]
-#![allow(unused_parens)]
-#![allow(unused_imports)]
-#![allow(clippy::unnecessary_cast)]
-
-use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
-use sp_std::marker::PhantomData;
-
-/// Weight functions needed for pallet_proxy_rmrk_equip.
-pub trait WeightInfo {
-	fn create_base(b: u32, ) -> Weight;
-	fn theme_add(b: u32, ) -> Weight;
-	fn equippable() -> Weight;
-}
-
-/// Weights for pallet_proxy_rmrk_equip using the Substrate node and recommended hardware.
-pub struct SubstrateWeight<T>(PhantomData<T>);
-impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
-	// Storage: Common CreatedCollectionCount (r:1 w:1)
-	// Storage: Common DestroyedCollectionCount (r:1 w:0)
-	// Storage: System Account (r:2 w:2)
-	// Storage: Common CollectionPropertyPermissions (r:0 w:1)
-	// Storage: Common CollectionProperties (r:0 w:1)
-	// Storage: Common CollectionById (r:0 w:1)
-	// Storage: RmrkEquip InernalPartId (r:1 w:1)
-	// Storage: Nonfungible TokensMinted (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:1 w:1)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:1)
-	fn create_base(b: u32, ) -> Weight {
-		Weight::from_ref_time(58_417_000)
-			// Standard Error: 27_000
-			.saturating_add(Weight::from_ref_time(20_439_000).saturating_mul(b as u64))
-			.saturating_add(T::DbWeight::get().reads(6 as u64))
-			.saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(b as u64)))
-			.saturating_add(T::DbWeight::get().writes(8 as u64))
-			.saturating_add(T::DbWeight::get().writes((4 as u64).saturating_mul(b as u64)))
-	}
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: RmrkEquip BaseHasDefaultTheme (r:1 w:0)
-	// Storage: Nonfungible TokensMinted (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:1 w:1)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:1)
-	fn theme_add(b: u32, ) -> Weight {
-		Weight::from_ref_time(46_005_000)
-			// Standard Error: 42_000
-			.saturating_add(Weight::from_ref_time(2_922_000).saturating_mul(b as u64))
-			.saturating_add(T::DbWeight::get().reads(6 as u64))
-			.saturating_add(T::DbWeight::get().writes(5 as u64))
-	}
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: RmrkEquip InernalPartId (r:1 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	fn equippable() -> Weight {
-		Weight::from_ref_time(32_526_000)
-			.saturating_add(T::DbWeight::get().reads(4 as u64))
-			.saturating_add(T::DbWeight::get().writes(1 as u64))
-	}
-}
-
-// For backwards compatibility and tests
-impl WeightInfo for () {
-	// Storage: Common CreatedCollectionCount (r:1 w:1)
-	// Storage: Common DestroyedCollectionCount (r:1 w:0)
-	// Storage: System Account (r:2 w:2)
-	// Storage: Common CollectionPropertyPermissions (r:0 w:1)
-	// Storage: Common CollectionProperties (r:0 w:1)
-	// Storage: Common CollectionById (r:0 w:1)
-	// Storage: RmrkEquip InernalPartId (r:1 w:1)
-	// Storage: Nonfungible TokensMinted (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:1 w:1)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:1)
-	fn create_base(b: u32, ) -> Weight {
-		Weight::from_ref_time(58_417_000)
-			// Standard Error: 27_000
-			.saturating_add(Weight::from_ref_time(20_439_000).saturating_mul(b as u64))
-			.saturating_add(RocksDbWeight::get().reads(6 as u64))
-			.saturating_add(RocksDbWeight::get().reads((2 as u64).saturating_mul(b as u64)))
-			.saturating_add(RocksDbWeight::get().writes(8 as u64))
-			.saturating_add(RocksDbWeight::get().writes((4 as u64).saturating_mul(b as u64)))
-	}
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: RmrkEquip BaseHasDefaultTheme (r:1 w:0)
-	// Storage: Nonfungible TokensMinted (r:1 w:1)
-	// Storage: Nonfungible AccountBalance (r:1 w:1)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	// Storage: Nonfungible TokenData (r:0 w:1)
-	// Storage: Nonfungible Owned (r:0 w:1)
-	fn theme_add(b: u32, ) -> Weight {
-		Weight::from_ref_time(46_005_000)
-			// Standard Error: 42_000
-			.saturating_add(Weight::from_ref_time(2_922_000).saturating_mul(b as u64))
-			.saturating_add(RocksDbWeight::get().reads(6 as u64))
-			.saturating_add(RocksDbWeight::get().writes(5 as u64))
-	}
-	// Storage: Common CollectionProperties (r:1 w:0)
-	// Storage: Common CollectionById (r:1 w:0)
-	// Storage: RmrkEquip InernalPartId (r:1 w:0)
-	// Storage: Nonfungible TokenProperties (r:1 w:1)
-	fn equippable() -> Weight {
-		Weight::from_ref_time(32_526_000)
-			.saturating_add(RocksDbWeight::get().reads(4 as u64))
-			.saturating_add(RocksDbWeight::get().writes(1 as u64))
-	}
-}

--- a/primitives/rmrk-rpc/CHANGELOG.md
+++ /dev/null
@@ -1,10 +0,0 @@
-<!-- bureaucrate goes here -->
-## [v0.0.2] 2022-08-16
-
-### Other changes
-
-- build: Upgrade polkadot to v0.9.27 2c498572636f2b34d53b1c51b7283a761a7dc90a
-
-- build: Upgrade polkadot to v0.9.26 85515e54c4ca1b82a2630034e55dcc804c643bf8
-
-- build: Upgrade polkadot to v0.9.25 cdfb9bdc7b205ff1b5134f034ef9973d769e5e6b
\ No newline at end of file

--- a/primitives/rmrk-rpc/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-edition = "2021"
-license = ""
-name = "rmrk-rpc"
-version = "0.0.2"
-
-[dependencies]
-codec = { workspace = true }
-rmrk-traits = { workspace = true }
-sp-api = { workspace = true }
-sp-runtime = { workspace = true }
-sp-std = { workspace = true }
-
-[features]
-default = ["std"]
-std = ["codec/std", "rmrk-traits/std", "sp-api/std", "sp-runtime/std", "sp-std/std"]

--- a/primitives/rmrk-rpc/src/lib.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-#![cfg_attr(not(feature = "std"), no_std)]
-
-use sp_api::{Encode, Decode};
-use sp_std::vec::Vec;
-use sp_runtime::DispatchError;
-use rmrk_traits::{primitives::*, NftChild};
-
-pub type Result<T> = core::result::Result<T, DispatchError>;
-
-pub type RpcString = Vec<u8>;
-
-pub type PropertyKey = RpcString;
-
-pub type ThemeName = RpcString;
-
-sp_api::decl_runtime_apis! {
-	pub trait RmrkApi<
-		AccountId,
-		CollectionInfo,
-		NftInfo,
-		ResourceInfo,
-		PropertyInfo,
-		BaseInfo,
-		PartType,
-		Theme
-	>
-	where
-		AccountId: Encode,
-		CollectionInfo: Decode,
-		NftInfo: Decode,
-		ResourceInfo: Decode,
-		PropertyInfo: Decode,
-		BaseInfo: Decode,
-		PartType: Decode,
-		Theme: Decode,
-	{
-		fn last_collection_idx() -> Result<CollectionId>;
-
-		fn collection_by_id(id: CollectionId) -> Result<Option<CollectionInfo>>;
-
-		fn nft_by_id(collection_id: CollectionId, nft_id: NftId) -> Result<Option<NftInfo>>;
-
-		fn account_tokens(account_id: AccountId, collection_id: CollectionId) -> Result<Vec<NftId>>;
-
-		fn nft_children(collection_id: CollectionId, nft_id: NftId) -> Result<Vec<NftChild>>;
-
-		fn collection_properties(collection_id: CollectionId, filter_keys: Option<Vec<PropertyKey>>) -> Result<Vec<PropertyInfo>>;
-
-		fn nft_properties(collection_id: CollectionId, nft_id: NftId, filter_keys: Option<Vec<PropertyKey>>) -> Result<Vec<PropertyInfo>>;
-
-		fn nft_resources(collection_id: CollectionId, nft_id: NftId) -> Result<Vec<ResourceInfo>>;
-
-		fn nft_resource_priority(collection_id: CollectionId, nft_id: NftId, resource_id: ResourceId) -> Result<Option<u32>>;
-
-		fn base(base_id: BaseId) -> Result<Option<BaseInfo>>;
-
-		fn base_parts(base_id: BaseId) -> Result<Vec<PartType>>;
-
-		fn theme_names(base_id: BaseId) -> Result<Vec<ThemeName>>;
-
-		fn theme(base_id: BaseId, theme_name: ThemeName, filter_keys: Option<Vec<PropertyKey>>) -> Result<Option<Theme>>;
-	}
-}

--- a/primitives/rmrk-traits/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-authors = ["RMRK Team", "Unique Network <support@uniquenetwork.io>"]
-description = "RMRK proxy data structs definitions"
-edition = "2021"
-homepage = "https://unique.network"
-license = 'GPLv3'
-name = "rmrk-traits"
-repository = 'https://github.com/UniqueNetwork/unique-chain'
-version = "0.1.0"
-
-[dependencies]
-# Note: `package = "parity-scale-codec"` must be supplied since the `Encode` macro searches for it.
-codec = { workspace = true, package = "parity-scale-codec" }
-
-scale-info = { workspace = true }
-serde = { workspace = true, optional = true }
-
-[features]
-default = ["std"]
-serde1 = ["serde/alloc"]
-std = ["codec/std", "serde/std", "serde1"]

--- a/primitives/rmrk-traits/src/base.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (C) 2021-2022 RMRK
-// This file is part of rmrk-substrate.
-// License: Apache 2.0 modified by RMRK, see https://github.com/rmrk-team/rmrk-substrate/blob/main/LICENSE
-
-use codec::{Decode, Encode, MaxEncodedLen};
-use scale_info::TypeInfo;
-
-#[cfg(feature = "std")]
-use serde::Serialize;
-
-#[cfg(feature = "std")]
-use crate::serialize;
-
-#[cfg_attr(feature = "std", derive(PartialEq, Eq, Serialize))]
-#[derive(Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = r#"
-			AccountId: Serialize,
-			BoundedString: AsRef<[u8]>
-		"#)
-)]
-pub struct BaseInfo<AccountId, BoundedString> {
-	/// Original creator of the Base
-	pub issuer: AccountId,
-
-	/// Specifies how an NFT should be rendered, ie "svg"
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub base_type: BoundedString,
-
-	/// User provided symbol during Base creation
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub symbol: BoundedString,
-}

--- a/primitives/rmrk-traits/src/collection.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (C) 2021-2022 RMRK
-// This file is part of rmrk-substrate.
-// License: Apache 2.0 modified by RMRK, see https://github.com/rmrk-team/rmrk-substrate/blob/main/LICENSE
-
-use codec::{Decode, Encode, MaxEncodedLen};
-use scale_info::TypeInfo;
-
-#[cfg(feature = "std")]
-use serde::Serialize;
-
-#[cfg(feature = "std")]
-use crate::serialize;
-
-#[cfg_attr(feature = "std", derive(PartialEq, Eq, Serialize))]
-#[derive(Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = r#"
-			AccountId: Serialize,
-			BoundedString: AsRef<[u8]>,
-			BoundedSymbol: AsRef<[u8]>
-		"#)
-)]
-pub struct CollectionInfo<BoundedString, BoundedSymbol, AccountId> {
-	/// Current bidder and bid price.
-	pub issuer: AccountId,
-
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub metadata: BoundedString,
-	pub max: Option<u32>,
-
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub symbol: BoundedSymbol,
-	pub nfts_count: u32,
-}

--- a/primitives/rmrk-traits/src/lib.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (C) 2021-2022 RMRK
-// This file is part of rmrk-substrate.
-// License: Apache 2.0 modified by RMRK, see https://github.com/rmrk-team/rmrk-substrate/blob/main/LICENSE
-
-#![cfg_attr(not(feature = "std"), no_std)]
-
-pub mod base;
-pub mod collection;
-pub mod nft;
-pub mod part;
-pub mod property;
-pub mod resource;
-pub mod theme;
-
-#[cfg(feature = "std")]
-mod serialize;
-
-pub use base::BaseInfo;
-pub use part::{EquippableList, FixedPart, PartType, SlotPart};
-pub use theme::{Theme, ThemeProperty};
-pub use collection::CollectionInfo;
-pub use nft::{AccountIdOrCollectionNftTuple, NftInfo, RoyaltyInfo, NftChild};
-pub use property::PropertyInfo;
-pub use resource::{BasicResource, ComposableResource, ResourceInfo, ResourceTypes, SlotResource};
-pub mod primitives {
-	pub type CollectionId = u32;
-	pub type ResourceId = u32;
-	pub type NftId = u32;
-	pub type BaseId = u32;
-	pub type SlotId = u32;
-	pub type PartId = u32;
-	pub type ZIndex = u32;
-}

no changes

--- a/primitives/rmrk-traits/src/part.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (C) 2021-2022 RMRK
-// This file is part of rmrk-substrate.
-// License: Apache 2.0 modified by RMRK, see https://github.com/rmrk-team/rmrk-substrate/blob/main/LICENSE
-
-use codec::{Decode, Encode, MaxEncodedLen};
-use scale_info::TypeInfo;
-
-#[cfg(feature = "std")]
-use serde::Serialize;
-
-#[cfg(feature = "std")]
-use crate::serialize;
-
-use crate::primitives::*;
-
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, Eq, MaxEncodedLen)]
-#[cfg_attr(feature = "std", serde(bound = "BoundedString: AsRef<[u8]>"))]
-pub struct FixedPart<BoundedString> {
-	pub id: PartId,
-	pub z: ZIndex,
-
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub src: BoundedString,
-}
-
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, Eq, MaxEncodedLen)]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = "BoundedCollectionList: AsRef<[CollectionId]>")
-)]
-pub enum EquippableList<BoundedCollectionList> {
-	All,
-	Empty,
-	Custom(#[cfg_attr(feature = "std", serde(with = "serialize::vec"))] BoundedCollectionList),
-}
-
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, Eq, MaxEncodedLen)]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = r#"
-			BoundedString: AsRef<[u8]>,
-			BoundedCollectionList: AsRef<[CollectionId]>
-		"#)
-)]
-pub struct SlotPart<BoundedString, BoundedCollectionList> {
-	pub id: PartId,
-	pub equippable: EquippableList<BoundedCollectionList>,
-
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub src: BoundedString,
-
-	pub z: ZIndex,
-}
-
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, Eq, MaxEncodedLen)]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = r#"
-			BoundedString: AsRef<[u8]>,
-			BoundedCollectionList: AsRef<[CollectionId]>
-		"#)
-)]
-pub enum PartType<BoundedString, BoundedCollectionList> {
-	FixedPart(FixedPart<BoundedString>),
-	SlotPart(SlotPart<BoundedString, BoundedCollectionList>),
-}
-
-impl<BoundedString, BoundedCollectionList> PartType<BoundedString, BoundedCollectionList> {
-	pub fn id(&self) -> PartId {
-		match self {
-			Self::FixedPart(part) => part.id,
-			Self::SlotPart(part) => part.id,
-		}
-	}
-
-	pub fn src(&self) -> &BoundedString {
-		match self {
-			Self::FixedPart(part) => &part.src,
-			Self::SlotPart(part) => &part.src,
-		}
-	}
-
-	pub fn z_index(&self) -> ZIndex {
-		match self {
-			Self::FixedPart(part) => part.z,
-			Self::SlotPart(part) => part.z,
-		}
-	}
-}

--- a/primitives/rmrk-traits/src/property.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (C) 2021-2022 RMRK
-// This file is part of rmrk-substrate.
-// License: Apache 2.0 modified by RMRK, see https://github.com/rmrk-team/rmrk-substrate/blob/main/LICENSE
-
-use codec::{Decode, Encode};
-use scale_info::TypeInfo;
-
-#[cfg(feature = "std")]
-use serde::Serialize;
-
-#[cfg(feature = "std")]
-use crate::serialize;
-
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[derive(Encode, Decode, PartialEq, TypeInfo)]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = r#"
-			BoundedKey: AsRef<[u8]>,
-			BoundedValue: AsRef<[u8]>
-		"#)
-)]
-pub struct PropertyInfo<BoundedKey, BoundedValue> {
-	/// Key of the property
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub key: BoundedKey,
-
-	/// Value of the property
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub value: BoundedValue,
-}

--- a/primitives/rmrk-traits/src/resource.rs
+++ /dev/null
@@ -1,168 +0,0 @@
-// Copyright (C) 2021-2022 RMRK
-// This file is part of rmrk-substrate.
-// License: Apache 2.0 modified by RMRK, see https://github.com/rmrk-team/rmrk-substrate/blob/main/LICENSE
-
-use codec::{Decode, Encode, MaxEncodedLen};
-use scale_info::TypeInfo;
-
-#[cfg(feature = "std")]
-use serde::Serialize;
-
-#[cfg(feature = "std")]
-use crate::serialize;
-
-use crate::primitives::*;
-
-#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[cfg_attr(feature = "std", serde(bound = "BoundedString: AsRef<[u8]>"))]
-pub struct BasicResource<BoundedString> {
-	/// If the resource is Media, the base property is absent. Media src should be a URI like an
-	/// IPFS hash.
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub src: Option<BoundedString>,
-
-	/// Reference to IPFS location of metadata
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub metadata: Option<BoundedString>,
-
-	/// Optional location or identier of license
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub license: Option<BoundedString>,
-
-	/// If the resource has the thumb property, this will be a URI to a thumbnail of the given
-	/// resource. For example, if we have a composable NFT like a Kanaria bird, the resource is
-	/// complex and too detailed to show in a search-results page or a list. Also, if a bird owns
-	/// another bird, showing the full render of one bird inside the other's inventory might be a
-	/// bit of a strain on the browser. For this reason, the thumb value can contain a URI to an
-	/// image that is lighter and faster to load but representative of this resource.
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub thumb: Option<BoundedString>,
-}
-
-#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = r#"
-			BoundedString: AsRef<[u8]>,
-			BoundedParts: AsRef<[PartId]>
-		"#)
-)]
-pub struct ComposableResource<BoundedString, BoundedParts> {
-	/// If a resource is composed, it will have an array of parts that compose it
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub parts: BoundedParts,
-
-	/// A Base is uniquely identified by the combination of the word `base`, its minting block
-	/// number, and user provided symbol during Base creation, glued by dashes `-`, e.g.
-	/// base-4477293-kanaria_superbird.
-	pub base: BaseId,
-
-	/// If the resource is Media, the base property is absent. Media src should be a URI like an
-	/// IPFS hash.
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub src: Option<BoundedString>,
-
-	/// Reference to IPFS location of metadata
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub metadata: Option<BoundedString>,
-
-	/// If the resource has the slot property, it was designed to fit into a specific Base's slot.
-	/// The baseslot will be composed of two dot-delimited values, like so:
-	/// "base-4477293-kanaria_superbird.machine_gun_scope". This means: "This resource is
-	/// compatible with the machine_gun_scope slot of base base-4477293-kanaria_superbird
-
-	/// Optional location or identier of license
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub license: Option<BoundedString>,
-
-	/// If the resource has the thumb property, this will be a URI to a thumbnail of the given
-	/// resource. For example, if we have a composable NFT like a Kanaria bird, the resource is
-	/// complex and too detailed to show in a search-results page or a list. Also, if a bird owns
-	/// another bird, showing the full render of one bird inside the other's inventory might be a
-	/// bit of a strain on the browser. For this reason, the thumb value can contain a URI to an
-	/// image that is lighter and faster to load but representative of this resource.
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub thumb: Option<BoundedString>,
-}
-
-#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[cfg_attr(feature = "std", serde(bound = "BoundedString: AsRef<[u8]>"))]
-pub struct SlotResource<BoundedString> {
-	/// A Base is uniquely identified by the combination of the word `base`, its minting block
-	/// number, and user provided symbol during Base creation, glued by dashes `-`, e.g.
-	/// base-4477293-kanaria_superbird.
-	pub base: BaseId,
-
-	/// If the resource is Media, the base property is absent. Media src should be a URI like an
-	/// IPFS hash.
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub src: Option<BoundedString>,
-
-	/// Reference to IPFS location of metadata
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub metadata: Option<BoundedString>,
-
-	/// If the resource has the slot property, it was designed to fit into a specific Base's slot.
-	/// The baseslot will be composed of two dot-delimited values, like so:
-	/// "base-4477293-kanaria_superbird.machine_gun_scope". This means: "This resource is
-	/// compatible with the machine_gun_scope slot of base base-4477293-kanaria_superbird
-	pub slot: SlotId,
-
-	/// The license field, if present, should contain a link to a license (IPFS or static HTTP
-	/// url), or an identifier, like RMRK_nocopy or ipfs://ipfs/someHashOfLicense.
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub license: Option<BoundedString>,
-
-	/// If the resource has the thumb property, this will be a URI to a thumbnail of the given
-	/// resource. For example, if we have a composable NFT like a Kanaria bird, the resource is
-	/// complex and too detailed to show in a search-results page or a list. Also, if a bird owns
-	/// another bird, showing the full render of one bird inside the other's inventory might be a
-	/// bit of a strain on the browser. For this reason, the thumb value can contain a URI to an
-	/// image that is lighter and faster to load but representative of this resource.
-	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]
-	pub thumb: Option<BoundedString>,
-}
-
-#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = r#"
-			BoundedString: AsRef<[u8]>,
-			BoundedParts: AsRef<[PartId]>
-		"#)
-)]
-pub enum ResourceTypes<BoundedString, BoundedParts> {
-	Basic(BasicResource<BoundedString>),
-	Composable(ComposableResource<BoundedString, BoundedParts>),
-	Slot(SlotResource<BoundedString>),
-}
-
-#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]
-#[cfg_attr(feature = "std", derive(Serialize))]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = r#"
-			BoundedString: AsRef<[u8]>,
-			BoundedParts: AsRef<[PartId]>
-		"#)
-)]
-pub struct ResourceInfo<BoundedString, BoundedParts> {
-	/// ID is a unique identifier for a resource across all those of a single NFT.
-	/// The combination of a collection ID, an NFT ID, and the resource ID must be
-	/// unique across the entire RMRK ecosystem.
-	//#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub id: ResourceId,
-
-	/// Resource type and the accordingly structured data stored
-	pub resource: ResourceTypes<BoundedString, BoundedParts>,
-
-	/// If resource is sent to non-rootowned NFT, pending will be false and need to be accepted
-	pub pending: bool,
-
-	/// If resource removal request is sent by non-rootowned NFT, pending will be true and need to be accepted
-	pub pending_removal: bool,
-}

--- a/primitives/rmrk-traits/src/serialize.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (C) 2021-2022 RMRK
-// This file is part of rmrk-substrate.
-// License: Apache 2.0 modified by RMRK, see https://github.com/rmrk-team/rmrk-substrate/blob/main/LICENSE
-
-use core::convert::AsRef;
-use serde::ser::{self, Serialize};
-
-pub mod vec {
-	use super::*;
-
-	pub fn serialize<D, V, C>(value: &C, serializer: D) -> Result<D::Ok, D::Error>
-	where
-		D: ser::Serializer,
-		V: Serialize,
-		C: AsRef<[V]>,
-	{
-		value.as_ref().serialize(serializer)
-	}
-}
-
-pub mod opt_vec {
-	use super::*;
-
-	pub fn serialize<D, V, C>(value: &Option<C>, serializer: D) -> Result<D::Ok, D::Error>
-	where
-		D: ser::Serializer,
-		V: Serialize,
-		C: AsRef<[V]>,
-	{
-		match value {
-			Some(value) => super::vec::serialize(value, serializer),
-			None => serializer.serialize_none(),
-		}
-	}
-}

--- a/primitives/rmrk-traits/src/theme.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (C) 2021-2022 RMRK
-// This file is part of rmrk-substrate.
-// License: Apache 2.0 modified by RMRK, see https://github.com/rmrk-team/rmrk-substrate/blob/main/LICENSE
-
-use codec::{Decode, Encode};
-use scale_info::TypeInfo;
-
-#[cfg(feature = "std")]
-use serde::Serialize;
-
-#[cfg(feature = "std")]
-use crate::serialize;
-
-#[cfg_attr(feature = "std", derive(Eq, Serialize))]
-#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq)]
-#[cfg_attr(
-	feature = "std",
-	serde(bound = r#"
-			BoundedString: AsRef<[u8]>,
-			PropertyList: AsRef<[ThemeProperty<BoundedString>]>,
-		"#)
-)]
-pub struct Theme<BoundedString, PropertyList> {
-	/// Name of the theme
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub name: BoundedString,
-
-	/// Theme properties
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub properties: PropertyList,
-	/// Inheritability
-	pub inherit: bool,
-}
-
-#[cfg_attr(feature = "std", derive(Eq, Serialize))]
-#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq)]
-#[cfg_attr(feature = "std", serde(bound = "BoundedString: AsRef<[u8]>"))]
-pub struct ThemeProperty<BoundedString> {
-	/// Key of the property
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub key: BoundedString,
-
-	/// Value of the property
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub value: BoundedString,
-}

--- a/runtime/common/config/pallets/rmrk.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
-// This file is part of Unique Network.
-
-// Unique Network is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Unique Network is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-
-use crate::{Runtime, RuntimeEvent};
-
-impl pallet_proxy_rmrk_core::Config for Runtime {
-	type WeightInfo = pallet_proxy_rmrk_core::weights::SubstrateWeight<Self>;
-	type RuntimeEvent = RuntimeEvent;
-}
-
-impl pallet_proxy_rmrk_equip::Config for Runtime {
-	type WeightInfo = pallet_proxy_rmrk_equip::weights::SubstrateWeight<Self>;
-	type RuntimeEvent = RuntimeEvent;
-}

--- a/tests/src/.outdated/rmrk/acceptNft.seqtest.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import {expect} from 'chai';
-import {getApiConnection} from '../substrate/substrate-api';
-import {
-  createCollection,
-  mintNft,
-  sendNft,
-  acceptNft,
-} from './util/tx';
-import {NftIdTuple} from './util/fetch';
-import {isNftChildOfAnother, expectTxFailure, requirePallets, Pallets} from './util/helpers';
-
-describe('integration test: accept NFT', () => {
-  let api: any;
-  before(async function() {
-    api = await getApiConnection();
-    await requirePallets(this, [Pallets.RmrkCore]);
-  });
-  
-  
-  const alice = '//Alice';
-  const bob = '//Bob';
-  
-  const createTestCollection = async (issuerUri: string) => {
-    return await createCollection(
-      api,
-      issuerUri,
-      'accept-metadata',
-      null,
-      'acpt',
-    );
-  };
-
-  it('accept NFT', async () => {
-    const ownerAlice = alice;
-    const ownerBob = bob;
-
-    const aliceCollectionId = await createTestCollection(alice);
-    const bobCollectionId = await createTestCollection(bob);
-
-    const parentNftId = await mintNft(api, alice, ownerAlice, aliceCollectionId, 'parent-nft-metadata');
-    const childNftId = await mintNft(api, bob, ownerBob, bobCollectionId, 'child-nft-metadata');
-
-    const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId];
-
-    await sendNft(api, 'pending', ownerBob, bobCollectionId, childNftId, newOwnerNFT);
-    await acceptNft(api, alice, bobCollectionId, childNftId, newOwnerNFT);
-
-    const isChild = await isNftChildOfAnother(api, bobCollectionId, childNftId, newOwnerNFT);
-    expect(isChild).to.be.true;
-  });
-
-  it('[negative] unable to accept NFT by a not-an-owner', async () => {
-    const ownerAlice = alice;
-    const ownerBob = bob;
-
-    const aliceCollectionId = await createTestCollection(alice);
-    const bobCollectionId = await createTestCollection(bob);
-
-    const parentNftId = await mintNft(api, alice, ownerAlice, aliceCollectionId, 'parent-nft-metadata');
-    const childNftId = await mintNft(api, bob, ownerBob, bobCollectionId, 'child-nft-metadata');
-
-    const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId];
-
-    await sendNft(api, 'pending', ownerBob, bobCollectionId, childNftId, newOwnerNFT);
-    const tx = acceptNft(api, bob, bobCollectionId, childNftId, newOwnerNFT);
-
-    await expectTxFailure(/rmrkCore\.NoPermission/, tx);
-  });
-
-  it('[negative] unable to accept non-existing NFT', async () => {
-    const collectionId = 0;
-    const maxNftId = 0xFFFFFFFF;
-
-    const owner = alice;
-    const aliceCollectionId = await createTestCollection(alice);
-
-    const parentNftId = await mintNft(api, alice, owner, aliceCollectionId, 'parent-nft-metadata');
-
-    const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId];
-
-    const tx = acceptNft(api, alice, collectionId, maxNftId, newOwnerNFT);
-
-    await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx);
-  });
-
-  it('[negative] unable to accept NFT which is not sent', async () => {
-    const ownerAlice = alice;
-    const ownerBob = bob;
-
-    const aliceCollectionId = await createTestCollection(alice);
-    const bobCollectionId = await createTestCollection(bob);
-
-    const parentNftId = await mintNft(api, alice, ownerAlice, aliceCollectionId, 'parent-nft-metadata');
-    const childNftId = await mintNft(api, bob, ownerBob, bobCollectionId, 'child-nft-metadata');
-
-    const newOwnerNFT: NftIdTuple = [aliceCollectionId, parentNftId];
-
-    const tx = acceptNft(api, alice, bobCollectionId, childNftId, newOwnerNFT);
-
-    await expectTxFailure(/rmrkCore\.NoPermission/, tx);
-
-    const isChild = await isNftChildOfAnother(api, bobCollectionId, childNftId, newOwnerNFT);
-    expect(isChild).to.be.false;
-  });
-
-  after(async() => { await api.disconnect(); });
-});

--- a/tests/src/.outdated/rmrk/addResource.seqtest.ts
+++ /dev/null
@@ -1,435 +0,0 @@
-import {expect} from 'chai';
-import {getApiConnection} from '../substrate/substrate-api';
-import {NftIdTuple} from './util/fetch';
-import {expectTxFailure, getResourceById, requirePallets, Pallets} from './util/helpers';
-import {
-  addNftBasicResource,
-  acceptNftResource,
-  createCollection,
-  mintNft,
-  sendNft,
-  addNftSlotResource,
-  addNftComposableResource,
-} from './util/tx';
-import {RmrkTraitsResourceResourceInfo as ResourceInfo} from '@polkadot/types/lookup';
-
-describe('integration test: add NFT resource', () => {
-  const alice = '//Alice';
-  const bob = '//Bob';
-  const src = 'test-res-src';
-  const metadata = 'test-res-metadata';
-  const license = 'test-res-license';
-  const thumb = 'test-res-thumb';
-
-  const nonexistentId = 99999;
-
-  let api: any;
-  before(async function() {
-    api = await getApiConnection();
-    await requirePallets(this, [Pallets.RmrkCore]);
-  });
-
-  it('add resource', async () => {
-    const collectionIdAlice = await createCollection(
-      api,
-      alice,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const nftAlice = await mintNft(
-      api,
-      alice,
-      alice,
-      collectionIdAlice,
-      'nft-metadata',
-    );
-
-    await addNftBasicResource(
-      api,
-      alice,
-      'added',
-      collectionIdAlice,
-      nftAlice,
-      src,
-      metadata,
-      license,
-      thumb,
-    );
-  });
-
-  it('add a resource to the nested NFT', async () => {
-    const collectionIdAlice = await createCollection(
-      api,
-      alice,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const parentNftId = await mintNft(api, alice, alice, collectionIdAlice, 'parent-nft-metadata');
-    const childNftId = await mintNft(api, alice, alice, collectionIdAlice, 'child-nft-metadata');
-
-    const newOwnerNFT: NftIdTuple = [collectionIdAlice, parentNftId];
-
-    await sendNft(api, 'sent', alice, collectionIdAlice, childNftId, newOwnerNFT);
-
-    await addNftBasicResource(
-      api,
-      alice,
-      'added',
-      collectionIdAlice,
-      childNftId,
-      src,
-      metadata,
-      license,
-      thumb,
-    );
-  });
-
-  it('add multiple resources', async () => {
-    const collectionIdAlice = await createCollection(
-      api,
-      alice,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const nftAlice = await mintNft(
-      api,
-      alice,
-      alice,
-      collectionIdAlice,
-      'nft-metadata',
-    );
-
-    const baseId = 42;
-    const slotId = 10;
-    const parts = [0, 5, 2];
-
-    const resourcesInfo = [];
-    const resourceNum = 4;
-
-    const checkResource = (resource: ResourceInfo, resType: string, expectedId: number, expected: {
-      src: string,
-      metadata: string,
-      license: string,
-      thumb: string
-    }) => {
-
-      // FIXME A workaround. It seems it is a PolkadotJS bug.
-      // All of the following are `false`.
-      //
-      // console.log('>>> basic:', resource.resource.isBasic);
-      // console.log('>>> composable:', resource.resource.isComposable);
-      // console.log('>>> slot:', resource.resource.isSlot);
-      const resourceJson = (resource.resource.toHuman() as any)[resType];
-
-      expect(resource.id.toNumber(), 'Error: Invalid resource Id')
-        .to.be.eq(expectedId);
-
-      expect(resourceJson.src, 'Error: Invalid resource src')
-        .to.be.eq(expected.src);
-      expect(resourceJson.metadata, 'Error: Invalid resource metadata')
-        .to.be.eq(expected.metadata);
-      expect(resourceJson.license, 'Error: Invalid resource license')
-        .to.be.eq(expected.license);
-      expect(resourceJson.thumb, 'Error: Invalid resource thumb')
-        .to.be.eq(expected.thumb);
-    };
-
-    for (let i = 0; i < resourceNum; i++) {
-      resourcesInfo.push({
-        src: src + 'r-' + i,
-        metadata: metadata + 'r-' + i,
-        license: license + 'r-' + i,
-        thumb: thumb + 'r-' + i,
-      });
-    }
-
-    const firstBasicResourceId = await addNftBasicResource(
-      api,
-      alice,
-      'added',
-      collectionIdAlice,
-      nftAlice,
-      resourcesInfo[0].src,
-      resourcesInfo[0].metadata,
-      resourcesInfo[0].license,
-      resourcesInfo[0].thumb,
-    );
-
-    const secondBasicResourceId = await addNftBasicResource(
-      api,
-      alice,
-      'added',
-      collectionIdAlice,
-      nftAlice,
-      resourcesInfo[1].src,
-      resourcesInfo[1].metadata,
-      resourcesInfo[1].license,
-      resourcesInfo[1].thumb,
-    );
-
-    const composableResourceId = await addNftComposableResource(
-      api,
-      alice,
-      'added',
-      collectionIdAlice,
-      nftAlice,
-      parts,
-      baseId,
-      resourcesInfo[2].src,
-      resourcesInfo[2].metadata,
-      resourcesInfo[2].license,
-      resourcesInfo[2].thumb,
-    );
-
-    const slotResourceId = await addNftSlotResource(
-      api,
-      alice,
-      'added',
-      collectionIdAlice,
-      nftAlice,
-      baseId,
-      slotId,
-      resourcesInfo[3].src,
-      resourcesInfo[3].metadata,
-      resourcesInfo[3].license,
-      resourcesInfo[3].thumb,
-    );
-
-    const firstResource = await getResourceById(api, collectionIdAlice, nftAlice, firstBasicResourceId);
-    await checkResource(firstResource, 'Basic', firstBasicResourceId, resourcesInfo[0]);
-
-    const secondResource = await getResourceById(api, collectionIdAlice, nftAlice, secondBasicResourceId);
-    await checkResource(secondResource, 'Basic', secondBasicResourceId, resourcesInfo[1]);
-
-    const composableResource = await getResourceById(api, collectionIdAlice, nftAlice, composableResourceId);
-    await checkResource(composableResource, 'Composable', composableResourceId, resourcesInfo[2]);
-
-    const slotResource = await getResourceById(api, collectionIdAlice, nftAlice, slotResourceId);
-    await checkResource(slotResource, 'Slot', slotResourceId, resourcesInfo[3]);
-  });
-
-  it('[negative]: unable to add a resource to the non-existing NFT', async () => {
-    const collectionIdAlice = await createCollection(
-      api,
-      alice,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const tx = addNftBasicResource(
-      api,
-      alice,
-      'added',
-      collectionIdAlice,
-      nonexistentId,
-      src,
-      metadata,
-      license,
-      thumb,
-    );
-  
-    await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx);
-  });
-
-  it('[negative]: unable to add a resource by a not-an-owner user', async () => {
-    const collectionIdAlice = await createCollection(
-      api,
-      alice,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const nftAlice = await mintNft(
-      api,
-      alice,
-      alice,
-      collectionIdAlice,
-      'nft-metadata',
-    );
-
-    const tx = addNftBasicResource(
-      api,
-      bob,
-      'added',
-      collectionIdAlice,
-      nftAlice,
-      src,
-      metadata,
-      license,
-      thumb,
-    );
-  
-    await expectTxFailure(/rmrkCore\.NoPermission/, tx);
-  });
-
-  it('[negative]: unable to add a resource to the nested NFT if it isnt root owned by the caller', async () => {
-    const collectionIdAlice = await createCollection(
-      api,
-      alice,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const parentNftId = await mintNft(api, alice, alice, collectionIdAlice, 'parent-nft-metadata');
-    const childNftId = await mintNft(api, alice, alice, collectionIdAlice, 'child-nft-metadata');
-
-    const newOwnerNFT: NftIdTuple = [collectionIdAlice, parentNftId];
-
-    await sendNft(api, 'sent', alice, collectionIdAlice, childNftId, newOwnerNFT);
-
-    const tx = addNftBasicResource(
-      api,
-      bob,
-      'added',
-      collectionIdAlice,
-      childNftId,
-      src,
-      metadata,
-      license,
-      thumb,
-    );
-    
-    await expectTxFailure(/rmrkCore\.NoPermission/, tx);
-  });
-
-  it('accept resource', async () => {
-    const collectionIdBob = await createCollection(
-      api,
-      bob,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const nftAlice = await mintNft(
-      api,
-      bob,
-      alice,
-      collectionIdBob,
-      'nft-metadata',
-    );
-
-    const resourceId = await addNftBasicResource(
-      api,
-      bob,
-      'pending',
-      collectionIdBob,
-      nftAlice,
-      src,
-      metadata,
-      license,
-      thumb,
-    );
-
-    await acceptNftResource(api, alice, collectionIdBob, nftAlice, resourceId);
-  });
-
-  it('[negative]: unable to accept a non-existing resource', async () => {
-    const collectionIdBob = await createCollection(
-      api,
-      bob,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const nftAlice = await mintNft(
-      api,
-      bob,
-      alice,
-      collectionIdBob,
-      'nft-metadata',
-    );
-
-    const tx = acceptNftResource(api, alice, collectionIdBob, nftAlice, nonexistentId);
-    await expectTxFailure(/rmrkCore\.ResourceDoesntExist/, tx);
-  });
-
-  it('[negative]: unable to accept a resource by a not-an-NFT-owner user', async () => {
-    const collectionIdBob = await createCollection(
-      api,
-      bob,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const nftAlice = await mintNft(
-      api,
-      bob,
-      alice,
-      collectionIdBob,
-      'nft-metadata',
-    );
-
-    const resourceId = await addNftBasicResource(
-      api,
-      bob,
-      'pending',
-      collectionIdBob,
-      nftAlice,
-      src,
-      metadata,
-      license,
-      thumb,
-    );
-
-    const tx = acceptNftResource(api, bob, collectionIdBob, nftAlice, resourceId);
-
-    await expectTxFailure(/rmrkCore\.NoPermission/, tx);
-  });
-
-  it('[negative]: unable to accept a resource to a non-target NFT', async () => {
-    const collectionIdBob = await createCollection(
-      api,
-      bob,
-      'test-metadata',
-      null,
-      'test-symbol',
-    );
-
-    const nftAlice = await mintNft(
-      api,
-      bob,
-      alice,
-      collectionIdBob,
-      'nft-metadata',
-    );
-
-    const wrongNft = await mintNft(
-      api,
-      bob,
-      alice,
-      collectionIdBob,
-      'nft-metadata',
-    );
-    
-    const resourceId = await addNftBasicResource(
-      api,
-      bob,
-      'pending',
-      collectionIdBob,
-      nftAlice,
-      src,
-      metadata,
-      license,
-      thumb,
-    );
-
-    const tx = acceptNftResource(api, bob, collectionIdBob, wrongNft, resourceId);
-
-    await expectTxFailure(/rmrkCore\.ResourceDoesntExist/, tx);
-  });
-
-
-  after(async() => { await api.disconnect(); });
-});