git.delta.rocks / unique-network / refs/commits / 35be72c17bf3

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6329,13 +6329,16 @@
 name = "pallet-rmrk-core"
 version = "0.1.0"
 dependencies = [
+ "derivative",
  "frame-benchmarking",
  "frame-support",
  "frame-system",
  "pallet-common",
  "pallet-evm",
  "pallet-nonfungible",
+ "pallet-structure",
  "parity-scale-codec 3.1.2",
+ "rmrk-traits",
  "scale-info",
  "sp-core",
  "sp-runtime",
@@ -6355,6 +6358,7 @@
  "pallet-nonfungible",
  "pallet-rmrk-core",
  "parity-scale-codec 3.1.2",
+ "rmrk-traits",
  "scale-info",
  "sp-core",
  "sp-runtime",
@@ -8577,6 +8581,7 @@
  "pallet-randomness-collective-flip",
  "pallet-refungible",
  "pallet-rmrk-core",
+ "pallet-rmrk-equip",
  "pallet-structure",
  "pallet-sudo",
  "pallet-template-transaction-payment",
@@ -8997,15 +9002,24 @@
 version = "0.0.1"
 dependencies = [
  "parity-scale-codec 2.3.1",
+ "rmrk-traits",
  "serde",
  "sp-api",
  "sp-core",
  "sp-runtime",
  "sp-std",
- "up-data-structs",
 ]
 
 [[package]]
+name = "rmrk-traits"
+version = "0.1.0"
+dependencies = [
+ "parity-scale-codec 3.1.2",
+ "scale-info",
+ "serde",
+]
+
+[[package]]
 name = "rocksdb"
 version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -12620,6 +12634,7 @@
  "pallet-randomness-collective-flip",
  "pallet-refungible",
  "pallet-rmrk-core",
+ "pallet-rmrk-equip",
  "pallet-structure",
  "pallet-sudo",
  "pallet-template-transaction-payment",
@@ -12722,6 +12737,7 @@
  "frame-system",
  "pallet-evm",
  "parity-scale-codec 3.1.2",
+ "rmrk-traits",
  "scale-info",
  "serde",
  "sp-core",

--- a/Makefile
+++ b/Makefile
@@ -105,5 +105,9 @@
 bench-scheduler:
 	make _bench2 PALLET=unique-scheduler PALLET_DIR=scheduler
 
+.PHONY: bench-rmrk-core
+bench-rmrk-core:
+	make _bench PALLET=proxy-rmrk-core
+
 .PHONY: bench
-bench: bench-evm-migration bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-scheduler
+bench: bench-evm-migration bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-scheduler bench-rmrk-core

--- a/client/rpc/src/lib.rs
+++ b/client/rpc/src/lib.rs
@@ -276,14 +276,15 @@
 			at: Option<BlockHash>,
 		) -> Result<Vec<ResourceInfo>>;
 
-		#[method(name = "rmrk_nftResourcePriorities")]
-		/// Get NFT resource priorities
-		fn nft_resource_priorities(
+		#[method(name = "rmrk_nftResourcePriority")]
+		/// Get NFT resource priority
+		fn nft_resource_priority(
 			&self,
 			collection_id: RmrkCollectionId,
 			nft_id: RmrkNftId,
+			resource_id: RmrkResourceId,
 			at: Option<BlockHash>,
-		) -> Result<Vec<RmrkResourceId>>;
+		) -> Result<Option<u32>>;
 
 		#[method(name = "rmrk_base")]
 		/// Get base info
@@ -325,6 +326,20 @@
 	}
 }
 
+pub struct Rmrk<C, P> {
+	client: Arc<C>,
+	_marker: std::marker::PhantomData<P>,
+}
+
+impl<C, P> Rmrk<C, P> {
+	pub fn new(client: Arc<C>) -> Self {
+		Self {
+			client,
+			_marker: Default::default(),
+		}
+	}
+}
+
 macro_rules! pass_method {
 	(
 		$method_name:ident(
@@ -473,7 +488,7 @@
 		BaseInfo,
 		PartType,
 		Theme,
-	> for Unique<C, Block>
+	> for Rmrk<C, Block>
 where
 	C: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
 	C::Api: RmrkRuntimeApi<
@@ -522,7 +537,7 @@
 		rmrk_api
 	);
 	pass_method!(nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Vec<ResourceInfo>, rmrk_api);
-	pass_method!(nft_resource_priorities(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Vec<RmrkResourceId>, rmrk_api);
+	pass_method!(nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Option<u32>, rmrk_api);
 	pass_method!(base(base_id: RmrkBaseId) -> Option<BaseInfo>, rmrk_api);
 	pass_method!(base_parts(base_id: RmrkBaseId) -> Vec<PartType>, rmrk_api);
 	pass_method!(theme_names(base_id: RmrkBaseId) -> Vec<RmrkThemeName>, rmrk_api);

--- a/crates/evm-coder/src/solidity.rs
+++ b/crates/evm-coder/src/solidity.rs
@@ -455,7 +455,7 @@
 	}
 }
 
-#[impl_for_tuples(0, 12)]
+#[impl_for_tuples(0, 24)]
 impl SolidityFunctions for Tuple {
 	for_tuples!( where #( Tuple: SolidityFunctions ),* );
 

--- a/node/cli/src/chain_spec.rs
+++ b/node/cli/src/chain_spec.rs
@@ -187,21 +187,33 @@
 	}};
 }
 
