git.delta.rocks / unique-network / refs/commits / 4b3d05886c9a

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6335,6 +6335,7 @@
  "pallet-common",
  "pallet-evm",
  "pallet-nonfungible",
+ "pallet-structure",
  "parity-scale-codec 3.1.2",
  "scale-info",
  "sp-core",

--- a/pallets/proxy-rmrk-core/Cargo.toml
+++ b/pallets/proxy-rmrk-core/Cargo.toml
@@ -18,6 +18,7 @@
 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" }
@@ -33,6 +34,7 @@
     "up-data-structs/std",
     "pallet-common/std",
     "pallet-nonfungible/std",
+    "pallet-structure/std",
     "pallet-evm/std",
     'frame-benchmarking/std',
 ]

--- a/pallets/proxy-rmrk-core/src/lib.rs
+++ b/pallets/proxy-rmrk-core/src/lib.rs
@@ -25,6 +25,7 @@
 	Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations,
 };
 use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData};
+use pallet_structure::Pallet as PalletStructure;
 use pallet_evm::account::CrossAccountId;
 use core::convert::AsRef;
 
@@ -56,7 +57,7 @@
 
 	#[pallet::storage]
 	#[pallet::getter(fn collection_index_map)]
-	pub type CollectionIndexMap<T: Config> = 
+	pub type CollectionIndexMap<T: Config> =
 		StorageMap<_, Twox64Concat, RmrkCollectionId, CollectionId, ValueQuery>;
 
 	#[pallet::pallet]
@@ -98,6 +99,10 @@
 			key: RmrkKeyString,
 			value: RmrkValueString,
 		},
+		ResourceAdded {
+			nft_id: RmrkNftId,
+			resource_id: RmrkResourceId,
+		},
 	}
 
 	#[pallet::error]
@@ -106,7 +111,7 @@
 		CorruptedCollectionType,
 		NftTypeEncodeError,
 		RmrkPropertyKeyIsTooLong,
-		RmrkPropertyValueIsTooLong,
+		RmrkPropertyValueIsTooLong, // todo utilize that in RPCs
 
 		/* RMRK compatible events */
 		CollectionNotEmpty,
@@ -115,6 +120,7 @@
 		CollectionUnknown,
 		NoPermission,
 		CollectionFullOrLocked,
+		// todo add resource errors?
 	}
 
 	#[pallet::call]
@@ -143,29 +149,21 @@
 					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,
 				..Default::default()
 			};
-
-			let collection_id_res =
-				<PalletNft<T>>::init_collection(T::CrossAccountId::from_sub(sender.clone()), data);
-
-			if let Err(DispatchError::Arithmetic(_)) = &collection_id_res {
-				return Err(<Error<T>>::NoAvailableCollectionId.into());
-			}
 
-			let unique_collection_id = collection_id_res?;
-			let rmrk_collection_id = <CollectionIndex<T>>::get();
-
 			<CollectionIndex<T>>::mutate(|n| *n += 1);
-			<CollectionIndexMap<T>>::insert(rmrk_collection_id, unique_collection_id);
 
-			<PalletCommon<T>>::set_scoped_collection_properties(
-				unique_collection_id,
-				PropertyScope::Rmrk,
+			let unique_collection_id = Self::init_collection(
+				T::CrossAccountId::from_sub(sender.clone()),
+				data,
 				[
 					Self::rmrk_property(Metadata, &metadata)?,
 					Self::rmrk_property(CollectionType, &misc::CollectionType::Regular)?,
 				]
 				.into_iter(),
-			)?;
+			)?; //collection_id_res?;
+			let rmrk_collection_id = <CollectionIndex<T>>::get();
+
+			<CollectionIndexMap<T>>::insert(rmrk_collection_id, unique_collection_id);
 
 			Self::deposit_event(Event::CollectionCreated {
 				issuer: sender,
@@ -290,13 +288,26 @@
 				&sender,
 				&cross_owner,
 				&collection,
-				NftType::Regular,
 				[
+					Self::rmrk_property(TokenType, &NftType::Regular)?,
 					Self::rmrk_property(RoyaltyInfo, &royalty_info)?,
 					Self::rmrk_property(Metadata, &metadata)?,
 					Self::rmrk_property(Equipped, &false)?,
-					Self::rmrk_property(ResourceCollection, &None::<CollectionId>)?,
-					Self::rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,
+					Self::rmrk_property(
+						ResourceCollection,
+						&Self::init_collection(
+							sender.clone(),
+							CreateCollectionData {
+								..Default::default()
+							},
+							[Self::rmrk_property(
+								CollectionType,
+								&misc::CollectionType::Resource,
+							)?]
+							.into_iter(),
+						)?,
+					)?, // todo possibly add limits to the collection if rmrk warrants them
+					Self::rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?, // todo create resource priorities?
 				]
 				.into_iter(),
 			)
@@ -392,6 +403,107 @@
 
 			Ok(())
 		}
+
+		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
+		#[transactional]
+		pub fn add_basic_resource(
+			origin: OriginFor<T>,
+			collection_id: RmrkCollectionId,
+			nft_id: RmrkNftId,
+			resource: RmrkBasicResource,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin.clone())?;
+
+			let resource_id = Self::resource_add(
+				sender,
+				Self::unique_collection_id(collection_id)?,
+				nft_id.into(),
+				[
+					Self::rmrk_property(TokenType, &NftType::Resource)?,
+					Self::rmrk_property(ResourceType, &misc::ResourceType::Basic)?,
+					Self::rmrk_property(Src, &resource.src)?,
+					Self::rmrk_property(Metadata, &resource.metadata)?,
+					Self::rmrk_property(License, &resource.license)?,
+					Self::rmrk_property(Thumb, &resource.thumb)?,
+				]
+				.into_iter(),
+			)?;
+
+			Self::deposit_event(Event::ResourceAdded {
+				nft_id,
+				resource_id,
+			});
+			Ok(())
+		}
+
+		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
+		#[transactional]
+		pub fn add_composable_resource(
+			origin: OriginFor<T>,
+			collection_id: RmrkCollectionId,
+			nft_id: RmrkNftId,
+			_resource_id: RmrkBoundedResource,
+			resource: RmrkComposableResource,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin.clone())?;
+
+			let resource_id = Self::resource_add(
+				sender,
+				Self::unique_collection_id(collection_id)?,
+				nft_id.into(),
+				[
+					Self::rmrk_property(TokenType, &NftType::Resource)?,
+					Self::rmrk_property(ResourceType, &misc::ResourceType::Composable)?,
+					Self::rmrk_property(Parts, &resource.parts)?,
+					Self::rmrk_property(Base, &resource.base)?,
+					Self::rmrk_property(Src, &resource.src)?,
+					Self::rmrk_property(Metadata, &resource.metadata)?,
+					Self::rmrk_property(License, &resource.license)?,
+					Self::rmrk_property(Thumb, &resource.thumb)?,
+				]
+				.into_iter(),
+			)?;
+
+			Self::deposit_event(Event::ResourceAdded {
+				nft_id,
+				resource_id,
+			});
+			Ok(())
+		}
+
+		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
+		#[transactional]
+		pub fn add_slot_resource(
+			origin: OriginFor<T>,
+			collection_id: RmrkCollectionId,
+			nft_id: RmrkNftId,
+			resource: RmrkSlotResource,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin.clone())?;
+
+			let resource_id = Self::resource_add(
+				sender,
+				Self::unique_collection_id(collection_id)?,
+				nft_id.into(),
+				[
+					Self::rmrk_property(TokenType, &NftType::Resource)?,
+					Self::rmrk_property(ResourceType, &misc::ResourceType::Slot)?,
+					Self::rmrk_property(Base, &resource.base)?,
+					Self::rmrk_property(Src, &resource.src)?,
+					Self::rmrk_property(Metadata, &resource.metadata)?,
+					Self::rmrk_property(Slot, &resource.slot)?,
+					Self::rmrk_property(License, &resource.license)?,
+					Self::rmrk_property(Thumb, &resource.thumb)?,
+				]
+				.into_iter(),
+			)?;
+
+			Self::deposit_event(Event::ResourceAdded {
+				nft_id,
+				resource_id,
+			});
+			Ok(())
+		}
 	}
 }
 
@@ -422,14 +534,32 @@
 		Ok(property)
 	}
 
+	fn init_collection(
+		sender: T::CrossAccountId,
+		data: CreateCollectionData<T::AccountId>,
+		properties: impl Iterator<Item = Property>,
+	) -> Result<CollectionId, DispatchError> {
+		let collection_id = <PalletNft<T>>::init_collection(sender, data);
+
+		if let Err(DispatchError::Arithmetic(_)) = &collection_id {
+			return Err(<Error<T>>::NoAvailableCollectionId.into());
+		}
+
+		<PalletCommon<T>>::set_scoped_collection_properties(
+			collection_id?,
+			PropertyScope::Rmrk,
+			properties,
+		)?;
+
+		collection_id
+	}
+
 	pub fn create_nft(
 		sender: &T::CrossAccountId,
 		owner: &T::CrossAccountId,
 		collection: &NonfungibleHandle<T>,
-		nft_type: NftType,
 		properties: impl Iterator<Item = Property>,
 	) -> Result<TokenId, DispatchError> {
-		todo!("store nft type");
 		let data = CreateNftExData {
 			properties: BoundedVec::default(),
 			owner: owner.clone(),
@@ -465,6 +595,57 @@
 		Ok(())
 	}
 
+	fn resource_add(
+		sender: T::AccountId,
+		collection_id: CollectionId,
+		token_id: TokenId,
+		resource_properties: impl Iterator<Item = Property>,
+	) -> Result<RmrkResourceId, DispatchError> {
+		let collection =
+			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
+		ensure!(collection.owner == sender, Error::<T>::NoPermission);
+
+		// Check NFT lock status // todo depends on market, maybe later
+		//ensure!(!Pallet::<T>::is_locked(collection_id, nft_id), pallet_uniques::Error::<T>::Locked);
+
+		let sender = T::CrossAccountId::from_sub(sender);
+		let budget = budget::Value::new(10);
+		let pending = <PalletStructure<T>>::check_indirectly_owned(
+			sender.clone(),
+			collection_id,
+			token_id,
+			None,
+			&budget,
+		)?;
+
+		let resource_collection_id: CollectionId =
+			Self::get_nft_property(collection_id, token_id, ResourceCollection)?
+				.decode_or_default();
+		let resource_collection =
+			Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?;
+
+		// todo probably add extra connections to bases, slots, etc., when RMRK starts to use them
+
+		let resource_id = Self::create_nft(
+			&sender, // todo owner of the nft?
+			&sender,
+			&resource_collection,
+			resource_properties.chain(
+				[
+					Self::rmrk_property(PendingResourceAccept, &pending)?,
+					Self::rmrk_property(PendingResourceRemoval, &false)?,
+				]
+				.into_iter(),
+			),
+		)
+		.map_err(|err| match err {
+			DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),
+			err => Self::map_common_err_to_proxy(err),
+		})?;
+
+		Ok(resource_id.0)
+	}
+
 	fn change_collection_owner(
 		collection_id: CollectionId,
 		collection_type: misc::CollectionType,
@@ -493,8 +674,11 @@
 		<CollectionIndex<T>>::get()
 	}
 
