git.delta.rocks / unique-network / refs/commits / 749341e77d24

--- a/Makefile
+++ b/Makefile
@@ -15,8 +15,9 @@
 NONFUNGIBLE_EVM_STUBS=./pallets/nonfungible/src/stubs
 NONFUNGIBLE_EVM_ABI=./tests/src/eth/nonFungibleAbi.json
 
-RENFUNGIBLE_EVM_ABI=./tests/src/eth/reFungibleAbi.json
-RENFUNGIBLE_TOKEN_EVM_ABI=./tests/src/eth/reFungibleTokenAbi.json
+REFUNGIBLE_EVM_STUBS=./pallets/refungible/src/stubs
+REFUNGIBLE_EVM_ABI=./tests/src/eth/reFungibleAbi.json
+REFUNGIBLE_TOKEN_EVM_ABI=./tests/src/eth/reFungibleTokenAbi.json
 
 CONTRACT_HELPERS_STUBS=./pallets/evm-contract-helpers/src/stubs/
 CONTRACT_HELPERS_ABI=./tests/src/eth/util/contractHelpersAbi.json
@@ -36,6 +37,10 @@
 UniqueNFT.sol:
 	PACKAGE=pallet-nonfungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh
 	PACKAGE=pallet-nonfungible NAME=erc::gen_impl OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh
+
+UniqueRefungible.sol:
+	PACKAGE=pallet-refungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh
+	PACKAGE=pallet-refungible NAME=erc::gen_impl OUTPUT=$(REFUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh
 	
 UniqueRefungible.sol:
 	PACKAGE=pallet-refungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh
@@ -61,9 +66,13 @@
 	INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw ./.maintain/scripts/compile_stub.sh
 	INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh
 
+UniqueRefungible: UniqueRefungible.sol
+	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungible.raw ./.maintain/scripts/compile_stub.sh
+	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh
+
 UniqueRefungibleToken: UniqueRefungibleToken.sol
 	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungibleToken.raw ./.maintain/scripts/compile_stub.sh
-	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(RENFUNGIBLE_TOKEN_EVM_ABI) ./.maintain/scripts/generate_abi.sh
+	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_TOKEN_EVM_ABI) ./.maintain/scripts/generate_abi.sh
 
 UniqueRefungible: UniqueRefungible.sol
 	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungible.raw ./.maintain/scripts/compile_stub.sh