-pub fn development_config() -> OpalChainSpec {
+pub fn development_config() -> DefaultChainSpec {
 	let mut properties = Map::new();
-	properties.insert("tokenSymbol".into(), opal_runtime::TOKEN_SYMBOL.into());
+	properties.insert("tokenSymbol".into(), default_runtime::TOKEN_SYMBOL.into());
 	properties.insert("tokenDecimals".into(), 18.into());
-	properties.insert("ss58Format".into(), opal_runtime::SS58Prefix::get().into());
+	properties.insert(
+		"ss58Format".into(),
+		default_runtime::SS58Prefix::get().into(),
+	);
 
-	OpalChainSpec::from_genesis(
+	DefaultChainSpec::from_genesis(
 		// Name
-		"OPAL by UNIQUE",
+		format!(
+			"{}{}",
+			default_runtime::RUNTIME_NAME.to_uppercase(),
+			if cfg!(feature = "unique-runtime") {
+				""
+			} else {
+				" by UNIQUE"
+			}
+		)
+		.as_str(),
 		// ID
-		"opal_dev",
+		format!("{}_dev", default_runtime::RUNTIME_NAME).as_str(),
 		ChainType::Local,
 		move || {
 			testnet_genesis!(
-				opal_runtime,
+				default_runtime,
 				// Sudo account
 				get_account_id_from_seed::<sr25519::Public>("Alice"),
 				vec![

--- a/node/cli/src/service.rs
+++ b/node/cli/src/service.rs
@@ -66,10 +66,10 @@
 use unique_runtime_common::types::{AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block};
 
 // RMRK
-/* TODO free RMRK! use up_data_structs::{
+use up_data_structs::{
 	RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo, RmrkBaseInfo,
 	RmrkPartType, RmrkTheme,
-};*/
+};
 
 /// Unique native executor instance.
 #[cfg(feature = "unique-runtime")]
@@ -354,7 +354,6 @@
 		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>
 		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>
 		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>
-		/* TODO free RMRK!
 		+ rmrk_rpc::RmrkApi<
 			Block,
 			AccountId,
@@ -365,8 +364,7 @@
 			RmrkBaseInfo<AccountId>,
 			RmrkPartType,
 			RmrkTheme,
-		>*/
-		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
+		> + substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
 		+ sp_api::Metadata<Block>
 		+ sp_offchain::OffchainWorkerApi<Block>
 		+ cumulus_primitives_core::CollectCollationInfo<Block>,
@@ -661,7 +659,6 @@
 		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>
 		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>
 		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>
-		/* TODO free RMRK!
 		+ rmrk_rpc::RmrkApi<
 			Block,
 			AccountId,
@@ -672,8 +669,7 @@
 			RmrkBaseInfo<AccountId>,
 			RmrkPartType,
 			RmrkTheme,
-		>*/
-		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
+		> + substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
 		+ sp_api::Metadata<Block>
 		+ sp_offchain::OffchainWorkerApi<Block>
 		+ cumulus_primitives_core::CollectCollationInfo<Block>
@@ -807,7 +803,6 @@
 		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>
 		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>
 		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>
-		/* TODO free RMRK!
 		+ rmrk_rpc::RmrkApi<
 			Block,
 			AccountId,
@@ -818,8 +813,7 @@
 			RmrkBaseInfo<AccountId>,
 			RmrkPartType,
 			RmrkTheme,
-		>*/
-		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
+		> + substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
 		+ sp_api::Metadata<Block>
 		+ sp_offchain::OffchainWorkerApi<Block>
 		+ cumulus_primitives_core::CollectCollationInfo<Block>

--- a/node/rpc/src/lib.rs
+++ b/node/rpc/src/lib.rs
@@ -44,10 +44,10 @@
 	Hash, AccountId, RuntimeInstance, Index, Block, BlockNumber, Balance,
 };
 // RMRK
-/* TODO free RMRK! use up_data_structs::{
+use up_data_structs::{
 	RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo, RmrkBaseInfo,
 	RmrkPartType, RmrkTheme,
-};*/
+};
 
 /// Extra dependencies for GRANDPA
 pub struct GrandpaDeps<B> {
@@ -146,7 +146,6 @@
 	C::Api: fp_rpc::EthereumRuntimeRPCApi<Block>,
 	C::Api: fp_rpc::ConvertTransactionRuntimeApi<Block>,
 	C::Api: up_rpc::UniqueApi<Block, <R as RuntimeInstance>::CrossAccountId, AccountId>,
-	/* TODO free RMRK!
 	C::Api: rmrk_rpc::RmrkApi<
 		Block,
 		AccountId,
@@ -157,7 +156,7 @@
 		RmrkBaseInfo<AccountId>,
 		RmrkPartType,
 		RmrkTheme,
-	>,*/
+	>,
 	B: sc_client_api::Backend<Block> + Send + Sync + 'static,
 	B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashFor<Block>>,
 	P: TransactionPool<Block = Block> + 'static,
@@ -170,7 +169,7 @@
 		Eth, EthApiServer, EthDevSigner, EthFilter, EthFilterApiServer, EthPubSub,
 		EthPubSubApiServer, EthSigner, Net, NetApiServer, Web3, Web3ApiServer,
 	};
-	use uc_rpc::{UniqueApiServer, Unique};
+	use uc_rpc::{UniqueApiServer, Unique, RmrkApiServer, Rmrk};
 	// use pallet_contracts_rpc::{Contracts, ContractsApi};
 	use pallet_transaction_payment_rpc::{TransactionPaymentRpc, TransactionPaymentApiServer};
 	use substrate_frame_rpc_system::{SystemRpc, SystemApiServer};
@@ -223,10 +222,8 @@
 		.into_rpc(),
 	)?;
 
-	// todo look into
-	//let unique = Unique::new(client.clone());
 	io.merge(Unique::new(client.clone()).into_rpc())?;
-	// TODO free RMRK! io.extend_with(RmrkApi::to_delegate(Unique::new(client.clone())));
+	io.merge(Rmrk::new(client.clone()).into_rpc())?;
 
 	if let Some(filter_pool) = filter_pool {
 		io.merge(

--- a/pallets/common/src/benchmarking.rs
+++ b/pallets/common/src/benchmarking.rs
@@ -109,7 +109,7 @@
 	create_collection_raw(
 		owner,
 		CollectionMode::NFT,
-		|owner, data| <Pallet<T>>::init_collection(owner, data),
+		|owner, data| <Pallet<T>>::init_collection(owner, data, true),
 		|h| h,
 	)
 }

--- a/pallets/common/src/dispatch.rs
+++ b/pallets/common/src/dispatch.rs
@@ -11,7 +11,7 @@
 use crate::{pallet::Config, CommonCollectionOperations, CollectionHandle};
 
 // TODO: move to benchmarking
-/// Price of [`dispatch_call`] call with noop `call` argument
+/// Price of [`dispatch_tx`] call with noop `call` argument
 pub fn dispatch_weight<T: Config>() -> Weight {
 	// Read collection
 	<T as frame_system::Config>::DbWeight::get().reads(1)
@@ -21,7 +21,7 @@
 }
 
 /// Helper function to implement substrate calls for common collection methods
-pub fn dispatch_call<
+pub fn dispatch_tx<
 	T: Config,
 	C: FnOnce(&dyn CommonCollectionOperations<T>) -> DispatchResultWithPostInfo,
 >(
@@ -36,6 +36,15 @@
 			},
 			error,
 		})?;
+	handle
+		.check_is_internal()
+		.map_err(|error| DispatchErrorWithPostInfo {
+			post_info: PostDispatchInfo {
+				actual_weight: Some(dispatch_weight::<T>()),
+				pays_fee: Pays::Yes,
+			},
+			error,
+		})?;
 	let dispatched = T::CollectionDispatch::dispatch(handle);
 	let mut result = call(dispatched.as_dyn());
 	match &mut result {

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -22,7 +22,7 @@
 pub use pallet_evm::{PrecompileOutput, PrecompileResult, PrecompileHandle, account::CrossAccountId};
 use pallet_evm_coder_substrate::dispatch_to_evm;
 use sp_std::vec::Vec;
-use up_data_structs::{Property, SponsoringRateLimit};
+use up_data_structs::{Property, SponsoringRateLimit, NestingRule, OwnerRestrictedSet, AccessMode};
 use alloc::format;
 
 use crate::{Pallet, CollectionHandle, Config, CollectionProperties};
@@ -46,7 +46,10 @@
 }
 
 #[solidity_interface(name = "Collection")]
-impl<T: Config> CollectionHandle<T> {
+impl<T: Config> CollectionHandle<T>
+// where
+// 	T::AccountId: From<H256>
+{
 	fn set_collection_property(&mut self, caller: caller, key: string, value: bytes) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let key = <Vec<u8>>::from(key)
@@ -79,25 +82,27 @@
 		Ok(prop.to_vec())
 	}
 
-	fn eth_set_sponsor(&mut self, caller: caller, sponsor: address) -> Result<void> {
+	fn set_collection_sponsor(&mut self, caller: caller, sponsor: address) -> Result<void> {
 		check_is_owner(caller, self)?;
 
 		let sponsor = T::CrossAccountId::from_eth(sponsor);
-		self.set_sponsor(sponsor.as_sub().clone());
-		save(self);
-		Ok(())
+		self.set_sponsor(sponsor.as_sub().clone())
+			.map_err(dispatch_to_evm::<T>)?;
+		save(self)
 	}
 
-	fn eth_confirm_sponsorship(&mut self, caller: caller) -> Result<void> {
+	fn confirm_collection_sponsorship(&mut self, caller: caller) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		if !self.confirm_sponsorship(caller.as_sub()) {
+		if !self
+			.confirm_sponsorship(caller.as_sub())
+			.map_err(dispatch_to_evm::<T>)?
+		{
 			return Err(Error::Revert("Caller is not set as sponsor".into()));
 		}
-		save(self);
-		Ok(())
+		save(self)
 	}
 
-	#[solidity(rename_selector = "setLimit")]
+	#[solidity(rename_selector = "setCollectionLimit")]
 	fn set_int_limit(&mut self, caller: caller, limit: string, value: uint32) -> Result<void> {
 		check_is_owner(caller, self)?;
 		let mut limits = self.limits.clone();
@@ -130,11 +135,10 @@
 		}
 		self.limits = <Pallet<T>>::clamp_limits(self.mode.clone(), &self.limits, limits)
 			.map_err(dispatch_to_evm::<T>)?;
-		save(self);
-		Ok(())
+		save(self)
 	}
 
-	#[solidity(rename_selector = "setLimit")]
+	#[solidity(rename_selector = "setCollectionLimit")]
 	fn set_bool_limit(&mut self, caller: caller, limit: string, value: bool) -> Result<void> {
 		check_is_owner(caller, self)?;
 		let mut limits = self.limits.clone();
@@ -158,16 +162,140 @@
 		}
 		self.limits = <Pallet<T>>::clamp_limits(self.mode.clone(), &self.limits, limits)
 			.map_err(dispatch_to_evm::<T>)?;
-		save(self);
-		Ok(())
+		save(self)
 	}
 
 	fn contract_address(&self, _caller: caller) -> Result<address> {
 		Ok(crate::eth::collection_id_to_address(self.id))
 	}
+
+	// fn add_admin_substrate(&self, caller: caller, new_admin: uint256) -> Result<void> {
+	// 	let mut new_admin_h256 = H256::default();
+	// 	new_admin.to_little_endian(&mut new_admin_h256.0);
+	// 	let account_id = T::AccountId::from(new_admin_h256);
+	// 	let caller = T::CrossAccountId::from_eth(caller);
+	// 	let new_admin = T::CrossAccountId::from_sub(account_id);
+	// 	<Pallet<T>>::toggle_admin(&self, &caller, &new_admin, true)
+	// 		.map_err(dispatch_to_evm::<T>)?;
+	// 	Ok(())
+	// }
+
+	// fn remove_admin_substrate(&self, caller: caller, new_admin: uint256) -> Result<void> {
+	// 	let mut new_admin_h256 = H256::default();
+	// 	new_admin.to_little_endian(&mut new_admin_h256.0);
+	// 	let account_id = T::AccountId::from(new_admin_h256);
+	// 	let caller = T::CrossAccountId::from_eth(caller);
+	// 	let new_admin = T::CrossAccountId::from_sub(account_id);
+	// 	<Pallet<T>>::toggle_admin(&self, &caller, &new_admin, false)
+	// 		.map_err(dispatch_to_evm::<T>)?;
+	// 	Ok(())
+	// }
+
+	fn add_collection_admin(&self, caller: caller, new_admin: address) -> Result<void> {
+		let caller = T::CrossAccountId::from_eth(caller);
+		self.check_is_owner_or_admin(&caller)
+			.map_err(dispatch_to_evm::<T>)?;
+		let new_admin = T::CrossAccountId::from_eth(new_admin);
+		<Pallet<T>>::toggle_admin(&self, &caller, &new_admin, true)
+			.map_err(dispatch_to_evm::<T>)?;
+		Ok(())
+	}
+
+	fn remove_collection_admin(&self, caller: caller, admin: address) -> Result<void> {
+		let caller = T::CrossAccountId::from_eth(caller);
+		self.check_is_owner_or_admin(&caller)
+			.map_err(dispatch_to_evm::<T>)?;
+		let admin = T::CrossAccountId::from_eth(admin);
+		<Pallet<T>>::toggle_admin(&self, &caller, &admin, false).map_err(dispatch_to_evm::<T>)?;
+		Ok(())
+	}
+
+	#[solidity(rename_selector = "setCollectionNesting")]
+	fn set_nesting_bool(&mut self, caller: caller, enable: bool) -> Result<void> {
+		let caller = T::CrossAccountId::from_eth(caller);
+		self.check_is_owner_or_admin(&caller)
+			.map_err(dispatch_to_evm::<T>)?;
+		self.collection.permissions.nesting = Some(match enable {
+			false => NestingRule::Disabled,
+			true => NestingRule::Owner,
+		});
+		save(self)?;
+		Ok(())
+	}
+
+	#[solidity(rename_selector = "setCollectionNesting")]
+	fn set_nesting(
+		&mut self,
+		caller: caller,
+		enable: bool,
+		collections: Vec<address>,
+	) -> Result<void> {
+		if collections.is_empty() {
+			return Err("No addresses provided".into());
+		}
+		if collections.len() >= OwnerRestrictedSet::bound() {
+			return Err(Error::Revert(format!(
+				"Out of bound: {} >= {}",
+				collections.len(),
+				OwnerRestrictedSet::bound()
+			)));
+		}
+		let caller = T::CrossAccountId::from_eth(caller);
+		self.check_is_owner_or_admin(&caller)
+			.map_err(dispatch_to_evm::<T>)?;
+		self.collection.permissions.nesting = Some(match enable {
+			false => NestingRule::Disabled,
+			true => {
+				let mut bv = OwnerRestrictedSet::new();
+				for i in collections {
+					bv.try_insert(crate::eth::map_eth_to_id(&i).ok_or(Error::Revert(
+						"Can't convert address into collection id".into(),
+					))?)
+					.map_err(|e| Error::Revert(format!("{:?}", e)))?;
+				}
+				NestingRule::OwnerRestricted(bv)
+			}
+		});
+		save(self)?;
+		Ok(())
+	}
+
+	fn set_collection_access(&mut self, caller: caller, mode: uint8) -> Result<void> {
+		let caller = T::CrossAccountId::from_eth(caller);
+		self.check_is_owner_or_admin(&caller)
+			.map_err(dispatch_to_evm::<T>)?;
+		self.collection.permissions.access = Some(match mode {
+			0 => AccessMode::Normal,
+			1 => AccessMode::AllowList,
+			_ => return Err("Not supported access mode".into()),
+		});
+		save(self)?;
+		Ok(())
+	}
+
+	fn add_to_collection_allow_list(&self, caller: caller, user: address) -> Result<void> {
+		let caller = check_is_owner_or_admin(caller, self)?;
+		let user = T::CrossAccountId::from_eth(user);
+		<Pallet<T>>::toggle_allowlist(self, &caller, &user, true).map_err(dispatch_to_evm::<T>)?;
+		Ok(())
+	}
+
+	fn remove_from_collection_allow_list(&self, caller: caller, user: address) -> Result<void> {
+		let caller = check_is_owner_or_admin(caller, self)?;
+		let user = T::CrossAccountId::from_eth(user);
+		<Pallet<T>>::toggle_allowlist(self, &caller, &user, false).map_err(dispatch_to_evm::<T>)?;
+		Ok(())
+	}
+
+	fn set_collection_mint_mode(&mut self, caller: caller, mode: bool) -> Result<void> {
+		check_is_owner_or_admin(caller, self)?;
+		self.collection.permissions.mint_mode = Some(mode);
+		save(self)?;
+		Ok(())
+	}
 }
 
-fn check_is_owner<T: Config>(caller: caller, collection: &CollectionHandle<T>) -> Result<()> {
+fn check_is_owner<T: Config>(caller: caller, collection: &CollectionHandle<T>) -> Result<void> {
 	let caller = T::CrossAccountId::from_eth(caller);
 	collection
 		.check_is_owner(&caller)
@@ -175,8 +303,24 @@
 	Ok(())
 }
 
-fn save<T: Config>(collection: &CollectionHandle<T>) {
+fn check_is_owner_or_admin<T: Config>(
+	caller: caller,
+	collection: &CollectionHandle<T>,
+) -> Result<T::CrossAccountId> {
+	let caller = T::CrossAccountId::from_eth(caller);
+	collection
+		.check_is_owner_or_admin(&caller)
+		.map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)?;
+	Ok(caller)
+}
+
+fn save<T: Config>(collection: &CollectionHandle<T>) -> Result<void> {
+	// TODO possibly delete for the lack of transaction
+	collection
+		.check_is_internal()
+		.map_err(dispatch_to_evm::<T>)?;
 	<crate::CollectionById<T>>::insert(collection.id, collection.collection.clone());
+	Ok(())
 }
 
 pub fn token_uri_key() -> up_data_structs::PropertyKey {

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -126,9 +126,11 @@
 	pub fn new(id: CollectionId) -> Option<Self> {
 		Self::new_with_gas_limit(id, u64::MAX)
 	}
+
 	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {
 		Ok(Self::new(id).ok_or(<Error<T>>::CollectionNotFound)?)
 	}
+
 	pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {
 		self.recorder
 			.consume_gas(T::GasWeightMapping::weight_to_gas(
@@ -137,6 +139,7 @@
 					.saturating_mul(reads),
 			))
 	}
+
 	pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {
 		self.recorder
 			.consume_gas(T::GasWeightMapping::weight_to_gas(
@@ -145,24 +148,46 @@
 					.saturating_mul(writes),
 			))
 	}
-	pub fn save(self) -> DispatchResult {
+	pub fn save(self) -> Result<(), DispatchError> {
 		<CollectionById<T>>::insert(self.id, self.collection);
 		Ok(())
 	}
 
-	pub fn set_sponsor(&mut self, sponsor: T::AccountId) {
+	pub fn set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {
 		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor);
+		Ok(())
 	}
 
-	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> bool {
+	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> Result<bool, DispatchError> {
 		if self.collection.sponsorship.pending_sponsor() != Some(sender) {
-			return false;
-		};
+			return Ok(false);
+		}
 
 		self.collection.sponsorship = SponsorshipState::Confirmed(sender.clone());
-		true
+		Ok(true)
+	}
+
+	/// Checks that the collection was created with, and must be operated upon through **Unique API**.
+	/// Now check only the `external_collection` flag and if it's **true**, then return `CollectionIsExternal` error.
+	pub fn check_is_internal(&self) -> DispatchResult {
+		if self.external_collection {
+			return Err(<Error<T>>::CollectionIsExternal)?;
+		}
+
+		Ok(())
 	}
+
+	/// Checks that the collection was created with, and must be operated upon through an **assimilated API**.
+	/// Now check only the `external_collection` flag and if it's **false**, then return `CollectionIsInternal` error.
+	pub fn check_is_external(&self) -> DispatchResult {
+		if !self.external_collection {
+			return Err(<Error<T>>::CollectionIsInternal)?;
+		}
+
+		Ok(())
+	}
 }
+
 impl<T: Config> Deref for CollectionHandle<T> {
 	type Target = Collection<T::AccountId>;
 
@@ -402,7 +427,7 @@
 		/// Target collection doesn't supports this operation
 		UnsupportedOperation,
 
-		/// Not sufficient founds to perform action
+		/// Not sufficient funds to perform action
 		NotSufficientFounds,
 
 		/// Collection has nesting disabled
@@ -429,6 +454,12 @@
 
 		/// Empty property keys are forbidden
 		EmptyPropertyKey,
+
+		/// Tried to access an external collection with an internal API
+		CollectionIsExternal,
+
+		/// Tried to access an internal collection with an external API
+		CollectionIsInternal,
 	}
 
 	#[pallet::storage]
@@ -664,6 +695,7 @@
 			sponsorship,
 			limits,
 			permissions,
+			external_collection,
 		} = <CollectionById<T>>::get(collection)?;
 
 		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)
@@ -693,6 +725,7 @@
 			permissions,
 			token_property_permissions,
 			properties,
+			read_only: external_collection,
 		})
 	}
 }