-	pub fn unique_collection_id(rmrk_collection_id: RmrkCollectionId) -> Result<CollectionId, DispatchError> {
-		<CollectionIndexMap<T>>::try_get(rmrk_collection_id).map_err(|_| <Error<T>>::CollectionUnknown.into())
+	pub fn unique_collection_id(
+		rmrk_collection_id: RmrkCollectionId,
+	) -> Result<CollectionId, DispatchError> {
+		<CollectionIndexMap<T>>::try_get(rmrk_collection_id)
+			.map_err(|_| <Error<T>>::CollectionUnknown.into())
 	}
 
 	pub fn get_nft_collection(
@@ -513,10 +697,6 @@
 		<CollectionHandle<T>>::try_get(collection_id).is_ok()
 	}
 
-	pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {
-		<TokenData<T>>::contains_key((collection_id, nft_id))
-	}
-
 	pub fn get_collection_property(
 		collection_id: CollectionId,
 		key: RmrkProperty,
@@ -553,6 +733,15 @@
 		Ok(())
 	}
 
+	pub fn get_typed_nft_collection(
+		collection_id: CollectionId,
+		collection_type: misc::CollectionType,
+	) -> Result<NonfungibleHandle<T>, DispatchError> {
+		Self::ensure_collection_type(collection_id, collection_type)?;
+
+		Self::get_nft_collection(collection_id)
+	}
+
 	pub fn get_nft_property(
 		collection_id: CollectionId,
 		nft_id: TokenId,
@@ -560,17 +749,23 @@
 	) -> Result<PropertyValue, DispatchError> {
 		let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))
 			.get(&Self::rmrk_property_key(key)?)
-			.ok_or(<Error<T>>::NoAvailableNftId)?
+			.ok_or(<Error<T>>::NoAvailableNftId)? // todo replace with better error
 			.clone();
 
 		Ok(nft_property)
 	}
 
+	pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {
+		<TokenData<T>>::contains_key((collection_id, nft_id))
+	}
+
 	pub fn get_nft_type(
-		_collection_id: CollectionId,
-		_token_id: TokenId,
+		collection_id: CollectionId,
+		token_id: TokenId,
 	) -> Result<NftType, DispatchError> {
-		todo!("should get it from properties?")
+		Ok(Self::get_nft_property(collection_id, token_id, TokenType)?.decode_or_default())
+		// todo throw error
+		// NftTypeEncodeError?
 	}
 
 	pub fn ensure_nft_type(
@@ -673,15 +868,6 @@
 		});
 
 		Ok(properties)
-	}
-
-	pub fn get_typed_nft_collection(
-		collection_id: CollectionId,
-		collection_type: misc::CollectionType,
-	) -> Result<NonfungibleHandle<T>, DispatchError> {
-		Self::ensure_collection_type(collection_id, collection_type)?;
-
-		Self::get_nft_collection(collection_id)
 	}
 
 	fn map_common_err_to_proxy(err: DispatchError) -> DispatchError {

--- a/pallets/proxy-rmrk-core/src/misc.rs
+++ b/pallets/proxy-rmrk-core/src/misc.rs
@@ -18,6 +18,7 @@
 	fn decode_or_default(&self) -> T;
 }
 
+// todo fail if unwrap doesn't work
 impl<T: Decode + Default, S> RmrkDecode<T, S> for BoundedVec<u8, S> {
 	fn decode_or_default(&self) -> T {
 		let mut value = self.as_slice();
@@ -30,6 +31,7 @@
 	fn rebind(&self) -> BoundedVec<u8, S>;
 }
 
+// todo fail if unwrap doesn't work
 impl<T, S> RmrkRebind<T, S> for BoundedVec<u8, T>
 where
 	BoundedVec<u8, S>: TryFrom<Vec<u8>>,
@@ -46,11 +48,22 @@
 	Base,
 }
 
-#[derive(Encode, Decode, PartialEq, Eq)]
+// todo remove default?
+#[derive(Encode, Decode, PartialEq, Eq, Default)]
 pub enum NftType {
+	#[default]
 	Regular,
 	Resource,
 	FixedPart,
 	SlotPart,
 	Theme,
 }
+
+// todo remove default?
+#[derive(Encode, Decode, PartialEq, Eq, Default)]
+pub enum ResourceType {
+	#[default]
+	Basic,
+	Composable,
+	Slot,
+}

--- a/pallets/proxy-rmrk-core/src/property.rs
+++ b/pallets/proxy-rmrk-core/src/property.rs
@@ -4,6 +4,7 @@
 pub enum RmrkProperty<'r> {
 	Metadata,
 	CollectionType,
+	TokenType,
 	RoyaltyInfo,
 	Equipped,
 	ResourceCollection,
@@ -47,6 +48,7 @@
 		match self {
 			Self::Metadata => key!("metadata"),
 			Self::CollectionType => key!("collection-type"),
+			Self::TokenType => key!("token-type"),
 			Self::RoyaltyInfo => key!("royalty-info"),
 			Self::Equipped => key!("equipped"),
 			Self::ResourceCollection => key!("resource-collection"),

--- a/pallets/proxy-rmrk-equip/src/lib.rs
+++ b/pallets/proxy-rmrk-equip/src/lib.rs
@@ -166,8 +166,8 @@
 				&sender,
 				owner,
 				&collection,
-				NftType::Theme,
 				[
+					<PalletCore<T>>::rmrk_property(TokenType, &NftType::Theme)?,
 					<PalletCore<T>>::rmrk_property(ThemeName, &theme.name)?,
 					<PalletCore<T>>::rmrk_property(ThemeInherit, &theme.inherit)?,
 				]
@@ -212,8 +212,8 @@
 			sender,
 			owner,
 			collection,
-			nft_type,
 			[
+				<PalletCore<T>>::rmrk_property(TokenType, &nft_type)?,
 				<PalletCore<T>>::rmrk_property(Src, &src)?,
 				<PalletCore<T>>::rmrk_property(ZIndex, &z_index)?,
 			]

--- a/primitives/data-structs/src/lib.rs
+++ b/primitives/data-structs/src/lib.rs
@@ -41,6 +41,7 @@
 // RMRK
 use rmrk::{
 	CollectionInfo, NftInfo, ResourceInfo, PropertyInfo, BaseInfo, PartType, Theme, ThemeProperty,
+	ResourceTypes, BasicResource, ComposableResource, SlotResource,
 };
 pub use rmrk::{
 	primitives::{
@@ -49,8 +50,6 @@
 	},
 	NftChild as RmrkNftChild, AccountIdOrCollectionNftTuple as RmrkAccountIdOrCollectionNftTuple,
 	FixedPart as RmrkFixedPart, SlotPart as RmrkSlotPart, EquippableList as RmrkEquippableList,
-	BasicResource as RmrkBasicResource, ComposableResource as RmrkComposableResource,
-	SlotResource as RmrkSlotResource,
 };
 
 mod bounded;
@@ -942,23 +941,26 @@
 pub type RmrkCollectionInfo<AccountId> =
 	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;
 pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;
-pub type RmrkResourceInfo = ResourceInfo<RmrkBoundedResource, RmrkString, RmrkBoundedParts>;
+pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;
 pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;
 pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;
 pub type RmrkPartType =
 	PartType<RmrkString, BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>>;
 pub type RmrkThemeProperty = ThemeProperty<RmrkString>;
 pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;
+pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;
+
+pub type RmrkBasicResource = BasicResource<RmrkString>;
+pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;
+pub type RmrkSlotResource = SlotResource<RmrkString>;
 
+pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;
 pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;
 pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;
 pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;
-
-type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;
-type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>;
+pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;
+pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed
 
 pub type RmrkRpcString = Vec<u8>;
 pub type RmrkThemeName = RmrkRpcString;
 pub type RmrkPropertyKey = RmrkRpcString;
-
-pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;

--- a/primitives/data-structs/src/rmrk.rs
+++ b/primitives/data-structs/src/rmrk.rs
@@ -282,17 +282,16 @@
 #[cfg_attr(
 	feature = "std",
 	serde(bound = r#"
-			BoundedResource: AsRef<[u8]>,
 			BoundedString: AsRef<[u8]>,
 			BoundedParts: AsRef<[PartId]>
 		"#)
 )]
-pub struct ResourceInfo<BoundedResource, BoundedString: Default, BoundedParts> {
+pub struct ResourceInfo<BoundedString: Default, BoundedParts> {
 	/// id is a 5-character string of reasonable uniqueness.
 	/// The combination of base ID and resource id should be unique across the entire RMRK
 	/// ecosystem which
-	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
-	pub id: BoundedResource,
+	//#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]
+	pub id: ResourceId,
 
 	/// Resource
 	pub resource: ResourceTypes<BoundedString, BoundedParts>,

--- a/runtime/common/src/runtime_apis.rs
+++ b/runtime/common/src/runtime_apis.rs
@@ -152,6 +152,7 @@
                         Err(_) => return Ok(None),
                     };
 
+                    // todo replace dispatch... calls with calls to rmrkcore and NFT collection. There's no point trying non-NFT collections
                     let nfts_count = dispatch_unique_runtime!(collection_id.total_supply())?;
 
                     Ok(Some(RmrkCollectionInfo {
@@ -171,6 +172,7 @@
                     let nft_id = TokenId(nft_by_id);
                     if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }
 
+                    // todo replace dispatch with collection
                     let owner = match dispatch_unique_runtime!(collection_id.token_owner(nft_id))? {
                         Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {
                             Some((col, tok)) => RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(col.0, tok.0),
@@ -270,34 +272,51 @@
 
                 fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
                     use frame_support::BoundedVec;
-                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, RmrkDecode}};
+                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType, RmrkDecode}};
+                    use pallet_common::CommonCollectionOperations;
 
                     let collection_id = RmrkCore::unique_collection_id(collection_id)?;
-                    if !RmrkCore::collection_exists(collection_id) { return Ok(Vec::new()); } // todo make sure the collection type doesn't matter
+                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }
 
                     let nft_id = TokenId(nft_id);
-                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Resource).is_err() { return Ok(Vec::new()); }
+                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }
 
-                    let resource_collection_id: CollectionId = RmrkCore::get_nft_property(collection_id, nft_id, RmrkProperty::ResourceCollection)
-                        .unwrap()
+                    let res_collection_id: CollectionId = RmrkCore::get_nft_property(collection_id, nft_id, RmrkProperty::ResourceCollection)?
                         .decode_or_default();
-                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Resource).is_err() { return Ok(Vec::new()); }
+                    let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;
 