1616
17extern crate alloc;17extern crate alloc;
18
19use alloc::string::ToString;
20use core::{
21	char::{REPLACEMENT_CHARACTER, decode_utf16},
22	convert::TryInto,
23};
18use evm_coder::{generate_stubgen, solidity_interface, types::*};24use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};
1925use frame_support::{BoundedBTreeMap, BoundedVec};
20use pallet_common::{CollectionHandle, erc::CollectionCall, erc::CommonEvmHandler};26use pallet_common::{
2127	CollectionHandle, CollectionPropertyPermissions,
28	erc::{
29		CommonEvmHandler, CollectionCall,
30		static_property::{key, value as property_value},
31	},
32};
22use pallet_evm::PrecompileHandle;33use pallet_evm::{account::CrossAccountId, PrecompileHandle};
23use pallet_evm_coder_substrate::call;34use pallet_evm_coder_substrate::{call, dispatch_to_evm};
35use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
36use sp_core::H160;
37use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};
38use up_data_structs::{
39	CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission,
40	PropertyPermission, TokenId,
41};
2442
25use crate::{Config, RefungibleHandle};43use crate::{
44	AccountBalance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,
45	TokenProperties, TokensMinted, weights::WeightInfo,
46};
47
48#[solidity_interface(name = "TokenProperties")]
49impl<T: Config> RefungibleHandle<T> {
50	fn set_token_property_permission(
51		&mut self,
52		caller: caller,
53		key: string,
54		is_mutable: bool,
55		collection_admin: bool,
56		token_owner: bool,
57	) -> Result<()> {
58		let caller = T::CrossAccountId::from_eth(caller);
59		<Pallet<T>>::set_token_property_permissions(
60			self,
61			&caller,
62			vec![PropertyKeyPermission {
63				key: <Vec<u8>>::from(key)
64					.try_into()
65					.map_err(|_| "too long key")?,
66				permission: PropertyPermission {
67					mutable: is_mutable,
68					collection_admin,
69					token_owner,
70				},
71			}],
72		)
73		.map_err(dispatch_to_evm::<T>)
74	}
75
76	fn set_property(
77		&mut self,
78		caller: caller,
79		token_id: uint256,
80		key: string,
81		value: bytes,
82	) -> Result<()> {
83		let caller = T::CrossAccountId::from_eth(caller);
84		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
85		let key = <Vec<u8>>::from(key)
86			.try_into()
87			.map_err(|_| "key too long")?;
88		let value = value.try_into().map_err(|_| "value too long")?;
89
90		let nesting_budget = self
91			.recorder
92			.weight_calls_budget(<StructureWeight<T>>::find_parent());
93
94		<Pallet<T>>::set_token_property(
95			self,
96			&caller,
97			TokenId(token_id),
98			Property { key, value },
99			&nesting_budget,
100		)
101		.map_err(dispatch_to_evm::<T>)
102	}
103
104	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {
105		let caller = T::CrossAccountId::from_eth(caller);
106		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
107		let key = <Vec<u8>>::from(key)
108			.try_into()
109			.map_err(|_| "key too long")?;
110
111		let nesting_budget = self
112			.recorder
113			.weight_calls_budget(<StructureWeight<T>>::find_parent());
114
115		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)
116			.map_err(dispatch_to_evm::<T>)
117	}
118
119	/// Throws error if key not found
120	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {
121		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
122		let key = <Vec<u8>>::from(key)
123			.try_into()
124			.map_err(|_| "key too long")?;
125
126		let props = <TokenProperties<T>>::get((self.id, token_id));
127		let prop = props.get(&key).ok_or("key not found")?;
128
129		Ok(prop.to_vec())
130	}
131}
132
133#[derive(ToLog)]
134pub enum ERC721Events {
135	Transfer {
136		#[indexed]
137		from: address,
138		#[indexed]
139		to: address,
140		#[indexed]
141		token_id: uint256,
142	},
143	/// @dev Not supported
144	Approval {
145		#[indexed]
146		owner: address,
147		#[indexed]
148		approved: address,
149		#[indexed]
150		token_id: uint256,
151	},
152	/// @dev Not supported
153	#[allow(dead_code)]
154	ApprovalForAll {
155		#[indexed]
156		owner: address,
157		#[indexed]
158		operator: address,
159		approved: bool,
160	},
161}
162
163#[derive(ToLog)]
164pub enum ERC721MintableEvents {
165	/// @dev Not supported
166	#[allow(dead_code)]
167	MintingFinished {},
168}
169
170#[solidity_interface(name = "ERC721Metadata")]
171impl<T: Config> RefungibleHandle<T> {
172	fn name(&self) -> Result<string> {
173		Ok(decode_utf16(self.name.iter().copied())
174			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
175			.collect::<string>())
176	}
177
178	fn symbol(&self) -> Result<string> {
179		Ok(string::from_utf8_lossy(&self.token_prefix).into())
180	}
181
182	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
183	///
184	/// @dev If the token has a `url` property and it is not empty, it is returned.
185	///  Else If the collection does not have a property with key `schemaName` or its value is not equal to `ERC721Metadata`, it return an error `tokenURI not set`.
186	///  If the collection property `baseURI` is empty or absent, return "" (empty string)
187	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix
188	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).
189	///
190	/// @return token's const_metadata
191	#[solidity(rename_selector = "tokenURI")]
192	fn token_uri(&self, token_id: uint256) -> Result<string> {
193		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
194
195		if let Ok(url) = get_token_property(self, token_id_u32, &key::url()) {
196			if !url.is_empty() {
197				return Ok(url);
198			}
199		} else if !is_erc721_metadata_compatible::<T>(self.id) {
200			return Err("tokenURI not set".into());
201		}
202
203		if let Some(base_uri) =
204			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())
205		{
206			if !base_uri.is_empty() {
207				let base_uri = string::from_utf8(base_uri.into_inner()).map_err(|e| {
208					Error::Revert(alloc::format!(
209						"Can not convert value \"baseURI\" to string with error \"{}\"",
210						e
211					))
212				})?;
213				if let Ok(suffix) = get_token_property(self, token_id_u32, &key::suffix()) {
214					if !suffix.is_empty() {
215						return Ok(base_uri + suffix.as_str());
216					}
217				}
218
219				return Ok(base_uri + token_id.to_string().as_str());
220			}
221		}
222
223		Ok("".into())
224	}
225}
226
227#[solidity_interface(name = "ERC721Enumerable")]
228impl<T: Config> RefungibleHandle<T> {
229	fn token_by_index(&self, index: uint256) -> Result<uint256> {
230		Ok(index)
231	}
232
233	/// Not implemented
234	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
235		// TODO: Not implemetable
236		Err("not implemented".into())
237	}
238
239	fn total_supply(&self) -> Result<uint256> {
240		self.consume_store_reads(1)?;
241		Ok(<Pallet<T>>::total_supply(self).into())
242	}
243}
244
245#[solidity_interface(name = "ERC721", events(ERC721Events))]
246impl<T: Config> RefungibleHandle<T> {
247	fn balance_of(&self, owner: address) -> Result<uint256> {
248		self.consume_store_reads(1)?;
249		let owner = T::CrossAccountId::from_eth(owner);
250		let balance = <AccountBalance<T>>::get((self.id, owner));
251		Ok(balance.into())
252	}
253
254	fn owner_of(&self, token_id: uint256) -> Result<address> {
255		self.consume_store_reads(2)?;
256		let token = token_id.try_into()?;
257		let owner = <Pallet<T>>::token_owner(self.id, token);
258		Ok(owner
259			.map(|address| *address.as_eth())
260			.unwrap_or_else(|| H160::default()))
261	}
262
263	/// @dev Not implemented
264	fn safe_transfer_from_with_data(
265		&mut self,
266		_from: address,
267		_to: address,
268		_token_id: uint256,
269		_data: bytes,
270		_value: value,
271	) -> Result<void> {
272		// TODO: Not implemetable
273		Err("not implemented".into())
274	}
275
276	/// @dev Not implemented
277	fn safe_transfer_from(
278		&mut self,
279		_from: address,
280		_to: address,
281		_token_id: uint256,
282		_value: value,
283	) -> Result<void> {
284		// TODO: Not implemetable
285		Err("not implemented".into())
286	}
287
288	/// @dev Not implemented
289	fn transfer_from(
290		&mut self,
291		_caller: caller,
292		_from: address,
293		_to: address,
294		_token_id: uint256,
295		_value: value,
296	) -> Result<void> {
297		Err("not implemented".into())
298	}
299
300	/// @dev Not implemented
301	fn approve(
302		&mut self,
303		_caller: caller,
304		_approved: address,
305		_token_id: uint256,
306		_value: value,
307	) -> Result<void> {
308		Err("not implemented".into())
309	}
310
311	/// @dev Not implemented
312	fn set_approval_for_all(
313		&mut self,
314		_caller: caller,
315		_operator: address,
316		_approved: bool,
317	) -> Result<void> {
318		// TODO: Not implemetable
319		Err("not implemented".into())
320	}
321
322	/// @dev Not implemented
323	fn get_approved(&self, _token_id: uint256) -> Result<address> {
324		// TODO: Not implemetable
325		Err("not implemented".into())
326	}
327
328	/// @dev Not implemented
329	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {
330		// TODO: Not implemetable
331		Err("not implemented".into())
332	}
333}
334
335#[solidity_interface(name = "ERC721Burnable")]
336impl<T: Config> RefungibleHandle<T> {
337	/// @dev Not implemented
338	fn burn(&mut self, _caller: caller, _token_id: uint256, _value: value) -> Result<void> {
339		Err("not implemented".into())
340	}
341}
342
343#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]
344impl<T: Config> RefungibleHandle<T> {
345	fn minting_finished(&self) -> Result<bool> {
346		Ok(false)
347	}
348
349	/// `token_id` should be obtained with `next_token_id` method,
350	/// unlike standard, you can't specify it manually
351	#[weight(<SelfWeightOf<T>>::create_item())]
352	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {
353		let caller = T::CrossAccountId::from_eth(caller);
354		let to = T::CrossAccountId::from_eth(to);
355		let token_id: u32 = token_id.try_into()?;
356		let budget = self
357			.recorder
358			.weight_calls_budget(<StructureWeight<T>>::find_parent());
359
360		if <TokensMinted<T>>::get(self.id)
361			.checked_add(1)
362			.ok_or("item id overflow")?
363			!= token_id
364		{
365			return Err("item id should be next".into());
366		}
367
368		let const_data = BoundedVec::default();
369		let users = [(to.clone(), 1)]
370			.into_iter()
371			.collect::<BTreeMap<_, _>>()
372			.try_into()
373			.unwrap();
374		<Pallet<T>>::create_item(
375			self,
376			&caller,
377			CreateItemData::<T> {
378				const_data,
379				users,
380				properties: CollectionPropertiesVec::default(),
381			},
382			&budget,
383		)
384		.map_err(dispatch_to_evm::<T>)?;
385
386		Ok(true)
387	}
388
389	/// `token_id` should be obtained with `next_token_id` method,
390	/// unlike standard, you can't specify it manually
391	#[solidity(rename_selector = "mintWithTokenURI")]
392	#[weight(<SelfWeightOf<T>>::create_item())]
393	fn mint_with_token_uri(
394		&mut self,
395		caller: caller,
396		to: address,
397		token_id: uint256,
398		token_uri: string,
399	) -> Result<bool> {
400		let key = key::url();
401		let permission = get_token_permission::<T>(self.id, &key)?;
402		if !permission.collection_admin {
403			return Err("Operation is not allowed".into());
404		}
405
406		let caller = T::CrossAccountId::from_eth(caller);
407		let to = T::CrossAccountId::from_eth(to);
408		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;
409		let budget = self
410			.recorder
411			.weight_calls_budget(<StructureWeight<T>>::find_parent());
412
413		if <TokensMinted<T>>::get(self.id)
414			.checked_add(1)
415			.ok_or("item id overflow")?
416			!= token_id
417		{
418			return Err("item id should be next".into());
419		}
420
421		let mut properties = CollectionPropertiesVec::default();
422		properties
423			.try_push(Property {
424				key,
425				value: token_uri
426					.into_bytes()
427					.try_into()
428					.map_err(|_| "token uri is too long")?,
429			})
430			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;
431
432		let const_data = BoundedVec::default();
433		let users = [(to.clone(), 1)]
434			.into_iter()
435			.collect::<BTreeMap<_, _>>()
436			.try_into()
437			.unwrap();
438		<Pallet<T>>::create_item(
439			self,
440			&caller,
441			CreateItemData::<T> {
442				const_data,
443				users,
444				properties,
445			},
446			&budget,
447		)
448		.map_err(dispatch_to_evm::<T>)?;
449		Ok(true)
450	}
451
452	/// @dev Not implemented
453	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {
454		Err("not implementable".into())
455	}
456}
457
458fn get_token_property<T: Config>(
459	collection: &CollectionHandle<T>,
460	token_id: u32,
461	key: &up_data_structs::PropertyKey,
462) -> Result<string> {
463	collection.consume_store_reads(1)?;
464	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))
465		.map_err(|_| Error::Revert("Token properties not found".into()))?;
466	if let Some(property) = properties.get(key) {
467		return Ok(string::from_utf8_lossy(property).into());
468	}
469
470	Err("Property tokenURI not found".into())
471}
472
473fn is_erc721_metadata_compatible<T: Config>(collection_id: CollectionId) -> bool {
474	if let Some(shema_name) =
475		pallet_common::Pallet::<T>::get_collection_property(collection_id, &key::schema_name())
476	{
477		let shema_name = shema_name.into_inner();
478		shema_name == property_value::ERC721_METADATA
479	} else {
480		false
481	}
482}
483
484fn get_token_permission<T: Config>(
485	collection_id: CollectionId,
486	key: &PropertyKey,
487) -> Result<PropertyPermission> {
488	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)
489		.map_err(|_| Error::Revert("No permissions for collection".into()))?;
490	let a = token_property_permissions
491		.get(key)
492		.map(Clone::clone)
493		.ok_or_else(|| {
494			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();
495			Error::Revert(alloc::format!("No permission for key {}", key))
496		})?;
497	Ok(a)
498}
499
500#[solidity_interface(name = "ERC721UniqueExtensions")]
501impl<T: Config> RefungibleHandle<T> {
502	/// @notice Returns next free RFT ID.
503	fn next_token_id(&self) -> Result<uint256> {
504		self.consume_store_reads(1)?;
505		Ok(<TokensMinted<T>>::get(self.id)
506			.checked_add(1)
507			.ok_or("item id overflow")?
508			.into())
509	}
510
511	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
512	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
513		let caller = T::CrossAccountId::from_eth(caller);
514		let to = T::CrossAccountId::from_eth(to);
515		let mut expected_index = <TokensMinted<T>>::get(self.id)
516			.checked_add(1)
517			.ok_or("item id overflow")?;
518		let budget = self
519			.recorder
520			.weight_calls_budget(<StructureWeight<T>>::find_parent());
521
522		let total_tokens = token_ids.len();
523		for id in token_ids.into_iter() {
524			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;
525			if id != expected_index {
526				return Err("item id should be next".into());
527			}
528			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
529		}
530		let const_data = BoundedVec::default();
531		let users = [(to.clone(), 1)]
532			.into_iter()
533			.collect::<BTreeMap<_, _>>()
534			.try_into()
535			.unwrap();
536		let create_item_data = CreateItemData::<T> {
537			const_data,
538			users,
539			properties: CollectionPropertiesVec::default(),
540		};
541		let data = (0..total_tokens)
542			.map(|_| create_item_data.clone())
543			.collect();
544
545		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)
546			.map_err(dispatch_to_evm::<T>)?;
547		Ok(true)
548	}
549
550	#[solidity(rename_selector = "mintBulkWithTokenURI")]
551	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]
552	fn mint_bulk_with_token_uri(
553		&mut self,
554		caller: caller,
555		to: address,
556		tokens: Vec<(uint256, string)>,
557	) -> Result<bool> {
558		let key = key::url();
559		let caller = T::CrossAccountId::from_eth(caller);
560		let to = T::CrossAccountId::from_eth(to);
561		let mut expected_index = <TokensMinted<T>>::get(self.id)
562			.checked_add(1)
563			.ok_or("item id overflow")?;
564		let budget = self
565			.recorder
566			.weight_calls_budget(<StructureWeight<T>>::find_parent());
567
568		let mut data = Vec::with_capacity(tokens.len());
569		let const_data = BoundedVec::default();
570		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]
571			.into_iter()
572			.collect::<BTreeMap<_, _>>()
573			.try_into()
574			.unwrap();
575		for (id, token_uri) in tokens {
576			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;
577			if id != expected_index {
578				return Err("item id should be next".into());
579			}
580			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
581
582			let mut properties = CollectionPropertiesVec::default();
583			properties
584				.try_push(Property {
585					key: key.clone(),
586					value: token_uri
587						.into_bytes()
588						.try_into()
589						.map_err(|_| "token uri is too long")?,
590				})
591				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;
592
593			let create_item_data = CreateItemData::<T> {
594				const_data: const_data.clone(),
595				users: users.clone(),
596				properties,
597			};
598			data.push(create_item_data);
599		}
600
601		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)
602			.map_err(dispatch_to_evm::<T>)?;
603		Ok(true)
604	}
605}
26606
27#[solidity_interface(607#[solidity_interface(
28	name = "UniqueRefungible",608	name = "UniqueRefungible",
29	is(via("CollectionHandle<T>", common_mut, Collection),)609	is(
610		ERC721,
611		ERC721Metadata,
612		ERC721Enumerable,
613		ERC721UniqueExtensions,
614		ERC721Mintable,
615		ERC721Burnable,
616		via("CollectionHandle<T>", common_mut, Collection),
617		TokenProperties,
618	)
30)]619)]
31impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> {}620impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> {}