@@ -730,6 +763,7 @@
 	pub fn init_collection(
 		owner: T::CrossAccountId,
 		data: CreateCollectionData<T::AccountId>,
+		is_external: bool,
 	) -> Result<CollectionId, DispatchError> {
 		{
 			ensure!(
@@ -773,6 +807,7 @@
 					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)
 				})
 				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,
+			external_collection: is_external,
 		};
 
 		let mut collection_properties = up_data_structs::CollectionProperties::get();
@@ -1097,7 +1132,7 @@
 		user: &T::CrossAccountId,
 		admin: bool,
 	) -> DispatchResult {
-		collection.check_is_owner_or_admin(sender)?;
+		collection.check_is_owner(sender)?;
 
 		let was_admin = <IsAdmin<T>>::get((collection.id, user));
 		if was_admin == admin {

--- a/pallets/fungible/src/lib.rs
+++ b/pallets/fungible/src/lib.rs
@@ -137,7 +137,7 @@
 		owner: T::CrossAccountId,
 		data: CreateCollectionData<T::AccountId>,
 	) -> Result<CollectionId, DispatchError> {
-		<PalletCommon<T>>::init_collection(owner, data)
+		<PalletCommon<T>>::init_collection(owner, data, false)
 	}
 	pub fn destroy_collection(
 		collection: FungibleHandle<T>,

--- a/pallets/nonfungible/src/benchmarking.rs
+++ b/pallets/nonfungible/src/benchmarking.rs
@@ -51,7 +51,7 @@
 	create_collection_raw(
 		owner,
 		CollectionMode::NFT,
-		<Pallet<T>>::init_collection,
+		|owner, data| <Pallet<T>>::init_collection(owner, data, true),
 		NonfungibleHandle::cast,
 	)
 }
@@ -99,7 +99,7 @@
 			sender: cross_from_sub(owner); burner: cross_sub;
 		};
 		let item = create_max_item(&collection, &sender, burner.clone())?;
-	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)}
+	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?}
 
 	burn_recursively_breadth_plus_self_plus_self_per_each_raw {
 		let b in 0..200;
@@ -111,7 +111,7 @@
 		for i in 0..b {
 			create_max_item(&collection, &sender, T::CrossTokenAddressMapping::token_to_address(collection.id, item))?;
 		}
-	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)}
+	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?}
 
 	transfer {
 		bench_init!{
@@ -183,7 +183,7 @@
 			value: property_value(),
 		}).collect::<Vec<_>>();
 		let item = create_max_item(&collection, &owner, owner.clone())?;
-	}: {<Pallet<T>>::set_token_properties(&collection, &owner, item, props)?}
+	}: {<Pallet<T>>::set_token_properties(&collection, &owner, item, props, false)?}
 
 	delete_token_properties {
 		let b in 0..MAX_PROPERTIES_PER_ITEM;
@@ -205,7 +205,7 @@
 			value: property_value(),
 		}).collect::<Vec<_>>();
 		let item = create_max_item(&collection, &owner, owner.clone())?;
-		<Pallet<T>>::set_token_properties(&collection, &owner, item, props)?;
+		<Pallet<T>>::set_token_properties(&collection, &owner, item, props, false)?;
 		let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();
 	}: {<Pallet<T>>::delete_token_properties(&collection, &owner, item, to_delete)?}
 }

--- a/pallets/nonfungible/src/common.rs
+++ b/pallets/nonfungible/src/common.rs
@@ -223,7 +223,7 @@
 		let weight = <CommonWeights<T>>::set_token_properties(properties.len() as u32);
 
 		with_weight(
-			<Pallet<T>>::set_token_properties(self, &sender, token_id, properties),
+			<Pallet<T>>::set_token_properties(self, &sender, token_id, properties, false),
 			weight,
 		)
 	}

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -82,8 +82,14 @@
 			.map_err(|_| "key too long")?;
 		let value = value.try_into().map_err(|_| "value too long")?;
 