-                    let resources = pallet_nonfungible::TokenProperties::<Runtime>::iter_prefix((resource_collection_id,))
-                        .filter_map(|(resource_id, properties)| Some(RmrkResourceInfo {
-                            id: BoundedVec::default(), // todo ResourceId property
-                            pending: RmrkCore::get_nft_property(resource_collection_id, resource_id, RmrkProperty::PendingResourceAccept).unwrap().decode_or_default(),
-                            pending_removal: RmrkCore::get_nft_property(resource_collection_id, resource_id, RmrkProperty::PendingResourceRemoval).unwrap().decode_or_default(),
-                            resource: RmrkCore::get_nft_property(resource_collection_id, resource_id, RmrkProperty::ResourceType).unwrap().decode_or_default(),/* {
-                                RmrkResourceTypes::Basic(resource) => RmrkResourceTypes::Basic(),/*(RmrkBasicResource {
-                                    src: RmrkCore::get_nft_property_inner(properties, RmrkProperty::Src).unwrap().decode_or_default(),
-                                    metadata: RmrkCore::get_nft_property_inner(properties, RmrkProperty::Metadata).unwrap().decode_or_default(),
-                                    license: RmrkCore::get_nft_property_inner(properties, RmrkProperty::License).unwrap().decode_or_default(),
-                                    thumb: RmrkCore::get_nft_property_inner(properties, RmrkProperty::Thumb).unwrap().decode_or_default(),
-                                },*///BasicResource<BoundedString>)
-                                _ => todo!(), //RmrkResourceTypes::Composable(ComposableResource<BoundedString, BoundedParts>),
-                                //RmrkResourceTypes::Slot(SlotResource<BoundedString>),
-                            },*/
+                    let resources = resource_collection
+                        .collection_tokens()
+                        .iter()
+                        .filter_map(|(res_id)| Some(RmrkResourceInfo {
+                            id: res_id.0,
+                            pending: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).unwrap().decode_or_default(),
+                            pending_removal: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).unwrap().decode_or_default(),
+                            resource: match RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::ResourceType).unwrap().decode_or_default() {
+                                ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {
+                                    src: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Src).unwrap().decode_or_default(),
+                                    metadata: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Metadata).unwrap().decode_or_default(),
+                                    license: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::License).unwrap().decode_or_default(),
+                                    thumb: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Thumb).unwrap().decode_or_default(),
+                                }),
+                                ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {
+                                    parts: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Parts).unwrap().decode_or_default(),
+                                    base: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Base).unwrap().decode_or_default(),
+                                    src: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Src).unwrap().decode_or_default(),
+                                    metadata: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Metadata).unwrap().decode_or_default(),
+                                    license: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::License).unwrap().decode_or_default(),
+                                    thumb: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Thumb).unwrap().decode_or_default(),
+                                }),
+                                ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {
+                                    base: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Base).unwrap().decode_or_default(),
+                                    src: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Src).unwrap().decode_or_default(),
+                                    metadata: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Metadata).unwrap().decode_or_default(),
+                                    slot: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Slot).unwrap().decode_or_default(),
+                                    license: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::License).unwrap().decode_or_default(),
+                                    thumb: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Thumb).unwrap().decode_or_default(),
+                                }),
+                                // todo refactor :|
+                            },
                         }))
                         .collect();
 
@@ -308,10 +327,10 @@
                     use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, RmrkDecode}};
 
                     let collection_id = RmrkCore::unique_collection_id(collection_id)?;
-                    if !RmrkCore::collection_exists(collection_id) { return Ok(Vec::new()); } // todo ensure the collection type doesn't matter
+                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }
 
                     let nft_id = TokenId(nft_id);
-                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Resource).is_err() { return Ok(Vec::new()); }
+                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }
 
                     /*let resource_collection_id: CollectionId = RmrkCore::get_nft_property(collection_id, nft_id, RmrkProperty::ResourceCollection)
                         .unwrap()
@@ -327,6 +346,7 @@
                         .sort_by_key(|(_, index)| *index)
                         .into_iter().map(|(resource_id, _)| resource_id)*/
                     let priorities = RmrkCore::get_nft_property(collection_id, nft_id, RmrkProperty::ResourcePriorities)?.decode_or_default();
+                    // todo let it simply be default here after removing default from decode
 
                     Ok(priorities)
                 }

--- a/tests/src/interfaces/augment-api-errors.ts
+++ b/tests/src/interfaces/augment-api-errors.ts
@@ -437,6 +437,33 @@
        **/
       [key: string]: AugmentedError<ApiType>;
     };