--- a/pallets/refungible/src/lib.rs
+++ b/pallets/refungible/src/lib.rs
@@ -88,6 +88,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 use crate::erc_token::ERC20Events;
+use crate::erc::ERC721Events;
 
 use codec::{Encode, Decode, MaxEncodedLen};
 use core::ops::Deref;
@@ -96,7 +97,8 @@
 use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};
 use pallet_evm_coder_substrate::WithRecorder;
 use pallet_common::{
-	CommonCollectionOperations, Error as CommonError, Event as CommonEvent, Pallet as PalletCommon,
+	CommonCollectionOperations, Error as CommonError, Event as CommonEvent,
+	eth::collection_id_to_address, Pallet as PalletCommon,
 };
 use pallet_structure::Pallet as PalletStructure;
 use scale_info::TypeInfo;
@@ -117,6 +119,9 @@
 pub mod erc;
 pub mod erc_token;
 pub mod weights;
+
+pub type CreateItemData<T> =
+	CreateRefungibleExData<<T as pallet_evm::account::Config>::CrossAccountId>;
 pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;
 
 /// Token data, stored independently from other data used to describe it
@@ -779,6 +784,7 @@
 				token,
 			)),
 		);
+
 		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(
 			collection.id,
 			token,
@@ -797,7 +803,7 @@
 	pub fn create_multiple_items(
 		collection: &RefungibleHandle<T>,
 		sender: &T::CrossAccountId,
-		data: Vec<CreateRefungibleExData<T::CrossAccountId>>,
+		data: Vec<CreateItemData<T>>,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
 		if !collection.is_owner_or_admin(sender) {
@@ -942,6 +948,14 @@
 						TokenId(token_id),
 					)),
 				);