-		<Pallet<T>>::set_token_property(self, &caller, TokenId(token_id), Property { key, value })
-			.map_err(dispatch_to_evm::<T>)
+		<Pallet<T>>::set_token_property(
+			self,
+			&caller,
+			TokenId(token_id),
+			Property { key, value },
+			false,
+		)
+		.map_err(dispatch_to_evm::<T>)
 	}
 
 	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {

--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -304,8 +304,9 @@
 	pub fn init_collection(
 		owner: T::CrossAccountId,
 		data: CreateCollectionData<T::AccountId>,
+		is_external: bool,
 	) -> Result<CollectionId, DispatchError> {
-		<PalletCommon<T>>::init_collection(owner, data)
+		<PalletCommon<T>>::init_collection(owner, data, is_external)
 	}
 	pub fn destroy_collection(
 		collection: NonfungibleHandle<T>,
@@ -447,8 +448,15 @@
 		sender: &T::CrossAccountId,
 		token_id: TokenId,
 		property: Property,
+		is_token_create: bool,
 	) -> DispatchResult {
-		Self::check_token_change_permission(collection, sender, token_id, &property.key)?;
+		Self::check_token_change_permission(
+			collection,
+			sender,
+			token_id,
+			&property.key,
+			is_token_create,
+		)?;
 
 		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {
 			let property = property.clone();
@@ -471,9 +479,10 @@
 		sender: &T::CrossAccountId,
 		token_id: TokenId,
 		properties: Vec<Property>,
+		is_token_create: bool,
 	) -> DispatchResult {
 		for property in properties {
-			Self::set_token_property(collection, sender, token_id, property)?;
+			Self::set_token_property(collection, sender, token_id, property, is_token_create)?;
 		}
 
 		Ok(())
@@ -485,7 +494,7 @@
 		token_id: TokenId,
 		property_key: PropertyKey,
 	) -> DispatchResult {
-		Self::check_token_change_permission(collection, sender, token_id, &property_key)?;
+		Self::check_token_change_permission(collection, sender, token_id, &property_key, false)?;
 
 		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {
 			properties.remove(&property_key)
@@ -506,6 +515,7 @@
 		sender: &T::CrossAccountId,
 		token_id: TokenId,
 		property_key: &PropertyKey,
+		is_token_create: bool,
 	) -> DispatchResult {
 		let permission = <PalletCommon<T>>::property_permissions(collection.id)
 			.get(property_key)
@@ -534,6 +544,11 @@
 				token_owner,
 				..
 			} => {
+				//TODO: investigate threats during public minting.
+				if is_token_create && (collection_admin || token_owner) {
+					return Ok(());
+				}
+
 				let mut check_result = Err(<CommonError<T>>::NoPermission.into());
 
 				if collection_admin {
@@ -772,6 +787,7 @@
 					sender,
 					TokenId(token),
 					data.properties.clone().into_inner(),
+					true,
 				) {
 					return TransactionOutcome::Rollback(Err(e));
 				}
@@ -889,6 +905,7 @@
 		if let Some(spender) = spender {
 			<PalletCommon<T>>::ensure_correct_receiver(spender)?;
 		}
+
 		let token_data =
 			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;
 		if &token_data.owner != sender {

binary blob — no preview

--- a/pallets/nonfungible/src/stubs/UniqueNFT.sol
+++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol
@@ -297,40 +297,7 @@
 	}
 }
 
-// Selector: 780e9d63
-contract ERC721Enumerable is Dummy, ERC165 {
-	// Selector: tokenByIndex(uint256) 4f6ccce7
-	function tokenByIndex(uint256 index) public view returns (uint256) {
-		require(false, stub_error);
-		index;
-		dummy;
-		return 0;
-	}
-
-	// Not implemented
-	//
-	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
-	function tokenOfOwnerByIndex(address owner, uint256 index)
-		public
-		view
-		returns (uint256)
-	{
-		require(false, stub_error);
-		owner;
-		index;
-		dummy;
-		return 0;
-	}
-
-	// Selector: totalSupply() 18160ddd
-	function totalSupply() public view returns (uint256) {
-		require(false, stub_error);
-		dummy;
-		return 0;
-	}
-}
-
-// Selector: c894dc35
+// Selector: 6aea9834
 contract Collection is Dummy, ERC165 {
 	// Selector: setCollectionProperty(string,bytes) 2f073f66
 	function setCollectionProperty(string memory key, bytes memory value)
@@ -363,29 +330,29 @@
 		return hex"";
 	}
 
-	// Selector: ethSetSponsor(address) 8f9af356
-	function ethSetSponsor(address sponsor) public {
+	// Selector: setCollectionSponsor(address) 7623402e
+	function setCollectionSponsor(address sponsor) public {
 		require(false, stub_error);
 		sponsor;
 		dummy = 0;
 	}
 
-	// Selector: ethConfirmSponsorship() a8580d1a
-	function ethConfirmSponsorship() public {
+	// Selector: confirmCollectionSponsorship() 3c50e97a
+	function confirmCollectionSponsorship() public {
 		require(false, stub_error);
 		dummy = 0;
 	}
 
-	// Selector: setLimit(string,uint32) 68db30ca
-	function setLimit(string memory limit, uint32 value) public {
+	// Selector: setCollectionLimit(string,uint32) 6a3841db
+	function setCollectionLimit(string memory limit, uint32 value) public {
 		require(false, stub_error);
 		limit;
 		value;
 		dummy = 0;
 	}
 
-	// Selector: setLimit(string,bool) ea67e4c2
-	function setLimit(string memory limit, bool value) public {
+	// Selector: setCollectionLimit(string,bool) 993b7fba
+	function setCollectionLimit(string memory limit, bool value) public {
 		require(false, stub_error);
 		limit;
 		value;
@@ -398,6 +365,98 @@
 		dummy;
 		return 0x0000000000000000000000000000000000000000;
 	}
+
+	// Selector: addCollectionAdmin(address) 92e462c7
+	function addCollectionAdmin(address newAdmin) public view {
+		require(false, stub_error);
+		newAdmin;
+		dummy;
+	}
+
+	// Selector: removeCollectionAdmin(address) fafd7b42
+	function removeCollectionAdmin(address admin) public view {
+		require(false, stub_error);
+		admin;
+		dummy;
+	}
+
+	// Selector: setCollectionNesting(bool) 112d4586
+	function setCollectionNesting(bool enable) public {
+		require(false, stub_error);
+		enable;
+		dummy = 0;
+	}
+
+	// Selector: setCollectionNesting(bool,address[]) 64872396
+	function setCollectionNesting(bool enable, address[] memory collections)
+		public
+	{
+		require(false, stub_error);
+		enable;
+		collections;
+		dummy = 0;
+	}
+
+	// Selector: setCollectionAccess(uint8) 41835d4c
+	function setCollectionAccess(uint8 mode) public {
+		require(false, stub_error);
+		mode;
+		dummy = 0;
+	}
+
+	// Selector: addToCollectionAllowList(address) 67844fe6
+	function addToCollectionAllowList(address user) public view {
+		require(false, stub_error);
+		user;
+		dummy;
+	}
+
+	// Selector: removeFromCollectionAllowList(address) 85c51acb
+	function removeFromCollectionAllowList(address user) public view {
+		require(false, stub_error);
+		user;
+		dummy;
+	}
+
+	// Selector: setCollectionMintMode(bool) 00018e84
+	function setCollectionMintMode(bool mode) public {
+		require(false, stub_error);
+		mode;
+		dummy = 0;
+	}
+}
+
+// Selector: 780e9d63
+contract ERC721Enumerable is Dummy, ERC165 {
+	// Selector: tokenByIndex(uint256) 4f6ccce7
+	function tokenByIndex(uint256 index) public view returns (uint256) {
+		require(false, stub_error);
+		index;
+		dummy;
+		return 0;
+	}
+
+	// Not implemented
+	//
+	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
+	function tokenOfOwnerByIndex(address owner, uint256 index)
+		public
+		view
+		returns (uint256)
+	{
+		require(false, stub_error);
+		owner;
+		index;
+		dummy;
+		return 0;
+	}
+
+	// Selector: totalSupply() 18160ddd
+	function totalSupply() public view returns (uint256) {
+		require(false, stub_error);
+		dummy;
+		return 0;
+	}
 }
 
 // Selector: d74d154f

--- a/pallets/proxy-rmrk-core/Cargo.toml
+++ b/pallets/proxy-rmrk-core/Cargo.toml
@@ -18,10 +18,13 @@
 sp-core = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.22" }
 pallet-common = { default-features = false, path = '../common' }
 pallet-nonfungible = { default-features = false, path = "../../pallets/nonfungible" }
+pallet-structure = { default-features = false, path = "../../pallets/structure" }
 up-data-structs = { default-features = false, path = '../../primitives/data-structs' }
 pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.22" }
 frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.22" }
+rmrk-traits = { default-features = false, path = "../../primitives/rmrk-traits" }
 scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
+derivative = { version = "2.2.0", features = ["use_core"] }
 
 [features]
 default = ["std"]
@@ -31,8 +34,10 @@
     "sp-runtime/std",
     "sp-std/std",
     "up-data-structs/std",
+    "rmrk-traits/std",
     "pallet-common/std",
     "pallet-nonfungible/std",
+    "pallet-structure/std",
     "pallet-evm/std",
     'frame-benchmarking/std',
 ]

20use frame_system::{pallet_prelude::*, ensure_signed};20use frame_system::{pallet_prelude::*, ensure_signed};
21use sp_runtime::{DispatchError, Permill, traits::StaticLookup};21use sp_runtime::{DispatchError, Permill, traits::StaticLookup};
22use sp_std::vec::Vec;22use sp_std::vec::Vec;
23use up_data_structs::*;23use up_data_structs::{*, mapping::TokenAddressMapping};
24use pallet_common::{24use pallet_common::{
25	Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations,25	Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations,
26};26};
27use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData};27use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData};
28use pallet_structure::{Pallet as PalletStructure, Error as StructureError};
28use pallet_evm::account::CrossAccountId;29use pallet_evm::account::CrossAccountId;
29use core::convert::AsRef;30use core::convert::AsRef;
3031
31pub use pallet::*;32pub use pallet::*;
3233
34#[cfg(feature = "runtime-benchmarks")]
35pub mod benchmarking;
33pub mod misc;36pub mod misc;
34pub mod property;37pub mod property;
38pub mod weights;
3539
40pub type SelfWeightOf<T> = <T as Config>::WeightInfo;
41
42use weights::WeightInfo;
36use misc::*;43use misc::*;
37pub use property::*;44pub use property::*;
3845
39use RmrkProperty::*;46use RmrkProperty::*;
4047
48const NESTING_BUDGET: u32 = 5;
49
41#[frame_support::pallet]50#[frame_support::pallet]
42pub mod pallet {51pub mod pallet {
43	use super::*;52	use super::*;
48		frame_system::Config + pallet_common::Config + pallet_nonfungible::Config + account::Config57		frame_system::Config + pallet_common::Config + pallet_nonfungible::Config + account::Config
49	{58	{
50		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;59		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
60		type WeightInfo: WeightInfo;
51	}61	}
5262
53	#[pallet::storage]63	#[pallet::storage]
54	#[pallet::getter(fn collection_index)]64	#[pallet::getter(fn collection_index)]
55	pub type CollectionIndex<T: Config> = StorageValue<_, RmrkCollectionId, ValueQuery>;65	pub type CollectionIndex<T: Config> = StorageValue<_, RmrkCollectionId, ValueQuery>;
5666
67	#[pallet::storage]
68	pub type UniqueCollectionId<T: Config> =
69		StorageMap<_, Twox64Concat, RmrkCollectionId, CollectionId, ValueQuery>;
70
71	#[pallet::storage]
72	pub type RmrkInernalCollectionId<T: Config> =
73		StorageMap<_, Twox64Concat, CollectionId, RmrkCollectionId, ValueQuery>;
74
57	#[pallet::pallet]75	#[pallet::pallet]
58	#[pallet::generate_store(pub(super) trait Store)]76	#[pallet::generate_store(pub(super) trait Store)]
59	pub struct Pallet<T>(_);77	pub struct Pallet<T>(_);
87			owner: T::AccountId,105			owner: T::AccountId,
88			nft_id: RmrkNftId,106			nft_id: RmrkNftId,
89		},107		},
108		NFTSent {
109			sender: T::AccountId,
110			recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,
111			collection_id: RmrkCollectionId,
112			nft_id: RmrkNftId,
113			approval_required: bool,
114		},
115		NFTAccepted {
116			sender: T::AccountId,
117			recipient: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,
118			collection_id: RmrkCollectionId,
119			nft_id: RmrkNftId,
120		},
121		NFTRejected {
122			sender: T::AccountId,
123			collection_id: RmrkCollectionId,
124			nft_id: RmrkNftId,
125		},
90		PropertySet {126		PropertySet {
91			collection_id: RmrkCollectionId,127			collection_id: RmrkCollectionId,
92			maybe_nft_id: Option<RmrkNftId>,128			maybe_nft_id: Option<RmrkNftId>,
93			key: RmrkKeyString,129			key: RmrkKeyString,
94			value: RmrkValueString,130			value: RmrkValueString,
95		},131		},
132		ResourceAdded {
133			nft_id: RmrkNftId,
134			resource_id: RmrkResourceId,
135		},
136		ResourceRemoval {
137			nft_id: RmrkNftId,
138			resource_id: RmrkResourceId,
139		},
140		ResourceAccepted {
141			nft_id: RmrkNftId,
142			resource_id: RmrkResourceId,
143		},
144		ResourceRemovalAccepted {
145			nft_id: RmrkNftId,
146			resource_id: RmrkResourceId,
147		},
148		PrioritySet {
149			collection_id: RmrkCollectionId,
150			nft_id: RmrkNftId,
151		},
96	}152	}
97153
98	#[pallet::error]154	#[pallet::error]
109		NoAvailableNftId,165		NoAvailableNftId,
110		CollectionUnknown,166		CollectionUnknown,
111		NoPermission,167		NoPermission,
168		NonTransferable,
112		CollectionFullOrLocked,169		CollectionFullOrLocked,
170		ResourceDoesntExist,
171		CannotSendToDescendentOrSelf,
172		CannotAcceptNonOwnedNft,
173		CannotRejectNonOwnedNft,
174		ResourceNotPending,
113	}175	}
114176
115	#[pallet::call]177	#[pallet::call]
116	impl<T: Config> Pallet<T> {178	impl<T: Config> Pallet<T> {
117		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]179		/// Create a collection
118		#[transactional]180		#[transactional]
181		#[pallet::weight(<SelfWeightOf<T>>::create_collection())]
119		pub fn create_collection(182		pub fn create_collection(
120			origin: OriginFor<T>,183			origin: OriginFor<T>,
121			metadata: RmrkString,184			metadata: RmrkString,
136					.into_inner()199					.into_inner()
137					.try_into()200					.try_into()
138					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,201					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,
202				permissions: Some(CollectionPermissions {
203					nesting: Some(NestingRule::Owner),
204					..Default::default()
205				}),
139				..Default::default()206				..Default::default()
140			};207			};
141208
142			let collection_id_res =209			let unique_collection_id = Self::init_collection(
143				<PalletNft<T>>::init_collection(T::CrossAccountId::from_sub(sender.clone()), data);210				T::CrossAccountId::from_sub(sender.clone()),
144
145			if let Err(DispatchError::Arithmetic(_)) = &collection_id_res {211				data,
146				return Err(<Error<T>>::NoAvailableCollectionId.into());
147			}
148
149			let collection_id = collection_id_res?;
150
151			<PalletCommon<T>>::set_scoped_collection_properties(
152				collection_id,
153				PropertyScope::Rmrk,
154				[212				[
155					Self::rmrk_property(Metadata, &metadata)?,213					Self::rmrk_property(Metadata, &metadata)?,
156					Self::rmrk_property(CollectionType, &misc::CollectionType::Regular)?,214					Self::rmrk_property(CollectionType, &misc::CollectionType::Regular)?,
157				]215				]
158				.into_iter(),216				.into_iter(),
159			)?;217			)?;
218			let rmrk_collection_id = <CollectionIndex<T>>::get();
160219
220			<UniqueCollectionId<T>>::insert(rmrk_collection_id, unique_collection_id);
221			<RmrkInernalCollectionId<T>>::insert(unique_collection_id, rmrk_collection_id);
222
161			<CollectionIndex<T>>::mutate(|n| *n += 1);223			<CollectionIndex<T>>::mutate(|n| *n += 1);
162224
163			Self::deposit_event(Event::CollectionCreated {225			Self::deposit_event(Event::CollectionCreated {
164				issuer: sender,226				issuer: sender,
165				collection_id: collection_id.0,227				collection_id: rmrk_collection_id,
166			});228			});
167229
168			Ok(())230			Ok(())
169		}231		}
170232
233		/// destroy collection
171		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]234		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
172		#[transactional]235		#[transactional]
173		pub fn destroy_collection(236		pub fn destroy_collection(
177			let sender = ensure_signed(origin)?;240			let sender = ensure_signed(origin)?;
178			let cross_sender = T::CrossAccountId::from_sub(sender.clone());241			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
179242
180			let unique_collection_id = collection_id.into();
181
182			let collection = Self::get_typed_nft_collection(243			let collection = Self::get_typed_nft_collection(
183				unique_collection_id,244				Self::unique_collection_id(collection_id)?,
184				misc::CollectionType::Regular,245				misc::CollectionType::Regular,
185			)?;246			)?;
247			collection.check_is_external()?;
186248
187			ensure!(
188				collection.total_supply() == 0,
189				<Error<T>>::CollectionNotEmpty
190			);
191
192			<PalletNft<T>>::destroy_collection(collection, &cross_sender)249			<PalletNft<T>>::destroy_collection(collection, &cross_sender)
193				.map_err(Self::map_common_err_to_proxy)?;250				.map_err(Self::map_unique_err_to_proxy)?;
194251
195			Self::deposit_event(Event::CollectionDestroyed {252			Self::deposit_event(Event::CollectionDestroyed {
196				issuer: sender,253				issuer: sender,
200			Ok(())257			Ok(())
201		}258		}
202259
260		/// Change the issuer of a collection
261		///
262		/// Parameters:
263		/// - `origin`: sender of the transaction
264		/// - `collection_id`: collection id of the nft to change issuer of
265		/// - `new_issuer`: Collection's new issuer
203		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]266		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
204		#[transactional]267		#[transactional]
205		pub fn change_collection_issuer(268		pub fn change_collection_issuer(
209		) -> DispatchResult {272		) -> DispatchResult {
210			let sender = ensure_signed(origin)?;273			let sender = ensure_signed(origin)?;
211274
275			let collection = Self::get_nft_collection(Self::unique_collection_id(collection_id)?)?;
276			collection.check_is_external()?;
277
212			let new_issuer = T::Lookup::lookup(new_issuer)?;278			let new_issuer = T::Lookup::lookup(new_issuer)?;
213279
214			Self::change_collection_owner(280			Self::change_collection_owner(
215				collection_id.into(),281				Self::unique_collection_id(collection_id)?,
216				misc::CollectionType::Regular,282				misc::CollectionType::Regular,
217				sender.clone(),283				sender.clone(),
218				new_issuer.clone(),284				new_issuer.clone(),
227			Ok(())293			Ok(())
228		}294		}
229295
296		/// lock collection
230		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]297		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
231		#[transactional]298		#[transactional]
232		pub fn lock_collection(299		pub fn lock_collection(
237			let cross_sender = T::CrossAccountId::from_sub(sender.clone());304			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
238305
239			let collection = Self::get_typed_nft_collection(306			let collection = Self::get_typed_nft_collection(
240				collection_id.into(),307				Self::unique_collection_id(collection_id)?,
241				misc::CollectionType::Regular,308				misc::CollectionType::Regular,
242			)?;309			)?;
310			collection.check_is_external()?;
243311
244			Self::check_collection_owner(&collection, &cross_sender)?;312			Self::check_collection_owner(&collection, &cross_sender)?;
245313
257			Ok(())325			Ok(())
258		}326		}
259327
328		/// Mints an NFT in the specified collection
329		/// Sets metadata and the royalty attribute
330		///
331		/// Parameters:
332		/// - `collection_id`: The class of the asset to be minted.
333		/// - `nft_id`: The nft value of the asset to be minted.
334		/// - `recipient`: Receiver of the royalty
335		/// - `royalty`: Permillage reward from each trade for the Recipient
336		/// - `metadata`: Arbitrary data about an nft, e.g. IPFS hash
337		/// - `transferable`: Ability to transfer this NFT
260		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]338		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
261		#[transactional]339		#[transactional]
262		pub fn mint_nft(340		pub fn mint_nft(
266			recipient: Option<T::AccountId>,344			recipient: Option<T::AccountId>,
267			royalty_amount: Option<Permill>,345			royalty_amount: Option<Permill>,
268			metadata: RmrkString,346			metadata: RmrkString,
347			transferable: bool,
269		) -> DispatchResult {348		) -> DispatchResult {
270			let sender = ensure_signed(origin)?;349			let sender = ensure_signed(origin)?;
271			let sender = T::CrossAccountId::from_sub(sender);350			let sender = T::CrossAccountId::from_sub(sender);
272			let cross_owner = T::CrossAccountId::from_sub(owner.clone());351			let cross_owner = T::CrossAccountId::from_sub(owner.clone());
273352
274			let royalty_info = royalty_amount.map(|amount| rmrk::RoyaltyInfo {353			let collection = Self::get_typed_nft_collection(
354				Self::unique_collection_id(collection_id)?,
355				misc::CollectionType::Regular,
356			)?;
357			collection.check_is_external()?;
358
359			let royalty_info = royalty_amount.map(|amount| rmrk_traits::RoyaltyInfo {
275				recipient: recipient.unwrap_or_else(|| owner.clone()),360				recipient: recipient.unwrap_or_else(|| owner.clone()),
276				amount,361				amount,
277			});362			});
278363
279			let collection = Self::get_typed_nft_collection(
280				collection_id.into(),
281				misc::CollectionType::Regular,
282			)?;
283
284			let nft_id = Self::create_nft(364			let nft_id = Self::create_nft(
285				&sender,365				&sender,
286				&cross_owner,366				&cross_owner,
287				&collection,367				&collection,
288				NftType::Regular,
289				[368				[
369					Self::rmrk_property(TokenType, &NftType::Regular)?,
370					Self::rmrk_property(Transferable, &transferable)?,
371					Self::rmrk_property(PendingNftAccept, &false)?,
290					Self::rmrk_property(RoyaltyInfo, &royalty_info)?,372					Self::rmrk_property(RoyaltyInfo, &royalty_info)?,
291					Self::rmrk_property(Metadata, &metadata)?,373					Self::rmrk_property(Metadata, &metadata)?,
292					Self::rmrk_property(Equipped, &false)?,374					Self::rmrk_property(Equipped, &false)?,
293					Self::rmrk_property(ResourceCollection, &None::<CollectionId>)?,375					Self::rmrk_property(
376						ResourceCollection,
377						&Self::init_collection(
378							sender.clone(),
379							CreateCollectionData {
380								..Default::default()
381							},
382							[Self::rmrk_property(
383								CollectionType,
384								&misc::CollectionType::Resource,
385							)?]
386							.into_iter(),
387						)?,
388					)?, // todo possibly add limits to the collection if rmrk warrants them
294					Self::rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,389					Self::rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,
295				]390				]
296				.into_iter(),391				.into_iter(),
297			)392			)
298			.map_err(|err| match err {393			.map_err(|err| match err {
299				DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),394				DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),
300				err => Self::map_common_err_to_proxy(err),395				err => Self::map_unique_err_to_proxy(err),
301			})?;396			})?;
302397
303			Self::deposit_event(Event::NftMinted {398			Self::deposit_event(Event::NftMinted {
309			Ok(())404			Ok(())
310		}405		}
311406
407		/// burn nft
312		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]408		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
313		#[transactional]409		#[transactional]
314		pub fn burn_nft(410		pub fn burn_nft(
319			let sender = ensure_signed(origin)?;415			let sender = ensure_signed(origin)?;
320			let cross_sender = T::CrossAccountId::from_sub(sender.clone());416			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
321417
418			let collection = Self::get_typed_nft_collection(
419				Self::unique_collection_id(collection_id)?,
420				misc::CollectionType::Regular,
421			)?;
422			collection.check_is_external()?;
423
322			Self::destroy_nft(424			Self::destroy_nft(
323				cross_sender,425				cross_sender,
324				collection_id.into(),426				Self::unique_collection_id(collection_id)?,
325				misc::CollectionType::Regular,
326				nft_id.into(),427				nft_id.into(),
327			)?;428			)
429			.map_err(Self::map_unique_err_to_proxy)?;
328430
329			Self::deposit_event(Event::NFTBurned {431			Self::deposit_event(Event::NFTBurned {
330				owner: sender,432				owner: sender,
334			Ok(())436			Ok(())
335		}437		}
336438
439		/// Transfers a NFT from an Account or NFT A to another Account or NFT B
440		///
441		/// Parameters:
442		/// - `origin`: sender of the transaction
443		/// - `rmrk_collection_id`: collection id of the nft to be transferred
444		/// - `rmrk_nft_id`: nft id of the nft to be transferred
445		/// - `new_owner`: new owner of the nft which can be either an account or a NFT
337		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]446		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
338		#[transactional]447		#[transactional]
448		pub fn send(
449			origin: OriginFor<T>,
450			rmrk_collection_id: RmrkCollectionId,
451			rmrk_nft_id: RmrkNftId,
452			new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,
453		) -> DispatchResult {
454			let sender = ensure_signed(origin.clone())?;
455			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
456
457			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
458			let nft_id = rmrk_nft_id.into();
459
460			let collection =
461				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
462			collection.check_is_external()?;
463
464			let token_data =
465				<TokenData<T>>::get((collection_id, nft_id)).ok_or(<Error<T>>::NoAvailableNftId)?;
466
467			let from = token_data.owner;
468
469			ensure!(
470				Self::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Transferable)?,
471				<Error<T>>::NonTransferable
472			);
473
474			ensure!(
475				!Self::get_nft_property_decoded(
476					collection_id,
477					nft_id,
478					RmrkProperty::PendingNftAccept
479				)?,
480				<Error<T>>::NoPermission
481			);
482
483			let target_owner;
484			let approval_required;
485
486			match new_owner {
487				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {
488					target_owner = T::CrossAccountId::from_sub(account_id.clone());
489					approval_required = false;
490				}
491				RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(
492					target_collection_id,
493					target_nft_id,
494				) => {
495					let target_collection_id = Self::unique_collection_id(target_collection_id)?;
496
497					let target_nft_budget = budget::Value::new(NESTING_BUDGET);
498
499					let target_nft_owner = <PalletStructure<T>>::get_checked_topmost_owner(
500						target_collection_id,
501						target_nft_id.into(),
502						Some((collection_id, nft_id)),
503						&target_nft_budget,
504					)
505					.map_err(Self::map_unique_err_to_proxy)?;
506
507					approval_required = cross_sender != target_nft_owner;
508
509					if approval_required {
510						target_owner = target_nft_owner;
511
512						<PalletNft<T>>::set_scoped_token_property(
513							collection.id,
514							nft_id,
515							PropertyScope::Rmrk,
516							Self::rmrk_property(PendingNftAccept, &approval_required)?,
517						)?;
518					} else {
519						target_owner = T::CrossTokenAddressMapping::token_to_address(
520							target_collection_id,
521							target_nft_id.into(),
522						);
523					}
524				}
525			}
526
527			let src_nft_budget = budget::Value::new(NESTING_BUDGET);
528
529			<PalletNft<T>>::transfer_from(
530				&collection,
531				&cross_sender,
532				&from,
533				&target_owner,
534				nft_id,
535				&src_nft_budget,
536			)
537			.map_err(Self::map_unique_err_to_proxy)?;
538
539			Self::deposit_event(Event::NFTSent {
540				sender,
541				recipient: new_owner,
542				collection_id: rmrk_collection_id,
543				nft_id: rmrk_nft_id,
544				approval_required,
545			});
546
547			Ok(())
548		}
549
550		/// Accepts an NFT sent from another account to self or owned NFT
551		///
552		/// Parameters:
553		/// - `origin`: sender of the transaction
554		/// - `rmrk_collection_id`: collection id of the nft to be accepted
555		/// - `rmrk_nft_id`: nft id of the nft to be accepted
556		/// - `new_owner`: either origin's account ID or origin-owned NFT, whichever the NFT was
557		///   sent to
558		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
559		#[transactional]
560		pub fn accept_nft(
561			origin: OriginFor<T>,
562			rmrk_collection_id: RmrkCollectionId,
563			rmrk_nft_id: RmrkNftId,
564			new_owner: RmrkAccountIdOrCollectionNftTuple<T::AccountId>,
565		) -> DispatchResult {
566			let sender = ensure_signed(origin.clone())?;
567			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
568
569			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
570			let nft_id = rmrk_nft_id.into();
571
572			let collection =
573				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
574			collection.check_is_external()?;
575
576			let new_cross_owner = match new_owner {
577				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {
578					T::CrossAccountId::from_sub(account_id.clone())
579				}
580				RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(
581					target_collection_id,
582					target_nft_id,
583				) => {
584					let target_collection_id = Self::unique_collection_id(target_collection_id)?;
585
586					T::CrossTokenAddressMapping::token_to_address(
587						target_collection_id,
588						TokenId(target_nft_id),
589					)
590				}
591			};
592
593			let budget = budget::Value::new(NESTING_BUDGET);
594
595			<PalletNft<T>>::transfer(
596				&collection,
597				&cross_sender,
598				&new_cross_owner,
599				nft_id,
600				&budget,
601			)
602			.map_err(|err| {
603				if err == <CommonError<T>>::OnlyOwnerAllowedToNest.into() {
604					<Error<T>>::CannotAcceptNonOwnedNft.into()
605				} else {
606					Self::map_unique_err_to_proxy(err)
607				}
608			})?;
609
610			<PalletNft<T>>::set_scoped_token_property(
611				collection.id,
612				nft_id,
613				PropertyScope::Rmrk,
614				Self::rmrk_property(PendingNftAccept, &false)?,
615			)?;
616
617			Self::deposit_event(Event::NFTAccepted {
618				sender,
619				recipient: new_owner,
620				collection_id: rmrk_collection_id,
621				nft_id: rmrk_nft_id,
622			});
623
624			Ok(())
625		}
626
627		/// Rejects an NFT sent from another account to self or owned NFT
628		///
629		/// Parameters:
630		/// - `origin`: sender of the transaction
631		/// - `rmrk_collection_id`: collection id of the nft to be accepted
632		/// - `rmrk_nft_id`: nft id of the nft to be accepted
633		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
634		#[transactional]
635		pub fn reject_nft(
636			origin: OriginFor<T>,
637			rmrk_collection_id: RmrkCollectionId,
638			rmrk_nft_id: RmrkNftId,
639		) -> DispatchResult {
640			let sender = ensure_signed(origin)?;
641			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
642
643			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
644			let nft_id = rmrk_nft_id.into();
645
646			let collection =
647				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
648			collection.check_is_external()?;
649
650			Self::destroy_nft(cross_sender, collection_id, nft_id).map_err(|err| {
651				if err == <CommonError<T>>::NoPermission.into()
652					|| err == <CommonError<T>>::ApprovedValueTooLow.into()
653				{
654					<Error<T>>::CannotRejectNonOwnedNft.into()
655				} else {
656					Self::map_unique_err_to_proxy(err)
657				}
658			})?;
659
660			Self::deposit_event(Event::NFTRejected {
661				sender,
662				collection_id: rmrk_collection_id,
663				nft_id: rmrk_nft_id,
664			});
665
666			Ok(())
667		}
668
669		/// accept the addition of a new resource to an existing NFT
670		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
671		#[transactional]
672		pub fn accept_resource(
673			origin: OriginFor<T>,
674			rmrk_collection_id: RmrkCollectionId,
675			rmrk_nft_id: RmrkNftId,
676			rmrk_resource_id: RmrkResourceId,
677		) -> DispatchResult {
678			let sender = ensure_signed(origin)?;
679			let cross_sender = T::CrossAccountId::from_sub(sender);
680
681			let collection_id = Self::unique_collection_id(rmrk_collection_id)
682				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
683			let collection =
684				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
685			collection.check_is_external()?;
686
687			let nft_id = rmrk_nft_id.into();
688			let resource_id = rmrk_resource_id.into();
689
690			let budget = budget::Value::new(NESTING_BUDGET);
691
692			let nft_owner =
693				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)
694					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
695
696			let resource_collection_id: CollectionId =
697				Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)
698					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
699
700			let is_pending: bool = Self::get_nft_property_decoded(
701				resource_collection_id,
702				resource_id,
703				PendingResourceAccept,
704			)
705			.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
706
707			ensure!(is_pending, <Error<T>>::ResourceNotPending);
708
709			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);
710
711			<PalletNft<T>>::set_scoped_token_property(
712				resource_collection_id,
713				rmrk_resource_id.into(),
714				PropertyScope::Rmrk,
715				Self::rmrk_property(PendingResourceAccept, &false)?,
716			)?;
717
718			Self::deposit_event(Event::<T>::ResourceAccepted {
719				nft_id: rmrk_nft_id,
720				resource_id: rmrk_resource_id,
721			});
722
723			Ok(())
724		}
725
726		/// accept the removal of a resource of an existing NFT
727		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
728		#[transactional]
729		pub fn accept_resource_removal(
730			origin: OriginFor<T>,
731			rmrk_collection_id: RmrkCollectionId,
732			rmrk_nft_id: RmrkNftId,
733			rmrk_resource_id: RmrkResourceId,
734		) -> DispatchResult {
735			let sender = ensure_signed(origin)?;
736			let cross_sender = T::CrossAccountId::from_sub(sender);
737
738			let collection_id = Self::unique_collection_id(rmrk_collection_id)
739				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
740			let collection =
741				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
742			collection.check_is_external()?;
743
744			let nft_id = rmrk_nft_id.into();
745			let resource_id = rmrk_resource_id.into();
746
747			let budget = budget::Value::new(NESTING_BUDGET);
748
749			let nft_owner =
750				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)
751					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
752
753			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);
754
755			let resource_collection_id: CollectionId =
756				Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)
757					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
758
759			let is_pending: bool = Self::get_nft_property_decoded(
760				resource_collection_id,
761				resource_id,
762				PendingResourceRemoval,
763			)
764			.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
765
766			ensure!(is_pending, <Error<T>>::ResourceNotPending);
767
768			let resource_collection = Self::get_typed_nft_collection(
769				resource_collection_id,
770				misc::CollectionType::Resource,
771			)?;
772
773			<PalletNft<T>>::burn(&resource_collection, &cross_sender, rmrk_resource_id.into())
774				.map_err(Self::map_unique_err_to_proxy)?;
775
776			Self::deposit_event(Event::<T>::ResourceRemovalAccepted {
777				nft_id: rmrk_nft_id,
778				resource_id: rmrk_resource_id,
779			});
780
781			Ok(())
782		}
783
784		/// set a custom value on an NFT
785		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
786		#[transactional]
339		pub fn set_property(787		pub fn set_property(
340			origin: OriginFor<T>,788			origin: OriginFor<T>,
341			#[pallet::compact] rmrk_collection_id: RmrkCollectionId,789			#[pallet::compact] rmrk_collection_id: RmrkCollectionId,
346			let sender = ensure_signed(origin)?;794			let sender = ensure_signed(origin)?;
347			let sender = T::CrossAccountId::from_sub(sender);795			let sender = T::CrossAccountId::from_sub(sender);
348796
349			let collection_id: CollectionId = rmrk_collection_id.into();797			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
798			let collection =
799				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
800			collection.check_is_external()?;
350801
802			let budget = budget::Value::new(NESTING_BUDGET);
803
351			match maybe_nft_id {804			match maybe_nft_id {
352				Some(nft_id) => {805				Some(nft_id) => {
353					let token_id: TokenId = nft_id.into();806					let token_id: TokenId = nft_id.into();
354807
355					Self::ensure_nft_owner(collection_id, token_id, &sender)?;
356					Self::ensure_nft_type(collection_id, token_id, NftType::Regular)?;808					Self::ensure_nft_type(collection_id, token_id, NftType::Regular)?;
809					Self::ensure_nft_owner(collection_id, token_id, &sender, &budget)?;
357810
358					<PalletNft<T>>::set_scoped_token_property(811					<PalletNft<T>>::set_scoped_token_property(
359						collection_id,812						collection_id,
388			Ok(())841			Ok(())
389		}842		}
843
844		/// set a different order of resource priority
845		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
846		#[transactional]
847		pub fn set_priority(
848			origin: OriginFor<T>,
849			rmrk_collection_id: RmrkCollectionId,
850			rmrk_nft_id: RmrkNftId,
851			priorities: BoundedVec<RmrkResourceId, RmrkMaxPriorities>,
852		) -> DispatchResult {
853			let sender = ensure_signed(origin)?;
854			let sender = T::CrossAccountId::from_sub(sender);
855
856			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
857			let nft_id = rmrk_nft_id.into();
858
859			let collection =
860				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
861			collection.check_is_external()?;
862
863			let budget = budget::Value::new(NESTING_BUDGET);
864
865			Self::ensure_nft_type(collection_id, nft_id, NftType::Regular)?;
866			Self::ensure_nft_owner(collection_id, nft_id, &sender, &budget)?;
867
868			<PalletNft<T>>::set_scoped_token_property(
869				collection_id,
870				nft_id,
871				PropertyScope::Rmrk,
872				Self::rmrk_property(ResourcePriorities, &priorities.into_inner())?,
873			)?;
874
875			Self::deposit_event(Event::<T>::PrioritySet {
876				collection_id: rmrk_collection_id,
877				nft_id: rmrk_nft_id,
878			});
879
880			Ok(())
881		}
882
883		/// Create basic resource
884		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
885		#[transactional]
886		pub fn add_basic_resource(
887			origin: OriginFor<T>,
888			rmrk_collection_id: RmrkCollectionId,
889			nft_id: RmrkNftId,
890			resource: RmrkBasicResource,
891		) -> DispatchResult {
892			let sender = ensure_signed(origin.clone())?;
893
894			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
895			let collection =
896				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
897			collection.check_is_external()?;
898
899			let resource_id = Self::resource_add(
900				sender,
901				collection_id,
902				nft_id.into(),
903				[
904					Self::rmrk_property(TokenType, &NftType::Resource)?,
905					Self::rmrk_property(ResourceType, &misc::ResourceType::Basic)?,
906					Self::rmrk_property(Src, &resource.src)?,
907					Self::rmrk_property(Metadata, &resource.metadata)?,
908					Self::rmrk_property(License, &resource.license)?,
909					Self::rmrk_property(Thumb, &resource.thumb)?,
910				]
911				.into_iter(),
912			)?;
913
914			Self::deposit_event(Event::ResourceAdded {
915				nft_id,
916				resource_id,
917			});
918			Ok(())
919		}
920
921		/// Create composable resource
922		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
923		#[transactional]
924		pub fn add_composable_resource(
925			origin: OriginFor<T>,
926			rmrk_collection_id: RmrkCollectionId,
927			nft_id: RmrkNftId,
928			_resource_id: RmrkBoundedResource,
929			resource: RmrkComposableResource,
930		) -> DispatchResult {
931			let sender = ensure_signed(origin.clone())?;
932
933			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
934			let collection =
935				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
936			collection.check_is_external()?;
937
938			let resource_id = Self::resource_add(
939				sender,
940				collection_id,
941				nft_id.into(),
942				[
943					Self::rmrk_property(TokenType, &NftType::Resource)?,
944					Self::rmrk_property(ResourceType, &misc::ResourceType::Composable)?,
945					Self::rmrk_property(Parts, &resource.parts)?,
946					Self::rmrk_property(Base, &resource.base)?,
947					Self::rmrk_property(Src, &resource.src)?,
948					Self::rmrk_property(Metadata, &resource.metadata)?,
949					Self::rmrk_property(License, &resource.license)?,
950					Self::rmrk_property(Thumb, &resource.thumb)?,
951				]
952				.into_iter(),
953			)?;
954
955			Self::deposit_event(Event::ResourceAdded {
956				nft_id,
957				resource_id,
958			});
959			Ok(())
960		}
961
962		/// Create slot resource
963		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
964		#[transactional]
965		pub fn add_slot_resource(
966			origin: OriginFor<T>,
967			rmrk_collection_id: RmrkCollectionId,
968			nft_id: RmrkNftId,
969			resource: RmrkSlotResource,
970		) -> DispatchResult {
971			let sender = ensure_signed(origin.clone())?;
972
973			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
974			let collection =
975				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
976			collection.check_is_external()?;
977
978			let resource_id = Self::resource_add(
979				sender,
980				collection_id,
981				nft_id.into(),
982				[
983					Self::rmrk_property(TokenType, &NftType::Resource)?,
984					Self::rmrk_property(ResourceType, &misc::ResourceType::Slot)?,
985					Self::rmrk_property(Base, &resource.base)?,
986					Self::rmrk_property(Src, &resource.src)?,
987					Self::rmrk_property(Metadata, &resource.metadata)?,
988					Self::rmrk_property(Slot, &resource.slot)?,
989					Self::rmrk_property(License, &resource.license)?,
990					Self::rmrk_property(Thumb, &resource.thumb)?,
991				]
992				.into_iter(),
993			)?;
994
995			Self::deposit_event(Event::ResourceAdded {
996				nft_id,
997				resource_id,
998			});
999			Ok(())
1000		}
1001
1002		/// remove resource
1003		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
1004		#[transactional]
1005		pub fn remove_resource(
1006			origin: OriginFor<T>,
1007			rmrk_collection_id: RmrkCollectionId,
1008			nft_id: RmrkNftId,
1009			resource_id: RmrkResourceId,
1010		) -> DispatchResult {
1011			let sender = ensure_signed(origin.clone())?;
1012
1013			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
1014			let collection =
1015				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
1016			collection.check_is_external()?;
1017
1018			Self::resource_remove(sender, collection_id, nft_id.into(), resource_id.into())?;
1019
1020			Self::deposit_event(Event::ResourceRemoval {
1021				nft_id,
1022				resource_id,
1023			});
1024			Ok(())
1025		}
390	}1026	}
391}1027}
3921028
401		Ok(scoped_key)1037		Ok(scoped_key)
402	}1038	}
4031039
1040	// todo think about renaming these
404	pub fn rmrk_property<E: Encode>(1041	pub fn rmrk_property<E: Encode>(
405		rmrk_key: RmrkProperty,1042		rmrk_key: RmrkProperty,
406		value: &E,1043		value: &E,
417		Ok(property)1054		Ok(property)
418	}1055	}
4191056
1057	pub fn decode_property<D: Decode>(vec: PropertyValue) -> Result<D, DispatchError> {
1058		vec.decode()
1059			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong.into())
1060	}
1061
1062	pub fn rebind<L, S>(vec: &BoundedVec<u8, L>) -> Result<BoundedVec<u8, S>, DispatchError>
1063	where
1064		BoundedVec<u8, S>: TryFrom<Vec<u8>>,
1065	{
1066		vec.rebind()
1067			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong.into())
1068	}
1069
1070	fn init_collection(
1071		sender: T::CrossAccountId,
1072		data: CreateCollectionData<T::AccountId>,
1073		properties: impl Iterator<Item = Property>,
1074	) -> Result<CollectionId, DispatchError> {
1075		let collection_id = <PalletNft<T>>::init_collection(sender, data, true);
1076
1077		if let Err(DispatchError::Arithmetic(_)) = &collection_id {
1078			return Err(<Error<T>>::NoAvailableCollectionId.into());
1079		}
1080
1081		<PalletCommon<T>>::set_scoped_collection_properties(
1082			collection_id?,
1083			PropertyScope::Rmrk,
1084			properties,
1085		)?;
1086
1087		collection_id
1088	}
1089
420	pub fn create_nft(1090	pub fn create_nft(
421		sender: &T::CrossAccountId,1091		sender: &T::CrossAccountId,
422		owner: &T::CrossAccountId,1092		owner: &T::CrossAccountId,
423		collection: &NonfungibleHandle<T>,1093		collection: &NonfungibleHandle<T>,
424		nft_type: NftType,
425		properties: impl Iterator<Item = Property>,1094		properties: impl Iterator<Item = Property>,
426	) -> Result<TokenId, DispatchError> {1095	) -> Result<TokenId, DispatchError> {
427		todo!("store nft type");
428		let data = CreateNftExData {1096		let data = CreateNftExData {
429			properties: BoundedVec::default(),1097			properties: BoundedVec::default(),
430			owner: owner.clone(),1098			owner: owner.clone(),
431		};1099		};
4321100
433		let budget = budget::Value::new(2);1101		let budget = budget::Value::new(NESTING_BUDGET);
4341102
435		<PalletNft<T>>::create_item(collection, sender, data, &budget)?;1103		<PalletNft<T>>::create_item(collection, sender, data, &budget)?;
4361104
449	fn destroy_nft(1117	fn destroy_nft(
450		sender: T::CrossAccountId,1118		sender: T::CrossAccountId,
451		collection_id: CollectionId,1119		collection_id: CollectionId,
452		collection_type: misc::CollectionType,
453		token_id: TokenId,1120		token_id: TokenId,
454	) -> DispatchResult {1121	) -> DispatchResult {
455		let collection = Self::get_typed_nft_collection(collection_id, collection_type)?;1122		let collection =
1123			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
4561124
457		<PalletNft<T>>::burn(&collection, &sender, token_id)1125		let token_data =
458			.map_err(Self::map_common_err_to_proxy)?;1126			<TokenData<T>>::get((collection_id, token_id)).ok_or(<Error<T>>::NoAvailableNftId)?;
4591127
1128		let from = token_data.owner;
1129
1130		let budget = budget::Value::new(NESTING_BUDGET);
1131
1132		<PalletNft<T>>::burn_from(&collection, &sender, &from, token_id, &budget)
1133	}
1134
1135	fn resource_add(
1136		sender: T::AccountId,
1137		collection_id: CollectionId,
1138		token_id: TokenId,
1139		resource_properties: impl Iterator<Item = Property>,
1140	) -> Result<RmrkResourceId, DispatchError> {
1141		let collection =
1142			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
1143		ensure!(collection.owner == sender, Error::<T>::NoPermission);
1144
1145		let sender = T::CrossAccountId::from_sub(sender);
1146		let budget = budget::Value::new(NESTING_BUDGET);
1147
1148		let nft_owner = <PalletStructure<T>>::find_topmost_owner(collection_id, token_id, &budget)
1149			.map_err(Self::map_unique_err_to_proxy)?;
1150
1151		let pending = sender != nft_owner;
1152
1153		let resource_collection_id: CollectionId =
1154			Self::get_nft_property_decoded(collection_id, token_id, ResourceCollection)?;
1155		let resource_collection =
1156			Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?;
1157
1158		// todo probably add extra connections to bases, slots, etc., when RMRK starts to use them
1159
1160		let resource_id = Self::create_nft(
1161			&sender,
1162			&nft_owner,
1163			&resource_collection,
1164			resource_properties.chain(
1165				[
1166					Self::rmrk_property(PendingResourceAccept, &pending)?,
1167					Self::rmrk_property(PendingResourceRemoval, &false)?,
1168				]
1169				.into_iter(),
1170			),
1171		)
1172		.map_err(|err| match err {
1173			DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),
1174			err => Self::map_unique_err_to_proxy(err),
1175		})?;
1176
1177		Ok(resource_id.0)
1178	}
1179
1180	fn resource_remove(
1181		sender: T::AccountId,
1182		collection_id: CollectionId,
1183		nft_id: TokenId,
1184		resource_id: TokenId,
1185	) -> DispatchResult {
1186		let collection =
1187			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
1188		ensure!(collection.owner == sender, Error::<T>::NoPermission);
1189
1190		let resource_collection_id: CollectionId =
1191			Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)?;
1192		let resource_collection =
1193			Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?;
1194		ensure!(
1195			<PalletNft<T>>::token_exists(&resource_collection, resource_id),
1196			Error::<T>::ResourceDoesntExist
1197		);
1198
1199		let budget = up_data_structs::budget::Value::new(10);
1200		let topmost_owner =
1201			<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)?;
1202
1203		let sender = T::CrossAccountId::from_sub(sender);
1204		if topmost_owner == sender {
1205			<PalletNft<T>>::burn(&resource_collection, &sender, resource_id)
1206				.map_err(Self::map_unique_err_to_proxy)?;
1207		} else {
1208			<PalletNft<T>>::set_scoped_token_property(
1209				resource_collection_id,
1210				resource_id,
1211				PropertyScope::Rmrk,
1212				Self::rmrk_property(PendingResourceRemoval, &true)?,
1213			)?;
1214		}
1215
460		Ok(())1216		Ok(())
461	}1217	}
481	) -> DispatchResult {1237	) -> DispatchResult {
482		collection1238		collection
483			.check_is_owner(account)1239			.check_is_owner(account)
484			.map_err(Self::map_common_err_to_proxy)1240			.map_err(Self::map_unique_err_to_proxy)
485	}1241	}
4861242
487	pub fn last_collection_idx() -> RmrkCollectionId {1243	pub fn last_collection_idx() -> RmrkCollectionId {
488		<CollectionIndex<T>>::get()1244		<CollectionIndex<T>>::get()
489	}1245	}
4901246
1247	pub fn unique_collection_id(
1248		rmrk_collection_id: RmrkCollectionId,
1249	) -> Result<CollectionId, DispatchError> {
1250		<UniqueCollectionId<T>>::try_get(rmrk_collection_id)
1251			.map_err(|_| <Error<T>>::CollectionUnknown.into())
1252	}
1253
1254	pub fn rmrk_collection_id(
1255		unique_collection_id: CollectionId,
1256	) -> Result<RmrkCollectionId, DispatchError> {
1257		<RmrkInernalCollectionId<T>>::try_get(unique_collection_id)
1258			.map_err(|_| <Error<T>>::CollectionUnknown.into())
1259	}
1260
491	pub fn get_nft_collection(1261	pub fn get_nft_collection(
492		collection_id: CollectionId,1262		collection_id: CollectionId,
493	) -> Result<NonfungibleHandle<T>, DispatchError> {1263	) -> Result<NonfungibleHandle<T>, DispatchError> {
504		<CollectionHandle<T>>::try_get(collection_id).is_ok()1274		<CollectionHandle<T>>::try_get(collection_id).is_ok()
505	}1275	}
5061276
507	pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {
508		<TokenData<T>>::contains_key((collection_id, nft_id))
509	}
510
511	pub fn get_collection_property(1277	pub fn get_collection_property(
512		collection_id: CollectionId,1278		collection_id: CollectionId,
513		key: RmrkProperty,1279		key: RmrkProperty,
520		Ok(collection_property)1286		Ok(collection_property)
521	}1287	}
5221288
1289	pub fn get_collection_property_decoded<V: Decode>(
1290		collection_id: CollectionId,
1291		key: RmrkProperty,
1292	) -> Result<V, DispatchError> {
1293		Self::decode_property(Self::get_collection_property(collection_id, key)?)
1294	}
1295
523	pub fn get_collection_type(1296	pub fn get_collection_type(
524		collection_id: CollectionId,1297		collection_id: CollectionId,
525	) -> Result<misc::CollectionType, DispatchError> {1298	) -> Result<misc::CollectionType, DispatchError> {
526		let value = Self::get_collection_property(collection_id, CollectionType)?;1299		Self::get_collection_property_decoded(collection_id, CollectionType)
527
528		let mut value = value.as_slice();
529
530		misc::CollectionType::decode(&mut value)
531			.map_err(|_| <Error<T>>::CorruptedCollectionType.into())1300			.map_err(|_| <Error<T>>::CorruptedCollectionType.into())
532	}1301	}
5331302
544		Ok(())1313		Ok(())
545	}1314	}
5461315
1316	pub fn get_typed_nft_collection(
1317		collection_id: CollectionId,
1318		collection_type: misc::CollectionType,
1319	) -> Result<NonfungibleHandle<T>, DispatchError> {
1320		Self::ensure_collection_type(collection_id, collection_type)?;
1321
1322		Self::get_nft_collection(collection_id)
1323	}
1324
1325	pub fn get_typed_nft_collection_mapped(
1326		rmrk_collection_id: RmrkCollectionId,
1327		collection_type: misc::CollectionType,
1328	) -> Result<(NonfungibleHandle<T>, CollectionId), DispatchError> {
1329		let unique_collection_id = match collection_type {
1330			misc::CollectionType::Regular => Self::unique_collection_id(rmrk_collection_id)?,
1331			_ => rmrk_collection_id.into(),
1332		};
1333
1334		let collection = Self::get_typed_nft_collection(unique_collection_id, collection_type)?;
1335
1336		Ok((collection, unique_collection_id))
1337	}
1338
547	pub fn get_nft_property(1339	pub fn get_nft_property(
548		collection_id: CollectionId,1340		collection_id: CollectionId,
549		nft_id: TokenId,1341		nft_id: TokenId,
550		key: RmrkProperty,1342		key: RmrkProperty,
551	) -> Result<PropertyValue, DispatchError> {1343	) -> Result<PropertyValue, DispatchError> {
552		let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))1344		let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))
553			.get(&Self::rmrk_property_key(key)?)1345			.get(&Self::rmrk_property_key(key)?)
554			.ok_or(<Error<T>>::NoAvailableNftId)?1346			.ok_or(<Error<T>>::NoAvailableNftId)? // todo replace with better error?
555			.clone();1347			.clone();
5561348
557		Ok(nft_property)1349		Ok(nft_property)
558	}1350	}
5591351
1352	pub fn get_nft_property_decoded<V: Decode>(
1353		collection_id: CollectionId,
1354		nft_id: TokenId,
1355		key: RmrkProperty,
1356	) -> Result<V, DispatchError> {
1357		Self::decode_property(Self::get_nft_property(collection_id, nft_id, key)?)
1358	}
1359
1360	pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {
1361		<TokenData<T>>::contains_key((collection_id, nft_id))
1362	}
1363
560	pub fn get_nft_type(1364	pub fn get_nft_type(
561		_collection_id: CollectionId,1365		collection_id: CollectionId,
562		_token_id: TokenId,1366		token_id: TokenId,
563	) -> Result<NftType, DispatchError> {1367	) -> Result<NftType, DispatchError> {
564		todo!("should get it from properties?")1368		Self::get_nft_property_decoded(collection_id, token_id, TokenType)
1369			.map_err(|_| <Error<T>>::NoAvailableNftId.into())
565	}1370	}
5661371
567	pub fn ensure_nft_type(1372	pub fn ensure_nft_type(
579		collection_id: CollectionId,1384		collection_id: CollectionId,
580		token_id: TokenId,1385		token_id: TokenId,
581		possible_owner: &T::CrossAccountId,1386		possible_owner: &T::CrossAccountId,
1387		nesting_budget: &dyn budget::Budget,
582	) -> DispatchResult {1388	) -> DispatchResult {
583		let token_data =1389		let is_owned = <PalletStructure<T>>::check_indirectly_owned(
584			<TokenData<T>>::get((collection_id, token_id)).ok_or(<Error<T>>::NoAvailableNftId)?;1390			possible_owner.clone(),
1391			collection_id,
1392			token_id,
1393			None,
1394			nesting_budget,
1395		)
1396		.map_err(Self::map_unique_err_to_proxy)?;
5851397
586		ensure!(1398		ensure!(is_owned, <Error<T>>::NoPermission);
587			token_data.owner == *possible_owner,
588			<Error<T>>::NoPermission
589		);
5901399
591		Ok(())1400		Ok(())
592	}1401	}
610						let key: Key = key.try_into().ok()?;1419						let key: Key = key.try_into().ok()?;
6111420
612						let value = match token_id {1421						let value = match token_id {
613							Some(token_id) => Self::get_nft_property(1422							Some(token_id) => Self::get_nft_property_decoded(
614								collection_id,1423								collection_id,
615								token_id,1424								token_id,
616								UserProperty(key.as_ref()),1425								UserProperty(key.as_ref()),
617							),1426							),
618							None => Self::get_collection_property(1427							None => Self::get_collection_property_decoded(
619								collection_id,1428								collection_id,
620								UserProperty(key.as_ref()),1429								UserProperty(key.as_ref()),
621							),1430							),
622						}1431						}
623						.ok()?1432						.ok()?;
624						.decode_or_default();
6251433
626						Some(mapper(key, value))1434						Some(mapper(key, value))
627					})1435					})
658			let key = key.as_slice().strip_prefix(key_prefix.as_slice())?;1466			let key = key.as_slice().strip_prefix(key_prefix.as_slice())?;
6591467
660			let key: Key = key.to_vec().try_into().ok()?;1468			let key: Key = key.to_vec().try_into().ok()?;
661			let value: Value = value.decode_or_default();1469			let value: Value = value.decode().ok()?;
6621470
663			Some(mapper(key, value))1471			Some(mapper(key, value))
664		});1472		});
6651473
666		Ok(properties)1474		Ok(properties)
667	}
668
669	pub fn get_typed_nft_collection(
670		collection_id: CollectionId,
671		collection_type: misc::CollectionType,
672	) -> Result<NonfungibleHandle<T>, DispatchError> {
673		Self::ensure_collection_type(collection_id, collection_type)?;
674
675		Self::get_nft_collection(collection_id)
676	}1475	}
6771476
678	fn map_common_err_to_proxy(err: DispatchError) -> DispatchError {1477	fn map_unique_err_to_proxy(err: DispatchError) -> DispatchError {
679		map_common_err_to_proxy! {1478		map_unique_err_to_proxy! {
680			match err {1479			match err {
681				NoPermission => NoPermission,1480				CommonError::NoPermission => NoPermission,
682				CollectionTokenLimitExceeded => CollectionFullOrLocked,1481				CommonError::CollectionTokenLimitExceeded => CollectionFullOrLocked,
683				PublicMintingNotAllowed => NoPermission,1482				CommonError::PublicMintingNotAllowed => NoPermission,
684				TokenNotFound => NoAvailableNftId1483				CommonError::TokenNotFound => NoAvailableNftId,
1484				CommonError::ApprovedValueTooLow => NoPermission,
1485				CommonError::CantDestroyNotEmptyCollection => CollectionNotEmpty,
1486				StructureError::TokenNotFound => NoAvailableNftId,
1487				StructureError::OuroborosDetected => CannotSendToDescendentOrSelf,
685			}1488			}
686		}1489		}
687	}1490	}