+    rmrkCore: {
+      CollectionFullOrLocked: AugmentedError<ApiType>;
+      CollectionNotEmpty: AugmentedError<ApiType>;
+      CollectionUnknown: AugmentedError<ApiType>;
+      CorruptedCollectionType: AugmentedError<ApiType>;
+      NftTypeEncodeError: AugmentedError<ApiType>;
+      NoAvailableCollectionId: AugmentedError<ApiType>;
+      NoAvailableNftId: AugmentedError<ApiType>;
+      NoPermission: AugmentedError<ApiType>;
+      RmrkPropertyKeyIsTooLong: AugmentedError<ApiType>;
+      RmrkPropertyValueIsTooLong: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    rmrkEquip: {
+      BaseDoesntExist: AugmentedError<ApiType>;
+      NeedsDefaultThemeFirst: AugmentedError<ApiType>;
+      NoAvailableBaseId: AugmentedError<ApiType>;
+      NoAvailablePartId: AugmentedError<ApiType>;
+      PermissionError: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
     structure: {
       /**
        * While searched for owner, encountered depth limit

--- a/tests/src/interfaces/augment-api-events.ts
+++ b/tests/src/interfaces/augment-api-events.ts
@@ -396,6 +396,27 @@
        **/
       [key: string]: AugmentedEvent<ApiType>;
     };
+    rmrkCore: {
+      CollectionCreated: AugmentedEvent<ApiType, [AccountId32, u32]>;
+      CollectionDestroyed: AugmentedEvent<ApiType, [AccountId32, u32]>;
+      CollectionLocked: AugmentedEvent<ApiType, [AccountId32, u32]>;
+      IssuerChanged: AugmentedEvent<ApiType, [AccountId32, AccountId32, u32]>;
+      NFTBurned: AugmentedEvent<ApiType, [AccountId32, u32]>;
+      NftMinted: AugmentedEvent<ApiType, [AccountId32, u32, u32]>;
+      PropertySet: AugmentedEvent<ApiType, [u32, Option<u32>, Bytes, Bytes]>;
+      ResourceAdded: AugmentedEvent<ApiType, [u32, u32]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    rmrkEquip: {
+      BaseCreated: AugmentedEvent<ApiType, [AccountId32, u32]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
     structure: {
       /**
        * Executed call on behalf of token

--- a/tests/src/interfaces/augment-api-query.ts
+++ b/tests/src/interfaces/augment-api-query.ts
@@ -415,6 +415,22 @@
        **/
       [key: string]: QueryableStorageEntry<ApiType>;
     };
+    rmrkCore: {
+      collectionIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      collectionIndexMap: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    rmrkEquip: {
+      baseHasDefaultTheme: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      inernalPartId: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
     structure: {
       /**
        * Generic query

--- a/tests/src/interfaces/augment-api-rpc.ts
+++ b/tests/src/interfaces/augment-api-rpc.ts
@@ -22,7 +22,7 @@
 import type { StorageKind } from '@polkadot/types/interfaces/offchain';
 import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
 import type { RpcMethods } from '@polkadot/types/interfaces/rpc';
-import type { AccountId, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
+import type { AccountId, AccountId32, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
 import type { MigrationStatusResult, ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state';
 import type { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo, SyncState } from '@polkadot/types/interfaces/system';
 import type { IExtrinsic, Observable } from '@polkadot/types/types';
@@ -397,6 +397,60 @@
        **/
       queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<RuntimeDispatchInfo>>;
     };
+    rmrk: {
+      /**
+       * Get tokens owned by an account in a collection
+       **/
+      accountTokens: AugmentedRpc<(accountId: AccountId32 | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<u32>>>;
+      /**
+       * Get base info
+       **/
+      base: AugmentedRpc<(baseId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<UpDataStructsRmrkBaseInfo>>>;
+      /**
+       * Get all Base's parts
+       **/
+      baseParts: AugmentedRpc<(baseId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsRmrkPartType>>>;
+      /**
+       * Get collection by id
+       **/
+      collectionById: AugmentedRpc<(id: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<UpDataStructsRmrkCollectionInfo>>>;
+      /**
+       * Get collection properties
+       **/
+      collectionProperties: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, filterKeys?: Vec<Text> | (Text | string)[], at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsRmrkPropertyInfo>>>;
+      /**
+       * Get the latest created collection id
+       **/
+      lastCollectionIdx: AugmentedRpc<(at?: Hash | string | Uint8Array) => Observable<u32>>;
+      /**
+       * Get NFT by collection id and NFT id
+       **/
+      nftById: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<UpDataStructsRmrkNftInfo>>>;
+      /**
+       * Get NFT children
+       **/
+      nftChildren: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsRmrkNftChild>>>;
+      /**
+       * Get NFT properties
+       **/
+      nftProperties: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, filterKeys?: Vec<Text> | (Text | string)[], at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsRmrkPropertyInfo>>>;
+      /**
+       * Get NFT resource priorities
+       **/
+      nftResourcePriorities: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<Bytes>>>;
+      /**
+       * Get NFT resources
+       **/
+      nftResources: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsRmrkResourceInfo>>>;
+      /**
+       * Get Base's theme names
+       **/
+      themeNames: AugmentedRpc<(baseId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<Bytes>>>;
+      /**
+       * Get Theme's keys values
+       **/
+      themes: AugmentedRpc<(baseId: u32 | AnyNumber | Uint8Array, themeName: Text | string, keys: Option<Vec<Text>> | null | object | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<UpDataStructsRmrkTheme>>>;
+    };
     rpc: {
       /**
        * Retrieves the list of RPC methods that are exposed by the node

--- a/tests/src/interfaces/augment-api-tx.ts
+++ b/tests/src/interfaces/augment-api-tx.ts
@@ -4,8 +4,8 @@
 import type { ApiTypes } from '@polkadot/api-base/types';
 import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types-codec';
 import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';
-import type { AccountId32, Call, H160, H256, MultiAddress, Perbill } from '@polkadot/types/interfaces/runtime';
-import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';
+import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';
+import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsRmrkBasicResource, UpDataStructsRmrkComposableResource, UpDataStructsRmrkPartType, UpDataStructsRmrkSlotResource, UpDataStructsRmrkTheme, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';
 
 declare module '@polkadot/api-base/types/submittable' {
   export interface AugmentedSubmittables<ApiType extends ApiTypes> {
@@ -346,6 +346,30 @@
        **/
       [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
+    rmrkCore: {
+      addBasicResource: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: UpDataStructsRmrkBasicResource | { src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, UpDataStructsRmrkBasicResource]>;
+      addComposableResource: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: Bytes | string | Uint8Array, resource: UpDataStructsRmrkComposableResource | { parts?: any; base?: any; src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, Bytes, UpDataStructsRmrkComposableResource]>;
+      addSlotResource: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: UpDataStructsRmrkSlotResource | { base?: any; src?: any; metadata?: any; slot?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, UpDataStructsRmrkSlotResource]>;
+      burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;
+      changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;
+      createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | object | string | Uint8Array, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;
+      destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
+      lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
+      mintNft: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option<AccountId32> | null | object | string | Uint8Array, royaltyAmount: Option<Permill> | null | object | string | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, u32, Option<AccountId32>, Option<Permill>, Bytes]>;
+      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]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
+    };
+    rmrkEquip: {
+      createBase: AugmentedSubmittable<(baseType: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, parts: Vec<UpDataStructsRmrkPartType> | (UpDataStructsRmrkPartType | { FixedPart: any } | { SlotPart: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes, Vec<UpDataStructsRmrkPartType>]>;
+      themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: UpDataStructsRmrkTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsRmrkTheme]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
+    };
     structure: {
       /**
        * Generic tx

--- a/tests/src/interfaces/augment-types.ts
+++ b/tests/src/interfaces/augment-types.ts
@@ -788,6 +788,12 @@
     PalletNonfungibleItemData: PalletNonfungibleItemData;
     PalletRefungibleError: PalletRefungibleError;
     PalletRefungibleItemData: PalletRefungibleItemData;
+    PalletRmrkCoreCall: PalletRmrkCoreCall;
+    PalletRmrkCoreError: PalletRmrkCoreError;
+    PalletRmrkCoreEvent: PalletRmrkCoreEvent;
+    PalletRmrkEquipCall: PalletRmrkEquipCall;
+    PalletRmrkEquipError: PalletRmrkEquipError;
+    PalletRmrkEquipEvent: PalletRmrkEquipEvent;
     PalletsOrigin: PalletsOrigin;
     PalletStorageMetadataLatest: PalletStorageMetadataLatest;
     PalletStorageMetadataV14: PalletStorageMetadataV14;

--- a/tests/src/interfaces/default/types.ts
+++ b/tests/src/interfaces/default/types.ts
@@ -1129,6 +1129,169 @@
   readonly constData: Bytes;
 }
 
+/** @name PalletRmrkCoreCall */
+export interface PalletRmrkCoreCall extends Enum {
+  readonly isCreateCollection: boolean;
+  readonly asCreateCollection: {
+    readonly metadata: Bytes;
+    readonly max: Option<u32>;
+    readonly symbol: Bytes;
+  } & Struct;
+  readonly isDestroyCollection: boolean;
+  readonly asDestroyCollection: {
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isChangeCollectionIssuer: boolean;
+  readonly asChangeCollectionIssuer: {
+    readonly collectionId: u32;
+    readonly newIssuer: MultiAddress;
+  } & Struct;
+  readonly isLockCollection: boolean;
+  readonly asLockCollection: {
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isMintNft: boolean;
+  readonly asMintNft: {
+    readonly owner: AccountId32;
+    readonly collectionId: u32;
+    readonly recipient: Option<AccountId32>;
+    readonly royaltyAmount: Option<Permill>;
+    readonly metadata: Bytes;
+  } & Struct;
+  readonly isBurnNft: boolean;
+  readonly asBurnNft: {
+    readonly collectionId: u32;
+    readonly nftId: u32;
+  } & Struct;
+  readonly isSetProperty: boolean;
+  readonly asSetProperty: {
+    readonly rmrkCollectionId: Compact<u32>;
+    readonly maybeNftId: Option<u32>;
+    readonly key: Bytes;
+    readonly value: Bytes;
+  } & Struct;
+  readonly isAddBasicResource: boolean;
+  readonly asAddBasicResource: {
+    readonly collectionId: u32;
+    readonly nftId: u32;
+    readonly resource: UpDataStructsRmrkBasicResource;
+  } & Struct;
+  readonly isAddComposableResource: boolean;
+  readonly asAddComposableResource: {
+    readonly collectionId: u32;
+    readonly nftId: u32;
+    readonly resourceId: Bytes;
+    readonly resource: UpDataStructsRmrkComposableResource;
+  } & Struct;
+  readonly isAddSlotResource: boolean;
+  readonly asAddSlotResource: {
+    readonly collectionId: u32;
+    readonly nftId: u32;
+    readonly resource: UpDataStructsRmrkSlotResource;
+  } & Struct;
+  readonly type: 'CreateCollection' | 'DestroyCollection' | 'ChangeCollectionIssuer' | 'LockCollection' | 'MintNft' | 'BurnNft' | 'SetProperty' | 'AddBasicResource' | 'AddComposableResource' | 'AddSlotResource';
+}
+
+/** @name PalletRmrkCoreError */
+export interface PalletRmrkCoreError extends Enum {
+  readonly isCorruptedCollectionType: boolean;
+  readonly isNftTypeEncodeError: boolean;
+  readonly isRmrkPropertyKeyIsTooLong: boolean;
+  readonly isRmrkPropertyValueIsTooLong: boolean;
+  readonly isCollectionNotEmpty: boolean;
+  readonly isNoAvailableCollectionId: boolean;
+  readonly isNoAvailableNftId: boolean;
+  readonly isCollectionUnknown: boolean;
+  readonly isNoPermission: boolean;
+  readonly isCollectionFullOrLocked: boolean;
+  readonly type: 'CorruptedCollectionType' | 'NftTypeEncodeError' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'CollectionFullOrLocked';
+}
+
+/** @name PalletRmrkCoreEvent */
+export interface PalletRmrkCoreEvent extends Enum {
+  readonly isCollectionCreated: boolean;
+  readonly asCollectionCreated: {
+    readonly issuer: AccountId32;
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isCollectionDestroyed: boolean;
+  readonly asCollectionDestroyed: {
+    readonly issuer: AccountId32;
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isIssuerChanged: boolean;
+  readonly asIssuerChanged: {
+    readonly oldIssuer: AccountId32;
+    readonly newIssuer: AccountId32;
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isCollectionLocked: boolean;
+  readonly asCollectionLocked: {
+    readonly issuer: AccountId32;
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isNftMinted: boolean;
+  readonly asNftMinted: {
+    readonly owner: AccountId32;
+    readonly collectionId: u32;
+    readonly nftId: u32;
+  } & Struct;
+  readonly isNftBurned: boolean;
+  readonly asNftBurned: {
+    readonly owner: AccountId32;
+    readonly nftId: u32;
+  } & Struct;
+  readonly isPropertySet: boolean;
+  readonly asPropertySet: {
+    readonly collectionId: u32;
+    readonly maybeNftId: Option<u32>;
+    readonly key: Bytes;
+    readonly value: Bytes;
+  } & Struct;
+  readonly isResourceAdded: boolean;
+  readonly asResourceAdded: {
+    readonly nftId: u32;
+    readonly resourceId: u32;
+  } & Struct;
+  readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'IssuerChanged' | 'CollectionLocked' | 'NftMinted' | 'NftBurned' | 'PropertySet' | 'ResourceAdded';
+}
+
+/** @name PalletRmrkEquipCall */
+export interface PalletRmrkEquipCall extends Enum {
+  readonly isCreateBase: boolean;
+  readonly asCreateBase: {
+    readonly baseType: Bytes;
+    readonly symbol: Bytes;
+    readonly parts: Vec<UpDataStructsRmrkPartType>;
+  } & Struct;
+  readonly isThemeAdd: boolean;
+  readonly asThemeAdd: {
+    readonly baseId: u32;
+    readonly theme: UpDataStructsRmrkTheme;
+  } & Struct;
+  readonly type: 'CreateBase' | 'ThemeAdd';
+}
+
+/** @name PalletRmrkEquipError */
+export interface PalletRmrkEquipError extends Enum {
+  readonly isPermissionError: boolean;
+  readonly isNoAvailableBaseId: boolean;
+  readonly isNoAvailablePartId: boolean;
+  readonly isBaseDoesntExist: boolean;
+  readonly isNeedsDefaultThemeFirst: boolean;
+  readonly type: 'PermissionError' | 'NoAvailableBaseId' | 'NoAvailablePartId' | 'BaseDoesntExist' | 'NeedsDefaultThemeFirst';
+}
+
+/** @name PalletRmrkEquipEvent */
+export interface PalletRmrkEquipEvent extends Enum {
+  readonly isBaseCreated: boolean;
+  readonly asBaseCreated: {
+    readonly issuer: AccountId32;
+    readonly baseId: u32;
+  } & Struct;
+  readonly type: 'BaseCreated';
+}
+
 /** @name PalletStructureCall */
 export interface PalletStructureCall extends Null {}
 
@@ -2014,7 +2177,7 @@
 
 /** @name UpDataStructsRmrkResourceInfo */
 export interface UpDataStructsRmrkResourceInfo extends Struct {
-  readonly id: Bytes;
+  readonly id: u32;
   readonly resource: UpDataStructsRmrkResourceTypes;
   readonly pending: bool;
   readonly pendingRemoval: bool;

1527   * Lookup205: pallet_structure::pallet::Call<T>1527   * Lookup205: pallet_structure::pallet::Call<T>
1528   **/1528   **/
1529  PalletStructureCall: 'Null',1529  PalletStructureCall: 'Null',
1530  /**
1531   * Lookup206: pallet_rmrk_core::pallet::Call<T>
1532   **/
1533  PalletRmrkCoreCall: {
1534    _enum: {
1535      create_collection: {
1536        metadata: 'Bytes',
1537        max: 'Option<u32>',
1538        symbol: 'Bytes',
1539      },
1540      destroy_collection: {
1541        collectionId: 'u32',
1542      },
1543      change_collection_issuer: {
1544        collectionId: 'u32',
1545        newIssuer: 'MultiAddress',
1546      },
1547      lock_collection: {
1548        collectionId: 'u32',
1549      },
1550      mint_nft: {
1551        owner: 'AccountId32',
1552        collectionId: 'u32',
1553        recipient: 'Option<AccountId32>',
1554        royaltyAmount: 'Option<Permill>',
1555        metadata: 'Bytes',
1556      },
1557      burn_nft: {
1558        collectionId: 'u32',
1559        nftId: 'u32',
1560      },
1561      set_property: {
1562        rmrkCollectionId: 'Compact<u32>',
1563        maybeNftId: 'Option<u32>',
1564        key: 'Bytes',
1565        value: 'Bytes',
1566      },
1567      add_basic_resource: {
1568        collectionId: 'u32',
1569        nftId: 'u32',
1570        resource: 'UpDataStructsRmrkBasicResource',
1571      },
1572      add_composable_resource: {
1573        collectionId: 'u32',
1574        nftId: 'u32',
1575        resourceId: 'Bytes',
1576        resource: 'UpDataStructsRmrkComposableResource',
1577      },
1578      add_slot_resource: {
1579        collectionId: 'u32',
1580        nftId: 'u32',
1581        resource: 'UpDataStructsRmrkSlotResource'
1582      }
1583    }
1584  },
1585  /**
1586   * Lookup212: up_data_structs::rmrk::BasicResource<frame_support::storage::bounded_vec::BoundedVec<T, S>>
1587   **/
1588  UpDataStructsRmrkBasicResource: {
1589    src: 'Option<Bytes>',
1590    metadata: 'Option<Bytes>',
1591    license: 'Option<Bytes>',
1592    thumb: 'Option<Bytes>'
1593  },
1594  /**
1595   * Lookup215: up_data_structs::rmrk::ComposableResource<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
1596   **/
1597  UpDataStructsRmrkComposableResource: {
1598    parts: 'Vec<u32>',
1599    base: 'u32',
1600    src: 'Option<Bytes>',
1601    metadata: 'Option<Bytes>',
1602    license: 'Option<Bytes>',
1603    thumb: 'Option<Bytes>'
1604  },
1605  /**
1606   * Lookup217: up_data_structs::rmrk::SlotResource<frame_support::storage::bounded_vec::BoundedVec<T, S>>
1607   **/
1608  UpDataStructsRmrkSlotResource: {
1609    base: 'u32',
1610    src: 'Option<Bytes>',
1611    metadata: 'Option<Bytes>',
1612    slot: 'u32',
1613    license: 'Option<Bytes>',
1614    thumb: 'Option<Bytes>'
1615  },
1616  /**
1617   * Lookup218: pallet_rmrk_equip::pallet::Call<T>
1618   **/
1619  PalletRmrkEquipCall: {
1620    _enum: {
1621      create_base: {
1622        baseType: 'Bytes',
1623        symbol: 'Bytes',
1624        parts: 'Vec<UpDataStructsRmrkPartType>',
1625      },
1626      theme_add: {
1627        baseId: 'u32',
1628        theme: 'UpDataStructsRmrkTheme'
1629      }
1630    }
1631  },
1632  /**
1633   * Lookup220: up_data_structs::rmrk::PartType<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
1634   **/
1635  UpDataStructsRmrkPartType: {
1636    _enum: {
1637      FixedPart: 'UpDataStructsRmrkFixedPart',
1638      SlotPart: 'UpDataStructsRmrkSlotPart'
1639    }
1640  },
1641  /**
1642   * Lookup222: up_data_structs::rmrk::FixedPart<frame_support::storage::bounded_vec::BoundedVec<T, S>>
1643   **/
1644  UpDataStructsRmrkFixedPart: {
1645    id: 'u32',
1646    z: 'u32',
1647    src: 'Bytes'
1648  },
1649  /**
1650   * Lookup223: up_data_structs::rmrk::SlotPart<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
1651   **/
1652  UpDataStructsRmrkSlotPart: {
1653    id: 'u32',
1654    equippable: 'UpDataStructsRmrkEquippableList',
1655    src: 'Bytes',
1656    z: 'u32'
1657  },
1658  /**
1659   * Lookup224: up_data_structs::rmrk::EquippableList<frame_support::storage::bounded_vec::BoundedVec<T, S>>
1660   **/
1661  UpDataStructsRmrkEquippableList: {
1662    _enum: {
1663      All: 'Null',
1664      Empty: 'Null',
1665      Custom: 'Vec<u32>'
1666    }
1667  },
1668  /**
1669   * Lookup226: up_data_structs::rmrk::Theme<frame_support::storage::bounded_vec::BoundedVec<T, S>, PropertyList>
1670   **/
1671  UpDataStructsRmrkTheme: {
1672    name: 'Bytes',
1673    properties: 'Vec<UpDataStructsRmrkThemeProperty>',
1674    inherit: 'bool'
1675  },
1676  /**
1677   * Lookup228: up_data_structs::rmrk::ThemeProperty<frame_support::storage::bounded_vec::BoundedVec<T, S>>
1678   **/
1679  UpDataStructsRmrkThemeProperty: {
1680    key: 'Bytes',
1681    value: 'Bytes'
1682  },
1530  /**1683  /**
1531   * Lookup206: pallet_evm::pallet::Call<T>1684   * Lookup229: pallet_evm::pallet::Call<T>
1532   **/1685   **/
1533  PalletEvmCall: {1686  PalletEvmCall: {
1534    _enum: {1687    _enum: {
1535      withdraw: {1688      withdraw: {
1570      }1723      }
1571    }1724    }
1572  },1725  },
1573  /**1726  /**
1574   * Lookup212: pallet_ethereum::pallet::Call<T>1727   * Lookup235: pallet_ethereum::pallet::Call<T>
1575   **/1728   **/
1576  PalletEthereumCall: {1729  PalletEthereumCall: {
1577    _enum: {1730    _enum: {
1578      transact: {1731      transact: {
1579        transaction: 'EthereumTransactionTransactionV2'1732        transaction: 'EthereumTransactionTransactionV2'
1580      }1733      }
1581    }1734    }
1582  },1735  },
1583  /**1736  /**
1584   * Lookup213: ethereum::transaction::TransactionV21737   * Lookup236: ethereum::transaction::TransactionV2
1585   **/1738   **/
1586  EthereumTransactionTransactionV2: {1739  EthereumTransactionTransactionV2: {
1587    _enum: {1740    _enum: {
1588      Legacy: 'EthereumTransactionLegacyTransaction',1741      Legacy: 'EthereumTransactionLegacyTransaction',
1589      EIP2930: 'EthereumTransactionEip2930Transaction',1742      EIP2930: 'EthereumTransactionEip2930Transaction',
1590      EIP1559: 'EthereumTransactionEip1559Transaction'1743      EIP1559: 'EthereumTransactionEip1559Transaction'
1591    }1744    }
1592  },1745  },
1593  /**1746  /**
1594   * Lookup214: ethereum::transaction::LegacyTransaction1747   * Lookup237: ethereum::transaction::LegacyTransaction
1595   **/1748   **/
1596  EthereumTransactionLegacyTransaction: {1749  EthereumTransactionLegacyTransaction: {
1597    nonce: 'U256',1750    nonce: 'U256',
1598    gasPrice: 'U256',1751    gasPrice: 'U256',
1602    input: 'Bytes',1755    input: 'Bytes',
1603    signature: 'EthereumTransactionTransactionSignature'1756    signature: 'EthereumTransactionTransactionSignature'
1604  },1757  },
1605  /**1758  /**
1606   * Lookup215: ethereum::transaction::TransactionAction1759   * Lookup238: ethereum::transaction::TransactionAction
1607   **/1760   **/
1608  EthereumTransactionTransactionAction: {1761  EthereumTransactionTransactionAction: {
1609    _enum: {1762    _enum: {
1610      Call: 'H160',1763      Call: 'H160',
1611      Create: 'Null'1764      Create: 'Null'
1612    }1765    }
1613  },1766  },
1614  /**1767  /**
1615   * Lookup216: ethereum::transaction::TransactionSignature1768   * Lookup239: ethereum::transaction::TransactionSignature
1616   **/1769   **/
1617  EthereumTransactionTransactionSignature: {1770  EthereumTransactionTransactionSignature: {
1618    v: 'u64',1771    v: 'u64',
1619    r: 'H256',1772    r: 'H256',
1620    s: 'H256'1773    s: 'H256'
1621  },1774  },
1622  /**1775  /**
1623   * Lookup218: ethereum::transaction::EIP2930Transaction1776   * Lookup241: ethereum::transaction::EIP2930Transaction
1624   **/1777   **/
1625  EthereumTransactionEip2930Transaction: {1778  EthereumTransactionEip2930Transaction: {
1626    chainId: 'u64',1779    chainId: 'u64',
1627    nonce: 'U256',1780    nonce: 'U256',
1635    r: 'H256',1788    r: 'H256',
1636    s: 'H256'1789    s: 'H256'
1637  },1790  },
1638  /**1791  /**
1639   * Lookup220: ethereum::transaction::AccessListItem1792   * Lookup243: ethereum::transaction::AccessListItem
1640   **/1793   **/
1641  EthereumTransactionAccessListItem: {1794  EthereumTransactionAccessListItem: {
1642    address: 'H160',1795    address: 'H160',
1643    storageKeys: 'Vec<H256>'1796    storageKeys: 'Vec<H256>'
1644  },1797  },
1645  /**1798  /**
1646   * Lookup221: ethereum::transaction::EIP1559Transaction1799   * Lookup244: ethereum::transaction::EIP1559Transaction
1647   **/1800   **/
1648  EthereumTransactionEip1559Transaction: {1801  EthereumTransactionEip1559Transaction: {
1649    chainId: 'u64',1802    chainId: 'u64',
1650    nonce: 'U256',1803    nonce: 'U256',
1659    r: 'H256',1812    r: 'H256',
1660    s: 'H256'1813    s: 'H256'
1661  },1814  },
1662  /**1815  /**
1663   * Lookup222: pallet_evm_migration::pallet::Call<T>1816   * Lookup245: pallet_evm_migration::pallet::Call<T>
1664   **/1817   **/
1665  PalletEvmMigrationCall: {1818  PalletEvmMigrationCall: {
1666    _enum: {1819    _enum: {
1667      begin: {1820      begin: {
1677      }1830      }
1678    }1831    }
1679  },1832  },
1680  /**1833  /**
1681   * Lookup225: pallet_sudo::pallet::Event<T>1834   * Lookup248: pallet_sudo::pallet::Event<T>
1682   **/1835   **/
1683  PalletSudoEvent: {1836  PalletSudoEvent: {
1684    _enum: {1837    _enum: {
1685      Sudid: {1838      Sudid: {
1693      }1846      }
1694    }1847    }
1695  },1848  },
1696  /**1849  /**
1697   * Lookup227: sp_runtime::DispatchError1850   * Lookup250: sp_runtime::DispatchError
1698   **/1851   **/
1699  SpRuntimeDispatchError: {1852  SpRuntimeDispatchError: {
1700    _enum: {1853    _enum: {
1701      Other: 'Null',1854      Other: 'Null',
1710      Transactional: 'SpRuntimeTransactionalError'1863      Transactional: 'SpRuntimeTransactionalError'
1711    }1864    }
1712  },1865  },
1713  /**1866  /**
1714   * Lookup228: sp_runtime::ModuleError1867   * Lookup251: sp_runtime::ModuleError
1715   **/1868   **/
1716  SpRuntimeModuleError: {1869  SpRuntimeModuleError: {
1717    index: 'u8',1870    index: 'u8',
1718    error: '[u8;4]'1871    error: '[u8;4]'
1719  },1872  },
1720  /**1873  /**
1721   * Lookup229: sp_runtime::TokenError1874   * Lookup252: sp_runtime::TokenError
1722   **/1875   **/
1723  SpRuntimeTokenError: {1876  SpRuntimeTokenError: {
1724    _enum: ['NoFunds', 'WouldDie', 'BelowMinimum', 'CannotCreate', 'UnknownAsset', 'Frozen', 'Unsupported']1877    _enum: ['NoFunds', 'WouldDie', 'BelowMinimum', 'CannotCreate', 'UnknownAsset', 'Frozen', 'Unsupported']
1725  },1878  },
1726  /**1879  /**
1727   * Lookup230: sp_runtime::ArithmeticError1880   * Lookup253: sp_runtime::ArithmeticError
1728   **/1881   **/
1729  SpRuntimeArithmeticError: {1882  SpRuntimeArithmeticError: {
1730    _enum: ['Underflow', 'Overflow', 'DivisionByZero']1883    _enum: ['Underflow', 'Overflow', 'DivisionByZero']
1731  },1884  },
1732  /**1885  /**
1733   * Lookup231: sp_runtime::TransactionalError1886   * Lookup254: sp_runtime::TransactionalError
1734   **/1887   **/
1735  SpRuntimeTransactionalError: {1888  SpRuntimeTransactionalError: {
1736    _enum: ['LimitReached', 'NoLayer']1889    _enum: ['LimitReached', 'NoLayer']
1737  },1890  },
1738  /**1891  /**
1739   * Lookup232: pallet_sudo::pallet::Error<T>1892   * Lookup255: pallet_sudo::pallet::Error<T>
1740   **/1893   **/
1741  PalletSudoError: {1894  PalletSudoError: {
1742    _enum: ['RequireSudo']1895    _enum: ['RequireSudo']
1743  },1896  },
1744  /**1897  /**
1745   * Lookup233: frame_system::AccountInfo<Index, pallet_balances::AccountData<Balance>>1898   * Lookup256: frame_system::AccountInfo<Index, pallet_balances::AccountData<Balance>>
1746   **/1899   **/
1747  FrameSystemAccountInfo: {1900  FrameSystemAccountInfo: {
1748    nonce: 'u32',1901    nonce: 'u32',
1749    consumers: 'u32',1902    consumers: 'u32',
1750    providers: 'u32',1903    providers: 'u32',
1751    sufficients: 'u32',1904    sufficients: 'u32',
1752    data: 'PalletBalancesAccountData'1905    data: 'PalletBalancesAccountData'
1753  },1906  },
1754  /**1907  /**
1755   * Lookup234: frame_support::weights::PerDispatchClass<T>1908   * Lookup257: frame_support::weights::PerDispatchClass<T>
1756   **/1909   **/
1757  FrameSupportWeightsPerDispatchClassU64: {1910  FrameSupportWeightsPerDispatchClassU64: {
1758    normal: 'u64',1911    normal: 'u64',
1759    operational: 'u64',1912    operational: 'u64',
1760    mandatory: 'u64'1913    mandatory: 'u64'
1761  },1914  },
1762  /**1915  /**
1763   * Lookup235: sp_runtime::generic::digest::Digest1916   * Lookup258: sp_runtime::generic::digest::Digest
1764   **/1917   **/
1765  SpRuntimeDigest: {1918  SpRuntimeDigest: {
1766    logs: 'Vec<SpRuntimeDigestDigestItem>'1919    logs: 'Vec<SpRuntimeDigestDigestItem>'
1767  },1920  },
1768  /**1921  /**
1769   * Lookup237: sp_runtime::generic::digest::DigestItem1922   * Lookup260: sp_runtime::generic::digest::DigestItem
1770   **/1923   **/
1771  SpRuntimeDigestDigestItem: {1924  SpRuntimeDigestDigestItem: {
1772    _enum: {1925    _enum: {
1773      Other: 'Bytes',1926      Other: 'Bytes',
1781      RuntimeEnvironmentUpdated: 'Null'1934      RuntimeEnvironmentUpdated: 'Null'
1782    }1935    }
1783  },1936  },
1784  /**1937  /**
1785   * Lookup239: frame_system::EventRecord<opal_runtime::Event, primitive_types::H256>1938   * Lookup262: frame_system::EventRecord<opal_runtime::Event, primitive_types::H256>
1786   **/1939   **/
1787  FrameSystemEventRecord: {1940  FrameSystemEventRecord: {
1788    phase: 'FrameSystemPhase',1941    phase: 'FrameSystemPhase',
1789    event: 'Event',1942    event: 'Event',
1790    topics: 'Vec<H256>'1943    topics: 'Vec<H256>'
1791  },1944  },
1792  /**1945  /**
1793   * Lookup241: frame_system::pallet::Event<T>1946   * Lookup264: frame_system::pallet::Event<T>
1794   **/1947   **/
1795  FrameSystemEvent: {1948  FrameSystemEvent: {
1796    _enum: {1949    _enum: {
1797      ExtrinsicSuccess: {1950      ExtrinsicSuccess: {
1817      }1970      }
1818    }1971    }
1819  },1972  },
1820  /**1973  /**
1821   * Lookup242: frame_support::weights::DispatchInfo1974   * Lookup265: frame_support::weights::DispatchInfo
1822   **/1975   **/
1823  FrameSupportWeightsDispatchInfo: {1976  FrameSupportWeightsDispatchInfo: {
1824    weight: 'u64',1977    weight: 'u64',
1825    class: 'FrameSupportWeightsDispatchClass',1978    class: 'FrameSupportWeightsDispatchClass',
1826    paysFee: 'FrameSupportWeightsPays'1979    paysFee: 'FrameSupportWeightsPays'
1827  },1980  },
1828  /**1981  /**
1829   * Lookup243: frame_support::weights::DispatchClass1982   * Lookup266: frame_support::weights::DispatchClass
1830   **/1983   **/
1831  FrameSupportWeightsDispatchClass: {1984  FrameSupportWeightsDispatchClass: {
1832    _enum: ['Normal', 'Operational', 'Mandatory']1985    _enum: ['Normal', 'Operational', 'Mandatory']
1833  },1986  },
1834  /**1987  /**
1835   * Lookup244: frame_support::weights::Pays1988   * Lookup267: frame_support::weights::Pays
1836   **/1989   **/
1837  FrameSupportWeightsPays: {1990  FrameSupportWeightsPays: {
1838    _enum: ['Yes', 'No']1991    _enum: ['Yes', 'No']
1839  },1992  },
1840  /**1993  /**
1841   * Lookup245: orml_vesting::module::Event<T>1994   * Lookup268: orml_vesting::module::Event<T>
1842   **/1995   **/
1843  OrmlVestingModuleEvent: {1996  OrmlVestingModuleEvent: {
1844    _enum: {1997    _enum: {
1845      VestingScheduleAdded: {1998      VestingScheduleAdded: {
1856      }2009      }
1857    }2010    }
1858  },2011  },
1859  /**2012  /**
1860   * Lookup246: cumulus_pallet_xcmp_queue::pallet::Event<T>2013   * Lookup269: cumulus_pallet_xcmp_queue::pallet::Event<T>
1861   **/2014   **/
1862  CumulusPalletXcmpQueueEvent: {2015  CumulusPalletXcmpQueueEvent: {
1863    _enum: {2016    _enum: {
1864      Success: 'Option<H256>',2017      Success: 'Option<H256>',
1871      OverweightServiced: '(u64,u64)'2024      OverweightServiced: '(u64,u64)'
1872    }2025    }
1873  },2026  },
1874  /**2027  /**
1875   * Lookup247: pallet_xcm::pallet::Event<T>2028   * Lookup270: pallet_xcm::pallet::Event<T>
1876   **/2029   **/
1877  PalletXcmEvent: {2030  PalletXcmEvent: {
1878    _enum: {2031    _enum: {
1879      Attempted: 'XcmV2TraitsOutcome',2032      Attempted: 'XcmV2TraitsOutcome',
1894      NotifyTargetMigrationFail: '(XcmVersionedMultiLocation,u64)'2047      NotifyTargetMigrationFail: '(XcmVersionedMultiLocation,u64)'
1895    }2048    }
1896  },2049  },
1897  /**2050  /**
1898   * Lookup248: xcm::v2::traits::Outcome2051   * Lookup271: xcm::v2::traits::Outcome
1899   **/2052   **/
1900  XcmV2TraitsOutcome: {2053  XcmV2TraitsOutcome: {
1901    _enum: {2054    _enum: {
1902      Complete: 'u64',2055      Complete: 'u64',
1903      Incomplete: '(u64,XcmV2TraitsError)',2056      Incomplete: '(u64,XcmV2TraitsError)',
1904      Error: 'XcmV2TraitsError'2057      Error: 'XcmV2TraitsError'
1905    }2058    }
1906  },2059  },
1907  /**2060  /**
1908   * Lookup250: cumulus_pallet_xcm::pallet::Event<T>2061   * Lookup273: cumulus_pallet_xcm::pallet::Event<T>
1909   **/2062   **/
1910  CumulusPalletXcmEvent: {2063  CumulusPalletXcmEvent: {
1911    _enum: {2064    _enum: {
1912      InvalidFormat: '[u8;8]',2065      InvalidFormat: '[u8;8]',
1913      UnsupportedVersion: '[u8;8]',2066      UnsupportedVersion: '[u8;8]',
1914      ExecutedDownward: '([u8;8],XcmV2TraitsOutcome)'2067      ExecutedDownward: '([u8;8],XcmV2TraitsOutcome)'
1915    }2068    }
1916  },2069  },
1917  /**2070  /**
1918   * Lookup251: cumulus_pallet_dmp_queue::pallet::Event<T>2071   * Lookup274: cumulus_pallet_dmp_queue::pallet::Event<T>
1919   **/2072   **/
1920  CumulusPalletDmpQueueEvent: {2073  CumulusPalletDmpQueueEvent: {
1921    _enum: {2074    _enum: {
1922      InvalidFormat: '[u8;32]',2075      InvalidFormat: '[u8;32]',
1927      OverweightServiced: '(u64,u64)'2080      OverweightServiced: '(u64,u64)'
1928    }2081    }
1929  },2082  },
1930  /**2083  /**
1931   * Lookup252: pallet_unique::RawEvent<sp_core::crypto::AccountId32, pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>2084   * Lookup275: pallet_unique::RawEvent<sp_core::crypto::AccountId32, pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
1932   **/2085   **/
1933  PalletUniqueRawEvent: {2086  PalletUniqueRawEvent: {
1934    _enum: {2087    _enum: {
1935      CollectionSponsorRemoved: 'u32',2088      CollectionSponsorRemoved: 'u32',
1944      CollectionPermissionSet: 'u32'2097      CollectionPermissionSet: 'u32'
1945    }2098    }
1946  },2099  },
1947  /**2100  /**
1948   * Lookup253: pallet_common::pallet::Event<T>2101   * Lookup276: pallet_common::pallet::Event<T>
1949   **/2102   **/
1950  PalletCommonEvent: {2103  PalletCommonEvent: {
1951    _enum: {2104    _enum: {
1952      CollectionCreated: '(u32,u8,AccountId32)',2105      CollectionCreated: '(u32,u8,AccountId32)',
1962      PropertyPermissionSet: '(u32,Bytes)'2115      PropertyPermissionSet: '(u32,Bytes)'
1963    }2116    }
1964  },2117  },
1965  /**2118  /**
1966   * Lookup254: pallet_structure::pallet::Event<T>2119   * Lookup277: pallet_structure::pallet::Event<T>
1967   **/2120   **/
1968  PalletStructureEvent: {2121  PalletStructureEvent: {
1969    _enum: {2122    _enum: {
1970      Executed: 'Result<Null, SpRuntimeDispatchError>'2123      Executed: 'Result<Null, SpRuntimeDispatchError>'
1971    }2124    }
1972  },2125  },
2126  /**
2127   * Lookup278: pallet_rmrk_core::pallet::Event<T>
2128   **/
2129  PalletRmrkCoreEvent: {
2130    _enum: {
2131      CollectionCreated: {
2132        issuer: 'AccountId32',
2133        collectionId: 'u32',
2134      },
2135      CollectionDestroyed: {
2136        issuer: 'AccountId32',
2137        collectionId: 'u32',
2138      },
2139      IssuerChanged: {
2140        oldIssuer: 'AccountId32',
2141        newIssuer: 'AccountId32',
2142        collectionId: 'u32',
2143      },
2144      CollectionLocked: {
2145        issuer: 'AccountId32',
2146        collectionId: 'u32',
2147      },
2148      NftMinted: {
2149        owner: 'AccountId32',
2150        collectionId: 'u32',
2151        nftId: 'u32',
2152      },
2153      NFTBurned: {
2154        owner: 'AccountId32',
2155        nftId: 'u32',
2156      },
2157      PropertySet: {
2158        collectionId: 'u32',
2159        maybeNftId: 'Option<u32>',
2160        key: 'Bytes',
2161        value: 'Bytes',
2162      },
2163      ResourceAdded: {
2164        nftId: 'u32',
2165        resourceId: 'u32'
2166      }
2167    }
2168  },
2169  /**
2170   * Lookup279: pallet_rmrk_equip::pallet::Event<T>
2171   **/
2172  PalletRmrkEquipEvent: {
2173    _enum: {
2174      BaseCreated: {
2175        issuer: 'AccountId32',
2176        baseId: 'u32'
2177      }
2178    }
2179  },
1973  /**2180  /**
1974   * Lookup255: pallet_evm::pallet::Event<T>2181   * Lookup280: pallet_evm::pallet::Event<T>
1975   **/2182   **/
1976  PalletEvmEvent: {2183  PalletEvmEvent: {
1977    _enum: {2184    _enum: {
1978      Log: 'EthereumLog',2185      Log: 'EthereumLog',
1984      BalanceWithdraw: '(AccountId32,H160,U256)'2191      BalanceWithdraw: '(AccountId32,H160,U256)'
1985    }2192    }
1986  },2193  },
1987  /**2194  /**
1988   * Lookup256: ethereum::log::Log2195   * Lookup281: ethereum::log::Log
1989   **/2196   **/
1990  EthereumLog: {2197  EthereumLog: {
1991    address: 'H160',2198    address: 'H160',
1992    topics: 'Vec<H256>',2199    topics: 'Vec<H256>',
1993    data: 'Bytes'2200    data: 'Bytes'
1994  },2201  },
1995  /**2202  /**
1996   * Lookup257: pallet_ethereum::pallet::Event2203   * Lookup282: pallet_ethereum::pallet::Event
1997   **/2204   **/
1998  PalletEthereumEvent: {2205  PalletEthereumEvent: {
1999    _enum: {2206    _enum: {
2000      Executed: '(H160,H160,H256,EvmCoreErrorExitReason)'2207      Executed: '(H160,H160,H256,EvmCoreErrorExitReason)'
2001    }2208    }
2002  },2209  },
2003  /**2210  /**
2004   * Lookup258: evm_core::error::ExitReason2211   * Lookup283: evm_core::error::ExitReason
2005   **/2212   **/
2006  EvmCoreErrorExitReason: {2213  EvmCoreErrorExitReason: {
2007    _enum: {2214    _enum: {
2008      Succeed: 'EvmCoreErrorExitSucceed',2215      Succeed: 'EvmCoreErrorExitSucceed',
2011      Fatal: 'EvmCoreErrorExitFatal'2218      Fatal: 'EvmCoreErrorExitFatal'
2012    }2219    }
2013  },2220  },
2014  /**2221  /**
2015   * Lookup259: evm_core::error::ExitSucceed2222   * Lookup284: evm_core::error::ExitSucceed
2016   **/2223   **/
2017  EvmCoreErrorExitSucceed: {2224  EvmCoreErrorExitSucceed: {
2018    _enum: ['Stopped', 'Returned', 'Suicided']2225    _enum: ['Stopped', 'Returned', 'Suicided']
2019  },2226  },
2020  /**2227  /**
2021   * Lookup260: evm_core::error::ExitError2228   * Lookup285: evm_core::error::ExitError
2022   **/2229   **/
2023  EvmCoreErrorExitError: {2230  EvmCoreErrorExitError: {
2024    _enum: {2231    _enum: {
2025      StackUnderflow: 'Null',2232      StackUnderflow: 'Null',
2039      InvalidCode: 'Null'2246      InvalidCode: 'Null'
2040    }2247    }
2041  },2248  },
2042  /**2249  /**
2043   * Lookup263: evm_core::error::ExitRevert2250   * Lookup288: evm_core::error::ExitRevert
2044   **/2251   **/
2045  EvmCoreErrorExitRevert: {2252  EvmCoreErrorExitRevert: {
2046    _enum: ['Reverted']2253    _enum: ['Reverted']
2047  },2254  },
2048  /**2255  /**
2049   * Lookup264: evm_core::error::ExitFatal2256   * Lookup289: evm_core::error::ExitFatal
2050   **/2257   **/
2051  EvmCoreErrorExitFatal: {2258  EvmCoreErrorExitFatal: {
2052    _enum: {2259    _enum: {
2053      NotSupported: 'Null',2260      NotSupported: 'Null',
2056      Other: 'Text'2263      Other: 'Text'
2057    }2264    }
2058  },2265  },
2059  /**2266  /**
2060   * Lookup265: frame_system::Phase2267   * Lookup290: frame_system::Phase
2061   **/2268   **/
2062  FrameSystemPhase: {2269  FrameSystemPhase: {
2063    _enum: {2270    _enum: {
2064      ApplyExtrinsic: 'u32',2271      ApplyExtrinsic: 'u32',
2065      Finalization: 'Null',2272      Finalization: 'Null',
2066      Initialization: 'Null'2273      Initialization: 'Null'
2067    }2274    }
2068  },2275  },
2069  /**2276  /**
2070   * Lookup267: frame_system::LastRuntimeUpgradeInfo2277   * Lookup292: frame_system::LastRuntimeUpgradeInfo
2071   **/2278   **/
2072  FrameSystemLastRuntimeUpgradeInfo: {2279  FrameSystemLastRuntimeUpgradeInfo: {
2073    specVersion: 'Compact<u32>',2280    specVersion: 'Compact<u32>',
2074    specName: 'Text'2281    specName: 'Text'
2075  },2282  },
2076  /**2283  /**
2077   * Lookup268: frame_system::limits::BlockWeights2284   * Lookup293: frame_system::limits::BlockWeights
2078   **/2285   **/
2079  FrameSystemLimitsBlockWeights: {2286  FrameSystemLimitsBlockWeights: {
2080    baseBlock: 'u64',2287    baseBlock: 'u64',
2081    maxBlock: 'u64',2288    maxBlock: 'u64',
2082    perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass'2289    perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass'
2083  },2290  },
2084  /**2291  /**
2085   * Lookup269: frame_support::weights::PerDispatchClass<frame_system::limits::WeightsPerClass>2292   * Lookup294: frame_support::weights::PerDispatchClass<frame_system::limits::WeightsPerClass>
2086   **/2293   **/
2087  FrameSupportWeightsPerDispatchClassWeightsPerClass: {2294  FrameSupportWeightsPerDispatchClassWeightsPerClass: {
2088    normal: 'FrameSystemLimitsWeightsPerClass',2295    normal: 'FrameSystemLimitsWeightsPerClass',
2089    operational: 'FrameSystemLimitsWeightsPerClass',2296    operational: 'FrameSystemLimitsWeightsPerClass',
2090    mandatory: 'FrameSystemLimitsWeightsPerClass'2297    mandatory: 'FrameSystemLimitsWeightsPerClass'
2091  },2298  },
2092  /**2299  /**
2093   * Lookup270: frame_system::limits::WeightsPerClass2300   * Lookup295: frame_system::limits::WeightsPerClass
2094   **/2301   **/
2095  FrameSystemLimitsWeightsPerClass: {2302  FrameSystemLimitsWeightsPerClass: {
2096    baseExtrinsic: 'u64',2303    baseExtrinsic: 'u64',
2097    maxExtrinsic: 'Option<u64>',2304    maxExtrinsic: 'Option<u64>',
2098    maxTotal: 'Option<u64>',2305    maxTotal: 'Option<u64>',
2099    reserved: 'Option<u64>'2306    reserved: 'Option<u64>'
2100  },2307  },
2101  /**2308  /**
2102   * Lookup272: frame_system::limits::BlockLength2309   * Lookup297: frame_system::limits::BlockLength
2103   **/2310   **/
2104  FrameSystemLimitsBlockLength: {2311  FrameSystemLimitsBlockLength: {
2105    max: 'FrameSupportWeightsPerDispatchClassU32'2312    max: 'FrameSupportWeightsPerDispatchClassU32'
2106  },2313  },
2107  /**2314  /**
2108   * Lookup273: frame_support::weights::PerDispatchClass<T>2315   * Lookup298: frame_support::weights::PerDispatchClass<T>
2109   **/2316   **/
2110  FrameSupportWeightsPerDispatchClassU32: {2317  FrameSupportWeightsPerDispatchClassU32: {
2111    normal: 'u32',2318    normal: 'u32',
2112    operational: 'u32',2319    operational: 'u32',
2113    mandatory: 'u32'2320    mandatory: 'u32'
2114  },2321  },
2115  /**2322  /**
2116   * Lookup274: frame_support::weights::RuntimeDbWeight2323   * Lookup299: frame_support::weights::RuntimeDbWeight
2117   **/2324   **/
2118  FrameSupportWeightsRuntimeDbWeight: {2325  FrameSupportWeightsRuntimeDbWeight: {
2119    read: 'u64',2326    read: 'u64',
2120    write: 'u64'2327    write: 'u64'
2121  },2328  },
2122  /**2329  /**
2123   * Lookup275: sp_version::RuntimeVersion2330   * Lookup300: sp_version::RuntimeVersion
2124   **/2331   **/
2125  SpVersionRuntimeVersion: {2332  SpVersionRuntimeVersion: {
2126    specName: 'Text',2333    specName: 'Text',
2127    implName: 'Text',2334    implName: 'Text',
2132    transactionVersion: 'u32',2339    transactionVersion: 'u32',
2133    stateVersion: 'u8'2340    stateVersion: 'u8'
2134  },2341  },
2135  /**2342  /**
2136   * Lookup279: frame_system::pallet::Error<T>2343   * Lookup304: frame_system::pallet::Error<T>
2137   **/2344   **/
2138  FrameSystemError: {2345  FrameSystemError: {
2139    _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered']2346    _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered']
2140  },2347  },
2141  /**2348  /**
2142   * Lookup281: orml_vesting::module::Error<T>2349   * Lookup306: orml_vesting::module::Error<T>
2143   **/2350   **/
2144  OrmlVestingModuleError: {2351  OrmlVestingModuleError: {
2145    _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded']2352    _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded']
2146  },2353  },
2147  /**2354  /**
2148   * Lookup283: cumulus_pallet_xcmp_queue::InboundChannelDetails2355   * Lookup308: cumulus_pallet_xcmp_queue::InboundChannelDetails
2149   **/2356   **/
2150  CumulusPalletXcmpQueueInboundChannelDetails: {2357  CumulusPalletXcmpQueueInboundChannelDetails: {
2151    sender: 'u32',2358    sender: 'u32',
2152    state: 'CumulusPalletXcmpQueueInboundState',2359    state: 'CumulusPalletXcmpQueueInboundState',
2153    messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>'2360    messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>'
2154  },2361  },
2155  /**2362  /**
2156   * Lookup284: cumulus_pallet_xcmp_queue::InboundState2363   * Lookup309: cumulus_pallet_xcmp_queue::InboundState
2157   **/2364   **/
2158  CumulusPalletXcmpQueueInboundState: {2365  CumulusPalletXcmpQueueInboundState: {
2159    _enum: ['Ok', 'Suspended']2366    _enum: ['Ok', 'Suspended']
2160  },2367  },
2161  /**2368  /**
2162   * Lookup287: polkadot_parachain::primitives::XcmpMessageFormat2369   * Lookup312: polkadot_parachain::primitives::XcmpMessageFormat
2163   **/2370   **/
2164  PolkadotParachainPrimitivesXcmpMessageFormat: {2371  PolkadotParachainPrimitivesXcmpMessageFormat: {
2165    _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals']2372    _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals']
2166  },2373  },
2167  /**2374  /**
2168   * Lookup290: cumulus_pallet_xcmp_queue::OutboundChannelDetails2375   * Lookup315: cumulus_pallet_xcmp_queue::OutboundChannelDetails
2169   **/2376   **/
2170  CumulusPalletXcmpQueueOutboundChannelDetails: {2377  CumulusPalletXcmpQueueOutboundChannelDetails: {
2171    recipient: 'u32',2378    recipient: 'u32',
2172    state: 'CumulusPalletXcmpQueueOutboundState',2379    state: 'CumulusPalletXcmpQueueOutboundState',
2173    signalsExist: 'bool',2380    signalsExist: 'bool',
2174    firstIndex: 'u16',2381    firstIndex: 'u16',
2175    lastIndex: 'u16'2382    lastIndex: 'u16'
2176  },2383  },
2177  /**2384  /**
2178   * Lookup291: cumulus_pallet_xcmp_queue::OutboundState2385   * Lookup316: cumulus_pallet_xcmp_queue::OutboundState
2179   **/2386   **/
2180  CumulusPalletXcmpQueueOutboundState: {2387  CumulusPalletXcmpQueueOutboundState: {
2181    _enum: ['Ok', 'Suspended']2388    _enum: ['Ok', 'Suspended']
2182  },2389  },
2183  /**2390  /**
2184   * Lookup293: cumulus_pallet_xcmp_queue::QueueConfigData2391   * Lookup318: cumulus_pallet_xcmp_queue::QueueConfigData
2185   **/2392   **/
2186  CumulusPalletXcmpQueueQueueConfigData: {2393  CumulusPalletXcmpQueueQueueConfigData: {
2187    suspendThreshold: 'u32',2394    suspendThreshold: 'u32',
2188    dropThreshold: 'u32',2395    dropThreshold: 'u32',
2191    weightRestrictDecay: 'u64',2398    weightRestrictDecay: 'u64',
2192    xcmpMaxIndividualWeight: 'u64'2399    xcmpMaxIndividualWeight: 'u64'
2193  },2400  },
2194  /**2401  /**
2195   * Lookup295: cumulus_pallet_xcmp_queue::pallet::Error<T>2402   * Lookup320: cumulus_pallet_xcmp_queue::pallet::Error<T>
2196   **/2403   **/
2197  CumulusPalletXcmpQueueError: {2404  CumulusPalletXcmpQueueError: {
2198    _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit']2405    _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit']
2199  },2406  },
2200  /**2407  /**
2201   * Lookup296: pallet_xcm::pallet::Error<T>2408   * Lookup321: pallet_xcm::pallet::Error<T>
2202   **/2409   **/
2203  PalletXcmError: {2410  PalletXcmError: {
2204    _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed']2411    _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed']
2205  },2412  },
2206  /**2413  /**
2207   * Lookup297: cumulus_pallet_xcm::pallet::Error<T>2414   * Lookup322: cumulus_pallet_xcm::pallet::Error<T>
2208   **/2415   **/
2209  CumulusPalletXcmError: 'Null',2416  CumulusPalletXcmError: 'Null',
2210  /**2417  /**
2211   * Lookup298: cumulus_pallet_dmp_queue::ConfigData2418   * Lookup323: cumulus_pallet_dmp_queue::ConfigData
2212   **/2419   **/
2213  CumulusPalletDmpQueueConfigData: {2420  CumulusPalletDmpQueueConfigData: {
2214    maxIndividual: 'u64'2421    maxIndividual: 'u64'
2215  },2422  },
2216  /**2423  /**
2217   * Lookup299: cumulus_pallet_dmp_queue::PageIndexData2424   * Lookup324: cumulus_pallet_dmp_queue::PageIndexData
2218   **/2425   **/
2219  CumulusPalletDmpQueuePageIndexData: {2426  CumulusPalletDmpQueuePageIndexData: {
2220    beginUsed: 'u32',2427    beginUsed: 'u32',
2221    endUsed: 'u32',2428    endUsed: 'u32',
2222    overweightCount: 'u64'2429    overweightCount: 'u64'
2223  },2430  },
2224  /**2431  /**
2225   * Lookup302: cumulus_pallet_dmp_queue::pallet::Error<T>2432   * Lookup327: cumulus_pallet_dmp_queue::pallet::Error<T>
2226   **/2433   **/
2227  CumulusPalletDmpQueueError: {2434  CumulusPalletDmpQueueError: {
2228    _enum: ['Unknown', 'OverLimit']2435    _enum: ['Unknown', 'OverLimit']
2229  },2436  },
2230  /**2437  /**
2231   * Lookup306: pallet_unique::Error<T>2438   * Lookup331: pallet_unique::Error<T>
2232   **/2439   **/
2233  PalletUniqueError: {2440  PalletUniqueError: {
2234    _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument']2441    _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument']
2235  },2442  },
2236  /**2443  /**
2237   * Lookup307: up_data_structs::Collection<sp_core::crypto::AccountId32>2444   * Lookup332: up_data_structs::Collection<sp_core::crypto::AccountId32>
2238   **/2445   **/
2239  UpDataStructsCollection: {2446  UpDataStructsCollection: {
2240    owner: 'AccountId32',2447    owner: 'AccountId32',
2241    mode: 'UpDataStructsCollectionMode',2448    mode: 'UpDataStructsCollectionMode',
2246    limits: 'UpDataStructsCollectionLimits',2453    limits: 'UpDataStructsCollectionLimits',
2247    permissions: 'UpDataStructsCollectionPermissions'2454    permissions: 'UpDataStructsCollectionPermissions'
2248  },2455  },
2249  /**2456  /**
2250   * Lookup308: up_data_structs::SponsorshipState<sp_core::crypto::AccountId32>2457   * Lookup333: up_data_structs::SponsorshipState<sp_core::crypto::AccountId32>
2251   **/2458   **/
2252  UpDataStructsSponsorshipState: {2459  UpDataStructsSponsorshipState: {
2253    _enum: {2460    _enum: {
2254      Disabled: 'Null',2461      Disabled: 'Null',
2255      Unconfirmed: 'AccountId32',2462      Unconfirmed: 'AccountId32',
2256      Confirmed: 'AccountId32'2463      Confirmed: 'AccountId32'
2257    }2464    }
2258  },2465  },
2259  /**2466  /**
2260   * Lookup309: up_data_structs::Properties2467   * Lookup334: up_data_structs::Properties
2261   **/2468   **/
2262  UpDataStructsProperties: {2469  UpDataStructsProperties: {
2263    map: 'UpDataStructsPropertiesMapBoundedVec',2470    map: 'UpDataStructsPropertiesMapBoundedVec',
2264    consumedSpace: 'u32',2471    consumedSpace: 'u32',
2265    spaceLimit: 'u32'2472    spaceLimit: 'u32'
2266  },2473  },
2267  /**2474  /**
2268   * Lookup310: up_data_structs::PropertiesMap<frame_support::storage::bounded_vec::BoundedVec<T, S>>2475   * Lookup335: up_data_structs::PropertiesMap<frame_support::storage::bounded_vec::BoundedVec<T, S>>
2269   **/2476   **/
2270  UpDataStructsPropertiesMapBoundedVec: 'BTreeMap<Bytes, Bytes>',2477  UpDataStructsPropertiesMapBoundedVec: 'BTreeMap<Bytes, Bytes>',
2271  /**2478  /**
2272   * Lookup315: up_data_structs::PropertiesMap<up_data_structs::PropertyPermission>2479   * Lookup340: up_data_structs::PropertiesMap<up_data_structs::PropertyPermission>
2273   **/2480   **/
2274  UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap<Bytes, UpDataStructsPropertyPermission>',2481  UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap<Bytes, UpDataStructsPropertyPermission>',
2275  /**2482  /**
2276   * Lookup322: up_data_structs::CollectionStats2483   * Lookup347: up_data_structs::CollectionStats
2277   **/2484   **/
2278  UpDataStructsCollectionStats: {2485  UpDataStructsCollectionStats: {
2279    created: 'u32',2486    created: 'u32',
2280    destroyed: 'u32',2487    destroyed: 'u32',
2353   * Lookup336: up_data_structs::rmrk::ResourceInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>2560   * Lookup336: up_data_structs::rmrk::ResourceInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
2354   **/2561   **/
2355  UpDataStructsRmrkResourceInfo: {2562  UpDataStructsRmrkResourceInfo: {
2356    id: 'Bytes',2563    id: 'u32',
2357    resource: 'UpDataStructsRmrkResourceTypes',2564    resource: 'UpDataStructsRmrkResourceTypes',
2358    pending: 'bool',2565    pending: 'bool',
2359    pendingRemoval: 'bool'2566    pendingRemoval: 'bool'