+				<PalletEvm<T>>::deposit_log(
+					ERC721Events::Transfer {
+						from: H160::default(),
+						to: *user.as_eth(),
+						token_id: token_id.into(),
+					}
+					.to_log(collection_id_to_address(collection.id)),
+				);
 				<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(
 					collection.id,
 					TokenId(token_id),
@@ -1120,7 +1134,7 @@
 	pub fn create_item(
 		collection: &RefungibleHandle<T>,
 		sender: &T::CrossAccountId,
-		data: CreateRefungibleExData<T::CrossAccountId>,
+		data: CreateItemData<T>,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
 		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)

--- a/pallets/refungible/src/stubs/UniqueRefungible.sol
+++ b/pallets/refungible/src/stubs/UniqueRefungible.sol
@@ -3,6 +3,12 @@
 
 pragma solidity >=0.8.0 <0.9.0;
 
+// Anonymous struct
+struct Tuple0 {
+	uint256 field_0;
+	string field_1;
+}
+
 // Common stubs holder
 contract Dummy {
 	uint8 dummy;
@@ -21,6 +27,351 @@
 	}
 }
 
+// Inline
+contract ERC721Events {
+	event Transfer(
+		address indexed from,
+		address indexed to,
+		uint256 indexed tokenId
+	);
+	event Approval(
+		address indexed owner,
+		address indexed approved,
+		uint256 indexed tokenId
+	);
+	event ApprovalForAll(
+		address indexed owner,
+		address indexed operator,
+		bool approved
+	);
+}
+
+// Inline
+contract ERC721MintableEvents {
+	event MintingFinished();
+}
+
+// Selector: 0784ee64
+contract ERC721UniqueExtensions is Dummy, ERC165 {
+	// @notice Returns next free RFT ID.
+	//
+	// Selector: nextTokenId() 75794a3c
+	function nextTokenId() public view returns (uint256) {
+		require(false, stub_error);
+		dummy;
+		return 0;
+	}
+
+	// Selector: mintBulk(address,uint256[]) 44a9945e
+	function mintBulk(address to, uint256[] memory tokenIds)
+		public
+		returns (bool)
+	{
+		require(false, stub_error);
+		to;
+		tokenIds;
+		dummy = 0;
+		return false;
+	}
+
+	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
+	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
+		public
+		returns (bool)
+	{
+		require(false, stub_error);
+		to;
+		tokens;
+		dummy = 0;
+		return false;
+	}
+}
+
+// Selector: 41369377
+contract TokenProperties is Dummy, ERC165 {
+	// Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa
+	function setTokenPropertyPermission(
+		string memory key,
+		bool isMutable,
+		bool collectionAdmin,
+		bool tokenOwner
+	) public {
+		require(false, stub_error);
+		key;
+		isMutable;
+		collectionAdmin;
+		tokenOwner;
+		dummy = 0;
+	}
+
+	// Selector: setProperty(uint256,string,bytes) 1752d67b
+	function setProperty(
+		uint256 tokenId,
+		string memory key,
+		bytes memory value
+	) public {
+		require(false, stub_error);
+		tokenId;
+		key;
+		value;
+		dummy = 0;
+	}
+
+	// Selector: deleteProperty(uint256,string) 066111d1
+	function deleteProperty(uint256 tokenId, string memory key) public {
+		require(false, stub_error);
+		tokenId;
+		key;
+		dummy = 0;
+	}
+
+	// Throws error if key not found
+	//
+	// Selector: property(uint256,string) 7228c327
+	function property(uint256 tokenId, string memory key)
+		public
+		view
+		returns (bytes memory)
+	{
+		require(false, stub_error);
+		tokenId;
+		key;
+		dummy;
+		return hex"";
+	}
+}
+
+// Selector: 42966c68
+contract ERC721Burnable is Dummy, ERC165 {
+	// @dev Not implemented
+	//
+	// Selector: burn(uint256) 42966c68
+	function burn(uint256 tokenId) public {
+		require(false, stub_error);
+		tokenId;
+		dummy = 0;
+	}
+}
+
+// Selector: 58800161
+contract ERC721 is Dummy, ERC165, ERC721Events {
+	// Selector: balanceOf(address) 70a08231
+	function balanceOf(address owner) public view returns (uint256) {
+		require(false, stub_error);
+		owner;
+		dummy;
+		return 0;
+	}
+
+	// Selector: ownerOf(uint256) 6352211e
+	function ownerOf(uint256 tokenId) public view returns (address) {
+		require(false, stub_error);
+		tokenId;
+		dummy;
+		return 0x0000000000000000000000000000000000000000;
+	}
+
+	// @dev Not implemented
+	//
+	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
+	function safeTransferFromWithData(
+		address from,
+		address to,
+		uint256 tokenId,
+		bytes memory data
+	) public {
+		require(false, stub_error);
+		from;
+		to;
+		tokenId;
+		data;
+		dummy = 0;
+	}
+
+	// @dev Not implemented
+	//
+	// Selector: safeTransferFrom(address,address,uint256) 42842e0e
+	function safeTransferFrom(
+		address from,
+		address to,
+		uint256 tokenId
+	) public {
+		require(false, stub_error);
+		from;
+		to;
+		tokenId;
+		dummy = 0;
+	}
+
+	// @dev Not implemented
+	//
+	// Selector: transferFrom(address,address,uint256) 23b872dd
+	function transferFrom(
+		address from,
+		address to,
+		uint256 tokenId
+	) public {
+		require(false, stub_error);
+		from;
+		to;
+		tokenId;
+		dummy = 0;
+	}
+
+	// @dev Not implemented
+	//
+	// Selector: approve(address,uint256) 095ea7b3
+	function approve(address approved, uint256 tokenId) public {
+		require(false, stub_error);
+		approved;
+		tokenId;
+		dummy = 0;
+	}
+
+	// @dev Not implemented
+	//
+	// Selector: setApprovalForAll(address,bool) a22cb465
+	function setApprovalForAll(address operator, bool approved) public {
+		require(false, stub_error);
+		operator;
+		approved;
+		dummy = 0;
+	}
+
+	// @dev Not implemented
+	//
+	// Selector: getApproved(uint256) 081812fc
+	function getApproved(uint256 tokenId) public view returns (address) {
+		require(false, stub_error);
+		tokenId;
+		dummy;
+		return 0x0000000000000000000000000000000000000000;
+	}
+
+	// @dev Not implemented
+	//
+	// Selector: isApprovedForAll(address,address) e985e9c5
+	function isApprovedForAll(address owner, address operator)
+		public
+		view
+		returns (address)
+	{
+		require(false, stub_error);
+		owner;
+		operator;
+		dummy;
+		return 0x0000000000000000000000000000000000000000;
+	}
+}
+
+// Selector: 5b5e139f
+contract ERC721Metadata is Dummy, ERC165 {
+	// Selector: name() 06fdde03
+	function name() public view returns (string memory) {
+		require(false, stub_error);
+		dummy;
+		return "";
+	}
+
+	// Selector: symbol() 95d89b41
+	function symbol() public view returns (string memory) {
+		require(false, stub_error);
+		dummy;
+		return "";
+	}
+
+	// Returns token's const_metadata
+	//
+	// Selector: tokenURI(uint256) c87b56dd
+	function tokenURI(uint256 tokenId) public view returns (string memory) {
+		require(false, stub_error);
+		tokenId;
+		dummy;
+		return "";
+	}
+}
+
+// Selector: 68ccfe89
+contract ERC721Mintable is Dummy, ERC165, ERC721MintableEvents {
+	// Selector: mintingFinished() 05d2035b
+	function mintingFinished() public view returns (bool) {
+		require(false, stub_error);
+		dummy;
+		return false;
+	}
+
+	// `token_id` should be obtained with `next_token_id` method,
+	// unlike standard, you can't specify it manually
+	//
+	// Selector: mint(address,uint256) 40c10f19
+	function mint(address to, uint256 tokenId) public returns (bool) {
+		require(false, stub_error);
+		to;
+		tokenId;
+		dummy = 0;
+		return false;
+	}
+
+	// `token_id` should be obtained with `next_token_id` method,
+	// unlike standard, you can't specify it manually
+	//
+	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
+	function mintWithTokenURI(
+		address to,
+		uint256 tokenId,
+		string memory tokenUri
+	) public returns (bool) {
+		require(false, stub_error);
+		to;
+		tokenId;
+		tokenUri;
+		dummy = 0;
+		return false;
+	}
+
+	// @dev Not implemented
+	//
+	// Selector: finishMinting() 7d64bcb4
+	function finishMinting() public returns (bool) {
+		require(false, stub_error);
+		dummy = 0;
+		return false;
+	}
+}
+
+// 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: 7d9262e6
 contract Collection is Dummy, ERC165 {
 	// Set collection property.
@@ -248,4 +599,15 @@
 	}
 }
 
-contract UniqueRefungible is Dummy, ERC165, Collection {}
+contract UniqueRefungible is
+	Dummy,
+	ERC165,
+	ERC721,
+	ERC721Metadata,
+	ERC721Enumerable,
+	ERC721UniqueExtensions,
+	ERC721Mintable,
+	ERC721Burnable,
+	Collection,
+	TokenProperties
+{}

--- a/tests/src/eth/api/UniqueRefungible.sol
+++ b/tests/src/eth/api/UniqueRefungible.sol
@@ -3,6 +3,12 @@
 
 pragma solidity >=0.8.0 <0.9.0;
 
+// Anonymous struct
+struct Tuple0 {
+	uint256 field_0;
+	string field_1;
+}
+
 // Common stubs holder
 interface Dummy {
 
@@ -12,6 +18,203 @@
 	function supportsInterface(bytes4 interfaceID) external view returns (bool);
 }
 
+// Inline
+interface ERC721Events {
+	event Transfer(
+		address indexed from,
+		address indexed to,
+		uint256 indexed tokenId
+	);
+	event Approval(
+		address indexed owner,
+		address indexed approved,
+		uint256 indexed tokenId
+	);
+	event ApprovalForAll(
+		address indexed owner,
+		address indexed operator,
+		bool approved
+	);
+}
+
+// Inline
+interface ERC721MintableEvents {
+	event MintingFinished();
+}
+
+// Selector: 0784ee64
+interface ERC721UniqueExtensions is Dummy, ERC165 {
+	// @notice Returns next free RFT ID.
+	//
+	// Selector: nextTokenId() 75794a3c
+	function nextTokenId() external view returns (uint256);
+
+	// Selector: mintBulk(address,uint256[]) 44a9945e
+	function mintBulk(address to, uint256[] memory tokenIds)
+		external
+		returns (bool);
+
+	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
+	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
+		external
+		returns (bool);
+}
+
+// Selector: 41369377
+interface TokenProperties is Dummy, ERC165 {
+	// Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa
+	function setTokenPropertyPermission(
+		string memory key,
+		bool isMutable,
+		bool collectionAdmin,
+		bool tokenOwner
+	) external;
+
+	// Selector: setProperty(uint256,string,bytes) 1752d67b
+	function setProperty(
+		uint256 tokenId,
+		string memory key,
+		bytes memory value
+	) external;
+
+	// Selector: deleteProperty(uint256,string) 066111d1
+	function deleteProperty(uint256 tokenId, string memory key) external;
+
+	// Throws error if key not found
+	//
+	// Selector: property(uint256,string) 7228c327
+	function property(uint256 tokenId, string memory key)
+		external
+		view
+		returns (bytes memory);
+}
+
+// Selector: 42966c68
+interface ERC721Burnable is Dummy, ERC165 {
+	// @dev Not implemented
+	//
+	// Selector: burn(uint256) 42966c68
+	function burn(uint256 tokenId) external;
+}
+
+// Selector: 58800161
+interface ERC721 is Dummy, ERC165, ERC721Events {
+	// Selector: balanceOf(address) 70a08231
+	function balanceOf(address owner) external view returns (uint256);
+
+	// Selector: ownerOf(uint256) 6352211e
+	function ownerOf(uint256 tokenId) external view returns (address);
+
+	// @dev Not implemented
+	//
+	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
+	function safeTransferFromWithData(
+		address from,
+		address to,
+		uint256 tokenId,
+		bytes memory data
+	) external;
+
+	// @dev Not implemented
+	//
+	// Selector: safeTransferFrom(address,address,uint256) 42842e0e
+	function safeTransferFrom(
+		address from,
+		address to,
+		uint256 tokenId
+	) external;
+
+	// @dev Not implemented
+	//
+	// Selector: transferFrom(address,address,uint256) 23b872dd
+	function transferFrom(
+		address from,
+		address to,
+		uint256 tokenId
+	) external;
+
+	// @dev Not implemented
+	//
+	// Selector: approve(address,uint256) 095ea7b3
+	function approve(address approved, uint256 tokenId) external;
+
+	// @dev Not implemented
+	//
+	// Selector: setApprovalForAll(address,bool) a22cb465
+	function setApprovalForAll(address operator, bool approved) external;
+
+	// @dev Not implemented
+	//
+	// Selector: getApproved(uint256) 081812fc
+	function getApproved(uint256 tokenId) external view returns (address);
+
+	// @dev Not implemented
+	//
+	// Selector: isApprovedForAll(address,address) e985e9c5
+	function isApprovedForAll(address owner, address operator)
+		external
+		view
+		returns (address);
+}
+
+// Selector: 5b5e139f
+interface ERC721Metadata is Dummy, ERC165 {
+	// Selector: name() 06fdde03
+	function name() external view returns (string memory);
+
+	// Selector: symbol() 95d89b41
+	function symbol() external view returns (string memory);
+
+	// Returns token's const_metadata
+	//
+	// Selector: tokenURI(uint256) c87b56dd
+	function tokenURI(uint256 tokenId) external view returns (string memory);
+}
+
+// Selector: 68ccfe89
+interface ERC721Mintable is Dummy, ERC165, ERC721MintableEvents {
+	// Selector: mintingFinished() 05d2035b
+	function mintingFinished() external view returns (bool);
+
+	// `token_id` should be obtained with `next_token_id` method,
+	// unlike standard, you can't specify it manually
+	//
+	// Selector: mint(address,uint256) 40c10f19
+	function mint(address to, uint256 tokenId) external returns (bool);
+
+	// `token_id` should be obtained with `next_token_id` method,
+	// unlike standard, you can't specify it manually
+	//
+	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
+	function mintWithTokenURI(
+		address to,
+		uint256 tokenId,
+		string memory tokenUri
+	) external returns (bool);
+
+	// @dev Not implemented
+	//
+	// Selector: finishMinting() 7d64bcb4
+	function finishMinting() external returns (bool);
+}
+
+// Selector: 780e9d63
+interface ERC721Enumerable is Dummy, ERC165 {
+	// Selector: tokenByIndex(uint256) 4f6ccce7
+	function tokenByIndex(uint256 index) external view returns (uint256);
+
+	// Not implemented
+	//
+	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
+	function tokenOfOwnerByIndex(address owner, uint256 index)
+		external
+		view
+		returns (uint256);
+
+	// Selector: totalSupply() 18160ddd
+	function totalSupply() external view returns (uint256);
+}
+
 // Selector: 7d9262e6
 interface Collection is Dummy, ERC165 {
 	// Set collection property.
@@ -160,4 +363,15 @@
 	function setCollectionMintMode(bool mode) external;
 }
 
-interface UniqueRefungible is Dummy, ERC165, Collection {}
+interface UniqueRefungible is
+	Dummy,
+	ERC165,
+	ERC721,
+	ERC721Metadata,
+	ERC721Enumerable,
+	ERC721UniqueExtensions,
+	ERC721Mintable,
+	ERC721Burnable,
+	Collection,
+	TokenProperties
+{}

--- a/tests/src/interfaces/augment-api-errors.ts
+++ b/tests/src/interfaces/augment-api-errors.ts
@@ -446,25 +446,83 @@
       [key: string]: AugmentedError<ApiType>;
     };
     rmrkCore: {
+      /**
+       * Not the target owner of the sent NFT.
+       **/
       CannotAcceptNonOwnedNft: AugmentedError<ApiType>;
+      /**
+       * Not the target owner of the sent NFT.
+       **/
       CannotRejectNonOwnedNft: AugmentedError<ApiType>;
+      /**
+       * NFT was not sent and is not pending.
+       **/
       CannotRejectNonPendingNft: AugmentedError<ApiType>;
+      /**
+       * If an NFT is sent to a descendant, that would form a nesting loop, an ouroboros.
+       * Sending to self is redundant.
+       **/
       CannotSendToDescendentOrSelf: AugmentedError<ApiType>;
+      /**
+       * Too many tokens created in the collection, no new ones are allowed.
+       **/
       CollectionFullOrLocked: AugmentedError<ApiType>;
+      /**
+       * Only destroying collections without tokens is allowed.
+       **/
       CollectionNotEmpty: AugmentedError<ApiType>;
+      /**
+       * Collection does not exist, has a wrong type, or does not map to a Unique ID.
+       **/
       CollectionUnknown: AugmentedError<ApiType>;
+      /**
+       * Property of the type of RMRK collection could not be read successfully.
+       **/
       CorruptedCollectionType: AugmentedError<ApiType>;
-      NftTypeEncodeError: AugmentedError<ApiType>;
+      /**
+       * Could not find an ID for a collection. It is likely there were too many collections created on the chain, causing an overflow.
+       **/
       NoAvailableCollectionId: AugmentedError<ApiType>;
+      /**
+       * 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: AugmentedError<ApiType>;
+      /**
+       * Could not find an ID for the resource. It is likely there were too many resources created on an NFT, causing an overflow.
+       **/
       NoAvailableResourceId: AugmentedError<ApiType>;
+      /**
+       * Token is marked as non-transferable, and thus cannot be transferred.
+       **/
       NonTransferable: AugmentedError<ApiType>;
+      /**
+       * No permission to perform action.
+       **/
       NoPermission: AugmentedError<ApiType>;
+      /**
+       * No such resource found.
+       **/
       ResourceDoesntExist: AugmentedError<ApiType>;
+      /**
+       * Resource is not pending for the operation.
+       **/
       ResourceNotPending: AugmentedError<ApiType>;
+      /**
+       * Could not find a property by the supplied key.
+       **/
       RmrkPropertyIsNotFound: AugmentedError<ApiType>;
+      /**
+       * Too many symbols supplied as the property key. The maximum is [256](up_data_structs::MAX_PROPERTY_KEY_LENGTH).
+       **/
       RmrkPropertyKeyIsTooLong: AugmentedError<ApiType>;
+      /**
+       * Too many bytes supplied as the property value. The maximum is [32768](up_data_structs::MAX_PROPERTY_VALUE_LENGTH).
+       **/
       RmrkPropertyValueIsTooLong: AugmentedError<ApiType>;
+      /**
+       * 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: AugmentedError<ApiType>;
       /**
        * Generic error
@@ -472,12 +530,33 @@
       [key: string]: AugmentedError<ApiType>;
     };
     rmrkEquip: {
+      /**
+       * Base collection linked to this ID does not exist.
+       **/
       BaseDoesntExist: AugmentedError<ApiType>;
+      /**
+       * No Theme named "default" is associated with the Base.
+       **/
       NeedsDefaultThemeFirst: AugmentedError<ApiType>;
+      /**
+       * 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: AugmentedError<ApiType>;
+      /**
+       * Could not find a suitable ID for a Part, likely too many Part tokens were created in the Base, causing an overflow
+       **/
       NoAvailablePartId: AugmentedError<ApiType>;
+      /**
+       * Cannot assign equippables to a fixed Part.
+       **/
       NoEquippableOnFixedPart: AugmentedError<ApiType>;
+      /**
+       * Part linked to this ID does not exist.
+       **/
       PartDoesntExist: AugmentedError<ApiType>;
+      /**
+       * No permission to perform action.
+       **/
       PermissionError: AugmentedError<ApiType>;
       /**
        * Generic error
@@ -508,15 +587,15 @@
     };
     structure: {
       /**
-       * While iterating over children, reached the breadth limit.
+       * While nesting, reached the breadth limit of nesting, exceeding the provided budget.
        **/
       BreadthLimit: AugmentedError<ApiType>;
       /**
-       * While searching for the owner, reached the depth limit.
+       * While nesting, reached the depth limit of nesting, exceeding the provided budget.
        **/
       DepthLimit: AugmentedError<ApiType>;
       /**
-       * While searching for the owner, encountered an already checked account, detecting a loop.
+       * While nesting, encountered an already checked account, detecting a loop.
        **/
       OuroborosDetected: AugmentedError<ApiType>;
       /**

--- a/tests/src/interfaces/augment-api-query.ts
+++ b/tests/src/interfaces/augment-api-query.ts
@@ -492,7 +492,13 @@
       [key: string]: QueryableStorageEntry<ApiType>;
     };
     rmrkCore: {
+      /**
+       * Latest yet-unused collection ID.
+       **/
       collectionIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Mapping from RMRK collection ID to Unique's.
+       **/
       uniqueCollectionId: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
       /**
        * Generic query
@@ -500,7 +506,13 @@
       [key: string]: QueryableStorageEntry<ApiType>;
     };
     rmrkEquip: {
+      /**
+       * Checkmark that a Base has a Theme NFT named "default".
+       **/
       baseHasDefaultTheme: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Map of a Base ID and a Part ID to an NFT in the Base collection serving as the Part.
+       **/
       inernalPartId: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
       /**
        * Generic query

--- a/tests/src/interfaces/augment-api-tx.ts
+++ b/tests/src/interfaces/augment-api-tx.ts
@@ -348,103 +348,259 @@
     };
     rmrkCore: {
       /**
-       * Accepts an NFT sent from another account to self or owned NFT
+       * 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.
        * 
-       * Parameters:
-       * - `origin`: sender of the transaction
-       * - `rmrk_collection_id`: collection id of the nft to be accepted
-       * - `rmrk_nft_id`: nft id of the nft to be accepted
-       * - `new_owner`: either origin's account ID or origin-owned NFT, whichever the NFT was
-       * sent to
+       * # Permissions:
+       * - Token-owner-to-be
+       * 
+       * # Arguments:
+       * - `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.
        **/
       acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;
       /**
-       * accept the addition of a new resource to an existing NFT
+       * 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:
+       * - `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.
        **/
       acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;
       /**
-       * accept the removal of a resource of an existing NFT
+       * 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:
+       * - `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.
        **/
       acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;
       /**
-       * Create basic resource
+       * 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:
+       * - `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.
        **/
       addBasicResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceBasicResource | { src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceBasicResource]>;
       /**
-       * Create composable resource
+       * 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:
+       * - `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.
        **/
       addComposableResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceComposableResource | { parts?: any; base?: any; src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceComposableResource]>;
       /**
-       * Create slot resource
+       * 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:
+       * - `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.
        **/
       addSlotResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceSlotResource | { base?: any; src?: any; metadata?: any; slot?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceSlotResource]>;
       /**
-       * burn nft
+       * 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:
+       * - `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.
        **/
       burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;
       /**
-       * Change the issuer of a collection
+       * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).
        * 
-       * Parameters:
-       * - `origin`: sender of the transaction
-       * - `collection_id`: collection id of the nft to change issuer of
-       * - `new_issuer`: Collection's new issuer
+       * # Permissions:
+       * * Collection issuer
+       * 
+       * # Arguments:
+       * - `collection_id`: RMRK collection ID to change the issuer of.
+       * - `new_issuer`: Collection's new issuer.
        **/
       changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;
       /**
-       * Create a collection
+       * Create a new collection of NFTs.
+       * 
+       * # Permissions:
+       * * Anyone - will be assigned as the issuer of the collection.
+       * 
+       * # Arguments:
+       * - `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.
        **/
       createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | object | string | Uint8Array, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;
       /**
-       * destroy collection
+       * Destroy a collection.
+       * 
+       * Only empty collections can be destroyed. If it has any tokens, they must be burned first.
+       * 
+       * # Permissions:
+       * * Collection issuer
+       * 
+       * # Arguments:
+       * - `collection_id`: RMRK ID of the collection to destroy.
        **/
       destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
       /**
-       * lock collection
+       * "Lock" the collection and prevent new token creation. Cannot be undone.
+       * 
+       * # Permissions:
+       * * Collection issuer
+       * 
+       * # Arguments:
+       * - `collection_id`: RMRK ID of the collection to lock.
        **/
       lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
       /**
-       * Mints an NFT in the specified collection
-       * Sets metadata and the royalty attribute
+       * Mint an NFT in a specified collection.
+       * 
+       * # Permissions:
+       * * Collection issuer
        * 
-       * Parameters:
-       * - `collection_id`: The class of the asset to be minted.
-       * - `nft_id`: The nft value of the asset to be minted.
-       * - `recipient`: Receiver of the royalty
-       * - `royalty`: Permillage reward from each trade for the Recipient
-       * - `metadata`: Arbitrary data about an nft, e.g. IPFS hash
-       * - `transferable`: Ability to transfer this NFT
+       * # Arguments:
+       * - `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.
        **/
       mintNft: AugmentedSubmittable<(owner: Option<AccountId32> | null | object | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option<AccountId32> | null | object | string | Uint8Array, royaltyAmount: Option<Permill> | null | object | string | Uint8Array, metadata: Bytes | string | Uint8Array, transferable: bool | boolean | Uint8Array, resources: Option<Vec<RmrkTraitsResourceResourceTypes>> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<AccountId32>, u32, Option<AccountId32>, Option<Permill>, Bytes, bool, Option<Vec<RmrkTraitsResourceResourceTypes>>]>;
       /**
-       * Rejects an NFT sent from another account to self or owned NFT
+       * 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
        * 
-       * Parameters:
-       * - `origin`: sender of the transaction
-       * - `rmrk_collection_id`: collection id of the nft to be accepted
-       * - `rmrk_nft_id`: nft id of the nft to be accepted
+       * # Arguments:
+       * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.
+       * - `rmrk_nft_id`: ID of the NFT to be rejected.
        **/
       rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;
       /**
-       * remove resource
+       * 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
+       * - `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.
        **/
       removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;
       /**
-       * Transfers a NFT from an Account or NFT A to another Account or NFT B
+       * 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`].
        * 
-       * Parameters:
-       * - `origin`: sender of the transaction
-       * - `rmrk_collection_id`: collection id of the nft to be transferred
-       * - `rmrk_nft_id`: nft id of the nft to be transferred
-       * - `new_owner`: new owner of the nft which can be either an account or a NFT
+       * 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:
+       * - `collection_id`: RMRK ID of the collection of the NFT to be transferred.
+       * - `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.
        **/
       send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;
       /**
-       * set a different order of resource priority
+       * 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:
+       * - `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.
        **/
       setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;
       /**
-       * set a custom value on an NFT
+       * 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:
+       * - `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.
        **/
       setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact<u32> | AnyNumber | Uint8Array, maybeNftId: Option<u32> | null | object | string | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Option<u32>, Bytes, Bytes]>;
       /**
@@ -454,32 +610,50 @@
     };
     rmrkEquip: {
       /**
-       * Creates a new Base.
-       * Modeled after [base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)
+       * 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.
        * 
-       * Parameters:
-       * - origin: Caller, will be assigned as the issuer of the Base
-       * - base_type: 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
+       * # Arguments:
+       * - `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).
        **/
       createBase: AugmentedSubmittable<(baseType: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, parts: Vec<RmrkTraitsPartPartType> | (RmrkTraitsPartPartType | { FixedPart: any } | { SlotPart: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes, Vec<RmrkTraitsPartPartType>]>;
+      /**
+       * 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:
+       * - `base_id`: Base containing the Slot Part to be updated.
+       * - `part_id`: Slot Part whose Equippable List is being updated.
+       * - `equippables`: List of equippables that will override the current Equippables list.
+       **/
       equippable: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, slotId: u32 | AnyNumber | Uint8Array, equippables: RmrkTraitsPartEquippableList | { All: any } | { Empty: any } | { Custom: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsPartEquippableList]>;
       /**
-       * Adds a Theme to a Base.
-       * Modeled after [themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md)
-       * Themes are stored in the Themes storage
+       * Add a Theme to a Base.
        * A Theme named "default" is required prior to adding other Themes.
        * 
-       * Parameters:
-       * - origin: The caller of the function, must be issuer of the base
-       * - base_id: The Base containing the Theme to be updated
-       * - theme: The Theme to add to the Base.  A Theme has a name and properties, which are an
+       * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).
+       * 
+       * # Permissions:
+       * - Base issuer
+       * 
+       * # Arguments:
+       * - `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
+       * - `key`: Arbitrary BoundedString, defined by client.
+       * - `value`: Arbitrary BoundedString, defined by client.
+       * - `inherit`: Optional bool.
        **/
       themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;
       /**

--- a/tests/src/interfaces/default/types.ts
+++ b/tests/src/interfaces/default/types.ts
@@ -1314,7 +1314,6 @@
 /** @name PalletRmrkCoreError */
 export interface PalletRmrkCoreError extends Enum {
   readonly isCorruptedCollectionType: boolean;
-  readonly isNftTypeEncodeError: boolean;
   readonly isRmrkPropertyKeyIsTooLong: boolean;
   readonly isRmrkPropertyValueIsTooLong: boolean;
   readonly isRmrkPropertyIsNotFound: boolean;
@@ -1333,7 +1332,7 @@
   readonly isCannotRejectNonPendingNft: boolean;
   readonly isResourceNotPending: boolean;
   readonly isNoAvailableResourceId: boolean;
-  readonly type: 'CorruptedCollectionType' | 'NftTypeEncodeError' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId';
+  readonly type: 'CorruptedCollectionType' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId';
 }
 
 /** @name PalletRmrkCoreEvent */

--- a/tests/src/interfaces/lookup.ts
+++ b/tests/src/interfaces/lookup.ts
@@ -2990,7 +2990,7 @@
    * Lookup400: pallet_rmrk_core::pallet::Error<T>
    **/
   PalletRmrkCoreError: {
-    _enum: ['CorruptedCollectionType', 'NftTypeEncodeError', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId']
+    _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId']
   },
   /**
    * Lookup402: pallet_rmrk_equip::pallet::Error<T>

--- a/tests/src/interfaces/types-lookup.ts
+++ b/tests/src/interfaces/types-lookup.ts
@@ -3144,7 +3144,6 @@
   /** @name PalletRmrkCoreError (400) */
   export interface PalletRmrkCoreError extends Enum {
     readonly isCorruptedCollectionType: boolean;
-    readonly isNftTypeEncodeError: boolean;
     readonly isRmrkPropertyKeyIsTooLong: boolean;
     readonly isRmrkPropertyValueIsTooLong: boolean;
     readonly isRmrkPropertyIsNotFound: boolean;
@@ -3163,7 +3162,7 @@
     readonly isCannotRejectNonPendingNft: boolean;
     readonly isResourceNotPending: boolean;
     readonly isNoAvailableResourceId: boolean;
-    readonly type: 'CorruptedCollectionType' | 'NftTypeEncodeError' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId';
+    readonly type: 'CorruptedCollectionType' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId';
   }
 
   /** @name PalletRmrkEquipError (402) */