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

difftreelog

createItem* fixes

kryadinskii2022-05-19parents: #b80b794 #a7fe253.patch.diff
in: master

43 files changed

modifiedCargo.lockdiffbeforeafterboth
before · Cargo.lock
1007 packageslockfile v3
modifiedclient/rpc/Cargo.tomldiffbeforeafterboth
--- a/client/rpc/Cargo.toml
+++ b/client/rpc/Cargo.toml
@@ -5,6 +5,7 @@
 edition = "2021"
 
 [dependencies]
+unique-runtime-common = { default-features = false, path = "../../runtime/common" }
 pallet-common = { default-features = false, path = '../../pallets/common' }
 up-data-structs = { default-features = false, path = '../../primitives/data-structs' }
 up-rpc = { path = "../../primitives/rpc" }
@@ -19,3 +20,8 @@
 sp-rpc = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
 sp-runtime = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
 pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }
+
+# RMRK
+# todo git
+rmrk-rpc = { git = "https://github.com/UniqueNetwork/rmrk-substrate.git", branch = "feature/separate-types-and-traits" } 
+rmrk-types = { git = "https://github.com/UniqueNetwork/rmrk-substrate.git", branch = "feature/separate-types-and-traits" }
modifiedclient/rpc/src/lib.rsdiffbeforeafterboth
--- a/client/rpc/src/lib.rs
+++ b/client/rpc/src/lib.rs
@@ -16,7 +16,7 @@
 
 use std::sync::Arc;
 
-use codec::Decode;
+use codec::{Decode, Encode};
 use jsonrpc_core::{Error as RpcError, ErrorCode, Result};
 use jsonrpc_derive::rpc;
 use up_data_structs::{
@@ -27,6 +27,15 @@
 use sp_blockchain::HeaderBackend;
 use up_rpc::UniqueApi as UniqueRuntimeApi;
 
+// RMRK
+use rmrk_rpc::RmrkApi as RmrkRuntimeApi;
+use up_data_structs::{
+	RmrkCollectionId, RmrkNftId, RmrkBaseId, RmrkNftChild, RmrkThemeName, RmrkPropertyKey,
+	RmrkResourceId,
+};
+
+pub use rmrk_unique_rpc::RmrkApi;
+
 #[rpc]
 pub trait UniqueApi<BlockHash, CrossAccountId, AccountId> {
 	#[rpc(name = "unique_accountTokens")]
@@ -179,6 +188,124 @@
 	) -> Result<Option<CollectionLimits>>;
 }
 
+mod rmrk_unique_rpc {
+	use super::*;
+
+	#[rpc(server)]
+	pub trait RmrkApi<
+		BlockHash,
+		AccountId,
+		CollectionInfo,
+		NftInfo,
+		ResourceInfo,
+		PropertyInfo,
+		BaseInfo,
+		PartType,
+		Theme,
+	>
+	{
+		#[rpc(name = "rmrk_lastCollectionIdx")]
+		/// Get the latest created collection id
+		fn last_collection_idx(&self, at: Option<BlockHash>) -> Result<RmrkCollectionId>;
+
+		#[rpc(name = "rmrk_collectionById")]
+		/// Get collection by id
+		fn collection_by_id(
+			&self,
+			id: RmrkCollectionId,
+			at: Option<BlockHash>,
+		) -> Result<Option<CollectionInfo>>;
+
+		#[rpc(name = "rmrk_nftById")]
+		/// Get NFT by collection id and NFT id
+		fn nft_by_id(
+			&self,
+			collection_id: RmrkCollectionId,
+			nft_id: RmrkNftId,
+			at: Option<BlockHash>,
+		) -> Result<Option<NftInfo>>;
+
+		#[rpc(name = "rmrk_accountTokens")]
+		/// Get tokens owned by an account in a collection
+		fn account_tokens(
+			&self,
+			account_id: AccountId,
+			collection_id: RmrkCollectionId,
+			at: Option<BlockHash>,
+		) -> Result<Vec<RmrkNftId>>;
+
+		#[rpc(name = "rmrk_nftChildren")]
+		/// Get NFT children
+		fn nft_children(
+			&self,
+			collection_id: RmrkCollectionId,
+			nft_id: RmrkNftId,
+			at: Option<BlockHash>,
+		) -> Result<Vec<RmrkNftChild>>;
+
+		#[rpc(name = "rmrk_collectionProperties")]
+		/// Get collection properties
+		fn collection_properties(
+			&self,
+			collection_id: RmrkCollectionId,
+			filter_keys: Option<Vec<RmrkPropertyKey>>, //String
+			at: Option<BlockHash>,
+		) -> Result<Vec<PropertyInfo>>;
+
+		#[rpc(name = "rmrk_nftProperties")]
+		/// Get NFT properties
+		fn nft_properties(
+			&self,
+			collection_id: RmrkCollectionId,
+			nft_id: RmrkNftId,
+			filter_keys: Option<Vec<RmrkPropertyKey>>,
+			at: Option<BlockHash>,
+		) -> Result<Vec<PropertyInfo>>;
+
+		#[rpc(name = "rmrk_nftResources")]
+		/// Get NFT resources
+		fn nft_resources(
+			&self,
+			collection_id: RmrkCollectionId,
+			nft_id: RmrkNftId,
+			at: Option<BlockHash>,
+		) -> Result<Vec<ResourceInfo>>;
+
+		#[rpc(name = "rmrk_nftResourcePriorities")]
+		/// Get NFT resource priorities
+		fn nft_resource_priorities(
+			&self,
+			collection_id: RmrkCollectionId,
+			nft_id: RmrkNftId,
+			at: Option<BlockHash>,
+		) -> Result<Vec<RmrkResourceId>>;
+
+		#[rpc(name = "rmrk_base")]
+		/// Get base info
+		fn base(&self, base_id: RmrkBaseId, at: Option<BlockHash>) -> Result<Option<BaseInfo>>;
+
+		#[rpc(name = "rmrk_baseParts")]
+		/// Get all Base's parts
+		fn base_parts(&self, base_id: RmrkBaseId, at: Option<BlockHash>) -> Result<Vec<PartType>>;
+
+		#[rpc(name = "rmrk_themeNames")]
+		fn theme_names(
+			&self,
+			base_id: RmrkBaseId,
+			at: Option<BlockHash>,
+		) -> Result<Vec<RmrkThemeName>>;
+
+		#[rpc(name = "rmrk_themes")]
+		fn theme(
+			&self,
+			base_id: RmrkBaseId,
+			theme_name: RmrkThemeName, // String
+			filter_keys: Option<Vec<RmrkPropertyKey>>,
+			at: Option<BlockHash>,
+		) -> Result<Option<Theme>>;
+	}
+}
+
 pub struct Unique<C, P> {
 	client: Arc<C>,
 	_marker: std::marker::PhantomData<P>,
@@ -209,7 +336,9 @@
 	(
 		$method_name:ident(
 			$($(#[map(|$map_arg:ident| $map:expr)])? $name:ident: $ty:ty),* $(,)?
-		) -> $result:ty $(=> $mapper:expr)?
+		) -> $result:ty $(=> $mapper:expr)?,
+		//$runtime_name:ident $(<$($lt: tt),+>)*
+		$runtime_api_macro:ident
 		$(; changed_in $ver:expr, $changed_method_name:ident ($($changed_name:expr), * $(,)?) => $fixer:expr)*
 	) => {
 		fn $method_name(
@@ -222,7 +351,7 @@
 			let api = self.client.runtime_api();
 			let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash));
 			let _api_version = if let Ok(Some(api_version)) =
-				api.api_version::<dyn UniqueRuntimeApi<Block, CrossAccountId, AccountId>>(&at)
+				api.api_version::<$runtime_api_macro!()>(&at)
 			{
 				api_version
 			} else {
@@ -253,6 +382,18 @@
 	};
 }
 
+macro_rules! unique_api {
+	() => {
+		dyn UniqueRuntimeApi<Block, CrossAccountId, AccountId>
+	};
+}
+
+macro_rules! rmrk_api {
+	() => {
+		dyn RmrkRuntimeApi<Block, AccountId, CollectionInfo, NftInfo, ResourceInfo, PropertyInfo, BaseInfo, PartType, Theme>
+	};
+}
+
 #[allow(deprecated)]
 impl<C, Block, CrossAccountId, AccountId>
 	UniqueApi<<Block as BlockT>::Hash, CrossAccountId, AccountId> for Unique<C, Block>
@@ -263,22 +404,38 @@
 	C::Api: UniqueRuntimeApi<Block, CrossAccountId, AccountId>,
 	CrossAccountId: pallet_evm::account::CrossAccountId<AccountId>,
 {
-	pass_method!(account_tokens(collection: CollectionId, account: CrossAccountId) -> Vec<TokenId>);
-	pass_method!(collection_tokens(collection: CollectionId) -> Vec<TokenId>);
-	pass_method!(token_exists(collection: CollectionId, token: TokenId) -> bool);
 	pass_method!(
-		token_owner(collection: CollectionId, token: TokenId) -> Option<CrossAccountId>;
-		changed_in 2, token_owner_before_version_2(collection, token) => |u| Some(u)
+		account_tokens(collection: CollectionId, account: CrossAccountId) -> Vec<TokenId>, unique_api
 	);
-	pass_method!(topmost_token_owner(collection: CollectionId, token: TokenId) -> Option<CrossAccountId>);
-	pass_method!(const_metadata(collection: CollectionId, token: TokenId) -> Vec<u8>);
+	pass_method!(
+		collection_tokens(collection: CollectionId) -> Vec<TokenId>, unique_api
+	);
+	pass_method!(
+		token_exists(collection: CollectionId, token: TokenId) -> bool, unique_api
+	);
+	pass_method!(
+		token_owner(collection: CollectionId, token: TokenId) -> Option<CrossAccountId>, unique_api
+	);
+	pass_method!(
+		topmost_token_owner(collection: CollectionId, token: TokenId) -> Option<CrossAccountId>, unique_api
+	);
+	pass_method!(
+		const_metadata(collection: CollectionId, token: TokenId) -> Vec<u8>, unique_api
+	);
+	pass_method!(total_supply(collection: CollectionId) -> u32, unique_api);
+	pass_method!(account_balance(collection: CollectionId, account: CrossAccountId) -> u32, unique_api);
+	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string(), unique_api);
+	pass_method!(
+		allowance(collection: CollectionId, sender: CrossAccountId, spender: CrossAccountId, token: TokenId) -> String => |v| v.to_string(),
+		unique_api
+	);
 
 	pass_method!(collection_properties(
 		collection: CollectionId,
 
 		#[map(|keys| string_keys_to_bytes_keys(keys))]
 		keys: Option<Vec<String>>
-	) -> Vec<Property>);
+	) -> Vec<Property>, unique_api);
 
 	pass_method!(token_properties(
 		collection: CollectionId,
@@ -286,14 +443,14 @@
 
 		#[map(|keys| string_keys_to_bytes_keys(keys))]
 		keys: Option<Vec<String>>
-	) -> Vec<Property>);
+	) -> Vec<Property>, unique_api);
 
 	pass_method!(property_permissions(
 		collection: CollectionId,
 
 		#[map(|keys| string_keys_to_bytes_keys(keys))]
 		keys: Option<Vec<String>>
-	) -> Vec<PropertyKeyPermission>);
+	) -> Vec<PropertyKeyPermission>, unique_api);
 
 	pass_method!(token_data(
 		collection: CollectionId,
@@ -301,25 +458,86 @@
 
 		#[map(|keys| string_keys_to_bytes_keys(keys))]
 		keys: Option<Vec<String>>,
-	) -> TokenData<CrossAccountId>);
+	) -> TokenData<CrossAccountId>, unique_api);
 
-	pass_method!(total_supply(collection: CollectionId) -> u32);
-	pass_method!(account_balance(collection: CollectionId, account: CrossAccountId) -> u32);
-	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string());
-	pass_method!(allowance(collection: CollectionId, sender: CrossAccountId, spender: CrossAccountId, token: TokenId) -> String => |v| v.to_string());
+	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>, unique_api);
+	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>, unique_api);
+	pass_method!(allowed(collection: CollectionId, user: CrossAccountId) -> bool, unique_api);
+	pass_method!(last_token_id(collection: CollectionId) -> TokenId, unique_api);
+	pass_method!(collection_by_id(collection: CollectionId) -> Option<RpcCollection<AccountId>>, unique_api);
+	pass_method!(collection_stats() -> CollectionStats, unique_api);
+	pass_method!(next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Option<u64>, unique_api);
+	pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>, unique_api);
+}
 
-	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>);
-	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>);
-	pass_method!(allowed(collection: CollectionId, user: CrossAccountId) -> bool);
-	pass_method!(last_token_id(collection: CollectionId) -> TokenId);
-	pass_method!(collection_by_id(collection: CollectionId) -> Option<RpcCollection<AccountId>>);
-	pass_method!(collection_stats() -> CollectionStats);
-	pass_method!(next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Option<u64>);
-	pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>);
+#[allow(deprecated)]
+impl<
+		C,
+		Block,
+		AccountId,
+		CollectionInfo,
+		NftInfo,
+		ResourceInfo,
+		PropertyInfo,
+		BaseInfo,
+		PartType,
+		Theme,
+	>
+	rmrk_unique_rpc::RmrkApi<
+		<Block as BlockT>::Hash,
+		AccountId,
+		CollectionInfo,
+		NftInfo,
+		ResourceInfo,
+		PropertyInfo,
+		BaseInfo,
+		PartType,
+		Theme,
+	> for Unique<C, Block>
+where
+	C: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
+	C::Api: RmrkRuntimeApi<
+		Block,
+		AccountId,
+		CollectionInfo,
+		NftInfo,
+		ResourceInfo,
+		PropertyInfo,
+		BaseInfo,
+		PartType,
+		Theme,
+	>,
+	AccountId: Decode + Encode,
+	CollectionInfo: Decode,
+	NftInfo: Decode,
+	ResourceInfo: Decode,
+	PropertyInfo: Decode,
+	BaseInfo: Decode,
+	PartType: Decode,
+	Theme: Decode,
+	Block: BlockT,
+{
+	pass_method!(last_collection_idx() -> RmrkCollectionId, rmrk_api);
+	pass_method!(collection_by_id(id: RmrkCollectionId) -> Option<CollectionInfo>, rmrk_api);
+	pass_method!(nft_by_id(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Option<NftInfo>, rmrk_api);
+	pass_method!(account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Vec<RmrkNftId>, rmrk_api);
+	pass_method!(nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Vec<RmrkNftChild>, rmrk_api);
+	pass_method!(
+		collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Vec<PropertyInfo>,
+		rmrk_api
+	);
+	pass_method!(
+		nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Vec<PropertyInfo>,
+		rmrk_api
+	);
+	pass_method!(nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Vec<ResourceInfo>, rmrk_api);
+	pass_method!(nft_resource_priorities(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Vec<RmrkResourceId>, rmrk_api);
+	pass_method!(base(base_id: RmrkBaseId) -> Option<BaseInfo>, rmrk_api);
+	pass_method!(base_parts(base_id: RmrkBaseId) -> Vec<PartType>, rmrk_api);
+	pass_method!(theme_names(base_id: RmrkBaseId) -> Vec<RmrkThemeName>, rmrk_api);
+	pass_method!(theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Option<Theme>, rmrk_api);
 }
 
 fn string_keys_to_bytes_keys(keys: Option<Vec<String>>) -> Option<Vec<Vec<u8>>> {
-	keys.map(|keys| {
-		keys.into_iter().map(|key| key.into_bytes()).collect()
-	})
+	keys.map(|keys| keys.into_iter().map(|key| key.into_bytes()).collect())
 }
modifiednode/cli/Cargo.tomldiffbeforeafterboth
--- a/node/cli/Cargo.toml
+++ b/node/cli/Cargo.toml
@@ -276,6 +276,14 @@
 branch = "polkadot-v0.9.21"
 
 ################################################################################
+# RMRK dependencies
+
+# todo git
+[dependencies.rmrk-rpc]
+git = "https://github.com/UniqueNetwork/rmrk-substrate.git"
+branch = "feature/separate-types-and-traits"
+
+################################################################################
 # Package
 
 [package]
modifiednode/cli/src/service.rsdiffbeforeafterboth
--- a/node/cli/src/service.rs
+++ b/node/cli/src/service.rs
@@ -67,6 +67,12 @@
 
 use unique_runtime_common::types::{AuraId, RuntimeInstance, AccountId, Balance, Index, Hash, Block};
 
+// RMRK
+use up_data_structs::{
+	RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo, RmrkBaseInfo,
+	RmrkPartType, RmrkTheme,
+};
+
 /// Unique native executor instance.
 #[cfg(feature = "unique-runtime")]
 pub struct UniqueRuntimeExecutor;
@@ -347,7 +353,17 @@
 		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>
 		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>
 		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>
-		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
+		+ rmrk_rpc::RmrkApi<
+			Block,
+			AccountId,
+			RmrkCollectionInfo<AccountId>,
+			RmrkInstanceInfo<AccountId>,
+			RmrkResourceInfo,
+			RmrkPropertyInfo,
+			RmrkBaseInfo<AccountId>,
+			RmrkPartType,
+			RmrkTheme,
+		> + substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
 		+ sp_api::Metadata<Block>
 		+ sp_offchain::OffchainWorkerApi<Block>
 		+ cumulus_primitives_core::CollectCollationInfo<Block>,
@@ -628,7 +644,17 @@
 		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>
 		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>
 		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>
-		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
+		+ rmrk_rpc::RmrkApi<
+			Block,
+			AccountId,
+			RmrkCollectionInfo<AccountId>,
+			RmrkInstanceInfo<AccountId>,
+			RmrkResourceInfo,
+			RmrkPropertyInfo,
+			RmrkBaseInfo<AccountId>,
+			RmrkPartType,
+			RmrkTheme,
+		> + substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
 		+ sp_api::Metadata<Block>
 		+ sp_offchain::OffchainWorkerApi<Block>
 		+ cumulus_primitives_core::CollectCollationInfo<Block>
@@ -761,7 +787,17 @@
 		+ pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>
 		+ sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>
 		+ up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>
-		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
+		+ rmrk_rpc::RmrkApi<
+			Block,
+			AccountId,
+			RmrkCollectionInfo<AccountId>,
+			RmrkInstanceInfo<AccountId>,
+			RmrkResourceInfo,
+			RmrkPropertyInfo,
+			RmrkBaseInfo<AccountId>,
+			RmrkPartType,
+			RmrkTheme,
+		> + substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
 		+ sp_api::Metadata<Block>
 		+ sp_offchain::OffchainWorkerApi<Block>
 		+ cumulus_primitives_core::CollectCollationInfo<Block>
modifiednode/rpc/Cargo.tomldiffbeforeafterboth
--- a/node/rpc/Cargo.toml
+++ b/node/rpc/Cargo.toml
@@ -49,11 +49,16 @@
 fc-db = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }
 fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }
 
+# RMRK
+# todo git
+rmrk-rpc = { git = "https://github.com/UniqueNetwork/rmrk-substrate.git", branch = "feature/separate-types-and-traits" }
+
 pallet-common = { default-features = false, path = "../../pallets/common" }
 unique-runtime-common = { default-features = false, path = "../../runtime/common" }
 pallet-unique = { path = "../../pallets/unique" }
 uc-rpc = { path = "../../client/rpc" }
 up-rpc = { path = "../../primitives/rpc" }
+up-data-structs = { default-features = false, path = "../../primitives/data-structs" }
 
 [dependencies.serde]
 features = ['derive']
modifiednode/rpc/src/lib.rsdiffbeforeafterboth
--- a/node/rpc/src/lib.rs
+++ b/node/rpc/src/lib.rs
@@ -43,6 +43,11 @@
 use unique_runtime_common::types::{
 	Hash, AccountId, RuntimeInstance, Index, Block, BlockNumber, Balance,
 };
+// RMRK
+use up_data_structs::{
+	RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo, RmrkBaseInfo,
+	RmrkPartType, RmrkTheme,
+};
 
 /// Public io handler for exporting into other modules
 pub type IoHandler = jsonrpc_core::IoHandler<sc_rpc::Metadata>;
@@ -144,6 +149,17 @@
 	C::Api: fp_rpc::EthereumRuntimeRPCApi<Block>,
 	C::Api: fp_rpc::ConvertTransactionRuntimeApi<Block>,
 	C::Api: up_rpc::UniqueApi<Block, <R as RuntimeInstance>::CrossAccountId, AccountId>,
+	C::Api: rmrk_rpc::RmrkApi<
+		Block,
+		AccountId,
+		RmrkCollectionInfo<AccountId>,
+		RmrkInstanceInfo<AccountId>,
+		RmrkResourceInfo,
+		RmrkPropertyInfo,
+		RmrkBaseInfo<AccountId>,
+		RmrkPartType,
+		RmrkTheme,
+	>,
 	B: sc_client_api::Backend<Block> + Send + Sync + 'static,
 	B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashFor<Block>>,
 	P: TransactionPool<Block = Block> + 'static,
@@ -157,7 +173,7 @@
 		EthPubSubApiServer, EthSigner, HexEncodedIdProvider, NetApi, NetApiServer, Web3Api,
 		Web3ApiServer,
 	};
-	use uc_rpc::{UniqueApi, Unique};
+	use uc_rpc::{UniqueApi, RmrkApi, Unique};
 	// use pallet_contracts_rpc::{Contracts, ContractsApi};
 	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApi};
 	use substrate_frame_rpc_system::{FullSystem, SystemApi};
@@ -213,7 +229,11 @@
 		fee_history_limit,
 		fee_history_cache,
 	)));
+
+	// todo look into
+	//let unique = Unique::new(client.clone());
 	io.extend_with(UniqueApi::to_delegate(Unique::new(client.clone())));
+	io.extend_with(RmrkApi::to_delegate(Unique::new(client.clone())));
 
 	if let Some(filter_pool) = filter_pool {
 		io.extend_with(EthFilterApiServer::to_delegate(EthFilterApi::new(
modifiedpallets/common/Cargo.tomldiffbeforeafterboth
--- a/pallets/common/Cargo.toml
+++ b/pallets/common/Cargo.toml
@@ -26,6 +26,10 @@
     "derive",
 ] }
 
+# RMRK
+# todo git
+rmrk-types = { default-features = false, git = "https://github.com/UniqueNetwork/rmrk-substrate.git", branch = "feature/separate-types-and-traits" }
+
 [features]
 default = ["std"]
 std = [
modifiedpallets/common/src/lib.rsdiffbeforeafterboth
--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -30,15 +30,52 @@
 };
 use pallet_evm::GasWeightMapping;
 use up_data_structs::{
-	COLLECTION_NUMBER_LIMIT, Collection, RpcCollection, CollectionId, CreateItemData,
-	MAX_TOKEN_PREFIX_LENGTH, COLLECTION_ADMINS_LIMIT, TokenId, CollectionStats,
-	MAX_TOKEN_OWNERSHIP, CollectionMode, NFT_SPONSOR_TRANSFER_TIMEOUT,
-	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT,
-	CUSTOM_DATA_LIMIT, CollectionLimits, CreateCollectionData, SponsorshipState, CreateItemExData,
-	SponsoringRateLimit, budget::Budget, COLLECTION_FIELD_LIMIT, CollectionField, PhantomType,
-	Property, Properties, PropertiesPermissionMap, PropertyKey, PropertyPermission,
-	PropertiesError, PropertyKeyPermission, TokenData, TrySetProperty,
+	COLLECTION_NUMBER_LIMIT,
+	Collection,
+	RpcCollection,
+	CollectionId,
+	CreateItemData,
+	MAX_TOKEN_PREFIX_LENGTH,
+	COLLECTION_ADMINS_LIMIT,
+	TokenId,
+	CollectionStats,
+	MAX_TOKEN_OWNERSHIP,
+	CollectionMode,
+	NFT_SPONSOR_TRANSFER_TIMEOUT,
+	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
+	REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
+	MAX_SPONSOR_TIMEOUT,
+	CUSTOM_DATA_LIMIT,
+	CollectionLimits,
+	CreateCollectionData,
+	SponsorshipState,
+	CreateItemExData,
+	SponsoringRateLimit,
+	budget::Budget,
+	COLLECTION_FIELD_LIMIT,
+	CollectionField,
+	PhantomType,
+	Property,
+	Properties,
+	PropertiesPermissionMap,
+	PropertyKey,
+	PropertyPermission,
+	PropertiesError,
+	PropertyKeyPermission,
+	TokenData,
+	TrySetProperty,
+	PropertyScope,
+	// RMRK
+	RmrkCollectionInfo,
+	RmrkInstanceInfo,
+	RmrkResourceInfo,
+	RmrkPropertyInfo,
+	RmrkBaseInfo,
+	RmrkPartType,
+	RmrkTheme,
+	RmrkNftChild,
 };
+
 pub use pallet::*;
 use sp_core::H160;
 use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};
@@ -441,6 +478,15 @@
 			TokenId,
 			PhantomType<TokenData<T::CrossAccountId>>,
 			PhantomType<RpcCollection<T::AccountId>>,
+			// RMRK
+			PhantomType<RmrkCollectionInfo<T::AccountId>>,
+			PhantomType<RmrkInstanceInfo<T::AccountId>>,
+			PhantomType<RmrkResourceInfo>,
+			PhantomType<RmrkPropertyInfo>,
+			PhantomType<RmrkBaseInfo<T::AccountId>>,
+			PhantomType<RmrkPartType>,
+			PhantomType<RmrkTheme>,
+			PhantomType<RmrkNftChild>,
 		),
 		QueryKind = OptionQuery,
 	>;
@@ -644,18 +690,14 @@
 
 		let mut collection_properties = up_data_structs::CollectionProperties::get();
 		collection_properties
-			.try_set_from_iter(data.properties.into_iter().map(|p| (p.key, p.value)))
+			.try_set_from_iter(data.properties.into_iter())
 			.map_err(<Error<T>>::from)?;
 
 		CollectionProperties::<T>::insert(id, collection_properties);
 
 		let mut token_props_permissions = PropertiesPermissionMap::new();
 		token_props_permissions
-			.try_set_from_iter(
-				data.token_property_permissions
-					.into_iter()
-					.map(|property| (property.key, property.permission)),
-			)
+			.try_set_from_iter(data.token_property_permissions.into_iter())
 			.map_err(<Error<T>>::from)?;
 
 		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);
@@ -720,6 +762,7 @@
 		<AdminAmount<T>>::remove(collection.id);
 		<IsAdmin<T>>::remove_prefix((collection.id,), None);
 		<Allowlist<T>>::remove_prefix((collection.id,), None);
+		<CollectionProperties<T>>::remove(collection.id);
 
 		<Pallet<T>>::deposit_event(Event::CollectionDestroyed(collection.id));
 		Ok(())
@@ -743,7 +786,34 @@
 		Ok(())
 	}
 
+	pub fn set_scoped_collection_property(
+		collection: &CollectionHandle<T>,
+		scope: PropertyScope,
+		property: Property,
+	) -> DispatchResult {
+		CollectionProperties::<T>::try_mutate(collection.id, |properties| {
+			properties.try_scoped_set(scope, property.key, property.value)
+		})
+		.map_err(<Error<T>>::from)?;
+
+		Ok(())
+	}
+
 	#[transactional]
+	pub fn set_scoped_collection_properties(
+		collection: &CollectionHandle<T>,
+		scope: PropertyScope,
+		properties: impl Iterator<Item=Property>,
+	) -> DispatchResult {
+		CollectionProperties::<T>::try_mutate(collection.id, |stored_properties| {
+			stored_properties.try_scoped_set_from_iter(scope, properties)
+		})
+		.map_err(<Error<T>>::from)?;
+
+		Ok(())
+	}
+
+	#[transactional]
 	pub fn set_collection_properties(
 		collection: &CollectionHandle<T>,
 		sender: &T::CrossAccountId,
@@ -849,23 +919,26 @@
 	) -> Result<Vec<Property>, DispatchError> {
 		let properties = Self::collection_properties(collection_id);
 
-		let properties = keys.map(|keys| {
-			keys.into_iter()
-			.filter_map(|key| {
-				properties.get(&key).map(|value| Property {
-					key,
-					value: value.clone(),
-				})
+		let properties = keys
+			.map(|keys| {
+				keys.into_iter()
+					.filter_map(|key| {
+						properties.get(&key).map(|value| Property {
+							key,
+							value: value.clone(),
+						})
+					})
+					.collect()
 			})
-			.collect()
-		}).unwrap_or(
-			properties.iter()
-				.map(|(key, value)| Property {
-					key: key.clone(),
-					value: value.clone(),
-				})
-				.collect()
-		);
+			.unwrap_or_else(|| {
+				properties
+					.iter()
+					.map(|(key, value)| Property {
+						key: key.clone(),
+						value: value.clone(),
+					})
+					.collect()
+			});
 
 		Ok(properties)
 	}
@@ -876,25 +949,28 @@
 	) -> Result<Vec<PropertyKeyPermission>, DispatchError> {
 		let permissions = Self::property_permissions(collection_id);
 
-		let key_permissions = keys.map(|keys| {
-			keys.into_iter()
-			.filter_map(|key| {
+		let key_permissions = keys
+			.map(|keys| {
+				keys.into_iter()
+					.filter_map(|key| {
+						permissions
+							.get(&key)
+							.map(|permission| PropertyKeyPermission {
+								key,
+								permission: permission.clone(),
+							})
+					})
+					.collect()
+			})
+			.unwrap_or_else(|| {
 				permissions
-					.get(&key)
-					.map(|permission| PropertyKeyPermission {
-						key,
+					.iter()
+					.map(|(key, permission)| PropertyKeyPermission {
+						key: key.clone(),
 						permission: permission.clone(),
 					})
-			})
-			.collect()
-		}).unwrap_or(
-			permissions.iter()
-				.map(|(key, permission)| PropertyKeyPermission {
-					key: key.clone(),
-					permission: permission.clone(),
-				})
-				.collect()
-		);
+					.collect()
+			});
 
 		Ok(key_permissions)
 	}
modifiedpallets/fungible/src/common.rsdiffbeforeafterboth
--- a/pallets/fungible/src/common.rs
+++ b/pallets/fungible/src/common.rs
@@ -319,7 +319,11 @@
 		Vec::new()
 	}
 
-	fn token_properties(&self, _token_id: TokenId, _keys: Option<Vec<PropertyKey>>) -> Vec<Property> {
+	fn token_properties(
+		&self,
+		_token_id: TokenId,
+		_keys: Option<Vec<PropertyKey>>,
+	) -> Vec<Property> {
 		Vec::new()
 	}
modifiedpallets/nonfungible/src/benchmarking.rsdiffbeforeafterboth
--- a/pallets/nonfungible/src/benchmarking.rs
+++ b/pallets/nonfungible/src/benchmarking.rs
@@ -28,10 +28,7 @@
 
 fn create_max_item_data<T: Config>(owner: T::CrossAccountId) -> CreateItemData<T> {
 	let const_data = create_data::<CUSTOM_DATA_LIMIT>();
-	CreateItemData::<T> {
-		const_data,
-		owner,
-	}
+	CreateItemData::<T> { const_data, owner }
 }
 fn create_max_item<T: Config>(
 	collection: &NonfungibleHandle<T>,
modifiedpallets/nonfungible/src/common.rsdiffbeforeafterboth
--- a/pallets/nonfungible/src/common.rs
+++ b/pallets/nonfungible/src/common.rs
@@ -18,8 +18,8 @@
 
 use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
 use up_data_structs::{
-	TokenId, CreateItemExData, CollectionId, budget::Budget, Property,
-	PropertyKey, PropertyKeyPermission,
+	TokenId, CreateItemExData, CollectionId, budget::Budget, Property, PropertyKey,
+	PropertyKeyPermission,
 };
 use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};
 use sp_runtime::DispatchError;
@@ -179,7 +179,7 @@
 		let weight = <CommonWeights<T>>::delete_collection_properties(property_keys.len() as u32);
 
 		with_weight(
-			<Pallet<T>>::delete_collection_properties(self, &sender, property_keys),
+			<Pallet<T>>::delete_collection_properties(self, sender, property_keys),
 			weight,
 		)
 	}
@@ -367,20 +367,23 @@
 
 		keys.map(|keys| {
 			keys.into_iter()
-			.filter_map(|key| {
-				properties.get(&key).map(|value| Property {
-					key,
+				.filter_map(|key| {
+					properties.get(&key).map(|value| Property {
+						key,
+						value: value.clone(),
+					})
+				})
+				.collect()
+		})
+		.unwrap_or_else(|| {
+			properties
+				.iter()
+				.map(|(key, value)| Property {
+					key: key.clone(),
 					value: value.clone(),
 				})
-			})
-			.collect()
-		}).unwrap_or(
-			properties.iter().map(|(key, value)| Property {
-				key: key.clone(),
-				value: value.clone(),
-			})
-			.collect()
-		)
+				.collect()
+		})
 	}
 
 	fn total_supply(&self) -> u32 {
modifiedpallets/nonfungible/src/lib.rsdiffbeforeafterboth
--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -257,6 +257,7 @@
 		<Owned<T>>::remove((collection.id, &token_data.owner, token));
 		<TokensBurnt<T>>::insert(collection.id, burnt);
 		<TokenData<T>>::remove((collection.id, token));
+		<TokenProperties<T>>::remove((collection.id, token));
 		let old_spender = <Allowance<T>>::take((collection.id, token));
 
 		if let Some(old_spender) = old_spender {
@@ -353,8 +354,8 @@
 	) -> DispatchResult {
 		let permission = <PalletCommon<T>>::property_permissions(collection.id)
 			.get(property_key)
-			.map(|p| p.clone())
-			.unwrap_or(PropertyPermission::none());
+			.cloned()
+			.unwrap_or_else(PropertyPermission::none);
 
 		let token_data = <TokenData<T>>::get((collection.id, token_id))
 			.ok_or(<CommonError<T>>::TokenNotFound)?;
modifiedpallets/refungible/src/common.rsdiffbeforeafterboth
--- a/pallets/refungible/src/common.rs
+++ b/pallets/refungible/src/common.rs
@@ -19,8 +19,8 @@
 use sp_std::collections::btree_map::BTreeMap;
 use frame_support::{dispatch::DispatchResultWithPostInfo, fail, weights::Weight};
 use up_data_structs::{
-	CollectionId, TokenId, CreateItemExData, CreateRefungibleExData,
-	budget::Budget, Property, PropertyKey, PropertyKeyPermission,
+	CollectionId, TokenId, CreateItemExData, CreateRefungibleExData, budget::Budget, Property,
+	PropertyKey, PropertyKeyPermission,
 };
 use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};
 use sp_runtime::DispatchError;
@@ -340,7 +340,11 @@
 			.into_inner()
 	}
 
-	fn token_properties(&self, _token_id: TokenId, _keys: Option<Vec<PropertyKey>>) -> Vec<Property> {
+	fn token_properties(
+		&self,
+		_token_id: TokenId,
+		_keys: Option<Vec<PropertyKey>>,
+	) -> Vec<Property> {
 		Vec::new()
 	}
modifiedpallets/refungible/src/lib.rsdiffbeforeafterboth
--- a/pallets/refungible/src/lib.rs
+++ b/pallets/refungible/src/lib.rs
@@ -53,7 +53,10 @@
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
-	use frame_support::{Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, traits::StorageVersion};
+	use frame_support::{
+		Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key,
+		traits::StorageVersion,
+	};
 	use frame_system::pallet_prelude::*;
 	use up_data_structs::{CollectionId, TokenId};
 	use super::weights::WeightInfo;
addedpallets/rmrk-proxy/Cargo.tomldiffbeforeafterboth
--- /dev/null
+++ b/pallets/rmrk-proxy/Cargo.toml
@@ -0,0 +1,49 @@
+[package]
+name = "pallet-rmrk-proxy"
+version = "0.1.0"
+license = "GPLv3"
+edition = "2021"
+
+[dependencies.codec]
+default-features = false
+features = ['derive']
+package = 'parity-scale-codec'
+version = '3.1.2'
+
+[dependencies]
+frame-support = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
+frame-system = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
+sp-runtime = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
+sp-std = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
+sp-core = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
+pallet-common = { default-features = false, path = '../common' }
+pallet-nonfungible = { default-features = false, path = "../../pallets/nonfungible" }
+# pallet-structure = { default-features = false, path = '../structure' }
+up-data-structs = { default-features = false, path = '../../primitives/data-structs' }
+# evm-coder = { default-features = false, path = '../../crates/evm-coder' }
+# pallet-evm-coder-substrate = { default-features = false, path = '../evm-coder-substrate' }
+pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }
+frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.21" }
+scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
+
+[features]
+default = ["std"]
+std = [
+    "frame-support/std",
+    "frame-system/std",
+    "sp-runtime/std",
+    "sp-std/std",
+    "up-data-structs/std",
+    "pallet-common/std",
+    "pallet-nonfungible/std",
+    "pallet-evm/std",
+    # "pallet-structure/std",
+    # "evm-coder/std",
+    # "pallet-evm-coder-substrate/std",
+    'frame-benchmarking/std',
+]
+runtime-benchmarks = [
+    'frame-benchmarking',
+    'frame-support/runtime-benchmarks',
+    'frame-system/runtime-benchmarks',
+]
addedpallets/rmrk-proxy/src/lib.rsdiffbeforeafterboth
--- /dev/null
+++ b/pallets/rmrk-proxy/src/lib.rs
@@ -0,0 +1,232 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::{pallet_prelude::*, transactional, BoundedVec, traits::ConstU32, dispatch::DispatchResult};
+use frame_system::{pallet_prelude::*, ensure_signed};
+use sp_runtime::DispatchError;
+use up_data_structs::*;
+use pallet_common::{Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations};
+use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle};
+use pallet_evm::account::CrossAccountId;
+
+pub use pallet::*;
+
+pub mod misc;
+
+use misc::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use pallet_evm::account;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+                    + pallet_common::Config
+                    + pallet_nonfungible::Config
+                    + account::Config {
+		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+        CollectionCreated {
+			issuer: T::AccountId,
+			collection_id: CollectionId,
+		},
+        CollectionDestroyed {
+			issuer: T::AccountId,
+			collection_id: CollectionId,
+		},
+        CollectionLocked {
+			issuer: T::AccountId,
+			collection_id: CollectionId,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+        /* Unique-specific events */
+        CorruptedCollectionType,
+        NotRmrkCollection,
+
+        /* RMRK compatible events */
+        CollectionNotEmpty,
+        NoAvailableCollectionId,
+        CollectionUnknown,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
+		#[transactional]
+		pub fn create_collection(
+			origin: OriginFor<T>,
+			metadata: PropertyValue,
+			max: Option<u32>,
+			symbol: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,
+		) -> DispatchResult {
+            let sender = ensure_signed(origin)?;
+
+            let limits = max.map(|max| CollectionLimits {
+                token_limit: Some(max),
+                ..Default::default()
+            });
+
+            let data = CreateCollectionData {
+                limits,
+                token_prefix: symbol,
+                ..Default::default()
+            };
+
+            let collection_id_res = <PalletNft<T>>::init_collection(sender.clone(), data);
+
+            if let Err(DispatchError::Arithmetic(_)) = &collection_id_res {
+                return Err(<Error<T>>::NoAvailableCollectionId.into());
+            }
+
+            let collection_id = collection_id_res?;
+
+            let collection = Self::get_nft_collection(collection_id)?.into_inner();
+
+            <PalletCommon<T>>::set_scoped_collection_properties(
+                &collection,
+                PropertyScope::Rmrk,
+                [
+                    rmrk_property!(Metadata, metadata),
+                    rmrk_property!(CollectionType, CollectionType::Regular),
+                ].into_iter()
+            )?;
+
+            Self::deposit_event(Event::CollectionCreated { issuer: sender, collection_id });
+
+            Ok(())
+        }
+
+        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
+		#[transactional]
+		pub fn destroy_collection(
+			origin: OriginFor<T>,
+			collection_id: CollectionId,
+		) -> DispatchResult {
+            let sender = ensure_signed(origin)?;
+            let cross_sender = T::CrossAccountId::from_sub(sender.clone());
+
+            let collection = Self::get_nft_collection(collection_id)?;
+
+            Self::check_collection_type(collection_id, CollectionType::Regular)?;
+
+            ensure!(collection.total_supply() == 0, <Error<T>>::CollectionNotEmpty);
+
+            <PalletNft<T>>::destroy_collection(collection, &cross_sender)?;
+
+            Self::deposit_event(Event::CollectionDestroyed { issuer: sender, collection_id });
+
+            Ok(())
+        }
+
+        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
+		#[transactional]
+		pub fn change_collection_issuer(
+			origin: OriginFor<T>,
+			collection_id: CollectionId,
+			new_issuer: T::AccountId,
+		) -> DispatchResult {
+            let sender = ensure_signed(origin)?;
+
+            Self::change_collection_owner(
+                collection_id,
+                CollectionType::Regular,
+                sender,
+                new_issuer
+            )?;
+
+            Ok(())
+        }
+
+        #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))]
+		#[transactional]
+		pub fn lock_collection(
+			origin: OriginFor<T>,
+			collection_id: CollectionId,
+		) -> DispatchResult {
+            let sender = ensure_signed(origin)?;
+            let cross_sender = T::CrossAccountId::from_sub(sender.clone());
+
+            let collection = Self::get_nft_collection(collection_id)?;
+            collection.check_is_owner(&cross_sender)?;
+
+            let token_count = collection.total_supply();
+
+            let mut collection = collection.into_inner();
+            collection.limits.token_limit = Some(token_count);
+            collection.save()?;
+
+			Self::deposit_event(Event::CollectionLocked { issuer: sender, collection_id });
+
+            Ok(())
+        }
+	}
+}
+
+impl<T: Config> Pallet<T> {
+    fn change_collection_owner(
+        collection_id: CollectionId,
+        collection_type: CollectionType,
+        sender: T::AccountId,
+        new_owner: T::AccountId,
+    ) -> DispatchResult {
+        let mut collection = Self::get_nft_collection(collection_id)?.into_inner();
+        collection.check_is_owner(&T::CrossAccountId::from_sub(sender))?;
+
+        Self::check_collection_type(collection_id, collection_type)?;
+
+        collection.owner = new_owner;
+        collection.save()
+    }
+
+    fn get_nft_collection(collection_id: CollectionId) -> Result<NonfungibleHandle<T>, DispatchError> {
+        let collection = <CollectionHandle<T>>::try_get(collection_id)
+            .map_err(|_| <Error<T>>::CollectionUnknown)?
+            .into_nft_collection()?;
+
+        Ok(collection)
+    }
+
+    fn get_collection_type(collection_id: CollectionId) -> Result<CollectionType, DispatchError> {
+        let collection_type: CollectionType = <PalletCommon<T>>::collection_properties(collection_id)
+            .get(&rmrk_property!(CollectionType))
+            .ok_or(<Error<T>>::NotRmrkCollection)?
+            .try_into()
+            .map_err(<Error<T>>::from)?;
+
+        Ok(collection_type)
+    }
+
+    fn check_collection_type(collection_id: CollectionId, collection_type: CollectionType) -> DispatchResult {
+        let actual_type = Self::get_collection_type(collection_id)?;
+        ensure!(actual_type == collection_type, <CommonError<T>>::NoPermission);
+
+        Ok(())
+    }
+}
addedpallets/rmrk-proxy/src/misc.rsdiffbeforeafterboth
--- /dev/null
+++ b/pallets/rmrk-proxy/src/misc.rs
@@ -0,0 +1,98 @@
+use super::*;
+use codec::{Encode, Decode};
+use frame_support::dispatch::Vec;
+use pallet_nonfungible::NonfungibleHandle;
+
+#[macro_export]
+macro_rules! rmrk_property {
+    ($key:ident, $value:expr) => {
+        Property {
+            key: rmrk_property!(@raw $key),
+            value: $value.into()
+        }
+    };
+
+    (@raw $key:ident) => {
+        RmrkProperty::$key.to_key()
+    };
+
+    ($key:ident) => {
+        PropertyScope::Rmrk.apply(rmrk_property!(@raw $key)).unwrap()
+    };
+}
+
+macro_rules! impl_rmrk_value {
+    ($enum_name:path, decode_error: $error:ident) => {
+        impl Into<PropertyValue> for $enum_name {
+            fn into(self) -> PropertyValue {
+                self.encode().try_into().unwrap()
+            }
+        }
+
+        impl TryFrom<&PropertyValue> for $enum_name {
+            type Error = MiscError;
+
+            fn try_from(value: &PropertyValue) -> Result<Self, Self::Error> {
+                let mut value = value.as_slice();
+
+                <$enum_name>::decode(&mut value)
+                    .map_err(|_| MiscError::$error)
+            }
+        }
+
+    };
+}
+
+pub enum MiscError {
+    CorruptedCollectionType,
+}
+
+impl<T: Config> From<MiscError> for Error<T> {
+    fn from(error: MiscError) -> Self {
+        match error {
+            MiscError::CorruptedCollectionType => Self::CorruptedCollectionType,
+        }
+    }
+}
+
+pub trait IntoNftCollection<T: Config> {
+    fn into_nft_collection(self) -> Result<NonfungibleHandle<T>, Error<T>>;
+}
+
+impl<T: Config> IntoNftCollection<T> for CollectionHandle<T> {
+    fn into_nft_collection(self) -> Result<NonfungibleHandle<T>, Error<T>> {
+        match self.mode {
+            CollectionMode::NFT => Ok(NonfungibleHandle::cast(self)),
+            _ => Err(<Error<T>>::NotRmrkCollection)
+        }
+    }
+}
+
+pub enum RmrkProperty {
+    Metadata,
+    CollectionType,
+}
+
+impl RmrkProperty {
+    pub fn to_key(self) -> PropertyKey {
+        let key = |str_key: &str| {
+            PropertyKey::try_from(
+                str_key.bytes().collect::<Vec<_>>()
+            ).unwrap()
+        };
+
+        match self {
+            Self::Metadata => key("metadata"),
+            Self::CollectionType => key("collection-type"),
+        }
+    }
+}
+
+#[derive(Encode, Decode, PartialEq, Eq)]
+pub enum CollectionType {
+    Regular,
+    Resource,
+    Base,
+}
+
+impl_rmrk_value!(CollectionType, decode_error: CorruptedCollectionType);
modifiedpallets/unique/src/lib.rsdiffbeforeafterboth
--- a/pallets/unique/src/lib.rs
+++ b/pallets/unique/src/lib.rs
@@ -35,16 +35,16 @@
 use frame_system::{self as system, ensure_signed};
 use sp_runtime::{sp_std::prelude::Vec};
 use up_data_structs::{
-	CONST_ON_CHAIN_SCHEMA_LIMIT, OFFCHAIN_SCHEMA_LIMIT,
-	MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
-	AccessMode, CreateItemData, CollectionLimits, CollectionId, CollectionMode, TokenId,
-	SchemaVersion, SponsorshipState, CreateCollectionData,
-	CreateItemExData, budget, CollectionField, Property, PropertyKey, PropertyKeyPermission,
+	CONST_ON_CHAIN_SCHEMA_LIMIT, OFFCHAIN_SCHEMA_LIMIT, MAX_COLLECTION_NAME_LENGTH,
+	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, AccessMode, CreateItemData,
+	CollectionLimits, CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState,
+	CreateCollectionData, CreateItemExData, budget, CollectionField, Property, PropertyKey,
+	PropertyKeyPermission,
 };
 use pallet_evm::account::CrossAccountId;
 use pallet_common::{
-	CollectionHandle, Pallet as PalletCommon, CommonWeightInfo,
-	dispatch::dispatch_call, dispatch::CollectionDispatch,
+	CollectionHandle, Pallet as PalletCommon, CommonWeightInfo, dispatch::dispatch_call,
+	dispatch::CollectionDispatch,
 };
 
 #[cfg(feature = "runtime-benchmarks")]
modifiedprimitives/data-structs/Cargo.tomldiffbeforeafterboth
--- a/primitives/data-structs/Cargo.toml
+++ b/primitives/data-structs/Cargo.toml
@@ -27,6 +27,10 @@
 struct-versioning = { path = "../../crates/struct-versioning" }
 pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }
 
+# RMRK
+# todo git
+rmrk-types = { default-features = false, git = "https://github.com/UniqueNetwork/rmrk-substrate.git", branch = "feature/separate-types-and-traits" }
+
 [features]
 default = ["std"]
 std = [
modifiedprimitives/data-structs/src/lib.rsdiffbeforeafterboth
--- a/primitives/data-structs/src/lib.rs
+++ b/primitives/data-structs/src/lib.rs
@@ -23,18 +23,31 @@
 use frame_support::{
 	storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet},
 	traits::Get,
+	parameter_types,
 };
 
 #[cfg(feature = "serde")]
 use serde::{Serialize, Deserialize};
 
 use sp_core::U256;
-use sp_runtime::{ArithmeticError, sp_std::prelude::Vec};
+use sp_runtime::{ArithmeticError, sp_std::prelude::Vec, Permill};
 use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
 use frame_support::{BoundedVec, traits::ConstU32};
 use derivative::Derivative;
 use scale_info::TypeInfo;
 
+// RMRK
+use rmrk_types::{
+	CollectionInfo, NftInfo, ResourceInfo, PropertyInfo, BaseInfo, PartType, Theme, ThemeProperty,
+};
+pub use rmrk_types::{
+	primitives::{
+		CollectionId as RmrkCollectionId, NftId as RmrkNftId, BaseId as RmrkBaseId,
+		PartId as RmrkPartId, ResourceId as RmrkResourceId,
+	},
+	NftChild as RmrkNftChild, AccountIdOrCollectionNftTuple as RmrkAccountIdOrCollectionNftTuple,
+};
+
 mod bounded;
 pub mod budget;
 pub mod mapping;
@@ -96,6 +109,13 @@
 pub const MAX_COLLECTION_PROPERTIES_ENCODE_LEN: u32 =
 	MAX_PROPERTIES_PER_ITEM * MAX_PROPERTY_KEY_LENGTH + MAX_COLLECTION_PROPERTIES_SIZE;
 
+// RMRK constants
+pub const RMRK_STRING_LIMIT: u32 = 128;
+pub const RMRK_COLLECTION_SYMBOL_LIMIT: u32 = 100;
+pub const RMRK_RESOURCE_SYMBOL_LIMIT: u32 = 10;
+pub const RMRK_KEY_LIMIT: u32 = 32;
+pub const RMRK_VALUE_LIMIT: u32 = 256;
+
 pub struct MaxPropertiesPermissionsEncodeLen;
 
 impl Get<u32> for MaxPropertiesPermissionsEncodeLen {
@@ -581,7 +601,8 @@
 	pub alive: u32,
 }
 
-#[derive(Encode, Decode, PartialEq, Clone, Debug)]
+#[derive(Encode, Decode, Clone, Debug)]
+#[cfg_attr(feature = "std", derive(PartialEq))]
 pub struct PhantomType<T>(core::marker::PhantomData<T>);
 
 impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {
@@ -636,6 +657,12 @@
 	pub value: PropertyValue,
 }
 
+impl Into<(PropertyKey, PropertyValue)> for Property {
+	fn into(self) -> (PropertyKey, PropertyValue) {
+		(self.key, self.value)
+	}
+}
+
 #[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]
 #[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub struct PropertyKeyPermission {
@@ -645,6 +672,13 @@
 	pub permission: PropertyPermission,
 }
 
+impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {
+	fn into(self) -> (PropertyKey, PropertyPermission) {
+		(self.key, self.permission)
+	}
+}
+
+#[derive(Debug)]
 pub enum PropertiesError {
 	NoSpaceForProperty,
 	PropertyLimitReached,
@@ -660,7 +694,7 @@
 }
 
 impl PropertyScope {
-	fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {
+	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {
 		let scope_str: &[u8] = match self {
 			Self::None => return Ok(key),
 			Self::Rmrk => b"rmrk",
@@ -680,18 +714,20 @@
 		&mut self,
 		scope: PropertyScope,
 		key: PropertyKey,
-		value: Self::Value
+		value: Self::Value,
 	) -> Result<(), PropertiesError>;
 
-	fn try_scoped_set_from_iter<I>(
+	fn try_scoped_set_from_iter<I, KV>(
 		&mut self,
 		scope: PropertyScope,
-		iter: I
+		iter: I,
 	) -> Result<(), PropertiesError>
 	where
-		I: Iterator<Item=(PropertyKey, Self::Value)>
+		I: Iterator<Item=KV>,
+		KV: Into<(PropertyKey, Self::Value)>
 	{
-		for (key, value) in iter {
+		for kv in iter {
+			let (key, value) = kv.into();
 			self.try_scoped_set(scope, key, value)?;
 		}
 
@@ -702,9 +738,10 @@
 		self.try_scoped_set(PropertyScope::None, key, value)
 	}
 
-	fn try_set_from_iter<I>(&mut self, iter: I) -> Result<(), PropertiesError>
+	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>
 	where
-		I: Iterator<Item = (PropertyKey, Self::Value)>,
+		I: Iterator<Item=KV>,
+		KV: Into<(PropertyKey, Self::Value)>
 	{
 		self.try_scoped_set_from_iter(PropertyScope::None, iter)
 	}
@@ -743,10 +780,8 @@
 		for byte in key.as_slice().iter() {
 			let byte = *byte;
 
-			if !byte.is_ascii_alphanumeric()
-				&& byte != b'_'
-				&& byte != b'-' {
-				return Err(PropertiesError::InvalidCharacterInPropertyKey)
+			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' {
+				return Err(PropertiesError::InvalidCharacterInPropertyKey);
 			}
 		}
 
@@ -761,7 +796,7 @@
 		&mut self,
 		scope: PropertyScope,
 		key: PropertyKey,
-		value: Self::Value
+		value: Self::Value,
 	) -> Result<(), PropertiesError> {
 		Self::check_property_key(&key)?;
 
@@ -819,7 +854,7 @@
 		&mut self,
 		scope: PropertyScope,
 		key: PropertyKey,
-		value: Self::Value
+		value: Self::Value,
 	) -> Result<(), PropertiesError> {
 		let value_len = value.len();
 
@@ -850,3 +885,43 @@
 		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)
 	}
 }
+
+// RMRK
+// todo document?
+parameter_types! {
+	#[derive(PartialEq, TypeInfo)]
+	pub const RmrkStringLimit: u32 = 128;
+	#[derive(PartialEq)]
+	pub const RmrkCollectionSymbolLimit: u32 = 100;
+	#[derive(PartialEq)]
+	pub const RmrkResourceSymbolLimit: u32 = 10;
+	#[derive(PartialEq)]
+	pub const RmrkKeyLimit: u32 = 32;
+	#[derive(PartialEq)]
+	pub const RmrkValueLimit: u32 = 256;
+	#[derive(PartialEq)]
+	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;
+	#[derive(PartialEq)]
+	pub const RmrkPartsLimit: u32 = 3;
+}
+
+pub type RmrkCollectionInfo<AccountId> =
+	CollectionInfo<RmrkString, BoundedVec<u8, RmrkCollectionSymbolLimit>, AccountId>;
+pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;
+pub type RmrkResourceInfo = ResourceInfo<
+	BoundedVec<u8, RmrkResourceSymbolLimit>,
+	RmrkString,
+	BoundedVec<RmrkPartId, RmrkPartsLimit>,
+>;
+pub type RmrkPropertyInfo =
+	PropertyInfo<BoundedVec<u8, RmrkKeyLimit>, BoundedVec<u8, RmrkValueLimit>>;
+pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;
+pub type RmrkPartType =
+	PartType<RmrkString, BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>>;
+pub type RmrkTheme = Theme<RmrkString, Vec<ThemeProperty<RmrkString>>>;
+
+pub type RmrkRpcString = Vec<u8>;
+pub type RmrkThemeName = RmrkRpcString;
+pub type RmrkPropertyKey = RmrkRpcString;
+
+type RmrkString = BoundedVec<u8, RmrkStringLimit>;
modifiedruntime/common/Cargo.tomldiffbeforeafterboth
--- a/runtime/common/Cargo.toml
+++ b/runtime/common/Cargo.toml
@@ -106,4 +106,9 @@
 [dependencies]
 pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.21-logs" }
 evm-coder = { default-features = false, path = '../../crates/evm-coder' }
-up-sponsorship = { default-features = false, git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = 'polkadot-v0.9.21' }
+up-sponsorship = { default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring", branch = 'polkadot-v0.9.21' }
+
+# RMRK
+# todo git
+rmrk-rpc = { default-features = false, git = "https://github.com/UniqueNetwork/rmrk-substrate.git", branch = "feature/separate-types-and-traits" } 
+rmrk-types = { default-features = false, git = "https://github.com/UniqueNetwork/rmrk-substrate.git", branch = "feature/separate-types-and-traits" }
modifiedruntime/common/src/runtime_apis.rsdiffbeforeafterboth
--- a/runtime/common/src/runtime_apis.rs
+++ b/runtime/common/src/runtime_apis.rs
@@ -130,6 +130,200 @@
                 }
             }
 
+            impl rmrk_rpc::RmrkApi<
+                Block,
+                AccountId,
+                RmrkCollectionInfo<AccountId>,
+                RmrkInstanceInfo<AccountId>,
+                RmrkResourceInfo,
+                RmrkPropertyInfo,
+                RmrkBaseInfo<AccountId>,
+                RmrkPartType,
+                RmrkTheme
+            > for Runtime {
+                fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
+                    Ok(<pallet_common::CreatedCollectionCount<Runtime>>::get().0)
+                }
+                fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {
+                    // TODO decide on displacement to palettes -- does RMRK belong there, spread across common and nonfungible?
+                    use frame_support::BoundedVec;
+
+                    let collection_id = CollectionId(collection_id);
+                    let collection = match <pallet_common::CollectionById<Runtime>>::get(collection_id) {
+                        Some(c) => c,
+                        None => return Ok(None)
+                    };
+                    let nfts_count: Result<u32, DispatchError> = dispatch_unique_runtime!(collection_id.total_supply());
+                    Ok(Some(RmrkCollectionInfo {
+                        issuer: collection.owner,
+                        metadata: BoundedVec::default(), // todo property - namespace:metadata
+                        max: Some(collection.limits.token_limit()), // must have some effective limits
+                        symbol: BoundedVec::try_from(collection.token_prefix.into_inner()).unwrap_or_default() /*{ // todo map_err
+                            Ok(s) => s,
+                            Err(_) => return Err(pallet_common::Error::<Runtime>::CollectionTokenPrefixLimitExceeded)
+                        }*/,
+                        nfts_count: nfts_count? // todo? <Runtime>::total_supply(collection_id)
+                    }))
+                }
+                fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {
+                    use frame_support::BoundedVec;
+                    use up_data_structs::mapping::TokenAddressMapping;
+
+                    let collection_id = CollectionId(collection_id);
+                    let nft_id = TokenId(nft_by_id);
+
+                    let owner = match (dispatch_unique_runtime!(collection_id.token_owner(nft_id)) as Result<Option<CrossAccountId>, DispatchError>)? {
+                        Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {
+                            Some((col, tok)) => RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(col.0, tok.0),
+                            None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())
+                        },
+                        None => return Ok(None)
+                    };
+
+                    Ok(Some(RmrkInstanceInfo {
+                        owner: owner,
+                        //recipient: , // prop
+                        royalty: None,//Permill::from_percent(0), // prop
+                        metadata: BoundedVec::default(), // prop
+                        equipped: false, // prop
+                        pending: false, // prop
+                    }))
+                }
+                fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {
+                    let cross_account_id = CrossAccountId::from_sub(account_id);
+                    let collection_id = CollectionId(collection_id);
+                    Ok(
+                        (dispatch_unique_runtime!(collection_id.account_tokens(cross_account_id)) as Result<Vec<TokenId>, DispatchError>)?
+                        //<Runtime as up_rpc::UniqueApi<Block, CrossAccountId, AccountId>>::account_tokens(collection_id, cross_account_id)?
+                            .into_iter()
+                            .map(|token| token.0)
+                            .collect::<Vec<_>>()
+                    )
+                }
+                fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {
+                    use up_data_structs::mapping::TokenAddressMapping;
+
+                    let collection_id = CollectionId(collection_id);
+                    let nft_id = TokenId(nft_id);
+                    let cross_account_id = CrossAccountId::from_eth(
+                        EvmTokenAddressMapping::token_to_address(collection_id, nft_id)
+                    );
+
+                    Ok(
+                        pallet_nonfungible::Owned::<Runtime>::iter_prefix((collection_id, cross_account_id))
+                            .map(|(child_id, _)| RmrkNftChild {
+                                collection_id: collection_id.0, // todo make sure they're always from this collection
+                                nft_id: child_id.0,
+                            })
+                            .collect()
+                    )
+                }
+                fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+                    use frame_support::BoundedVec;
+
+                    let collection_id = CollectionId(collection_id);
+                    let properties = pallet_common::Pallet::<Runtime>::collection_properties(collection_id);
+
+                    return Ok(match filter_keys {
+                        Some(keys) => {
+                            let keys = pallet_common::Pallet::<Runtime>::bytes_keys_to_property_keys(keys)?;
+                            let properties = keys
+                                .into_iter()
+                                .filter_map(|key| {
+                                    properties.get(&key).map(|value| RmrkPropertyInfo {
+                                        key: BoundedVec::try_from(key.into_inner()).unwrap_or_default(),
+                                        value: BoundedVec::try_from(value.clone().into_inner()).unwrap_or_default(),
+                                    })
+                                })
+                                .collect();
+
+                            properties
+                        }
+                        None => {
+                            properties
+                                .iter()
+                                .map(|(key, value)| RmrkPropertyInfo {
+                                    key: BoundedVec::try_from(key.clone().into_inner()).unwrap_or_default(),
+                                    value: BoundedVec::try_from(value.clone().into_inner()).unwrap_or_default(),
+                                })
+                                .collect()
+                        }
+                    });
+                }
+                fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+                    use frame_support::BoundedVec;
+
+                    let collection_id = CollectionId(collection_id);
+                    let token_id = TokenId(nft_id);
+
+		            let properties = pallet_nonfungible::Pallet::<Runtime>::token_properties((collection_id, token_id)); // todo look into usage of nonfungible
+
+                    return Ok(match filter_keys {
+                        Some(keys) => {
+                            let keys = pallet_common::Pallet::<Runtime>::bytes_keys_to_property_keys(keys)?;
+                            let properties = keys
+                                .into_iter()
+                                .filter_map(|key| {
+                                    properties.get(&key).map(|value| RmrkPropertyInfo {
+                                        key: BoundedVec::try_from(key.into_inner()).unwrap_or_default(),
+                                        value: BoundedVec::try_from(value.clone().into_inner()).unwrap_or_default(),
+                                    })
+                                })
+                                .collect();
+
+                            properties
+                        }
+                        None => {
+                            properties
+                                .iter()
+                                .map(|(key, value)| RmrkPropertyInfo {
+                                    key: BoundedVec::try_from(key.clone().into_inner()).unwrap_or_default(),
+                                    value: BoundedVec::try_from(value.clone().into_inner()).unwrap_or_default(),
+                                })
+                                .collect()
+                        }
+                    });
+                }
+                fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
+                    todo!()
+                }
+                fn nft_resource_priorities(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceId>, DispatchError> {
+                    todo!()
+                }
+                fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {
+                    use frame_support::{BoundedVec, ensure};
+                    use scale_info::prelude::string::String;
+
+                    let collection_id = CollectionId(base_id);
+                    let collection = match <pallet_common::CollectionById<Runtime>>::get(collection_id) {
+                        Some(c) => c,
+                        None => return Ok(None)
+                    };
+
+                    // string_keys_to_bytes_keys
+                    let keys = pallet_common::Pallet::<Runtime>::bytes_keys_to_property_keys(
+                        Vec::from([String::from("rmrk:base-type").into_bytes()])
+                    )?;
+                    let properties = pallet_common::Pallet::<Runtime>::filter_collection_properties(collection_id, Some(keys))?;
+                    //ensure!(properties.len() == 1); // todo make sure it's fine to have ensure in place // no access to errors from here? displace?
+
+                    Ok(Some( RmrkBaseInfo {
+                        issuer: collection.owner,
+                        base_type: BoundedVec::try_from(properties[0].value.clone().into_inner()).unwrap_or_default(), // todo map_err? no access to errors
+                        symbol: BoundedVec::try_from(collection.token_prefix.into_inner()).unwrap_or_default(),
+                    }))
+                }
+                fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
+                    todo!()
+                }
+                fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
+                    todo!()
+                }
+                fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {
+                    todo!()
+                }
+            }
+
             impl sp_api::Core<Block> for Runtime {
                 fn version() -> RuntimeVersion {
                     VERSION
modifiedruntime/common/src/sponsoring.rsdiffbeforeafterboth
--- a/runtime/common/src/sponsoring.rs
+++ b/runtime/common/src/sponsoring.rs
@@ -21,17 +21,16 @@
 	storage::{StorageMap, StorageDoubleMap, StorageNMap},
 };
 use up_data_structs::{
-	CollectionId, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
-	NFT_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, TokenId, CollectionMode,
-	CreateItemData,
+	CollectionId, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, NFT_SPONSOR_TRANSFER_TIMEOUT,
+	REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, TokenId, CollectionMode, CreateItemData,
 };
 use sp_runtime::traits::Saturating;
 use pallet_common::{CollectionHandle};
 use pallet_evm::account::CrossAccountId;
 use pallet_unique::{
 	Call as UniqueCall, Config as UniqueConfig, FungibleApproveBasket, RefungibleApproveBasket,
-	NftApproveBasket, CreateItemBasket, ReFungibleTransferBasket,
-	FungibleTransferBasket, NftTransferBasket,
+	NftApproveBasket, CreateItemBasket, ReFungibleTransferBasket, FungibleTransferBasket,
+	NftTransferBasket,
 };
 use pallet_fungible::Config as FungibleConfig;
 use pallet_nonfungible::Config as NonfungibleConfig;
modifiedruntime/opal/Cargo.tomldiffbeforeafterboth
--- a/runtime/opal/Cargo.toml
+++ b/runtime/opal/Cargo.toml
@@ -33,6 +33,7 @@
     'pallet-fungible/runtime-benchmarks',
     'pallet-refungible/runtime-benchmarks',
     'pallet-nonfungible/runtime-benchmarks',
+    'pallet-rmrk-proxy/runtime-benchmarks',
     'pallet-unique/runtime-benchmarks',
     'pallet-inflation/runtime-benchmarks',
     'pallet-xcm/runtime-benchmarks',
@@ -89,6 +90,7 @@
     'pallet-fungible/std',
     'pallet-refungible/std',
     'pallet-nonfungible/std',
+    'pallet-rmrk-proxy/std',
     'pallet-unique/std',
     'pallet-unq-scheduler/std',
     'pallet-charge-transaction/std',
@@ -109,6 +111,7 @@
     'xcm-builder/std',
     'xcm-executor/std',
     'unique-runtime-common/std',
+    'rmrk-rpc/std',
 
     "orml-vesting/std",
 ]
@@ -386,6 +389,15 @@
 default-features = false
 
 ################################################################################
+# RMRK dependencies
+
+# todo git
+[dependencies.rmrk-rpc]
+default-features = false
+git = "https://github.com/UniqueNetwork/rmrk-substrate.git"
+branch = "feature/separate-types-and-traits"
+
+################################################################################
 # local dependencies
 
 [dependencies]
@@ -405,6 +417,7 @@
 pallet-fungible = { default-features = false, path = "../../pallets/fungible" }
 pallet-refungible = { default-features = false, path = "../../pallets/refungible" }
 pallet-nonfungible = { default-features = false, path = "../../pallets/nonfungible" }
+pallet-rmrk-proxy = { default-features = false, path = "../../pallets/rmrk-proxy" }
 pallet-unq-scheduler = { path = '../../pallets/scheduler', default-features = false }
 # pallet-contract-helpers = { path = '../pallets/contract-helpers', default-features = false, version = '0.1.0' }
 pallet-charge-transaction = { git = "https://github.com/uniquenetwork/pallet-sponsoring", branch = "polkadot-v0.9.21", package = "pallet-template-transaction-payment", default-features = false, version = "3.0.0" }
modifiedruntime/opal/src/lib.rsdiffbeforeafterboth
--- a/runtime/opal/src/lib.rs
+++ b/runtime/opal/src/lib.rs
@@ -901,6 +901,10 @@
 	type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;
 }
 
+impl pallet_rmrk_proxy::Config for Runtime {
+	type Event = Event;
+}
+
 impl pallet_unique::Config for Runtime {
 	type Event = Event;
 	type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;
@@ -1013,6 +1017,7 @@
 		Refungible: pallet_refungible::{Pallet, Storage} = 68,
 		Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,
 		Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,
+		RmrkProxy: pallet_rmrk_proxy::{Pallet, Call, Storage, Event<T>} = 71,
 
 		// Frontier
 		EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,
modifiedruntime/quartz/Cargo.tomldiffbeforeafterboth
--- a/runtime/quartz/Cargo.toml
+++ b/runtime/quartz/Cargo.toml
@@ -386,6 +386,15 @@
 default-features = false
 
 ################################################################################
+# RMRK dependencies
+
+# todo git
+[dependencies.rmrk-rpc]
+default-features = false
+git = "https://github.com/UniqueNetwork/rmrk-substrate.git"
+branch = "feature/separate-types-and-traits"
+
+################################################################################
 # local dependencies
 
 [dependencies]
modifiedruntime/tests/src/tests.rsdiffbeforeafterboth
--- a/runtime/tests/src/tests.rs
+++ b/runtime/tests/src/tests.rs
@@ -18,9 +18,9 @@
 use crate::{Test, TestCrossAccountId, CollectionCreationPrice, Origin, Unique, new_test_ext};
 use up_data_structs::{
 	COLLECTION_NUMBER_LIMIT, CollectionId, CreateItemData, CreateFungibleData, CreateNftData,
-	CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT,
-	TokenId, MAX_TOKEN_OWNERSHIP, CreateCollectionData, CollectionField, SchemaVersion,
-	CollectionMode, AccessMode,
+	CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT, TokenId,
+	MAX_TOKEN_OWNERSHIP, CreateCollectionData, CollectionField, SchemaVersion, CollectionMode,
+	AccessMode,
 };
 use frame_support::{assert_noop, assert_ok, assert_err};
 use sp_std::convert::TryInto;
@@ -47,6 +47,7 @@
 fn default_nft_data() -> CreateNftData {
 	CreateNftData {
 		const_data: vec![1, 2, 3].try_into().unwrap(),
+		properties: vec![].try_into().unwrap(),
 	}
 }
modifiedruntime/unique/Cargo.tomldiffbeforeafterboth
--- a/runtime/unique/Cargo.toml
+++ b/runtime/unique/Cargo.toml
@@ -386,6 +386,15 @@
 default-features = false
 
 ################################################################################
+# RMRK dependencies
+
+# todo git
+[dependencies.rmrk-rpc]
+default-features = false
+git = "https://github.com/UniqueNetwork/rmrk-substrate.git"
+branch = "feature/separate-types-and-traits"
+
+################################################################################
 # local dependencies
 
 [dependencies]
modifiedtests/src/interfaces/augment-api-query.tsdiffbeforeafterboth
--- a/tests/src/interfaces/augment-api-query.ts
+++ b/tests/src/interfaces/augment-api-query.ts
@@ -5,7 +5,7 @@
 import type { BTreeMap, Bytes, Option, U256, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types-codec';
 import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';
 import type { AccountId32, H160, H256 } from '@polkadot/types/interfaces/runtime';
-import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumLog, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletNonfungibleItemData, PalletRefungibleItemData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsTokenData, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpRuntimeDigest, SpTrieStorageProof, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsPropertyPermission } from '@polkadot/types/lookup';
+import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumLog, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletNonfungibleItemData, PalletRefungibleItemData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PhantomTypeUpDataStructsBaseInfo, PhantomTypeUpDataStructsCollectionInfo, PhantomTypeUpDataStructsNftChild, PhantomTypeUpDataStructsNftInfo, PhantomTypeUpDataStructsPartType, PhantomTypeUpDataStructsPropertyInfo, PhantomTypeUpDataStructsResourceInfo, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsTheme, PhantomTypeUpDataStructsTokenData, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpRuntimeDigest, SpTrieStorageProof, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsPropertyPermission } from '@polkadot/types/lookup';
 import type { Observable } from '@polkadot/types/types';
 
 declare module '@polkadot/api-base/types/storage' {
@@ -92,7 +92,7 @@
       /**
        * Not used by code, exists only to provide some types to metadata
        **/
-      dummyStorageValue: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[UpDataStructsCollectionStats, u32, u32, PhantomTypeUpDataStructsTokenData, PhantomTypeUpDataStructsRpcCollection]>>>, []> & QueryableStorageEntry<ApiType, []>;
+      dummyStorageValue: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[UpDataStructsCollectionStats, u32, u32, PhantomTypeUpDataStructsTokenData, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsCollectionInfo, PhantomTypeUpDataStructsNftInfo, PhantomTypeUpDataStructsResourceInfo, PhantomTypeUpDataStructsPropertyInfo, PhantomTypeUpDataStructsBaseInfo, PhantomTypeUpDataStructsPartType, PhantomTypeUpDataStructsTheme, PhantomTypeUpDataStructsNftChild]>>>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * List of collection admins
        **/
modifiedtests/src/interfaces/augment-api-rpc.tsdiffbeforeafterboth
--- a/tests/src/interfaces/augment-api-rpc.ts
+++ b/tests/src/interfaces/augment-api-rpc.ts
@@ -1,7 +1,7 @@
 // Auto-generated via `yarn polkadot-types-from-chain`, do not edit
 /* eslint-disable */
 
-import type { PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCollectionLimits, UpDataStructsCollectionStats, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsRpcCollection, UpDataStructsTokenData } from './unique';
+import type { PalletEvmAccountBasicCrossAccountIdRepr, RmrkTypesBaseInfo, RmrkTypesCollectionInfo, RmrkTypesNftChild, RmrkTypesNftInfo, RmrkTypesPartType, RmrkTypesPropertyInfo, RmrkTypesResourceInfo, RmrkTypesTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionStats, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsRpcCollection, UpDataStructsTokenData } from './unique';
 import type { AugmentedRpc } from '@polkadot/rpc-core/types';
 import type { Metadata, StorageKey } from '@polkadot/types';
 import type { Bytes, HashMap, Json, Null, Option, Text, U256, U64, Vec, bool, u128, u32, u64 } from '@polkadot/types-codec';
@@ -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';
@@ -393,6 +393,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<RmrkTypesBaseInfo>>>;
+      /**
+       * Get all Base's parts
+       **/
+      baseParts: AugmentedRpc<(baseId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<RmrkTypesPartType>>>;
+      /**
+       * Get collection by id
+       **/
+      collectionById: AugmentedRpc<(id: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<RmrkTypesCollectionInfo>>>;
+      /**
+       * Get collection properties
+       **/
+      collectionProperties: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<RmrkTypesPropertyInfo>>>;
+      /**
+       * 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<RmrkTypesNftInfo>>>;
+      /**
+       * Get NFT children
+       **/
+      nftChildren: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<RmrkTypesNftChild>>>;
+      /**
+       * Get NFT properties
+       **/
+      nftProperties: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<RmrkTypesPropertyInfo>>>;
+      /**
+       * 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<RmrkTypesResourceInfo>>>;
+      /**
+       * 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<RmrkTypesTheme>>>;
+    };
     rpc: {
       /**
        * Retrieves the list of RPC methods that are exposed by the node
modifiedtests/src/interfaces/augment-api-tx.tsdiffbeforeafterboth
--- a/tests/src/interfaces/augment-api-tx.ts
+++ b/tests/src/interfaces/augment-api-tx.ts
@@ -3,7 +3,7 @@
 
 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, ITuple } from '@polkadot/types-codec/types';
+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, UpDataStructsAccessMode, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsSchemaVersion, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';
 
@@ -378,7 +378,7 @@
        * - Weight of derivative `call` execution + 10,000.
        * # </weight>
        **/
-      sudo: AugmentedSubmittable<(call: Call) => SubmittableExtrinsic<ApiType>, [Call]>;
+      sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;
       /**
        * Authenticates the sudo key and dispatches a function call with `Signed` origin from
        * a given account.
@@ -392,7 +392,7 @@
        * - Weight of derivative `call` execution + 10,000.
        * # </weight>
        **/
-      sudoAs: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, call: Call) => SubmittableExtrinsic<ApiType>, [MultiAddress, Call]>;
+      sudoAs: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Call]>;
       /**
        * Authenticates the sudo key and dispatches a function call with `Root` origin.
        * This function does not check the weight of the call, and instead allows the
@@ -405,7 +405,7 @@
        * - The weight of this call is defined by the caller.
        * # </weight>
        **/
-      sudoUncheckedWeight: AugmentedSubmittable<(call: Call, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;
+      sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;
       /**
        * Generic tx
        **/
modifiedtests/src/interfaces/augment-types.tsdiffbeforeafterboth
--- a/tests/src/interfaces/augment-types.ts
+++ b/tests/src/interfaces/augment-types.ts
@@ -1,7 +1,7 @@
 // Auto-generated via `yarn polkadot-types-from-defs`, do not edit
 /* eslint-disable */
 
-import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportStorageBoundedBTreeSet, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsTokenData, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExData, UpDataStructsNestingRule, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsRpcCollection, UpDataStructsSchemaVersion, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './unique';
+import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructsBaseInfo, PhantomTypeUpDataStructsCollectionInfo, PhantomTypeUpDataStructsNftChild, PhantomTypeUpDataStructsNftInfo, PhantomTypeUpDataStructsPartType, PhantomTypeUpDataStructsPropertyInfo, PhantomTypeUpDataStructsResourceInfo, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsTheme, PhantomTypeUpDataStructsTokenData, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTypesAccountIdOrCollectionNftTuple, RmrkTypesBaseInfo, RmrkTypesCollectionInfo, RmrkTypesEquippableList, RmrkTypesFixedPart, RmrkTypesNftChild, RmrkTypesNftInfo, RmrkTypesPartType, RmrkTypesPropertyInfo, RmrkTypesResourceInfo, RmrkTypesRoyaltyInfo, RmrkTypesSlotPart, RmrkTypesTheme, RmrkTypesThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExData, UpDataStructsNestingRule, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsRpcCollection, UpDataStructsSchemaVersion, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './unique';
 import type { Data, StorageKey } from '@polkadot/types';
 import type { BitVec, Bool, Bytes, I128, I16, I256, I32, I64, I8, Json, Null, Raw, Text, Type, U128, U16, U256, U32, U64, U8, USize, bool, i128, i16, i256, i32, i64, i8, u128, u16, u256, u32, u64, u8, usize } from '@polkadot/types-codec';
 import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDestroyWitness, AssetDetails, AssetMetadata, TAssetBalance, TAssetDepositBalance } from '@polkadot/types/interfaces/assets';
@@ -478,7 +478,6 @@
     ForkTreePendingChangeNode: ForkTreePendingChangeNode;
     FpRpcTransactionStatus: FpRpcTransactionStatus;
     FrameSupportPalletId: FrameSupportPalletId;
-    FrameSupportStorageBoundedBTreeSet: FrameSupportStorageBoundedBTreeSet;
     FrameSupportTokensMiscBalanceStatus: FrameSupportTokensMiscBalanceStatus;
     FrameSupportWeightsDispatchClass: FrameSupportWeightsDispatchClass;
     FrameSupportWeightsDispatchInfo: FrameSupportWeightsDispatchInfo;
@@ -850,7 +849,15 @@
     PerU16: PerU16;
     Phantom: Phantom;
     PhantomData: PhantomData;
+    PhantomTypeUpDataStructsBaseInfo: PhantomTypeUpDataStructsBaseInfo;
+    PhantomTypeUpDataStructsCollectionInfo: PhantomTypeUpDataStructsCollectionInfo;
+    PhantomTypeUpDataStructsNftChild: PhantomTypeUpDataStructsNftChild;
+    PhantomTypeUpDataStructsNftInfo: PhantomTypeUpDataStructsNftInfo;
+    PhantomTypeUpDataStructsPartType: PhantomTypeUpDataStructsPartType;
+    PhantomTypeUpDataStructsPropertyInfo: PhantomTypeUpDataStructsPropertyInfo;
+    PhantomTypeUpDataStructsResourceInfo: PhantomTypeUpDataStructsResourceInfo;
     PhantomTypeUpDataStructsRpcCollection: PhantomTypeUpDataStructsRpcCollection;
+    PhantomTypeUpDataStructsTheme: PhantomTypeUpDataStructsTheme;
     PhantomTypeUpDataStructsTokenData: PhantomTypeUpDataStructsTokenData;
     Phase: Phase;
     PhragmenScore: PhragmenScore;
@@ -943,6 +950,20 @@
     Retriable: Retriable;
     RewardDestination: RewardDestination;
     RewardPoint: RewardPoint;
+    RmrkTypesAccountIdOrCollectionNftTuple: RmrkTypesAccountIdOrCollectionNftTuple;
+    RmrkTypesBaseInfo: RmrkTypesBaseInfo;
+    RmrkTypesCollectionInfo: RmrkTypesCollectionInfo;
+    RmrkTypesEquippableList: RmrkTypesEquippableList;
+    RmrkTypesFixedPart: RmrkTypesFixedPart;
+    RmrkTypesNftChild: RmrkTypesNftChild;
+    RmrkTypesNftInfo: RmrkTypesNftInfo;
+    RmrkTypesPartType: RmrkTypesPartType;
+    RmrkTypesPropertyInfo: RmrkTypesPropertyInfo;
+    RmrkTypesResourceInfo: RmrkTypesResourceInfo;
+    RmrkTypesRoyaltyInfo: RmrkTypesRoyaltyInfo;
+    RmrkTypesSlotPart: RmrkTypesSlotPart;
+    RmrkTypesTheme: RmrkTypesTheme;
+    RmrkTypesThemeProperty: RmrkTypesThemeProperty;
     RoundSnapshot: RoundSnapshot;
     RoundState: RoundState;
     RpcMethods: RpcMethods;
modifiedtests/src/interfaces/definitions.tsdiffbeforeafterboth
--- a/tests/src/interfaces/definitions.ts
+++ b/tests/src/interfaces/definitions.ts
@@ -15,3 +15,4 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 export {default as unique} from './unique/definitions';
+export {default as rmrk} from './rmrk/definitions';
modifiedtests/src/interfaces/lookup.tsdiffbeforeafterboth
--- a/tests/src/interfaces/lookup.ts
+++ b/tests/src/interfaces/lookup.ts
@@ -1448,14 +1448,10 @@
     _enum: {
       Disabled: 'Null',
       Owner: 'Null',
-      OwnerRestricted: 'FrameSupportStorageBoundedBTreeSet'
+      OwnerRestricted: 'BTreeSet<u32>'
     }
   },
   /**
-   * Lookup171: frame_support::storage::bounded_btree_set::BoundedBTreeSet<up_data_structs::CollectionId, S>
-   **/
-  FrameSupportStorageBoundedBTreeSet: 'BTreeSet<u32>',
-  /**
    * Lookup177: up_data_structs::PropertyKeyPermission
    **/
   UpDataStructsPropertyKeyPermission: {
@@ -2351,56 +2347,212 @@
     properties: 'Vec<UpDataStructsProperty>'
   },
   /**
-   * Lookup333: pallet_common::pallet::Error<T>
+   * Lookup333: PhantomType::up_data_structs<rmrk_types::CollectionInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>, sp_core::crypto::AccountId32>>
+   **/
+  PhantomTypeUpDataStructsCollectionInfo: '[Lookup334;0]',
+  /**
+   * Lookup334: rmrk_types::CollectionInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>, sp_core::crypto::AccountId32>
+   **/
+  RmrkTypesCollectionInfo: {
+    issuer: 'AccountId32',
+    metadata: 'Bytes',
+    max: 'Option<u32>',
+    symbol: 'Bytes',
+    nftsCount: 'u32'
+  },
+  /**
+   * Lookup338: PhantomType::up_data_structs<rmrk_types::NftInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill, frame_support::storage::bounded_vec::BoundedVec<T, S>>>
+   **/
+  PhantomTypeUpDataStructsNftInfo: '[Lookup339;0]',
+  /**
+   * Lookup339: rmrk_types::NftInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill, frame_support::storage::bounded_vec::BoundedVec<T, S>>
+   **/
+  RmrkTypesNftInfo: {
+    owner: 'RmrkTypesAccountIdOrCollectionNftTuple',
+    royalty: 'Option<RmrkTypesRoyaltyInfo>',
+    metadata: 'Bytes',
+    equipped: 'bool',
+    pending: 'bool'
+  },
+  /**
+   * Lookup340: rmrk_types::AccountIdOrCollectionNftTuple<sp_core::crypto::AccountId32>
+   **/
+  RmrkTypesAccountIdOrCollectionNftTuple: {
+    _enum: {
+      AccountId: 'AccountId32',
+      CollectionAndNftTuple: '(u32,u32)'
+    }
+  },
+  /**
+   * Lookup342: rmrk_types::RoyaltyInfo<sp_core::crypto::AccountId32, sp_arithmetic::per_things::Permill>
+   **/
+  RmrkTypesRoyaltyInfo: {
+    recipient: 'AccountId32',
+    amount: 'Permill'
+  },
+  /**
+   * Lookup344: PhantomType::up_data_structs<rmrk_types::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>>>
+   **/
+  PhantomTypeUpDataStructsResourceInfo: '[Lookup345;0]',
+  /**
+   * Lookup345: rmrk_types::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>>
+   **/
+  RmrkTypesResourceInfo: {
+    id: 'Bytes',
+    pending: 'bool',
+    pendingRemoval: 'bool',
+    parts: 'Option<Vec<u32>>',
+    base: 'Option<u32>',
+    src: 'Option<Bytes>',
+    metadata: 'Option<Bytes>',
+    slot: 'Option<u32>',
+    license: 'Option<Bytes>',
+    thumb: 'Option<Bytes>'
+  },
+  /**
+   * Lookup351: PhantomType::up_data_structs<rmrk_types::PropertyInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>>
+   **/
+  PhantomTypeUpDataStructsPropertyInfo: '[Lookup352;0]',
+  /**
+   * Lookup352: rmrk_types::PropertyInfo<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
+   **/
+  RmrkTypesPropertyInfo: {
+    key: 'Bytes',
+    value: 'Bytes'
+  },
+  /**
+   * Lookup356: PhantomType::up_data_structs<rmrk_types::BaseInfo<sp_core::crypto::AccountId32, frame_support::storage::bounded_vec::BoundedVec<T, S>>>
+   **/
+  PhantomTypeUpDataStructsBaseInfo: '[Lookup357;0]',
+  /**
+   * Lookup357: rmrk_types::BaseInfo<sp_core::crypto::AccountId32, frame_support::storage::bounded_vec::BoundedVec<T, S>>
+   **/
+  RmrkTypesBaseInfo: {
+    issuer: 'AccountId32',
+    baseType: 'Bytes',
+    symbol: 'Bytes'
+  },
+  /**
+   * Lookup359: PhantomType::up_data_structs<rmrk_types::PartType<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>>
+   **/
+  PhantomTypeUpDataStructsPartType: '[Lookup360;0]',
+  /**
+   * Lookup360: rmrk_types::PartType<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
+   **/
+  RmrkTypesPartType: {
+    _enum: {
+      FixedPart: 'RmrkTypesFixedPart',
+      SlotPart: 'RmrkTypesSlotPart'
+    }
+  },
+  /**
+   * Lookup362: rmrk_types::FixedPart<frame_support::storage::bounded_vec::BoundedVec<T, S>>
+   **/
+  RmrkTypesFixedPart: {
+    id: 'u32',
+    z: 'u32',
+    src: 'Bytes'
+  },
+  /**
+   * Lookup363: rmrk_types::SlotPart<frame_support::storage::bounded_vec::BoundedVec<T, S>, frame_support::storage::bounded_vec::BoundedVec<T, S>>
+   **/
+  RmrkTypesSlotPart: {
+    id: 'u32',
+    equippable: 'RmrkTypesEquippableList',
+    src: 'Bytes',
+    z: 'u32'
+  },
+  /**
+   * Lookup364: rmrk_types::EquippableList<frame_support::storage::bounded_vec::BoundedVec<T, S>>
+   **/
+  RmrkTypesEquippableList: {
+    _enum: {
+      All: 'Null',
+      Empty: 'Null',
+      Custom: 'Vec<u32>'
+    }
+  },
+  /**
+   * Lookup366: PhantomType::up_data_structs<rmrk_types::Theme<frame_support::storage::bounded_vec::BoundedVec<T, S>, BoundedPropertyList>>
+   **/
+  PhantomTypeUpDataStructsTheme: '[Lookup367;0]',
+  /**
+   * Lookup367: rmrk_types::Theme<frame_support::storage::bounded_vec::BoundedVec<T, S>, BoundedPropertyList>
+   **/
+  RmrkTypesTheme: {
+    name: 'Bytes',
+    properties: 'Vec<RmrkTypesThemeProperty>',
+    inherit: 'bool'
+  },
+  /**
+   * Lookup369: rmrk_types::ThemeProperty<frame_support::storage::bounded_vec::BoundedVec<T, S>>
+   **/
+  RmrkTypesThemeProperty: {
+    key: 'Bytes',
+    value: 'Bytes'
+  },
+  /**
+   * Lookup371: PhantomType::up_data_structs<rmrk_types::NftChild>
+   **/
+  PhantomTypeUpDataStructsNftChild: '[Lookup372;0]',
+  /**
+   * Lookup372: rmrk_types::NftChild
+   **/
+  RmrkTypesNftChild: {
+    collectionId: 'u32',
+    nftId: 'u32'
+  },
+  /**
+   * Lookup374: pallet_common::pallet::Error<T>
    **/
   PalletCommonError: {
     _enum: ['CollectionNotFound', 'MustBeTokenOwner', 'NoPermission', 'PublicMintingNotAllowed', 'AddressNotInAllowlist', 'CollectionNameLimitExceeded', 'CollectionDescriptionLimitExceeded', 'CollectionTokenPrefixLimitExceeded', 'TotalCollectionsLimitExceeded', 'CollectionAdminCountExceeded', 'CollectionLimitBoundsExceeded', 'OwnerPermissionsCantBeReverted', 'TransferNotAllowed', 'AccountTokenLimitExceeded', 'CollectionTokenLimitExceeded', 'MetadataFlagFrozen', 'TokenNotFound', 'TokenValueTooLow', 'ApprovedValueTooLow', 'CantApproveMoreThanOwned', 'AddressIsZero', 'UnsupportedOperation', 'NotSufficientFounds', 'NestingIsDisabled', 'OnlyOwnerAllowedToNest', 'SourceCollectionIsNotAllowedToNest', 'CollectionFieldSizeExceeded', 'NoSpaceForProperty', 'PropertyLimitReached', 'PropertyKeyIsTooLong', 'InvalidCharacterInPropertyKey', 'EmptyPropertyKey']
   },
   /**
-   * Lookup335: pallet_fungible::pallet::Error<T>
+   * Lookup376: pallet_fungible::pallet::Error<T>
    **/
   PalletFungibleError: {
     _enum: ['NotFungibleDataUsedToMintFungibleCollectionToken', 'FungibleItemsHaveNoId', 'FungibleItemsDontHaveData', 'FungibleDisallowsNesting', 'SettingPropertiesNotAllowed']
   },
   /**
-   * Lookup336: pallet_refungible::ItemData
+   * Lookup377: pallet_refungible::ItemData
    **/
   PalletRefungibleItemData: {
     constData: 'Bytes'
   },
   /**
-   * Lookup340: pallet_refungible::pallet::Error<T>
+   * Lookup381: pallet_refungible::pallet::Error<T>
    **/
   PalletRefungibleError: {
     _enum: ['NotRefungibleDataUsedToMintFungibleCollectionToken', 'WrongRefungiblePieces', 'RefungibleDisallowsNesting', 'SettingPropertiesNotAllowed']
   },
   /**
-   * Lookup341: pallet_nonfungible::ItemData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
+   * Lookup382: pallet_nonfungible::ItemData<pallet_evm::account::BasicCrossAccountIdRepr<sp_core::crypto::AccountId32>>
    **/
   PalletNonfungibleItemData: {
     constData: 'Bytes',
     owner: 'PalletEvmAccountBasicCrossAccountIdRepr'
   },
   /**
-   * Lookup342: pallet_nonfungible::pallet::Error<T>
+   * Lookup383: pallet_nonfungible::pallet::Error<T>
    **/
   PalletNonfungibleError: {
     _enum: ['NotNonfungibleDataUsedToMintFungibleCollectionToken', 'NonfungibleItemsHaveNoAmount']
   },
   /**
-   * Lookup343: pallet_structure::pallet::Error<T>
+   * Lookup384: pallet_structure::pallet::Error<T>
    **/
   PalletStructureError: {
     _enum: ['OuroborosDetected', 'DepthLimit', 'TokenNotFound']
   },
   /**
-   * Lookup346: pallet_evm::pallet::Error<T>
+   * Lookup387: pallet_evm::pallet::Error<T>
    **/
   PalletEvmError: {
     _enum: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce']
   },
   /**
-   * Lookup349: fp_rpc::TransactionStatus
+   * Lookup390: fp_rpc::TransactionStatus
    **/
   FpRpcTransactionStatus: {
     transactionHash: 'H256',
@@ -2412,11 +2564,11 @@
     logsBloom: 'EthbloomBloom'
   },
   /**
-   * Lookup351: ethbloom::Bloom
+   * Lookup392: ethbloom::Bloom
    **/
   EthbloomBloom: '[u8;256]',
   /**
-   * Lookup353: ethereum::receipt::ReceiptV3
+   * Lookup394: ethereum::receipt::ReceiptV3
    **/
   EthereumReceiptReceiptV3: {
     _enum: {
@@ -2426,7 +2578,7 @@
     }
   },
   /**
-   * Lookup354: ethereum::receipt::EIP658ReceiptData
+   * Lookup395: ethereum::receipt::EIP658ReceiptData
    **/
   EthereumReceiptEip658ReceiptData: {
     statusCode: 'u8',
@@ -2435,7 +2587,7 @@
     logs: 'Vec<EthereumLog>'
   },
   /**
-   * Lookup355: ethereum::block::Block<ethereum::transaction::TransactionV2>
+   * Lookup396: ethereum::block::Block<ethereum::transaction::TransactionV2>
    **/
   EthereumBlock: {
     header: 'EthereumHeader',
@@ -2443,7 +2595,7 @@
     ommers: 'Vec<EthereumHeader>'
   },
   /**
-   * Lookup356: ethereum::header::Header
+   * Lookup397: ethereum::header::Header
    **/
   EthereumHeader: {
     parentHash: 'H256',
@@ -2463,41 +2615,41 @@
     nonce: 'EthereumTypesHashH64'
   },
   /**
-   * Lookup357: ethereum_types::hash::H64
+   * Lookup398: ethereum_types::hash::H64
    **/
   EthereumTypesHashH64: '[u8;8]',
   /**
-   * Lookup362: pallet_ethereum::pallet::Error<T>
+   * Lookup403: pallet_ethereum::pallet::Error<T>
    **/
   PalletEthereumError: {
     _enum: ['InvalidSignature', 'PreLogExists']
   },
   /**
-   * Lookup363: pallet_evm_coder_substrate::pallet::Error<T>
+   * Lookup404: pallet_evm_coder_substrate::pallet::Error<T>
    **/
   PalletEvmCoderSubstrateError: {
     _enum: ['OutOfGas', 'OutOfFund']
   },
   /**
-   * Lookup364: pallet_evm_contract_helpers::SponsoringModeT
+   * Lookup405: pallet_evm_contract_helpers::SponsoringModeT
    **/
   PalletEvmContractHelpersSponsoringModeT: {
     _enum: ['Disabled', 'Allowlisted', 'Generous']
   },
   /**
-   * Lookup366: pallet_evm_contract_helpers::pallet::Error<T>
+   * Lookup407: pallet_evm_contract_helpers::pallet::Error<T>
    **/
   PalletEvmContractHelpersError: {
     _enum: ['NoPermission']
   },
   /**
-   * Lookup367: pallet_evm_migration::pallet::Error<T>
+   * Lookup408: pallet_evm_migration::pallet::Error<T>
    **/
   PalletEvmMigrationError: {
     _enum: ['AccountNotEmpty', 'AccountIsNotMigrating']
   },
   /**
-   * Lookup369: sp_runtime::MultiSignature
+   * Lookup410: sp_runtime::MultiSignature
    **/
   SpRuntimeMultiSignature: {
     _enum: {
@@ -2507,43 +2659,43 @@
     }
   },
   /**
-   * Lookup370: sp_core::ed25519::Signature
+   * Lookup411: sp_core::ed25519::Signature
    **/
   SpCoreEd25519Signature: '[u8;64]',
   /**
-   * Lookup372: sp_core::sr25519::Signature
+   * Lookup413: sp_core::sr25519::Signature
    **/
   SpCoreSr25519Signature: '[u8;64]',
   /**
-   * Lookup373: sp_core::ecdsa::Signature
+   * Lookup414: sp_core::ecdsa::Signature
    **/
   SpCoreEcdsaSignature: '[u8;65]',
   /**
-   * Lookup376: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
+   * Lookup417: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
    **/
   FrameSystemExtensionsCheckSpecVersion: 'Null',
   /**
-   * Lookup377: frame_system::extensions::check_genesis::CheckGenesis<T>
+   * Lookup418: frame_system::extensions::check_genesis::CheckGenesis<T>
    **/
   FrameSystemExtensionsCheckGenesis: 'Null',
   /**
-   * Lookup380: frame_system::extensions::check_nonce::CheckNonce<T>
+   * Lookup421: frame_system::extensions::check_nonce::CheckNonce<T>
    **/
   FrameSystemExtensionsCheckNonce: 'Compact<u32>',
   /**
-   * Lookup381: frame_system::extensions::check_weight::CheckWeight<T>
+   * Lookup422: frame_system::extensions::check_weight::CheckWeight<T>
    **/
   FrameSystemExtensionsCheckWeight: 'Null',
   /**
-   * Lookup382: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>
+   * Lookup423: pallet_template_transaction_payment::ChargeTransactionPayment<opal_runtime::Runtime>
    **/
   PalletTemplateTransactionPaymentChargeTransactionPayment: 'Compact<u128>',
   /**
-   * Lookup383: opal_runtime::Runtime
+   * Lookup424: opal_runtime::Runtime
    **/
   OpalRuntimeRuntime: 'Null',
   /**
-   * Lookup384: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>
+   * Lookup425: pallet_ethereum::FakeTransactionFinalizer<opal_runtime::Runtime>
    **/
   PalletEthereumFakeTransactionFinalizer: 'Null'
 };
modifiedtests/src/interfaces/registry.tsdiffbeforeafterboth
--- a/tests/src/interfaces/registry.ts
+++ b/tests/src/interfaces/registry.ts
@@ -1,7 +1,7 @@
 // Auto-generated via `yarn polkadot-types-from-defs`, do not edit
 /* eslint-disable */
 
-import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportStorageBoundedBTreeSet, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsTokenData, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExData, UpDataStructsNestingRule, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsRpcCollection, UpDataStructsSchemaVersion, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';
+import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OpalRuntimeRuntime, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEthereumFakeTransactionFinalizer, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletStructureCall, PalletStructureError, PalletStructureEvent, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PhantomTypeUpDataStructsBaseInfo, PhantomTypeUpDataStructsCollectionInfo, PhantomTypeUpDataStructsNftChild, PhantomTypeUpDataStructsNftInfo, PhantomTypeUpDataStructsPartType, PhantomTypeUpDataStructsPropertyInfo, PhantomTypeUpDataStructsResourceInfo, PhantomTypeUpDataStructsRpcCollection, PhantomTypeUpDataStructsTheme, PhantomTypeUpDataStructsTokenData, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2AbridgedHrmpChannel, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RmrkTypesAccountIdOrCollectionNftTuple, RmrkTypesBaseInfo, RmrkTypesCollectionInfo, RmrkTypesEquippableList, RmrkTypesFixedPart, RmrkTypesNftChild, RmrkTypesNftInfo, RmrkTypesPartType, RmrkTypesPropertyInfo, RmrkTypesResourceInfo, RmrkTypesRoyaltyInfo, RmrkTypesSlotPart, RmrkTypesTheme, RmrkTypesThemeProperty, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeModuleError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpRuntimeTransactionalError, SpTrieStorageProof, SpVersionRuntimeVersion, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionField, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsCreateNftData, UpDataStructsCreateNftExData, UpDataStructsCreateReFungibleData, UpDataStructsCreateRefungibleExData, UpDataStructsNestingRule, UpDataStructsProperties, UpDataStructsPropertiesMapBoundedVec, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsPropertyPermission, UpDataStructsRpcCollection, UpDataStructsSchemaVersion, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, UpDataStructsTokenData, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';
 
 declare module '@polkadot/types/types/registry' {
   export interface InterfaceTypes {
@@ -47,7 +47,6 @@
     EvmCoreErrorExitSucceed: EvmCoreErrorExitSucceed;
     FpRpcTransactionStatus: FpRpcTransactionStatus;
     FrameSupportPalletId: FrameSupportPalletId;
-    FrameSupportStorageBoundedBTreeSet: FrameSupportStorageBoundedBTreeSet;
     FrameSupportTokensMiscBalanceStatus: FrameSupportTokensMiscBalanceStatus;
     FrameSupportWeightsDispatchClass: FrameSupportWeightsDispatchClass;
     FrameSupportWeightsDispatchInfo: FrameSupportWeightsDispatchInfo;
@@ -125,7 +124,15 @@
     PalletXcmCall: PalletXcmCall;
     PalletXcmError: PalletXcmError;
     PalletXcmEvent: PalletXcmEvent;
+    PhantomTypeUpDataStructsBaseInfo: PhantomTypeUpDataStructsBaseInfo;
+    PhantomTypeUpDataStructsCollectionInfo: PhantomTypeUpDataStructsCollectionInfo;
+    PhantomTypeUpDataStructsNftChild: PhantomTypeUpDataStructsNftChild;
+    PhantomTypeUpDataStructsNftInfo: PhantomTypeUpDataStructsNftInfo;
+    PhantomTypeUpDataStructsPartType: PhantomTypeUpDataStructsPartType;
+    PhantomTypeUpDataStructsPropertyInfo: PhantomTypeUpDataStructsPropertyInfo;
+    PhantomTypeUpDataStructsResourceInfo: PhantomTypeUpDataStructsResourceInfo;
     PhantomTypeUpDataStructsRpcCollection: PhantomTypeUpDataStructsRpcCollection;
+    PhantomTypeUpDataStructsTheme: PhantomTypeUpDataStructsTheme;
     PhantomTypeUpDataStructsTokenData: PhantomTypeUpDataStructsTokenData;
     PolkadotCorePrimitivesInboundDownwardMessage: PolkadotCorePrimitivesInboundDownwardMessage;
     PolkadotCorePrimitivesInboundHrmpMessage: PolkadotCorePrimitivesInboundHrmpMessage;
@@ -135,6 +142,20 @@
     PolkadotPrimitivesV2AbridgedHrmpChannel: PolkadotPrimitivesV2AbridgedHrmpChannel;
     PolkadotPrimitivesV2PersistedValidationData: PolkadotPrimitivesV2PersistedValidationData;
     PolkadotPrimitivesV2UpgradeRestriction: PolkadotPrimitivesV2UpgradeRestriction;
+    RmrkTypesAccountIdOrCollectionNftTuple: RmrkTypesAccountIdOrCollectionNftTuple;
+    RmrkTypesBaseInfo: RmrkTypesBaseInfo;
+    RmrkTypesCollectionInfo: RmrkTypesCollectionInfo;
+    RmrkTypesEquippableList: RmrkTypesEquippableList;
+    RmrkTypesFixedPart: RmrkTypesFixedPart;
+    RmrkTypesNftChild: RmrkTypesNftChild;
+    RmrkTypesNftInfo: RmrkTypesNftInfo;
+    RmrkTypesPartType: RmrkTypesPartType;
+    RmrkTypesPropertyInfo: RmrkTypesPropertyInfo;
+    RmrkTypesResourceInfo: RmrkTypesResourceInfo;
+    RmrkTypesRoyaltyInfo: RmrkTypesRoyaltyInfo;
+    RmrkTypesSlotPart: RmrkTypesSlotPart;
+    RmrkTypesTheme: RmrkTypesTheme;
+    RmrkTypesThemeProperty: RmrkTypesThemeProperty;
     SpCoreEcdsaSignature: SpCoreEcdsaSignature;
     SpCoreEd25519Signature: SpCoreEd25519Signature;
     SpCoreSr25519Signature: SpCoreSr25519Signature;
addedtests/src/interfaces/rmrk/definitions.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/interfaces/rmrk/definitions.ts
@@ -0,0 +1,115 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+import types from '../lookup';
+
+type RpcParam = {
+  name: string;
+  type: string;
+  isOptional?: true;
+};
+
+const atParam = {name: 'at', type: 'Hash', isOptional: true};
+const fn = (description: string, params: RpcParam[], type: string) => ({
+    description,
+    params: [...params, atParam],
+    type,
+});
+
+export default {
+    types,
+    rpc: {
+        lastCollectionIdx: fn('Get the latest created collection id', [], 'u32'),
+        collectionById: fn('Get collection by id', [{name: 'id', type: 'u32'}], 'Option<RmrkTypesCollectionInfo>'),
+        nftById: fn(
+            'Get NFT by collection id and NFT id',
+            [
+                {name: 'collectionId', type: 'u32'},
+                {name: 'nftId', type: 'u32'},
+            ],
+            'Option<RmrkTypesNftInfo>'
+        ),
+        accountTokens: fn(
+            'Get tokens owned by an account in a collection',
+            [
+                {name: 'accountId', type: 'AccountId32'},
+                {name: 'collectionId', type: 'u32'}
+            ],
+            'Vec<u32>'
+        ),
+        nftChildren: fn(
+            'Get NFT children',
+            [
+                {name: 'collectionId', type: 'u32'},
+                {name: 'nftId', type: 'u32'},
+            ],
+            'Vec<RmrkTypesNftChild>'
+        ),
+        collectionProperties: fn(
+            'Get collection properties',
+            [{name: 'collectionId', type: 'u32'}],
+            'Vec<RmrkTypesPropertyInfo>'
+        ),
+        nftProperties: fn(
+            'Get NFT properties',
+            [
+                {name: 'collectionId', type: 'u32'},
+                {name: 'nftId', type: 'u32'}
+            ],
+            'Vec<RmrkTypesPropertyInfo>'
+        ),
+        nftResources: fn(
+            'Get NFT resources',
+            [
+                {name: 'collectionId', type: 'u32'},
+                {name: 'nftId', type: 'u32'}
+            ],
+            'Vec<RmrkTypesResourceInfo>'
+        ),
+        nftResourcePriorities: fn(
+            'Get NFT resource priorities',
+            [
+                {name: 'collectionId', type: 'u32'},
+                {name: 'nftId', type: 'u32'}
+            ],
+            'Vec<Bytes>'
+        ),
+        base: fn(
+            'Get base info',
+            [{name: 'baseId', type: 'u32'}],
+            'Option<RmrkTypesBaseInfo>'
+        ),
+        baseParts: fn(
+            'Get all Base\'s parts',
+            [{name: 'baseId', type: 'u32'}],
+            'Vec<RmrkTypesPartType>'
+        ),
+        themeNames: fn(
+            'Get Base\'s theme names',
+            [{name: 'baseId', type: 'u32'}],
+            'Vec<Bytes>'
+        ),
+        themes: fn(
+            'Get Theme\'s keys values',
+            [
+                {name: 'baseId', type: 'u32'},
+                {name: 'themeName', type: 'String'},
+                {name: 'keys', type: 'Option<Vec<String>>'}
+            ],
+            'Option<RmrkTypesTheme>'
+        )
+    }
+};
addedtests/src/interfaces/rmrk/index.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/interfaces/rmrk/index.ts
@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './types';
addedtests/src/interfaces/rmrk/types.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/interfaces/rmrk/types.ts
@@ -0,0 +1,2910 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { BTreeMap, BTreeSet, Bytes, Compact, Enum, Null, Option, Result, Struct, Text, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
+import type { ITuple } from '@polkadot/types-codec/types';
+import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';
+import type { Event } from '@polkadot/types/interfaces/system';
+
+/** @name CumulusPalletDmpQueueCall */
+export interface CumulusPalletDmpQueueCall extends Enum {
+  readonly isServiceOverweight: boolean;
+  readonly asServiceOverweight: {
+    readonly index: u64;
+    readonly weightLimit: u64;
+  } & Struct;
+  readonly type: 'ServiceOverweight';
+}
+
+/** @name CumulusPalletDmpQueueConfigData */
+export interface CumulusPalletDmpQueueConfigData extends Struct {
+  readonly maxIndividual: u64;
+}
+
+/** @name CumulusPalletDmpQueueError */
+export interface CumulusPalletDmpQueueError extends Enum {
+  readonly isUnknown: boolean;
+  readonly isOverLimit: boolean;
+  readonly type: 'Unknown' | 'OverLimit';
+}
+
+/** @name CumulusPalletDmpQueueEvent */
+export interface CumulusPalletDmpQueueEvent extends Enum {
+  readonly isInvalidFormat: boolean;
+  readonly asInvalidFormat: U8aFixed;
+  readonly isUnsupportedVersion: boolean;
+  readonly asUnsupportedVersion: U8aFixed;
+  readonly isExecutedDownward: boolean;
+  readonly asExecutedDownward: ITuple<[U8aFixed, XcmV2TraitsOutcome]>;
+  readonly isWeightExhausted: boolean;
+  readonly asWeightExhausted: ITuple<[U8aFixed, u64, u64]>;
+  readonly isOverweightEnqueued: boolean;
+  readonly asOverweightEnqueued: ITuple<[U8aFixed, u64, u64]>;
+  readonly isOverweightServiced: boolean;
+  readonly asOverweightServiced: ITuple<[u64, u64]>;
+  readonly type: 'InvalidFormat' | 'UnsupportedVersion' | 'ExecutedDownward' | 'WeightExhausted' | 'OverweightEnqueued' | 'OverweightServiced';
+}
+
+/** @name CumulusPalletDmpQueuePageIndexData */
+export interface CumulusPalletDmpQueuePageIndexData extends Struct {
+  readonly beginUsed: u32;
+  readonly endUsed: u32;
+  readonly overweightCount: u64;
+}
+
+/** @name CumulusPalletParachainSystemCall */
+export interface CumulusPalletParachainSystemCall extends Enum {
+  readonly isSetValidationData: boolean;
+  readonly asSetValidationData: {
+    readonly data: CumulusPrimitivesParachainInherentParachainInherentData;
+  } & Struct;
+  readonly isSudoSendUpwardMessage: boolean;
+  readonly asSudoSendUpwardMessage: {
+    readonly message: Bytes;
+  } & Struct;
+  readonly isAuthorizeUpgrade: boolean;
+  readonly asAuthorizeUpgrade: {
+    readonly codeHash: H256;
+  } & Struct;
+  readonly isEnactAuthorizedUpgrade: boolean;
+  readonly asEnactAuthorizedUpgrade: {
+    readonly code: Bytes;
+  } & Struct;
+  readonly type: 'SetValidationData' | 'SudoSendUpwardMessage' | 'AuthorizeUpgrade' | 'EnactAuthorizedUpgrade';
+}
+
+/** @name CumulusPalletParachainSystemError */
+export interface CumulusPalletParachainSystemError extends Enum {
+  readonly isOverlappingUpgrades: boolean;
+  readonly isProhibitedByPolkadot: boolean;
+  readonly isTooBig: boolean;
+  readonly isValidationDataNotAvailable: boolean;
+  readonly isHostConfigurationNotAvailable: boolean;
+  readonly isNotScheduled: boolean;
+  readonly isNothingAuthorized: boolean;
+  readonly isUnauthorized: boolean;
+  readonly type: 'OverlappingUpgrades' | 'ProhibitedByPolkadot' | 'TooBig' | 'ValidationDataNotAvailable' | 'HostConfigurationNotAvailable' | 'NotScheduled' | 'NothingAuthorized' | 'Unauthorized';
+}
+
+/** @name CumulusPalletParachainSystemEvent */
+export interface CumulusPalletParachainSystemEvent extends Enum {
+  readonly isValidationFunctionStored: boolean;
+  readonly isValidationFunctionApplied: boolean;
+  readonly asValidationFunctionApplied: u32;
+  readonly isValidationFunctionDiscarded: boolean;
+  readonly isUpgradeAuthorized: boolean;
+  readonly asUpgradeAuthorized: H256;
+  readonly isDownwardMessagesReceived: boolean;
+  readonly asDownwardMessagesReceived: u32;
+  readonly isDownwardMessagesProcessed: boolean;
+  readonly asDownwardMessagesProcessed: ITuple<[u64, H256]>;
+  readonly type: 'ValidationFunctionStored' | 'ValidationFunctionApplied' | 'ValidationFunctionDiscarded' | 'UpgradeAuthorized' | 'DownwardMessagesReceived' | 'DownwardMessagesProcessed';
+}
+
+/** @name CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot */
+export interface CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot extends Struct {
+  readonly dmqMqcHead: H256;
+  readonly relayDispatchQueueSize: ITuple<[u32, u32]>;
+  readonly ingressChannels: Vec<ITuple<[u32, PolkadotPrimitivesV2AbridgedHrmpChannel]>>;
+  readonly egressChannels: Vec<ITuple<[u32, PolkadotPrimitivesV2AbridgedHrmpChannel]>>;
+}
+
+/** @name CumulusPalletXcmCall */
+export interface CumulusPalletXcmCall extends Null {}
+
+/** @name CumulusPalletXcmError */
+export interface CumulusPalletXcmError extends Null {}
+
+/** @name CumulusPalletXcmEvent */
+export interface CumulusPalletXcmEvent extends Enum {
+  readonly isInvalidFormat: boolean;
+  readonly asInvalidFormat: U8aFixed;
+  readonly isUnsupportedVersion: boolean;
+  readonly asUnsupportedVersion: U8aFixed;
+  readonly isExecutedDownward: boolean;
+  readonly asExecutedDownward: ITuple<[U8aFixed, XcmV2TraitsOutcome]>;
+  readonly type: 'InvalidFormat' | 'UnsupportedVersion' | 'ExecutedDownward';
+}
+
+/** @name CumulusPalletXcmpQueueCall */
+export interface CumulusPalletXcmpQueueCall extends Enum {
+  readonly isServiceOverweight: boolean;
+  readonly asServiceOverweight: {
+    readonly index: u64;
+    readonly weightLimit: u64;
+  } & Struct;
+  readonly isSuspendXcmExecution: boolean;
+  readonly isResumeXcmExecution: boolean;
+  readonly isUpdateSuspendThreshold: boolean;
+  readonly asUpdateSuspendThreshold: {
+    readonly new_: u32;
+  } & Struct;
+  readonly isUpdateDropThreshold: boolean;
+  readonly asUpdateDropThreshold: {
+    readonly new_: u32;
+  } & Struct;
+  readonly isUpdateResumeThreshold: boolean;
+  readonly asUpdateResumeThreshold: {
+    readonly new_: u32;
+  } & Struct;
+  readonly isUpdateThresholdWeight: boolean;
+  readonly asUpdateThresholdWeight: {
+    readonly new_: u64;
+  } & Struct;
+  readonly isUpdateWeightRestrictDecay: boolean;
+  readonly asUpdateWeightRestrictDecay: {
+    readonly new_: u64;
+  } & Struct;
+  readonly isUpdateXcmpMaxIndividualWeight: boolean;
+  readonly asUpdateXcmpMaxIndividualWeight: {
+    readonly new_: u64;
+  } & Struct;
+  readonly type: 'ServiceOverweight' | 'SuspendXcmExecution' | 'ResumeXcmExecution' | 'UpdateSuspendThreshold' | 'UpdateDropThreshold' | 'UpdateResumeThreshold' | 'UpdateThresholdWeight' | 'UpdateWeightRestrictDecay' | 'UpdateXcmpMaxIndividualWeight';
+}
+
+/** @name CumulusPalletXcmpQueueError */
+export interface CumulusPalletXcmpQueueError extends Enum {
+  readonly isFailedToSend: boolean;
+  readonly isBadXcmOrigin: boolean;
+  readonly isBadXcm: boolean;
+  readonly isBadOverweightIndex: boolean;
+  readonly isWeightOverLimit: boolean;
+  readonly type: 'FailedToSend' | 'BadXcmOrigin' | 'BadXcm' | 'BadOverweightIndex' | 'WeightOverLimit';
+}
+
+/** @name CumulusPalletXcmpQueueEvent */
+export interface CumulusPalletXcmpQueueEvent extends Enum {
+  readonly isSuccess: boolean;
+  readonly asSuccess: Option<H256>;
+  readonly isFail: boolean;
+  readonly asFail: ITuple<[Option<H256>, XcmV2TraitsError]>;
+  readonly isBadVersion: boolean;
+  readonly asBadVersion: Option<H256>;
+  readonly isBadFormat: boolean;
+  readonly asBadFormat: Option<H256>;
+  readonly isUpwardMessageSent: boolean;
+  readonly asUpwardMessageSent: Option<H256>;
+  readonly isXcmpMessageSent: boolean;
+  readonly asXcmpMessageSent: Option<H256>;
+  readonly isOverweightEnqueued: boolean;
+  readonly asOverweightEnqueued: ITuple<[u32, u32, u64, u64]>;
+  readonly isOverweightServiced: boolean;
+  readonly asOverweightServiced: ITuple<[u64, u64]>;
+  readonly type: 'Success' | 'Fail' | 'BadVersion' | 'BadFormat' | 'UpwardMessageSent' | 'XcmpMessageSent' | 'OverweightEnqueued' | 'OverweightServiced';
+}
+
+/** @name CumulusPalletXcmpQueueInboundChannelDetails */
+export interface CumulusPalletXcmpQueueInboundChannelDetails extends Struct {
+  readonly sender: u32;
+  readonly state: CumulusPalletXcmpQueueInboundState;
+  readonly messageMetadata: Vec<ITuple<[u32, PolkadotParachainPrimitivesXcmpMessageFormat]>>;
+}
+
+/** @name CumulusPalletXcmpQueueInboundState */
+export interface CumulusPalletXcmpQueueInboundState extends Enum {
+  readonly isOk: boolean;
+  readonly isSuspended: boolean;
+  readonly type: 'Ok' | 'Suspended';
+}
+
+/** @name CumulusPalletXcmpQueueOutboundChannelDetails */
+export interface CumulusPalletXcmpQueueOutboundChannelDetails extends Struct {
+  readonly recipient: u32;
+  readonly state: CumulusPalletXcmpQueueOutboundState;
+  readonly signalsExist: bool;
+  readonly firstIndex: u16;
+  readonly lastIndex: u16;
+}
+
+/** @name CumulusPalletXcmpQueueOutboundState */
+export interface CumulusPalletXcmpQueueOutboundState extends Enum {
+  readonly isOk: boolean;
+  readonly isSuspended: boolean;
+  readonly type: 'Ok' | 'Suspended';
+}
+
+/** @name CumulusPalletXcmpQueueQueueConfigData */
+export interface CumulusPalletXcmpQueueQueueConfigData extends Struct {
+  readonly suspendThreshold: u32;
+  readonly dropThreshold: u32;
+  readonly resumeThreshold: u32;
+  readonly thresholdWeight: u64;
+  readonly weightRestrictDecay: u64;
+  readonly xcmpMaxIndividualWeight: u64;
+}
+
+/** @name CumulusPrimitivesParachainInherentParachainInherentData */
+export interface CumulusPrimitivesParachainInherentParachainInherentData extends Struct {
+  readonly validationData: PolkadotPrimitivesV2PersistedValidationData;
+  readonly relayChainState: SpTrieStorageProof;
+  readonly downwardMessages: Vec<PolkadotCorePrimitivesInboundDownwardMessage>;
+  readonly horizontalMessages: BTreeMap<u32, Vec<PolkadotCorePrimitivesInboundHrmpMessage>>;
+}
+
+/** @name EthbloomBloom */
+export interface EthbloomBloom extends U8aFixed {}
+
+/** @name EthereumBlock */
+export interface EthereumBlock extends Struct {
+  readonly header: EthereumHeader;
+  readonly transactions: Vec<EthereumTransactionTransactionV2>;
+  readonly ommers: Vec<EthereumHeader>;
+}
+
+/** @name EthereumHeader */
+export interface EthereumHeader extends Struct {
+  readonly parentHash: H256;
+  readonly ommersHash: H256;
+  readonly beneficiary: H160;
+  readonly stateRoot: H256;
+  readonly transactionsRoot: H256;
+  readonly receiptsRoot: H256;
+  readonly logsBloom: EthbloomBloom;
+  readonly difficulty: U256;
+  readonly number: U256;
+  readonly gasLimit: U256;
+  readonly gasUsed: U256;
+  readonly timestamp: u64;
+  readonly extraData: Bytes;
+  readonly mixHash: H256;
+  readonly nonce: EthereumTypesHashH64;
+}
+
+/** @name EthereumLog */
+export interface EthereumLog extends Struct {
+  readonly address: H160;
+  readonly topics: Vec<H256>;
+  readonly data: Bytes;
+}
+
+/** @name EthereumReceiptEip658ReceiptData */
+export interface EthereumReceiptEip658ReceiptData extends Struct {
+  readonly statusCode: u8;
+  readonly usedGas: U256;
+  readonly logsBloom: EthbloomBloom;
+  readonly logs: Vec<EthereumLog>;
+}
+
+/** @name EthereumReceiptReceiptV3 */
+export interface EthereumReceiptReceiptV3 extends Enum {
+  readonly isLegacy: boolean;
+  readonly asLegacy: EthereumReceiptEip658ReceiptData;
+  readonly isEip2930: boolean;
+  readonly asEip2930: EthereumReceiptEip658ReceiptData;
+  readonly isEip1559: boolean;
+  readonly asEip1559: EthereumReceiptEip658ReceiptData;
+  readonly type: 'Legacy' | 'Eip2930' | 'Eip1559';
+}
+
+/** @name EthereumTransactionAccessListItem */
+export interface EthereumTransactionAccessListItem extends Struct {
+  readonly address: H160;
+  readonly storageKeys: Vec<H256>;
+}
+
+/** @name EthereumTransactionEip1559Transaction */
+export interface EthereumTransactionEip1559Transaction extends Struct {
+  readonly chainId: u64;
+  readonly nonce: U256;
+  readonly maxPriorityFeePerGas: U256;
+  readonly maxFeePerGas: U256;
+  readonly gasLimit: U256;
+  readonly action: EthereumTransactionTransactionAction;
+  readonly value: U256;
+  readonly input: Bytes;
+  readonly accessList: Vec<EthereumTransactionAccessListItem>;
+  readonly oddYParity: bool;
+  readonly r: H256;
+  readonly s: H256;
+}
+
+/** @name EthereumTransactionEip2930Transaction */
+export interface EthereumTransactionEip2930Transaction extends Struct {
+  readonly chainId: u64;
+  readonly nonce: U256;
+  readonly gasPrice: U256;
+  readonly gasLimit: U256;
+  readonly action: EthereumTransactionTransactionAction;
+  readonly value: U256;
+  readonly input: Bytes;
+  readonly accessList: Vec<EthereumTransactionAccessListItem>;
+  readonly oddYParity: bool;
+  readonly r: H256;
+  readonly s: H256;
+}
+
+/** @name EthereumTransactionLegacyTransaction */
+export interface EthereumTransactionLegacyTransaction extends Struct {
+  readonly nonce: U256;
+  readonly gasPrice: U256;
+  readonly gasLimit: U256;
+  readonly action: EthereumTransactionTransactionAction;
+  readonly value: U256;
+  readonly input: Bytes;
+  readonly signature: EthereumTransactionTransactionSignature;
+}
+
+/** @name EthereumTransactionTransactionAction */
+export interface EthereumTransactionTransactionAction extends Enum {
+  readonly isCall: boolean;
+  readonly asCall: H160;
+  readonly isCreate: boolean;
+  readonly type: 'Call' | 'Create';
+}
+
+/** @name EthereumTransactionTransactionSignature */
+export interface EthereumTransactionTransactionSignature extends Struct {
+  readonly v: u64;
+  readonly r: H256;
+  readonly s: H256;
+}
+
+/** @name EthereumTransactionTransactionV2 */
+export interface EthereumTransactionTransactionV2 extends Enum {
+  readonly isLegacy: boolean;
+  readonly asLegacy: EthereumTransactionLegacyTransaction;
+  readonly isEip2930: boolean;
+  readonly asEip2930: EthereumTransactionEip2930Transaction;
+  readonly isEip1559: boolean;
+  readonly asEip1559: EthereumTransactionEip1559Transaction;
+  readonly type: 'Legacy' | 'Eip2930' | 'Eip1559';
+}
+
+/** @name EthereumTypesHashH64 */
+export interface EthereumTypesHashH64 extends U8aFixed {}
+
+/** @name EvmCoreErrorExitError */
+export interface EvmCoreErrorExitError extends Enum {
+  readonly isStackUnderflow: boolean;
+  readonly isStackOverflow: boolean;
+  readonly isInvalidJump: boolean;
+  readonly isInvalidRange: boolean;
+  readonly isDesignatedInvalid: boolean;
+  readonly isCallTooDeep: boolean;
+  readonly isCreateCollision: boolean;
+  readonly isCreateContractLimit: boolean;
+  readonly isOutOfOffset: boolean;
+  readonly isOutOfGas: boolean;
+  readonly isOutOfFund: boolean;
+  readonly isPcUnderflow: boolean;
+  readonly isCreateEmpty: boolean;
+  readonly isOther: boolean;
+  readonly asOther: Text;
+  readonly isInvalidCode: boolean;
+  readonly type: 'StackUnderflow' | 'StackOverflow' | 'InvalidJump' | 'InvalidRange' | 'DesignatedInvalid' | 'CallTooDeep' | 'CreateCollision' | 'CreateContractLimit' | 'OutOfOffset' | 'OutOfGas' | 'OutOfFund' | 'PcUnderflow' | 'CreateEmpty' | 'Other' | 'InvalidCode';
+}
+
+/** @name EvmCoreErrorExitFatal */
+export interface EvmCoreErrorExitFatal extends Enum {
+  readonly isNotSupported: boolean;
+  readonly isUnhandledInterrupt: boolean;
+  readonly isCallErrorAsFatal: boolean;
+  readonly asCallErrorAsFatal: EvmCoreErrorExitError;
+  readonly isOther: boolean;
+  readonly asOther: Text;
+  readonly type: 'NotSupported' | 'UnhandledInterrupt' | 'CallErrorAsFatal' | 'Other';
+}
+
+/** @name EvmCoreErrorExitReason */
+export interface EvmCoreErrorExitReason extends Enum {
+  readonly isSucceed: boolean;
+  readonly asSucceed: EvmCoreErrorExitSucceed;
+  readonly isError: boolean;
+  readonly asError: EvmCoreErrorExitError;
+  readonly isRevert: boolean;
+  readonly asRevert: EvmCoreErrorExitRevert;
+  readonly isFatal: boolean;
+  readonly asFatal: EvmCoreErrorExitFatal;
+  readonly type: 'Succeed' | 'Error' | 'Revert' | 'Fatal';
+}
+
+/** @name EvmCoreErrorExitRevert */
+export interface EvmCoreErrorExitRevert extends Enum {
+  readonly isReverted: boolean;
+  readonly type: 'Reverted';
+}
+
+/** @name EvmCoreErrorExitSucceed */
+export interface EvmCoreErrorExitSucceed extends Enum {
+  readonly isStopped: boolean;
+  readonly isReturned: boolean;
+  readonly isSuicided: boolean;
+  readonly type: 'Stopped' | 'Returned' | 'Suicided';
+}
+
+/** @name FpRpcTransactionStatus */
+export interface FpRpcTransactionStatus extends Struct {
+  readonly transactionHash: H256;
+  readonly transactionIndex: u32;
+  readonly from: H160;
+  readonly to: Option<H160>;
+  readonly contractAddress: Option<H160>;
+  readonly logs: Vec<EthereumLog>;
+  readonly logsBloom: EthbloomBloom;
+}
+
+/** @name FrameSupportPalletId */
+export interface FrameSupportPalletId extends U8aFixed {}
+
+/** @name FrameSupportTokensMiscBalanceStatus */
+export interface FrameSupportTokensMiscBalanceStatus extends Enum {
+  readonly isFree: boolean;
+  readonly isReserved: boolean;
+  readonly type: 'Free' | 'Reserved';
+}
+
+/** @name FrameSupportWeightsDispatchClass */
+export interface FrameSupportWeightsDispatchClass extends Enum {
+  readonly isNormal: boolean;
+  readonly isOperational: boolean;
+  readonly isMandatory: boolean;
+  readonly type: 'Normal' | 'Operational' | 'Mandatory';
+}
+
+/** @name FrameSupportWeightsDispatchInfo */
+export interface FrameSupportWeightsDispatchInfo extends Struct {
+  readonly weight: u64;
+  readonly class: FrameSupportWeightsDispatchClass;
+  readonly paysFee: FrameSupportWeightsPays;
+}
+
+/** @name FrameSupportWeightsPays */
+export interface FrameSupportWeightsPays extends Enum {
+  readonly isYes: boolean;
+  readonly isNo: boolean;
+  readonly type: 'Yes' | 'No';
+}
+
+/** @name FrameSupportWeightsPerDispatchClassU32 */
+export interface FrameSupportWeightsPerDispatchClassU32 extends Struct {
+  readonly normal: u32;
+  readonly operational: u32;
+  readonly mandatory: u32;
+}
+
+/** @name FrameSupportWeightsPerDispatchClassU64 */
+export interface FrameSupportWeightsPerDispatchClassU64 extends Struct {
+  readonly normal: u64;
+  readonly operational: u64;
+  readonly mandatory: u64;
+}
+
+/** @name FrameSupportWeightsPerDispatchClassWeightsPerClass */
+export interface FrameSupportWeightsPerDispatchClassWeightsPerClass extends Struct {
+  readonly normal: FrameSystemLimitsWeightsPerClass;
+  readonly operational: FrameSystemLimitsWeightsPerClass;
+  readonly mandatory: FrameSystemLimitsWeightsPerClass;
+}
+
+/** @name FrameSupportWeightsRuntimeDbWeight */
+export interface FrameSupportWeightsRuntimeDbWeight extends Struct {
+  readonly read: u64;
+  readonly write: u64;
+}
+
+/** @name FrameSupportWeightsWeightToFeeCoefficient */
+export interface FrameSupportWeightsWeightToFeeCoefficient extends Struct {
+  readonly coeffInteger: u128;
+  readonly coeffFrac: Perbill;
+  readonly negative: bool;
+  readonly degree: u8;
+}
+
+/** @name FrameSystemAccountInfo */
+export interface FrameSystemAccountInfo extends Struct {
+  readonly nonce: u32;
+  readonly consumers: u32;
+  readonly providers: u32;
+  readonly sufficients: u32;
+  readonly data: PalletBalancesAccountData;
+}
+
+/** @name FrameSystemCall */
+export interface FrameSystemCall extends Enum {
+  readonly isFillBlock: boolean;
+  readonly asFillBlock: {
+    readonly ratio: Perbill;
+  } & Struct;
+  readonly isRemark: boolean;
+  readonly asRemark: {
+    readonly remark: Bytes;
+  } & Struct;
+  readonly isSetHeapPages: boolean;
+  readonly asSetHeapPages: {
+    readonly pages: u64;
+  } & Struct;
+  readonly isSetCode: boolean;
+  readonly asSetCode: {
+    readonly code: Bytes;
+  } & Struct;
+  readonly isSetCodeWithoutChecks: boolean;
+  readonly asSetCodeWithoutChecks: {
+    readonly code: Bytes;
+  } & Struct;
+  readonly isSetStorage: boolean;
+  readonly asSetStorage: {
+    readonly items: Vec<ITuple<[Bytes, Bytes]>>;
+  } & Struct;
+  readonly isKillStorage: boolean;
+  readonly asKillStorage: {
+    readonly keys_: Vec<Bytes>;
+  } & Struct;
+  readonly isKillPrefix: boolean;
+  readonly asKillPrefix: {
+    readonly prefix: Bytes;
+    readonly subkeys: u32;
+  } & Struct;
+  readonly isRemarkWithEvent: boolean;
+  readonly asRemarkWithEvent: {
+    readonly remark: Bytes;
+  } & Struct;
+  readonly type: 'FillBlock' | 'Remark' | 'SetHeapPages' | 'SetCode' | 'SetCodeWithoutChecks' | 'SetStorage' | 'KillStorage' | 'KillPrefix' | 'RemarkWithEvent';
+}
+
+/** @name FrameSystemError */
+export interface FrameSystemError extends Enum {
+  readonly isInvalidSpecName: boolean;
+  readonly isSpecVersionNeedsToIncrease: boolean;
+  readonly isFailedToExtractRuntimeVersion: boolean;
+  readonly isNonDefaultComposite: boolean;
+  readonly isNonZeroRefCount: boolean;
+  readonly isCallFiltered: boolean;
+  readonly type: 'InvalidSpecName' | 'SpecVersionNeedsToIncrease' | 'FailedToExtractRuntimeVersion' | 'NonDefaultComposite' | 'NonZeroRefCount' | 'CallFiltered';
+}
+
+/** @name FrameSystemEvent */
+export interface FrameSystemEvent extends Enum {
+  readonly isExtrinsicSuccess: boolean;
+  readonly asExtrinsicSuccess: {
+    readonly dispatchInfo: FrameSupportWeightsDispatchInfo;
+  } & Struct;
+  readonly isExtrinsicFailed: boolean;
+  readonly asExtrinsicFailed: {
+    readonly dispatchError: SpRuntimeDispatchError;
+    readonly dispatchInfo: FrameSupportWeightsDispatchInfo;
+  } & Struct;
+  readonly isCodeUpdated: boolean;
+  readonly isNewAccount: boolean;
+  readonly asNewAccount: {
+    readonly account: AccountId32;
+  } & Struct;
+  readonly isKilledAccount: boolean;
+  readonly asKilledAccount: {
+    readonly account: AccountId32;
+  } & Struct;
+  readonly isRemarked: boolean;
+  readonly asRemarked: {
+    readonly sender: AccountId32;
+    readonly hash_: H256;
+  } & Struct;
+  readonly type: 'ExtrinsicSuccess' | 'ExtrinsicFailed' | 'CodeUpdated' | 'NewAccount' | 'KilledAccount' | 'Remarked';
+}
+
+/** @name FrameSystemEventRecord */
+export interface FrameSystemEventRecord extends Struct {
+  readonly phase: FrameSystemPhase;
+  readonly event: Event;
+  readonly topics: Vec<H256>;
+}
+
+/** @name FrameSystemExtensionsCheckGenesis */
+export interface FrameSystemExtensionsCheckGenesis extends Null {}
+
+/** @name FrameSystemExtensionsCheckNonce */
+export interface FrameSystemExtensionsCheckNonce extends Compact<u32> {}
+
+/** @name FrameSystemExtensionsCheckSpecVersion */
+export interface FrameSystemExtensionsCheckSpecVersion extends Null {}
+
+/** @name FrameSystemExtensionsCheckWeight */
+export interface FrameSystemExtensionsCheckWeight extends Null {}
+
+/** @name FrameSystemLastRuntimeUpgradeInfo */
+export interface FrameSystemLastRuntimeUpgradeInfo extends Struct {
+  readonly specVersion: Compact<u32>;
+  readonly specName: Text;
+}
+
+/** @name FrameSystemLimitsBlockLength */
+export interface FrameSystemLimitsBlockLength extends Struct {
+  readonly max: FrameSupportWeightsPerDispatchClassU32;
+}
+
+/** @name FrameSystemLimitsBlockWeights */
+export interface FrameSystemLimitsBlockWeights extends Struct {
+  readonly baseBlock: u64;
+  readonly maxBlock: u64;
+  readonly perClass: FrameSupportWeightsPerDispatchClassWeightsPerClass;
+}
+
+/** @name FrameSystemLimitsWeightsPerClass */
+export interface FrameSystemLimitsWeightsPerClass extends Struct {
+  readonly baseExtrinsic: u64;
+  readonly maxExtrinsic: Option<u64>;
+  readonly maxTotal: Option<u64>;
+  readonly reserved: Option<u64>;
+}
+
+/** @name FrameSystemPhase */
+export interface FrameSystemPhase extends Enum {
+  readonly isApplyExtrinsic: boolean;
+  readonly asApplyExtrinsic: u32;
+  readonly isFinalization: boolean;
+  readonly isInitialization: boolean;
+  readonly type: 'ApplyExtrinsic' | 'Finalization' | 'Initialization';
+}
+
+/** @name OpalRuntimeRuntime */
+export interface OpalRuntimeRuntime extends Null {}
+
+/** @name OrmlVestingModuleCall */
+export interface OrmlVestingModuleCall extends Enum {
+  readonly isClaim: boolean;
+  readonly isVestedTransfer: boolean;
+  readonly asVestedTransfer: {
+    readonly dest: MultiAddress;
+    readonly schedule: OrmlVestingVestingSchedule;
+  } & Struct;
+  readonly isUpdateVestingSchedules: boolean;
+  readonly asUpdateVestingSchedules: {
+    readonly who: MultiAddress;
+    readonly vestingSchedules: Vec<OrmlVestingVestingSchedule>;
+  } & Struct;
+  readonly isClaimFor: boolean;
+  readonly asClaimFor: {
+    readonly dest: MultiAddress;
+  } & Struct;
+  readonly type: 'Claim' | 'VestedTransfer' | 'UpdateVestingSchedules' | 'ClaimFor';
+}
+
+/** @name OrmlVestingModuleError */
+export interface OrmlVestingModuleError extends Enum {
+  readonly isZeroVestingPeriod: boolean;
+  readonly isZeroVestingPeriodCount: boolean;
+  readonly isInsufficientBalanceToLock: boolean;
+  readonly isTooManyVestingSchedules: boolean;
+  readonly isAmountLow: boolean;
+  readonly isMaxVestingSchedulesExceeded: boolean;
+  readonly type: 'ZeroVestingPeriod' | 'ZeroVestingPeriodCount' | 'InsufficientBalanceToLock' | 'TooManyVestingSchedules' | 'AmountLow' | 'MaxVestingSchedulesExceeded';
+}
+
+/** @name OrmlVestingModuleEvent */
+export interface OrmlVestingModuleEvent extends Enum {
+  readonly isVestingScheduleAdded: boolean;
+  readonly asVestingScheduleAdded: {
+    readonly from: AccountId32;
+    readonly to: AccountId32;
+    readonly vestingSchedule: OrmlVestingVestingSchedule;
+  } & Struct;
+  readonly isClaimed: boolean;
+  readonly asClaimed: {
+    readonly who: AccountId32;
+    readonly amount: u128;
+  } & Struct;
+  readonly isVestingSchedulesUpdated: boolean;
+  readonly asVestingSchedulesUpdated: {
+    readonly who: AccountId32;
+  } & Struct;
+  readonly type: 'VestingScheduleAdded' | 'Claimed' | 'VestingSchedulesUpdated';
+}
+
+/** @name OrmlVestingVestingSchedule */
+export interface OrmlVestingVestingSchedule extends Struct {
+  readonly start: u32;
+  readonly period: u32;
+  readonly periodCount: u32;
+  readonly perPeriod: Compact<u128>;
+}
+
+/** @name PalletBalancesAccountData */
+export interface PalletBalancesAccountData extends Struct {
+  readonly free: u128;
+  readonly reserved: u128;
+  readonly miscFrozen: u128;
+  readonly feeFrozen: u128;
+}
+
+/** @name PalletBalancesBalanceLock */
+export interface PalletBalancesBalanceLock extends Struct {
+  readonly id: U8aFixed;
+  readonly amount: u128;
+  readonly reasons: PalletBalancesReasons;
+}
+
+/** @name PalletBalancesCall */
+export interface PalletBalancesCall extends Enum {
+  readonly isTransfer: boolean;
+  readonly asTransfer: {
+    readonly dest: MultiAddress;
+    readonly value: Compact<u128>;
+  } & Struct;
+  readonly isSetBalance: boolean;
+  readonly asSetBalance: {
+    readonly who: MultiAddress;
+    readonly newFree: Compact<u128>;
+    readonly newReserved: Compact<u128>;
+  } & Struct;
+  readonly isForceTransfer: boolean;
+  readonly asForceTransfer: {
+    readonly source: MultiAddress;
+    readonly dest: MultiAddress;
+    readonly value: Compact<u128>;
+  } & Struct;
+  readonly isTransferKeepAlive: boolean;
+  readonly asTransferKeepAlive: {
+    readonly dest: MultiAddress;
+    readonly value: Compact<u128>;
+  } & Struct;
+  readonly isTransferAll: boolean;
+  readonly asTransferAll: {
+    readonly dest: MultiAddress;
+    readonly keepAlive: bool;
+  } & Struct;
+  readonly isForceUnreserve: boolean;
+  readonly asForceUnreserve: {
+    readonly who: MultiAddress;
+    readonly amount: u128;
+  } & Struct;
+  readonly type: 'Transfer' | 'SetBalance' | 'ForceTransfer' | 'TransferKeepAlive' | 'TransferAll' | 'ForceUnreserve';
+}
+
+/** @name PalletBalancesError */
+export interface PalletBalancesError extends Enum {
+  readonly isVestingBalance: boolean;
+  readonly isLiquidityRestrictions: boolean;
+  readonly isInsufficientBalance: boolean;
+  readonly isExistentialDeposit: boolean;
+  readonly isKeepAlive: boolean;
+  readonly isExistingVestingSchedule: boolean;
+  readonly isDeadAccount: boolean;
+  readonly isTooManyReserves: boolean;
+  readonly type: 'VestingBalance' | 'LiquidityRestrictions' | 'InsufficientBalance' | 'ExistentialDeposit' | 'KeepAlive' | 'ExistingVestingSchedule' | 'DeadAccount' | 'TooManyReserves';
+}
+
+/** @name PalletBalancesEvent */
+export interface PalletBalancesEvent extends Enum {
+  readonly isEndowed: boolean;
+  readonly asEndowed: {
+    readonly account: AccountId32;
+    readonly freeBalance: u128;
+  } & Struct;
+  readonly isDustLost: boolean;
+  readonly asDustLost: {
+    readonly account: AccountId32;
+    readonly amount: u128;
+  } & Struct;
+  readonly isTransfer: boolean;
+  readonly asTransfer: {
+    readonly from: AccountId32;
+    readonly to: AccountId32;
+    readonly amount: u128;
+  } & Struct;
+  readonly isBalanceSet: boolean;
+  readonly asBalanceSet: {
+    readonly who: AccountId32;
+    readonly free: u128;
+    readonly reserved: u128;
+  } & Struct;
+  readonly isReserved: boolean;
+  readonly asReserved: {
+    readonly who: AccountId32;
+    readonly amount: u128;
+  } & Struct;
+  readonly isUnreserved: boolean;
+  readonly asUnreserved: {
+    readonly who: AccountId32;
+    readonly amount: u128;
+  } & Struct;
+  readonly isReserveRepatriated: boolean;
+  readonly asReserveRepatriated: {
+    readonly from: AccountId32;
+    readonly to: AccountId32;
+    readonly amount: u128;
+    readonly destinationStatus: FrameSupportTokensMiscBalanceStatus;
+  } & Struct;
+  readonly isDeposit: boolean;
+  readonly asDeposit: {
+    readonly who: AccountId32;
+    readonly amount: u128;
+  } & Struct;
+  readonly isWithdraw: boolean;
+  readonly asWithdraw: {
+    readonly who: AccountId32;
+    readonly amount: u128;
+  } & Struct;
+  readonly isSlashed: boolean;
+  readonly asSlashed: {
+    readonly who: AccountId32;
+    readonly amount: u128;
+  } & Struct;
+  readonly type: 'Endowed' | 'DustLost' | 'Transfer' | 'BalanceSet' | 'Reserved' | 'Unreserved' | 'ReserveRepatriated' | 'Deposit' | 'Withdraw' | 'Slashed';
+}
+
+/** @name PalletBalancesReasons */
+export interface PalletBalancesReasons extends Enum {
+  readonly isFee: boolean;
+  readonly isMisc: boolean;
+  readonly isAll: boolean;
+  readonly type: 'Fee' | 'Misc' | 'All';
+}
+
+/** @name PalletBalancesReleases */
+export interface PalletBalancesReleases extends Enum {
+  readonly isV100: boolean;
+  readonly isV200: boolean;
+  readonly type: 'V100' | 'V200';
+}
+
+/** @name PalletBalancesReserveData */
+export interface PalletBalancesReserveData extends Struct {
+  readonly id: U8aFixed;
+  readonly amount: u128;
+}
+
+/** @name PalletCommonError */
+export interface PalletCommonError extends Enum {
+  readonly isCollectionNotFound: boolean;
+  readonly isMustBeTokenOwner: boolean;
+  readonly isNoPermission: boolean;
+  readonly isPublicMintingNotAllowed: boolean;
+  readonly isAddressNotInAllowlist: boolean;
+  readonly isCollectionNameLimitExceeded: boolean;
+  readonly isCollectionDescriptionLimitExceeded: boolean;
+  readonly isCollectionTokenPrefixLimitExceeded: boolean;
+  readonly isTotalCollectionsLimitExceeded: boolean;
+  readonly isCollectionAdminCountExceeded: boolean;
+  readonly isCollectionLimitBoundsExceeded: boolean;
+  readonly isOwnerPermissionsCantBeReverted: boolean;
+  readonly isTransferNotAllowed: boolean;
+  readonly isAccountTokenLimitExceeded: boolean;
+  readonly isCollectionTokenLimitExceeded: boolean;
+  readonly isMetadataFlagFrozen: boolean;
+  readonly isTokenNotFound: boolean;
+  readonly isTokenValueTooLow: boolean;
+  readonly isApprovedValueTooLow: boolean;
+  readonly isCantApproveMoreThanOwned: boolean;
+  readonly isAddressIsZero: boolean;
+  readonly isUnsupportedOperation: boolean;
+  readonly isNotSufficientFounds: boolean;
+  readonly isNestingIsDisabled: boolean;
+  readonly isOnlyOwnerAllowedToNest: boolean;
+  readonly isSourceCollectionIsNotAllowedToNest: boolean;
+  readonly isCollectionFieldSizeExceeded: boolean;
+  readonly isNoSpaceForProperty: boolean;
+  readonly isPropertyLimitReached: boolean;
+  readonly isPropertyKeyIsTooLong: boolean;
+  readonly isInvalidCharacterInPropertyKey: boolean;
+  readonly isEmptyPropertyKey: boolean;
+  readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'NestingIsDisabled' | 'OnlyOwnerAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded' | 'NoSpaceForProperty' | 'PropertyLimitReached' | 'PropertyKeyIsTooLong' | 'InvalidCharacterInPropertyKey' | 'EmptyPropertyKey';
+}
+
+/** @name PalletCommonEvent */
+export interface PalletCommonEvent extends Enum {
+  readonly isCollectionCreated: boolean;
+  readonly asCollectionCreated: ITuple<[u32, u8, AccountId32]>;
+  readonly isCollectionDestroyed: boolean;
+  readonly asCollectionDestroyed: u32;
+  readonly isItemCreated: boolean;
+  readonly asItemCreated: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, u128]>;
+  readonly isItemDestroyed: boolean;
+  readonly asItemDestroyed: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, u128]>;
+  readonly isTransfer: boolean;
+  readonly asTransfer: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>;
+  readonly isApproved: boolean;
+  readonly asApproved: ITuple<[u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u128]>;
+  readonly isCollectionPropertySet: boolean;
+  readonly asCollectionPropertySet: ITuple<[u32, Bytes]>;
+  readonly isCollectionPropertyDeleted: boolean;
+  readonly asCollectionPropertyDeleted: ITuple<[u32, Bytes]>;
+  readonly isTokenPropertySet: boolean;
+  readonly asTokenPropertySet: ITuple<[u32, u32, Bytes]>;
+  readonly isTokenPropertyDeleted: boolean;
+  readonly asTokenPropertyDeleted: ITuple<[u32, u32, Bytes]>;
+  readonly isPropertyPermissionSet: boolean;
+  readonly asPropertyPermissionSet: ITuple<[u32, Bytes]>;
+  readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved' | 'CollectionPropertySet' | 'CollectionPropertyDeleted' | 'TokenPropertySet' | 'TokenPropertyDeleted' | 'PropertyPermissionSet';
+}
+
+/** @name PalletEthereumCall */
+export interface PalletEthereumCall extends Enum {
+  readonly isTransact: boolean;
+  readonly asTransact: {
+    readonly transaction: EthereumTransactionTransactionV2;
+  } & Struct;
+  readonly type: 'Transact';
+}
+
+/** @name PalletEthereumError */
+export interface PalletEthereumError extends Enum {
+  readonly isInvalidSignature: boolean;
+  readonly isPreLogExists: boolean;
+  readonly type: 'InvalidSignature' | 'PreLogExists';
+}
+
+/** @name PalletEthereumEvent */
+export interface PalletEthereumEvent extends Enum {
+  readonly isExecuted: boolean;
+  readonly asExecuted: ITuple<[H160, H160, H256, EvmCoreErrorExitReason]>;
+  readonly type: 'Executed';
+}
+
+/** @name PalletEthereumFakeTransactionFinalizer */
+export interface PalletEthereumFakeTransactionFinalizer extends Null {}
+
+/** @name PalletEvmAccountBasicCrossAccountIdRepr */
+export interface PalletEvmAccountBasicCrossAccountIdRepr extends Enum {
+  readonly isSubstrate: boolean;
+  readonly asSubstrate: AccountId32;
+  readonly isEthereum: boolean;
+  readonly asEthereum: H160;
+  readonly type: 'Substrate' | 'Ethereum';
+}
+
+/** @name PalletEvmCall */
+export interface PalletEvmCall extends Enum {
+  readonly isWithdraw: boolean;
+  readonly asWithdraw: {
+    readonly address: H160;
+    readonly value: u128;
+  } & Struct;
+  readonly isCall: boolean;
+  readonly asCall: {
+    readonly source: H160;
+    readonly target: H160;
+    readonly input: Bytes;
+    readonly value: U256;
+    readonly gasLimit: u64;
+    readonly maxFeePerGas: U256;
+    readonly maxPriorityFeePerGas: Option<U256>;
+    readonly nonce: Option<U256>;
+    readonly accessList: Vec<ITuple<[H160, Vec<H256>]>>;
+  } & Struct;
+  readonly isCreate: boolean;
+  readonly asCreate: {
+    readonly source: H160;
+    readonly init: Bytes;
+    readonly value: U256;
+    readonly gasLimit: u64;
+    readonly maxFeePerGas: U256;
+    readonly maxPriorityFeePerGas: Option<U256>;
+    readonly nonce: Option<U256>;
+    readonly accessList: Vec<ITuple<[H160, Vec<H256>]>>;
+  } & Struct;
+  readonly isCreate2: boolean;
+  readonly asCreate2: {
+    readonly source: H160;
+    readonly init: Bytes;
+    readonly salt: H256;
+    readonly value: U256;
+    readonly gasLimit: u64;
+    readonly maxFeePerGas: U256;
+    readonly maxPriorityFeePerGas: Option<U256>;
+    readonly nonce: Option<U256>;
+    readonly accessList: Vec<ITuple<[H160, Vec<H256>]>>;
+  } & Struct;
+  readonly type: 'Withdraw' | 'Call' | 'Create' | 'Create2';
+}
+
+/** @name PalletEvmCoderSubstrateError */
+export interface PalletEvmCoderSubstrateError extends Enum {
+  readonly isOutOfGas: boolean;
+  readonly isOutOfFund: boolean;
+  readonly type: 'OutOfGas' | 'OutOfFund';
+}
+
+/** @name PalletEvmContractHelpersError */
+export interface PalletEvmContractHelpersError extends Enum {
+  readonly isNoPermission: boolean;
+  readonly type: 'NoPermission';
+}
+
+/** @name PalletEvmContractHelpersSponsoringModeT */
+export interface PalletEvmContractHelpersSponsoringModeT extends Enum {
+  readonly isDisabled: boolean;
+  readonly isAllowlisted: boolean;
+  readonly isGenerous: boolean;
+  readonly type: 'Disabled' | 'Allowlisted' | 'Generous';
+}
+
+/** @name PalletEvmError */
+export interface PalletEvmError extends Enum {
+  readonly isBalanceLow: boolean;
+  readonly isFeeOverflow: boolean;
+  readonly isPaymentOverflow: boolean;
+  readonly isWithdrawFailed: boolean;
+  readonly isGasPriceTooLow: boolean;
+  readonly isInvalidNonce: boolean;
+  readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce';
+}
+
+/** @name PalletEvmEvent */
+export interface PalletEvmEvent extends Enum {
+  readonly isLog: boolean;
+  readonly asLog: EthereumLog;
+  readonly isCreated: boolean;
+  readonly asCreated: H160;
+  readonly isCreatedFailed: boolean;
+  readonly asCreatedFailed: H160;
+  readonly isExecuted: boolean;
+  readonly asExecuted: H160;
+  readonly isExecutedFailed: boolean;
+  readonly asExecutedFailed: H160;
+  readonly isBalanceDeposit: boolean;
+  readonly asBalanceDeposit: ITuple<[AccountId32, H160, U256]>;
+  readonly isBalanceWithdraw: boolean;
+  readonly asBalanceWithdraw: ITuple<[AccountId32, H160, U256]>;
+  readonly type: 'Log' | 'Created' | 'CreatedFailed' | 'Executed' | 'ExecutedFailed' | 'BalanceDeposit' | 'BalanceWithdraw';
+}
+
+/** @name PalletEvmMigrationCall */
+export interface PalletEvmMigrationCall extends Enum {
+  readonly isBegin: boolean;
+  readonly asBegin: {
+    readonly address: H160;
+  } & Struct;
+  readonly isSetData: boolean;
+  readonly asSetData: {
+    readonly address: H160;
+    readonly data: Vec<ITuple<[H256, H256]>>;
+  } & Struct;
+  readonly isFinish: boolean;
+  readonly asFinish: {
+    readonly address: H160;
+    readonly code: Bytes;
+  } & Struct;
+  readonly type: 'Begin' | 'SetData' | 'Finish';
+}
+
+/** @name PalletEvmMigrationError */
+export interface PalletEvmMigrationError extends Enum {
+  readonly isAccountNotEmpty: boolean;
+  readonly isAccountIsNotMigrating: boolean;
+  readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating';
+}
+
+/** @name PalletFungibleError */
+export interface PalletFungibleError extends Enum {
+  readonly isNotFungibleDataUsedToMintFungibleCollectionToken: boolean;
+  readonly isFungibleItemsHaveNoId: boolean;
+  readonly isFungibleItemsDontHaveData: boolean;
+  readonly isFungibleDisallowsNesting: boolean;
+  readonly isSettingPropertiesNotAllowed: boolean;
+  readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
+}
+
+/** @name PalletInflationCall */
+export interface PalletInflationCall extends Enum {
+  readonly isStartInflation: boolean;
+  readonly asStartInflation: {
+    readonly inflationStartRelayBlock: u32;
+  } & Struct;
+  readonly type: 'StartInflation';
+}
+
+/** @name PalletNonfungibleError */
+export interface PalletNonfungibleError extends Enum {
+  readonly isNotNonfungibleDataUsedToMintFungibleCollectionToken: boolean;
+  readonly isNonfungibleItemsHaveNoAmount: boolean;
+  readonly type: 'NotNonfungibleDataUsedToMintFungibleCollectionToken' | 'NonfungibleItemsHaveNoAmount';
+}
+
+/** @name PalletNonfungibleItemData */
+export interface PalletNonfungibleItemData extends Struct {
+  readonly constData: Bytes;
+  readonly owner: PalletEvmAccountBasicCrossAccountIdRepr;
+}
+
+/** @name PalletRefungibleError */
+export interface PalletRefungibleError extends Enum {
+  readonly isNotRefungibleDataUsedToMintFungibleCollectionToken: boolean;
+  readonly isWrongRefungiblePieces: boolean;
+  readonly isRefungibleDisallowsNesting: boolean;
+  readonly isSettingPropertiesNotAllowed: boolean;
+  readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RefungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
+}
+
+/** @name PalletRefungibleItemData */
+export interface PalletRefungibleItemData extends Struct {
+  readonly constData: Bytes;
+}
+
+/** @name PalletStructureCall */
+export interface PalletStructureCall extends Null {}
+
+/** @name PalletStructureError */
+export interface PalletStructureError extends Enum {
+  readonly isOuroborosDetected: boolean;
+  readonly isDepthLimit: boolean;
+  readonly isTokenNotFound: boolean;
+  readonly type: 'OuroborosDetected' | 'DepthLimit' | 'TokenNotFound';
+}
+
+/** @name PalletStructureEvent */
+export interface PalletStructureEvent extends Enum {
+  readonly isExecuted: boolean;
+  readonly asExecuted: Result<Null, SpRuntimeDispatchError>;
+  readonly type: 'Executed';
+}
+
+/** @name PalletSudoCall */
+export interface PalletSudoCall extends Enum {
+  readonly isSudo: boolean;
+  readonly asSudo: {
+    readonly call: Call;
+  } & Struct;
+  readonly isSudoUncheckedWeight: boolean;
+  readonly asSudoUncheckedWeight: {
+    readonly call: Call;
+    readonly weight: u64;
+  } & Struct;
+  readonly isSetKey: boolean;
+  readonly asSetKey: {
+    readonly new_: MultiAddress;
+  } & Struct;
+  readonly isSudoAs: boolean;
+  readonly asSudoAs: {
+    readonly who: MultiAddress;
+    readonly call: Call;
+  } & Struct;
+  readonly type: 'Sudo' | 'SudoUncheckedWeight' | 'SetKey' | 'SudoAs';
+}
+
+/** @name PalletSudoError */
+export interface PalletSudoError extends Enum {
+  readonly isRequireSudo: boolean;
+  readonly type: 'RequireSudo';
+}
+
+/** @name PalletSudoEvent */
+export interface PalletSudoEvent extends Enum {
+  readonly isSudid: boolean;
+  readonly asSudid: {
+    readonly sudoResult: Result<Null, SpRuntimeDispatchError>;
+  } & Struct;
+  readonly isKeyChanged: boolean;
+  readonly asKeyChanged: {
+    readonly oldSudoer: Option<AccountId32>;
+  } & Struct;
+  readonly isSudoAsDone: boolean;
+  readonly asSudoAsDone: {
+    readonly sudoResult: Result<Null, SpRuntimeDispatchError>;
+  } & Struct;
+  readonly type: 'Sudid' | 'KeyChanged' | 'SudoAsDone';
+}
+
+/** @name PalletTemplateTransactionPaymentCall */
+export interface PalletTemplateTransactionPaymentCall extends Null {}
+
+/** @name PalletTemplateTransactionPaymentChargeTransactionPayment */
+export interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact<u128> {}
+
+/** @name PalletTimestampCall */
+export interface PalletTimestampCall extends Enum {
+  readonly isSet: boolean;
+  readonly asSet: {
+    readonly now: Compact<u64>;
+  } & Struct;
+  readonly type: 'Set';
+}
+
+/** @name PalletTransactionPaymentReleases */
+export interface PalletTransactionPaymentReleases extends Enum {
+  readonly isV1Ancient: boolean;
+  readonly isV2: boolean;
+  readonly type: 'V1Ancient' | 'V2';
+}
+
+/** @name PalletTreasuryCall */
+export interface PalletTreasuryCall extends Enum {
+  readonly isProposeSpend: boolean;
+  readonly asProposeSpend: {
+    readonly value: Compact<u128>;
+    readonly beneficiary: MultiAddress;
+  } & Struct;
+  readonly isRejectProposal: boolean;
+  readonly asRejectProposal: {
+    readonly proposalId: Compact<u32>;
+  } & Struct;
+  readonly isApproveProposal: boolean;
+  readonly asApproveProposal: {
+    readonly proposalId: Compact<u32>;
+  } & Struct;
+  readonly type: 'ProposeSpend' | 'RejectProposal' | 'ApproveProposal';
+}
+
+/** @name PalletTreasuryError */
+export interface PalletTreasuryError extends Enum {
+  readonly isInsufficientProposersBalance: boolean;
+  readonly isInvalidIndex: boolean;
+  readonly isTooManyApprovals: boolean;
+  readonly type: 'InsufficientProposersBalance' | 'InvalidIndex' | 'TooManyApprovals';
+}
+
+/** @name PalletTreasuryEvent */
+export interface PalletTreasuryEvent extends Enum {
+  readonly isProposed: boolean;
+  readonly asProposed: {
+    readonly proposalIndex: u32;
+  } & Struct;
+  readonly isSpending: boolean;
+  readonly asSpending: {
+    readonly budgetRemaining: u128;
+  } & Struct;
+  readonly isAwarded: boolean;
+  readonly asAwarded: {
+    readonly proposalIndex: u32;
+    readonly award: u128;
+    readonly account: AccountId32;
+  } & Struct;
+  readonly isRejected: boolean;
+  readonly asRejected: {
+    readonly proposalIndex: u32;
+    readonly slashed: u128;
+  } & Struct;
+  readonly isBurnt: boolean;
+  readonly asBurnt: {
+    readonly burntFunds: u128;
+  } & Struct;
+  readonly isRollover: boolean;
+  readonly asRollover: {
+    readonly rolloverBalance: u128;
+  } & Struct;
+  readonly isDeposit: boolean;
+  readonly asDeposit: {
+    readonly value: u128;
+  } & Struct;
+  readonly type: 'Proposed' | 'Spending' | 'Awarded' | 'Rejected' | 'Burnt' | 'Rollover' | 'Deposit';
+}
+
+/** @name PalletTreasuryProposal */
+export interface PalletTreasuryProposal extends Struct {
+  readonly proposer: AccountId32;
+  readonly value: u128;
+  readonly beneficiary: AccountId32;
+  readonly bond: u128;
+}
+
+/** @name PalletUniqueCall */
+export interface PalletUniqueCall extends Enum {
+  readonly isCreateCollection: boolean;
+  readonly asCreateCollection: {
+    readonly collectionName: Vec<u16>;
+    readonly collectionDescription: Vec<u16>;
+    readonly tokenPrefix: Bytes;
+    readonly mode: UpDataStructsCollectionMode;
+  } & Struct;
+  readonly isCreateCollectionEx: boolean;
+  readonly asCreateCollectionEx: {
+    readonly data: UpDataStructsCreateCollectionData;
+  } & Struct;
+  readonly isDestroyCollection: boolean;
+  readonly asDestroyCollection: {
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isAddToAllowList: boolean;
+  readonly asAddToAllowList: {
+    readonly collectionId: u32;
+    readonly address: PalletEvmAccountBasicCrossAccountIdRepr;
+  } & Struct;
+  readonly isRemoveFromAllowList: boolean;
+  readonly asRemoveFromAllowList: {
+    readonly collectionId: u32;
+    readonly address: PalletEvmAccountBasicCrossAccountIdRepr;
+  } & Struct;
+  readonly isSetPublicAccessMode: boolean;
+  readonly asSetPublicAccessMode: {
+    readonly collectionId: u32;
+    readonly mode: UpDataStructsAccessMode;
+  } & Struct;
+  readonly isSetMintPermission: boolean;
+  readonly asSetMintPermission: {
+    readonly collectionId: u32;
+    readonly mintPermission: bool;
+  } & Struct;
+  readonly isChangeCollectionOwner: boolean;
+  readonly asChangeCollectionOwner: {
+    readonly collectionId: u32;
+    readonly newOwner: AccountId32;
+  } & Struct;
+  readonly isAddCollectionAdmin: boolean;
+  readonly asAddCollectionAdmin: {
+    readonly collectionId: u32;
+    readonly newAdminId: PalletEvmAccountBasicCrossAccountIdRepr;
+  } & Struct;
+  readonly isRemoveCollectionAdmin: boolean;
+  readonly asRemoveCollectionAdmin: {
+    readonly collectionId: u32;
+    readonly accountId: PalletEvmAccountBasicCrossAccountIdRepr;
+  } & Struct;
+  readonly isSetCollectionSponsor: boolean;
+  readonly asSetCollectionSponsor: {
+    readonly collectionId: u32;
+    readonly newSponsor: AccountId32;
+  } & Struct;
+  readonly isConfirmSponsorship: boolean;
+  readonly asConfirmSponsorship: {
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isRemoveCollectionSponsor: boolean;
+  readonly asRemoveCollectionSponsor: {
+    readonly collectionId: u32;
+  } & Struct;
+  readonly isCreateItem: boolean;
+  readonly asCreateItem: {
+    readonly collectionId: u32;
+    readonly owner: PalletEvmAccountBasicCrossAccountIdRepr;
+    readonly data: UpDataStructsCreateItemData;
+  } & Struct;
+  readonly isCreateMultipleItems: boolean;
+  readonly asCreateMultipleItems: {
+    readonly collectionId: u32;
+    readonly owner: PalletEvmAccountBasicCrossAccountIdRepr;
+    readonly itemsData: Vec<UpDataStructsCreateItemData>;
+  } & Struct;
+  readonly isSetCollectionProperties: boolean;
+  readonly asSetCollectionProperties: {
+    readonly collectionId: u32;
+    readonly properties: Vec<UpDataStructsProperty>;
+  } & Struct;
+  readonly isDeleteCollectionProperties: boolean;
+  readonly asDeleteCollectionProperties: {
+    readonly collectionId: u32;
+    readonly propertyKeys: Vec<Bytes>;
+  } & Struct;
+  readonly isSetTokenProperties: boolean;
+  readonly asSetTokenProperties: {
+    readonly collectionId: u32;
+    readonly tokenId: u32;
+    readonly properties: Vec<UpDataStructsProperty>;
+  } & Struct;
+  readonly isDeleteTokenProperties: boolean;
+  readonly asDeleteTokenProperties: {
+    readonly collectionId: u32;
+    readonly tokenId: u32;
+    readonly propertyKeys: Vec<Bytes>;
+  } & Struct;
+  readonly isSetPropertyPermissions: boolean;
+  readonly asSetPropertyPermissions: {
+    readonly collectionId: u32;
+    readonly propertyPermissions: Vec<UpDataStructsPropertyKeyPermission>;
+  } & Struct;
+  readonly isCreateMultipleItemsEx: boolean;
+  readonly asCreateMultipleItemsEx: {
+    readonly collectionId: u32;
+    readonly data: UpDataStructsCreateItemExData;
+  } & Struct;
+  readonly isSetTransfersEnabledFlag: boolean;
+  readonly asSetTransfersEnabledFlag: {
+    readonly collectionId: u32;
+    readonly value: bool;
+  } & Struct;
+  readonly isBurnItem: boolean;
+  readonly asBurnItem: {
+    readonly collectionId: u32;
+    readonly itemId: u32;
+    readonly value: u128;
+  } & Struct;
+  readonly isBurnFrom: boolean;
+  readonly asBurnFrom: {
+    readonly collectionId: u32;
+    readonly from: PalletEvmAccountBasicCrossAccountIdRepr;
+    readonly itemId: u32;
+    readonly value: u128;
+  } & Struct;
+  readonly isTransfer: boolean;
+  readonly asTransfer: {
+    readonly recipient: PalletEvmAccountBasicCrossAccountIdRepr;
+    readonly collectionId: u32;
+    readonly itemId: u32;
+    readonly value: u128;
+  } & Struct;
+  readonly isApprove: boolean;
+  readonly asApprove: {
+    readonly spender: PalletEvmAccountBasicCrossAccountIdRepr;
+    readonly collectionId: u32;
+    readonly itemId: u32;
+    readonly amount: u128;
+  } & Struct;
+  readonly isTransferFrom: boolean;
+  readonly asTransferFrom: {
+    readonly from: PalletEvmAccountBasicCrossAccountIdRepr;
+    readonly recipient: PalletEvmAccountBasicCrossAccountIdRepr;
+    readonly collectionId: u32;
+    readonly itemId: u32;
+    readonly value: u128;
+  } & Struct;
+  readonly isSetSchemaVersion: boolean;
+  readonly asSetSchemaVersion: {
+    readonly collectionId: u32;
+    readonly version: UpDataStructsSchemaVersion;
+  } & Struct;
+  readonly isSetOffchainSchema: boolean;
+  readonly asSetOffchainSchema: {
+    readonly collectionId: u32;
+    readonly schema: Bytes;
+  } & Struct;
+  readonly isSetConstOnChainSchema: boolean;
+  readonly asSetConstOnChainSchema: {
+    readonly collectionId: u32;
+    readonly schema: Bytes;
+  } & Struct;
+  readonly isSetCollectionLimits: boolean;
+  readonly asSetCollectionLimits: {
+    readonly collectionId: u32;
+    readonly newLimit: UpDataStructsCollectionLimits;
+  } & Struct;
+  readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'SetPublicAccessMode' | 'SetMintPermission' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetSchemaVersion' | 'SetOffchainSchema' | 'SetConstOnChainSchema' | 'SetCollectionLimits';
+}
+
+/** @name PalletUniqueError */
+export interface PalletUniqueError extends Enum {
+  readonly isCollectionDecimalPointLimitExceeded: boolean;
+  readonly isConfirmUnsetSponsorFail: boolean;
+  readonly isEmptyArgument: boolean;
+  readonly type: 'CollectionDecimalPointLimitExceeded' | 'ConfirmUnsetSponsorFail' | 'EmptyArgument';
+}
+
+/** @name PalletUniqueRawEvent */
+export interface PalletUniqueRawEvent extends Enum {
+  readonly isCollectionSponsorRemoved: boolean;
+  readonly asCollectionSponsorRemoved: u32;
+  readonly isCollectionAdminAdded: boolean;
+  readonly asCollectionAdminAdded: ITuple<[u32, PalletEvmAccountBasicCrossAccountIdRepr]>;
+  readonly isCollectionOwnedChanged: boolean;
+  readonly asCollectionOwnedChanged: ITuple<[u32, AccountId32]>;
+  readonly isCollectionSponsorSet: boolean;
+  readonly asCollectionSponsorSet: ITuple<[u32, AccountId32]>;
+  readonly isConstOnChainSchemaSet: boolean;
+  readonly asConstOnChainSchemaSet: u32;
+  readonly isSponsorshipConfirmed: boolean;
+  readonly asSponsorshipConfirmed: ITuple<[u32, AccountId32]>;
+  readonly isCollectionAdminRemoved: boolean;
+  readonly asCollectionAdminRemoved: ITuple<[u32, PalletEvmAccountBasicCrossAccountIdRepr]>;
+  readonly isAllowListAddressRemoved: boolean;
+  readonly asAllowListAddressRemoved: ITuple<[u32, PalletEvmAccountBasicCrossAccountIdRepr]>;
+  readonly isAllowListAddressAdded: boolean;
+  readonly asAllowListAddressAdded: ITuple<[u32, PalletEvmAccountBasicCrossAccountIdRepr]>;
+  readonly isCollectionLimitSet: boolean;
+  readonly asCollectionLimitSet: u32;
+  readonly isMintPermissionSet: boolean;
+  readonly asMintPermissionSet: u32;
+  readonly isOffchainSchemaSet: boolean;
+  readonly asOffchainSchemaSet: u32;
+  readonly isPublicAccessModeSet: boolean;
+  readonly asPublicAccessModeSet: ITuple<[u32, UpDataStructsAccessMode]>;
+  readonly isSchemaVersionSet: boolean;
+  readonly asSchemaVersionSet: u32;
+  readonly type: 'CollectionSponsorRemoved' | 'CollectionAdminAdded' | 'CollectionOwnedChanged' | 'CollectionSponsorSet' | 'ConstOnChainSchemaSet' | 'SponsorshipConfirmed' | 'CollectionAdminRemoved' | 'AllowListAddressRemoved' | 'AllowListAddressAdded' | 'CollectionLimitSet' | 'MintPermissionSet' | 'OffchainSchemaSet' | 'PublicAccessModeSet' | 'SchemaVersionSet';
+}
+
+/** @name PalletXcmCall */
+export interface PalletXcmCall extends Enum {
+  readonly isSend: boolean;
+  readonly asSend: {
+    readonly dest: XcmVersionedMultiLocation;
+    readonly message: XcmVersionedXcm;
+  } & Struct;
+  readonly isTeleportAssets: boolean;
+  readonly asTeleportAssets: {
+    readonly dest: XcmVersionedMultiLocation;
+    readonly beneficiary: XcmVersionedMultiLocation;
+    readonly assets: XcmVersionedMultiAssets;
+    readonly feeAssetItem: u32;
+  } & Struct;
+  readonly isReserveTransferAssets: boolean;
+  readonly asReserveTransferAssets: {
+    readonly dest: XcmVersionedMultiLocation;
+    readonly beneficiary: XcmVersionedMultiLocation;
+    readonly assets: XcmVersionedMultiAssets;
+    readonly feeAssetItem: u32;
+  } & Struct;
+  readonly isExecute: boolean;
+  readonly asExecute: {
+    readonly message: XcmVersionedXcm;
+    readonly maxWeight: u64;
+  } & Struct;
+  readonly isForceXcmVersion: boolean;
+  readonly asForceXcmVersion: {
+    readonly location: XcmV1MultiLocation;
+    readonly xcmVersion: u32;
+  } & Struct;
+  readonly isForceDefaultXcmVersion: boolean;
+  readonly asForceDefaultXcmVersion: {
+    readonly maybeXcmVersion: Option<u32>;
+  } & Struct;
+  readonly isForceSubscribeVersionNotify: boolean;
+  readonly asForceSubscribeVersionNotify: {
+    readonly location: XcmVersionedMultiLocation;
+  } & Struct;
+  readonly isForceUnsubscribeVersionNotify: boolean;
+  readonly asForceUnsubscribeVersionNotify: {
+    readonly location: XcmVersionedMultiLocation;
+  } & Struct;
+  readonly isLimitedReserveTransferAssets: boolean;
+  readonly asLimitedReserveTransferAssets: {
+    readonly dest: XcmVersionedMultiLocation;
+    readonly beneficiary: XcmVersionedMultiLocation;
+    readonly assets: XcmVersionedMultiAssets;
+    readonly feeAssetItem: u32;
+    readonly weightLimit: XcmV2WeightLimit;
+  } & Struct;
+  readonly isLimitedTeleportAssets: boolean;
+  readonly asLimitedTeleportAssets: {
+    readonly dest: XcmVersionedMultiLocation;
+    readonly beneficiary: XcmVersionedMultiLocation;
+    readonly assets: XcmVersionedMultiAssets;
+    readonly feeAssetItem: u32;
+    readonly weightLimit: XcmV2WeightLimit;
+  } & Struct;
+  readonly type: 'Send' | 'TeleportAssets' | 'ReserveTransferAssets' | 'Execute' | 'ForceXcmVersion' | 'ForceDefaultXcmVersion' | 'ForceSubscribeVersionNotify' | 'ForceUnsubscribeVersionNotify' | 'LimitedReserveTransferAssets' | 'LimitedTeleportAssets';
+}
+
+/** @name PalletXcmError */
+export interface PalletXcmError extends Enum {
+  readonly isUnreachable: boolean;
+  readonly isSendFailure: boolean;
+  readonly isFiltered: boolean;
+  readonly isUnweighableMessage: boolean;
+  readonly isDestinationNotInvertible: boolean;
+  readonly isEmpty: boolean;
+  readonly isCannotReanchor: boolean;
+  readonly isTooManyAssets: boolean;
+  readonly isInvalidOrigin: boolean;
+  readonly isBadVersion: boolean;
+  readonly isBadLocation: boolean;
+  readonly isNoSubscription: boolean;
+  readonly isAlreadySubscribed: boolean;
+  readonly type: 'Unreachable' | 'SendFailure' | 'Filtered' | 'UnweighableMessage' | 'DestinationNotInvertible' | 'Empty' | 'CannotReanchor' | 'TooManyAssets' | 'InvalidOrigin' | 'BadVersion' | 'BadLocation' | 'NoSubscription' | 'AlreadySubscribed';
+}
+
+/** @name PalletXcmEvent */
+export interface PalletXcmEvent extends Enum {
+  readonly isAttempted: boolean;
+  readonly asAttempted: XcmV2TraitsOutcome;
+  readonly isSent: boolean;
+  readonly asSent: ITuple<[XcmV1MultiLocation, XcmV1MultiLocation, XcmV2Xcm]>;
+  readonly isUnexpectedResponse: boolean;
+  readonly asUnexpectedResponse: ITuple<[XcmV1MultiLocation, u64]>;
+  readonly isResponseReady: boolean;
+  readonly asResponseReady: ITuple<[u64, XcmV2Response]>;
+  readonly isNotified: boolean;
+  readonly asNotified: ITuple<[u64, u8, u8]>;
+  readonly isNotifyOverweight: boolean;
+  readonly asNotifyOverweight: ITuple<[u64, u8, u8, u64, u64]>;
+  readonly isNotifyDispatchError: boolean;
+  readonly asNotifyDispatchError: ITuple<[u64, u8, u8]>;
+  readonly isNotifyDecodeFailed: boolean;
+  readonly asNotifyDecodeFailed: ITuple<[u64, u8, u8]>;
+  readonly isInvalidResponder: boolean;
+  readonly asInvalidResponder: ITuple<[XcmV1MultiLocation, u64, Option<XcmV1MultiLocation>]>;
+  readonly isInvalidResponderVersion: boolean;
+  readonly asInvalidResponderVersion: ITuple<[XcmV1MultiLocation, u64]>;
+  readonly isResponseTaken: boolean;
+  readonly asResponseTaken: u64;
+  readonly isAssetsTrapped: boolean;
+  readonly asAssetsTrapped: ITuple<[H256, XcmV1MultiLocation, XcmVersionedMultiAssets]>;
+  readonly isVersionChangeNotified: boolean;
+  readonly asVersionChangeNotified: ITuple<[XcmV1MultiLocation, u32]>;
+  readonly isSupportedVersionChanged: boolean;
+  readonly asSupportedVersionChanged: ITuple<[XcmV1MultiLocation, u32]>;
+  readonly isNotifyTargetSendFail: boolean;
+  readonly asNotifyTargetSendFail: ITuple<[XcmV1MultiLocation, u64, XcmV2TraitsError]>;
+  readonly isNotifyTargetMigrationFail: boolean;
+  readonly asNotifyTargetMigrationFail: ITuple<[XcmVersionedMultiLocation, u64]>;
+  readonly type: 'Attempted' | 'Sent' | 'UnexpectedResponse' | 'ResponseReady' | 'Notified' | 'NotifyOverweight' | 'NotifyDispatchError' | 'NotifyDecodeFailed' | 'InvalidResponder' | 'InvalidResponderVersion' | 'ResponseTaken' | 'AssetsTrapped' | 'VersionChangeNotified' | 'SupportedVersionChanged' | 'NotifyTargetSendFail' | 'NotifyTargetMigrationFail';
+}
+
+/** @name PhantomTypeUpDataStructsBaseInfo */
+export interface PhantomTypeUpDataStructsBaseInfo extends Vec<Lookup357> {}
+
+/** @name PhantomTypeUpDataStructsCollectionInfo */
+export interface PhantomTypeUpDataStructsCollectionInfo extends Vec<Lookup334> {}
+
+/** @name PhantomTypeUpDataStructsNftChild */
+export interface PhantomTypeUpDataStructsNftChild extends Vec<Lookup372> {}
+
+/** @name PhantomTypeUpDataStructsNftInfo */
+export interface PhantomTypeUpDataStructsNftInfo extends Vec<Lookup339> {}
+
+/** @name PhantomTypeUpDataStructsPartType */
+export interface PhantomTypeUpDataStructsPartType extends Vec<Lookup360> {}
+
+/** @name PhantomTypeUpDataStructsPropertyInfo */
+export interface PhantomTypeUpDataStructsPropertyInfo extends Vec<Lookup352> {}
+
+/** @name PhantomTypeUpDataStructsResourceInfo */
+export interface PhantomTypeUpDataStructsResourceInfo extends Vec<Lookup345> {}
+
+/** @name PhantomTypeUpDataStructsRpcCollection */
+export interface PhantomTypeUpDataStructsRpcCollection extends Vec<Lookup331> {}
+
+/** @name PhantomTypeUpDataStructsTheme */
+export interface PhantomTypeUpDataStructsTheme extends Vec<Lookup367> {}
+
+/** @name PhantomTypeUpDataStructsTokenData */
+export interface PhantomTypeUpDataStructsTokenData extends Vec<Lookup327> {}
+
+/** @name PolkadotCorePrimitivesInboundDownwardMessage */
+export interface PolkadotCorePrimitivesInboundDownwardMessage extends Struct {
+  readonly sentAt: u32;
+  readonly msg: Bytes;
+}
+
+/** @name PolkadotCorePrimitivesInboundHrmpMessage */
+export interface PolkadotCorePrimitivesInboundHrmpMessage extends Struct {
+  readonly sentAt: u32;
+  readonly data: Bytes;
+}
+
+/** @name PolkadotCorePrimitivesOutboundHrmpMessage */
+export interface PolkadotCorePrimitivesOutboundHrmpMessage extends Struct {
+  readonly recipient: u32;
+  readonly data: Bytes;
+}
+
+/** @name PolkadotParachainPrimitivesXcmpMessageFormat */
+export interface PolkadotParachainPrimitivesXcmpMessageFormat extends Enum {
+  readonly isConcatenatedVersionedXcm: boolean;
+  readonly isConcatenatedEncodedBlob: boolean;
+  readonly isSignals: boolean;
+  readonly type: 'ConcatenatedVersionedXcm' | 'ConcatenatedEncodedBlob' | 'Signals';
+}
+
+/** @name PolkadotPrimitivesV2AbridgedHostConfiguration */
+export interface PolkadotPrimitivesV2AbridgedHostConfiguration extends Struct {
+  readonly maxCodeSize: u32;
+  readonly maxHeadDataSize: u32;
+  readonly maxUpwardQueueCount: u32;
+  readonly maxUpwardQueueSize: u32;
+  readonly maxUpwardMessageSize: u32;
+  readonly maxUpwardMessageNumPerCandidate: u32;
+  readonly hrmpMaxMessageNumPerCandidate: u32;
+  readonly validationUpgradeCooldown: u32;
+  readonly validationUpgradeDelay: u32;
+}
+
+/** @name PolkadotPrimitivesV2AbridgedHrmpChannel */
+export interface PolkadotPrimitivesV2AbridgedHrmpChannel extends Struct {
+  readonly maxCapacity: u32;
+  readonly maxTotalSize: u32;
+  readonly maxMessageSize: u32;
+  readonly msgCount: u32;
+  readonly totalSize: u32;
+  readonly mqcHead: Option<H256>;
+}
+
+/** @name PolkadotPrimitivesV2PersistedValidationData */
+export interface PolkadotPrimitivesV2PersistedValidationData extends Struct {
+  readonly parentHead: Bytes;
+  readonly relayParentNumber: u32;
+  readonly relayParentStorageRoot: H256;
+  readonly maxPovSize: u32;
+}
+
+/** @name PolkadotPrimitivesV2UpgradeRestriction */
+export interface PolkadotPrimitivesV2UpgradeRestriction extends Enum {
+  readonly isPresent: boolean;
+  readonly type: 'Present';
+}
+
+/** @name RmrkTypesAccountIdOrCollectionNftTuple */
+export interface RmrkTypesAccountIdOrCollectionNftTuple extends Enum {
+  readonly isAccountId: boolean;
+  readonly asAccountId: AccountId32;
+  readonly isCollectionAndNftTuple: boolean;
+  readonly asCollectionAndNftTuple: ITuple<[u32, u32]>;
+  readonly type: 'AccountId' | 'CollectionAndNftTuple';
+}
+
+/** @name RmrkTypesBaseInfo */
+export interface RmrkTypesBaseInfo extends Struct {
+  readonly issuer: AccountId32;
+  readonly baseType: Bytes;
+  readonly symbol: Bytes;
+}
+
+/** @name RmrkTypesCollectionInfo */
+export interface RmrkTypesCollectionInfo extends Struct {
+  readonly issuer: AccountId32;
+  readonly metadata: Bytes;
+  readonly max: Option<u32>;
+  readonly symbol: Bytes;
+  readonly nftsCount: u32;
+}
+
+/** @name RmrkTypesEquippableList */
+export interface RmrkTypesEquippableList extends Enum {
+  readonly isAll: boolean;
+  readonly isEmpty: boolean;
+  readonly isCustom: boolean;
+  readonly asCustom: Vec<u32>;
+  readonly type: 'All' | 'Empty' | 'Custom';
+}
+
+/** @name RmrkTypesFixedPart */
+export interface RmrkTypesFixedPart extends Struct {
+  readonly id: u32;
+  readonly z: u32;
+  readonly src: Bytes;
+}
+
+/** @name RmrkTypesNftChild */
+export interface RmrkTypesNftChild extends Struct {
+  readonly collectionId: u32;
+  readonly nftId: u32;
+}
+
+/** @name RmrkTypesNftInfo */
+export interface RmrkTypesNftInfo extends Struct {
+  readonly owner: RmrkTypesAccountIdOrCollectionNftTuple;
+  readonly royalty: Option<RmrkTypesRoyaltyInfo>;
+  readonly metadata: Bytes;
+  readonly equipped: bool;
+  readonly pending: bool;
+}
+
+/** @name RmrkTypesPartType */
+export interface RmrkTypesPartType extends Enum {
+  readonly isFixedPart: boolean;
+  readonly asFixedPart: RmrkTypesFixedPart;
+  readonly isSlotPart: boolean;
+  readonly asSlotPart: RmrkTypesSlotPart;
+  readonly type: 'FixedPart' | 'SlotPart';
+}
+
+/** @name RmrkTypesPropertyInfo */
+export interface RmrkTypesPropertyInfo extends Struct {
+  readonly key: Bytes;
+  readonly value: Bytes;
+}
+
+/** @name RmrkTypesResourceInfo */
+export interface RmrkTypesResourceInfo extends Struct {
+  readonly id: Bytes;
+  readonly pending: bool;
+  readonly pendingRemoval: bool;
+  readonly parts: Option<Vec<u32>>;
+  readonly base: Option<u32>;
+  readonly src: Option<Bytes>;
+  readonly metadata: Option<Bytes>;
+  readonly slot: Option<u32>;
+  readonly license: Option<Bytes>;
+  readonly thumb: Option<Bytes>;
+}
+
+/** @name RmrkTypesRoyaltyInfo */
+export interface RmrkTypesRoyaltyInfo extends Struct {
+  readonly recipient: AccountId32;
+  readonly amount: Permill;
+}
+
+/** @name RmrkTypesSlotPart */
+export interface RmrkTypesSlotPart extends Struct {
+  readonly id: u32;
+  readonly equippable: RmrkTypesEquippableList;
+  readonly src: Bytes;
+  readonly z: u32;
+}
+
+/** @name RmrkTypesTheme */
+export interface RmrkTypesTheme extends Struct {
+  readonly name: Bytes;
+  readonly properties: Vec<RmrkTypesThemeProperty>;
+  readonly inherit: bool;
+}
+
+/** @name RmrkTypesThemeProperty */
+export interface RmrkTypesThemeProperty extends Struct {
+  readonly key: Bytes;
+  readonly value: Bytes;
+}
+
+/** @name SpCoreEcdsaSignature */
+export interface SpCoreEcdsaSignature extends U8aFixed {}
+
+/** @name SpCoreEd25519Signature */
+export interface SpCoreEd25519Signature extends U8aFixed {}
+
+/** @name SpCoreSr25519Signature */
+export interface SpCoreSr25519Signature extends U8aFixed {}
+
+/** @name SpRuntimeArithmeticError */
+export interface SpRuntimeArithmeticError extends Enum {
+  readonly isUnderflow: boolean;
+  readonly isOverflow: boolean;
+  readonly isDivisionByZero: boolean;
+  readonly type: 'Underflow' | 'Overflow' | 'DivisionByZero';
+}
+
+/** @name SpRuntimeDigest */
+export interface SpRuntimeDigest extends Struct {
+  readonly logs: Vec<SpRuntimeDigestDigestItem>;
+}
+
+/** @name SpRuntimeDigestDigestItem */
+export interface SpRuntimeDigestDigestItem extends Enum {
+  readonly isOther: boolean;
+  readonly asOther: Bytes;
+  readonly isConsensus: boolean;
+  readonly asConsensus: ITuple<[U8aFixed, Bytes]>;
+  readonly isSeal: boolean;
+  readonly asSeal: ITuple<[U8aFixed, Bytes]>;
+  readonly isPreRuntime: boolean;
+  readonly asPreRuntime: ITuple<[U8aFixed, Bytes]>;
+  readonly isRuntimeEnvironmentUpdated: boolean;
+  readonly type: 'Other' | 'Consensus' | 'Seal' | 'PreRuntime' | 'RuntimeEnvironmentUpdated';
+}
+
+/** @name SpRuntimeDispatchError */
+export interface SpRuntimeDispatchError extends Enum {
+  readonly isOther: boolean;
+  readonly isCannotLookup: boolean;
+  readonly isBadOrigin: boolean;
+  readonly isModule: boolean;
+  readonly asModule: SpRuntimeModuleError;
+  readonly isConsumerRemaining: boolean;
+  readonly isNoProviders: boolean;
+  readonly isTooManyConsumers: boolean;
+  readonly isToken: boolean;
+  readonly asToken: SpRuntimeTokenError;
+  readonly isArithmetic: boolean;
+  readonly asArithmetic: SpRuntimeArithmeticError;
+  readonly isTransactional: boolean;
+  readonly asTransactional: SpRuntimeTransactionalError;
+  readonly type: 'Other' | 'CannotLookup' | 'BadOrigin' | 'Module' | 'ConsumerRemaining' | 'NoProviders' | 'TooManyConsumers' | 'Token' | 'Arithmetic' | 'Transactional';
+}
+
+/** @name SpRuntimeModuleError */
+export interface SpRuntimeModuleError extends Struct {
+  readonly index: u8;
+  readonly error: U8aFixed;
+}
+
+/** @name SpRuntimeMultiSignature */
+export interface SpRuntimeMultiSignature extends Enum {
+  readonly isEd25519: boolean;
+  readonly asEd25519: SpCoreEd25519Signature;
+  readonly isSr25519: boolean;
+  readonly asSr25519: SpCoreSr25519Signature;
+  readonly isEcdsa: boolean;
+  readonly asEcdsa: SpCoreEcdsaSignature;
+  readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa';
+}
+
+/** @name SpRuntimeTokenError */
+export interface SpRuntimeTokenError extends Enum {
+  readonly isNoFunds: boolean;
+  readonly isWouldDie: boolean;
+  readonly isBelowMinimum: boolean;
+  readonly isCannotCreate: boolean;
+  readonly isUnknownAsset: boolean;
+  readonly isFrozen: boolean;
+  readonly isUnsupported: boolean;
+  readonly type: 'NoFunds' | 'WouldDie' | 'BelowMinimum' | 'CannotCreate' | 'UnknownAsset' | 'Frozen' | 'Unsupported';
+}
+
+/** @name SpRuntimeTransactionalError */
+export interface SpRuntimeTransactionalError extends Enum {
+  readonly isLimitReached: boolean;
+  readonly isNoLayer: boolean;
+  readonly type: 'LimitReached' | 'NoLayer';
+}
+
+/** @name SpTrieStorageProof */
+export interface SpTrieStorageProof extends Struct {
+  readonly trieNodes: BTreeSet<Bytes>;
+}
+
+/** @name SpVersionRuntimeVersion */
+export interface SpVersionRuntimeVersion extends Struct {
+  readonly specName: Text;
+  readonly implName: Text;
+  readonly authoringVersion: u32;
+  readonly specVersion: u32;
+  readonly implVersion: u32;
+  readonly apis: Vec<ITuple<[U8aFixed, u32]>>;
+  readonly transactionVersion: u32;
+  readonly stateVersion: u8;
+}
+
+/** @name UpDataStructsAccessMode */
+export interface UpDataStructsAccessMode extends Enum {
+  readonly isNormal: boolean;
+  readonly isAllowList: boolean;
+  readonly type: 'Normal' | 'AllowList';
+}
+
+/** @name UpDataStructsCollection */
+export interface UpDataStructsCollection extends Struct {
+  readonly owner: AccountId32;
+  readonly mode: UpDataStructsCollectionMode;
+  readonly access: UpDataStructsAccessMode;
+  readonly name: Vec<u16>;
+  readonly description: Vec<u16>;
+  readonly tokenPrefix: Bytes;
+  readonly mintMode: bool;
+  readonly schemaVersion: UpDataStructsSchemaVersion;
+  readonly sponsorship: UpDataStructsSponsorshipState;
+  readonly limits: UpDataStructsCollectionLimits;
+}
+
+/** @name UpDataStructsCollectionField */
+export interface UpDataStructsCollectionField extends Enum {
+  readonly isConstOnChainSchema: boolean;
+  readonly isOffchainSchema: boolean;
+  readonly type: 'ConstOnChainSchema' | 'OffchainSchema';
+}
+
+/** @name UpDataStructsCollectionLimits */
+export interface UpDataStructsCollectionLimits extends Struct {
+  readonly accountTokenOwnershipLimit: Option<u32>;
+  readonly sponsoredDataSize: Option<u32>;
+  readonly sponsoredDataRateLimit: Option<UpDataStructsSponsoringRateLimit>;
+  readonly tokenLimit: Option<u32>;
+  readonly sponsorTransferTimeout: Option<u32>;
+  readonly sponsorApproveTimeout: Option<u32>;
+  readonly ownerCanTransfer: Option<bool>;
+  readonly ownerCanDestroy: Option<bool>;
+  readonly transfersEnabled: Option<bool>;
+  readonly nestingRule: Option<UpDataStructsNestingRule>;
+}
+
+/** @name UpDataStructsCollectionMode */
+export interface UpDataStructsCollectionMode extends Enum {
+  readonly isNft: boolean;
+  readonly isFungible: boolean;
+  readonly asFungible: u8;
+  readonly isReFungible: boolean;
+  readonly type: 'Nft' | 'Fungible' | 'ReFungible';
+}
+
+/** @name UpDataStructsCollectionStats */
+export interface UpDataStructsCollectionStats extends Struct {
+  readonly created: u32;
+  readonly destroyed: u32;
+  readonly alive: u32;
+}
+
+/** @name UpDataStructsCreateCollectionData */
+export interface UpDataStructsCreateCollectionData extends Struct {
+  readonly mode: UpDataStructsCollectionMode;
+  readonly access: Option<UpDataStructsAccessMode>;
+  readonly name: Vec<u16>;
+  readonly description: Vec<u16>;
+  readonly tokenPrefix: Bytes;
+  readonly offchainSchema: Bytes;
+  readonly schemaVersion: Option<UpDataStructsSchemaVersion>;
+  readonly pendingSponsor: Option<AccountId32>;
+  readonly limits: Option<UpDataStructsCollectionLimits>;
+  readonly constOnChainSchema: Bytes;
+  readonly tokenPropertyPermissions: Vec<UpDataStructsPropertyKeyPermission>;
+  readonly properties: Vec<UpDataStructsProperty>;
+}
+
+/** @name UpDataStructsCreateFungibleData */
+export interface UpDataStructsCreateFungibleData extends Struct {
+  readonly value: u128;
+}
+
+/** @name UpDataStructsCreateItemData */
+export interface UpDataStructsCreateItemData extends Enum {
+  readonly isNft: boolean;
+  readonly asNft: UpDataStructsCreateNftData;
+  readonly isFungible: boolean;
+  readonly asFungible: UpDataStructsCreateFungibleData;
+  readonly isReFungible: boolean;
+  readonly asReFungible: UpDataStructsCreateReFungibleData;
+  readonly type: 'Nft' | 'Fungible' | 'ReFungible';
+}
+
+/** @name UpDataStructsCreateItemExData */
+export interface UpDataStructsCreateItemExData extends Enum {
+  readonly isNft: boolean;
+  readonly asNft: Vec<UpDataStructsCreateNftExData>;
+  readonly isFungible: boolean;
+  readonly asFungible: BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr,u128>;
+  readonly isRefungibleMultipleItems: boolean;
+  readonly asRefungibleMultipleItems: Vec<UpDataStructsCreateRefungibleExData>;
+  readonly isRefungibleMultipleOwners: boolean;
+  readonly asRefungibleMultipleOwners: UpDataStructsCreateRefungibleExData;
+  readonly type: 'Nft' | 'Fungible' | 'RefungibleMultipleItems' | 'RefungibleMultipleOwners';
+}
+
+/** @name UpDataStructsCreateNftData */
+export interface UpDataStructsCreateNftData extends Struct {
+  readonly constData: Bytes;
+  readonly properties: Vec<UpDataStructsProperty>;
+}
+
+/** @name UpDataStructsCreateNftExData */
+export interface UpDataStructsCreateNftExData extends Struct {
+  readonly constData: Bytes;
+  readonly properties: Vec<UpDataStructsProperty>;
+  readonly owner: PalletEvmAccountBasicCrossAccountIdRepr;
+}
+
+/** @name UpDataStructsCreateReFungibleData */
+export interface UpDataStructsCreateReFungibleData extends Struct {
+  readonly constData: Bytes;
+  readonly pieces: u128;
+}
+
+/** @name UpDataStructsCreateRefungibleExData */
+export interface UpDataStructsCreateRefungibleExData extends Struct {
+  readonly constData: Bytes;
+  readonly users: BTreeMap<PalletEvmAccountBasicCrossAccountIdRepr, u128>;
+}
+
+/** @name UpDataStructsNestingRule */
+export interface UpDataStructsNestingRule extends Enum {
+  readonly isDisabled: boolean;
+  readonly isOwner: boolean;
+  readonly isOwnerRestricted: boolean;
+  readonly asOwnerRestricted: BTreeSet<u32>;
+  readonly type: 'Disabled' | 'Owner' | 'OwnerRestricted';
+}
+
+/** @name UpDataStructsProperties */
+export interface UpDataStructsProperties extends Struct {
+  readonly map: UpDataStructsPropertiesMapBoundedVec;
+  readonly consumedSpace: u32;
+  readonly spaceLimit: u32;
+}
+
+/** @name UpDataStructsPropertiesMapBoundedVec */
+export interface UpDataStructsPropertiesMapBoundedVec extends BTreeMap<Bytes, Bytes> {}
+
+/** @name UpDataStructsPropertiesMapPropertyPermission */
+export interface UpDataStructsPropertiesMapPropertyPermission extends BTreeMap<Bytes, UpDataStructsPropertyPermission> {}
+
+/** @name UpDataStructsProperty */
+export interface UpDataStructsProperty extends Struct {
+  readonly key: Bytes;
+  readonly value: Bytes;
+}
+
+/** @name UpDataStructsPropertyKeyPermission */
+export interface UpDataStructsPropertyKeyPermission extends Struct {
+  readonly key: Bytes;
+  readonly permission: UpDataStructsPropertyPermission;
+}
+
+/** @name UpDataStructsPropertyPermission */
+export interface UpDataStructsPropertyPermission extends Struct {
+  readonly mutable: bool;
+  readonly collectionAdmin: bool;
+  readonly tokenOwner: bool;
+}
+
+/** @name UpDataStructsRpcCollection */
+export interface UpDataStructsRpcCollection extends Struct {
+  readonly owner: AccountId32;
+  readonly mode: UpDataStructsCollectionMode;
+  readonly access: UpDataStructsAccessMode;
+  readonly name: Vec<u16>;
+  readonly description: Vec<u16>;
+  readonly tokenPrefix: Bytes;
+  readonly mintMode: bool;
+  readonly offchainSchema: Bytes;
+  readonly schemaVersion: UpDataStructsSchemaVersion;
+  readonly sponsorship: UpDataStructsSponsorshipState;
+  readonly limits: UpDataStructsCollectionLimits;
+  readonly constOnChainSchema: Bytes;
+  readonly tokenPropertyPermissions: Vec<UpDataStructsPropertyKeyPermission>;
+  readonly properties: Vec<UpDataStructsProperty>;
+}
+
+/** @name UpDataStructsSchemaVersion */
+export interface UpDataStructsSchemaVersion extends Enum {
+  readonly isImageURL: boolean;
+  readonly isUnique: boolean;
+  readonly type: 'ImageURL' | 'Unique';
+}
+
+/** @name UpDataStructsSponsoringRateLimit */
+export interface UpDataStructsSponsoringRateLimit extends Enum {
+  readonly isSponsoringDisabled: boolean;
+  readonly isBlocks: boolean;
+  readonly asBlocks: u32;
+  readonly type: 'SponsoringDisabled' | 'Blocks';
+}
+
+/** @name UpDataStructsSponsorshipState */
+export interface UpDataStructsSponsorshipState extends Enum {
+  readonly isDisabled: boolean;
+  readonly isUnconfirmed: boolean;
+  readonly asUnconfirmed: AccountId32;
+  readonly isConfirmed: boolean;
+  readonly asConfirmed: AccountId32;
+  readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed';
+}
+
+/** @name UpDataStructsTokenData */
+export interface UpDataStructsTokenData extends Struct {
+  readonly constData: Bytes;
+  readonly properties: Vec<UpDataStructsProperty>;
+  readonly owner: Option<PalletEvmAccountBasicCrossAccountIdRepr>;
+}
+
+/** @name XcmDoubleEncoded */
+export interface XcmDoubleEncoded extends Struct {
+  readonly encoded: Bytes;
+}
+
+/** @name XcmV0Junction */
+export interface XcmV0Junction extends Enum {
+  readonly isParent: boolean;
+  readonly isParachain: boolean;
+  readonly asParachain: Compact<u32>;
+  readonly isAccountId32: boolean;
+  readonly asAccountId32: {
+    readonly network: XcmV0JunctionNetworkId;
+    readonly id: U8aFixed;
+  } & Struct;
+  readonly isAccountIndex64: boolean;
+  readonly asAccountIndex64: {
+    readonly network: XcmV0JunctionNetworkId;
+    readonly index: Compact<u64>;
+  } & Struct;
+  readonly isAccountKey20: boolean;
+  readonly asAccountKey20: {
+    readonly network: XcmV0JunctionNetworkId;
+    readonly key: U8aFixed;
+  } & Struct;
+  readonly isPalletInstance: boolean;
+  readonly asPalletInstance: u8;
+  readonly isGeneralIndex: boolean;
+  readonly asGeneralIndex: Compact<u128>;
+  readonly isGeneralKey: boolean;
+  readonly asGeneralKey: Bytes;
+  readonly isOnlyChild: boolean;
+  readonly isPlurality: boolean;
+  readonly asPlurality: {
+    readonly id: XcmV0JunctionBodyId;
+    readonly part: XcmV0JunctionBodyPart;
+  } & Struct;
+  readonly type: 'Parent' | 'Parachain' | 'AccountId32' | 'AccountIndex64' | 'AccountKey20' | 'PalletInstance' | 'GeneralIndex' | 'GeneralKey' | 'OnlyChild' | 'Plurality';
+}
+
+/** @name XcmV0JunctionBodyId */
+export interface XcmV0JunctionBodyId extends Enum {
+  readonly isUnit: boolean;
+  readonly isNamed: boolean;
+  readonly asNamed: Bytes;
+  readonly isIndex: boolean;
+  readonly asIndex: Compact<u32>;
+  readonly isExecutive: boolean;
+  readonly isTechnical: boolean;
+  readonly isLegislative: boolean;
+  readonly isJudicial: boolean;
+  readonly type: 'Unit' | 'Named' | 'Index' | 'Executive' | 'Technical' | 'Legislative' | 'Judicial';
+}
+
+/** @name XcmV0JunctionBodyPart */
+export interface XcmV0JunctionBodyPart extends Enum {
+  readonly isVoice: boolean;
+  readonly isMembers: boolean;
+  readonly asMembers: {
+    readonly count: Compact<u32>;
+  } & Struct;
+  readonly isFraction: boolean;
+  readonly asFraction: {
+    readonly nom: Compact<u32>;
+    readonly denom: Compact<u32>;
+  } & Struct;
+  readonly isAtLeastProportion: boolean;
+  readonly asAtLeastProportion: {
+    readonly nom: Compact<u32>;
+    readonly denom: Compact<u32>;
+  } & Struct;
+  readonly isMoreThanProportion: boolean;
+  readonly asMoreThanProportion: {
+    readonly nom: Compact<u32>;
+    readonly denom: Compact<u32>;
+  } & Struct;
+  readonly type: 'Voice' | 'Members' | 'Fraction' | 'AtLeastProportion' | 'MoreThanProportion';
+}
+
+/** @name XcmV0JunctionNetworkId */
+export interface XcmV0JunctionNetworkId extends Enum {
+  readonly isAny: boolean;
+  readonly isNamed: boolean;
+  readonly asNamed: Bytes;
+  readonly isPolkadot: boolean;
+  readonly isKusama: boolean;
+  readonly type: 'Any' | 'Named' | 'Polkadot' | 'Kusama';
+}
+
+/** @name XcmV0MultiAsset */
+export interface XcmV0MultiAsset extends Enum {
+  readonly isNone: boolean;
+  readonly isAll: boolean;
+  readonly isAllFungible: boolean;
+  readonly isAllNonFungible: boolean;
+  readonly isAllAbstractFungible: boolean;
+  readonly asAllAbstractFungible: {
+    readonly id: Bytes;
+  } & Struct;
+  readonly isAllAbstractNonFungible: boolean;
+  readonly asAllAbstractNonFungible: {
+    readonly class: Bytes;
+  } & Struct;
+  readonly isAllConcreteFungible: boolean;
+  readonly asAllConcreteFungible: {
+    readonly id: XcmV0MultiLocation;
+  } & Struct;
+  readonly isAllConcreteNonFungible: boolean;
+  readonly asAllConcreteNonFungible: {
+    readonly class: XcmV0MultiLocation;
+  } & Struct;
+  readonly isAbstractFungible: boolean;
+  readonly asAbstractFungible: {
+    readonly id: Bytes;
+    readonly amount: Compact<u128>;
+  } & Struct;
+  readonly isAbstractNonFungible: boolean;
+  readonly asAbstractNonFungible: {
+    readonly class: Bytes;
+    readonly instance: XcmV1MultiassetAssetInstance;
+  } & Struct;
+  readonly isConcreteFungible: boolean;
+  readonly asConcreteFungible: {
+    readonly id: XcmV0MultiLocation;
+    readonly amount: Compact<u128>;
+  } & Struct;
+  readonly isConcreteNonFungible: boolean;
+  readonly asConcreteNonFungible: {
+    readonly class: XcmV0MultiLocation;
+    readonly instance: XcmV1MultiassetAssetInstance;
+  } & Struct;
+  readonly type: 'None' | 'All' | 'AllFungible' | 'AllNonFungible' | 'AllAbstractFungible' | 'AllAbstractNonFungible' | 'AllConcreteFungible' | 'AllConcreteNonFungible' | 'AbstractFungible' | 'AbstractNonFungible' | 'ConcreteFungible' | 'ConcreteNonFungible';
+}
+
+/** @name XcmV0MultiLocation */
+export interface XcmV0MultiLocation extends Enum {
+  readonly isNull: boolean;
+  readonly isX1: boolean;
+  readonly asX1: XcmV0Junction;
+  readonly isX2: boolean;
+  readonly asX2: ITuple<[XcmV0Junction, XcmV0Junction]>;
+  readonly isX3: boolean;
+  readonly asX3: ITuple<[XcmV0Junction, XcmV0Junction, XcmV0Junction]>;
+  readonly isX4: boolean;
+  readonly asX4: ITuple<[XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction]>;
+  readonly isX5: boolean;
+  readonly asX5: ITuple<[XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction]>;
+  readonly isX6: boolean;
+  readonly asX6: ITuple<[XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction]>;
+  readonly isX7: boolean;
+  readonly asX7: ITuple<[XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction]>;
+  readonly isX8: boolean;
+  readonly asX8: ITuple<[XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction, XcmV0Junction]>;
+  readonly type: 'Null' | 'X1' | 'X2' | 'X3' | 'X4' | 'X5' | 'X6' | 'X7' | 'X8';
+}
+
+/** @name XcmV0Order */
+export interface XcmV0Order extends Enum {
+  readonly isNull: boolean;
+  readonly isDepositAsset: boolean;
+  readonly asDepositAsset: {
+    readonly assets: Vec<XcmV0MultiAsset>;
+    readonly dest: XcmV0MultiLocation;
+  } & Struct;
+  readonly isDepositReserveAsset: boolean;
+  readonly asDepositReserveAsset: {
+    readonly assets: Vec<XcmV0MultiAsset>;
+    readonly dest: XcmV0MultiLocation;
+    readonly effects: Vec<XcmV0Order>;
+  } & Struct;
+  readonly isExchangeAsset: boolean;
+  readonly asExchangeAsset: {
+    readonly give: Vec<XcmV0MultiAsset>;
+    readonly receive: Vec<XcmV0MultiAsset>;
+  } & Struct;
+  readonly isInitiateReserveWithdraw: boolean;
+  readonly asInitiateReserveWithdraw: {
+    readonly assets: Vec<XcmV0MultiAsset>;
+    readonly reserve: XcmV0MultiLocation;
+    readonly effects: Vec<XcmV0Order>;
+  } & Struct;
+  readonly isInitiateTeleport: boolean;
+  readonly asInitiateTeleport: {
+    readonly assets: Vec<XcmV0MultiAsset>;
+    readonly dest: XcmV0MultiLocation;
+    readonly effects: Vec<XcmV0Order>;
+  } & Struct;
+  readonly isQueryHolding: boolean;
+  readonly asQueryHolding: {
+    readonly queryId: Compact<u64>;
+    readonly dest: XcmV0MultiLocation;
+    readonly assets: Vec<XcmV0MultiAsset>;
+  } & Struct;
+  readonly isBuyExecution: boolean;
+  readonly asBuyExecution: {
+    readonly fees: XcmV0MultiAsset;
+    readonly weight: u64;
+    readonly debt: u64;
+    readonly haltOnError: bool;
+    readonly xcm: Vec<XcmV0Xcm>;
+  } & Struct;
+  readonly type: 'Null' | 'DepositAsset' | 'DepositReserveAsset' | 'ExchangeAsset' | 'InitiateReserveWithdraw' | 'InitiateTeleport' | 'QueryHolding' | 'BuyExecution';
+}
+
+/** @name XcmV0OriginKind */
+export interface XcmV0OriginKind extends Enum {
+  readonly isNative: boolean;
+  readonly isSovereignAccount: boolean;
+  readonly isSuperuser: boolean;
+  readonly isXcm: boolean;
+  readonly type: 'Native' | 'SovereignAccount' | 'Superuser' | 'Xcm';
+}
+
+/** @name XcmV0Response */
+export interface XcmV0Response extends Enum {
+  readonly isAssets: boolean;
+  readonly asAssets: Vec<XcmV0MultiAsset>;
+  readonly type: 'Assets';
+}
+
+/** @name XcmV0Xcm */
+export interface XcmV0Xcm extends Enum {
+  readonly isWithdrawAsset: boolean;
+  readonly asWithdrawAsset: {
+    readonly assets: Vec<XcmV0MultiAsset>;
+    readonly effects: Vec<XcmV0Order>;
+  } & Struct;
+  readonly isReserveAssetDeposit: boolean;
+  readonly asReserveAssetDeposit: {
+    readonly assets: Vec<XcmV0MultiAsset>;
+    readonly effects: Vec<XcmV0Order>;
+  } & Struct;
+  readonly isTeleportAsset: boolean;
+  readonly asTeleportAsset: {
+    readonly assets: Vec<XcmV0MultiAsset>;
+    readonly effects: Vec<XcmV0Order>;
+  } & Struct;
+  readonly isQueryResponse: boolean;
+  readonly asQueryResponse: {
+    readonly queryId: Compact<u64>;
+    readonly response: XcmV0Response;
+  } & Struct;
+  readonly isTransferAsset: boolean;
+  readonly asTransferAsset: {
+    readonly assets: Vec<XcmV0MultiAsset>;
+    readonly dest: XcmV0MultiLocation;
+  } & Struct;
+  readonly isTransferReserveAsset: boolean;
+  readonly asTransferReserveAsset: {
+    readonly assets: Vec<XcmV0MultiAsset>;
+    readonly dest: XcmV0MultiLocation;
+    readonly effects: Vec<XcmV0Order>;
+  } & Struct;
+  readonly isTransact: boolean;
+  readonly asTransact: {
+    readonly originType: XcmV0OriginKind;
+    readonly requireWeightAtMost: u64;
+    readonly call: XcmDoubleEncoded;
+  } & Struct;
+  readonly isHrmpNewChannelOpenRequest: boolean;
+  readonly asHrmpNewChannelOpenRequest: {
+    readonly sender: Compact<u32>;
+    readonly maxMessageSize: Compact<u32>;
+    readonly maxCapacity: Compact<u32>;
+  } & Struct;
+  readonly isHrmpChannelAccepted: boolean;
+  readonly asHrmpChannelAccepted: {
+    readonly recipient: Compact<u32>;
+  } & Struct;
+  readonly isHrmpChannelClosing: boolean;
+  readonly asHrmpChannelClosing: {
+    readonly initiator: Compact<u32>;
+    readonly sender: Compact<u32>;
+    readonly recipient: Compact<u32>;
+  } & Struct;
+  readonly isRelayedFrom: boolean;
+  readonly asRelayedFrom: {
+    readonly who: XcmV0MultiLocation;
+    readonly message: XcmV0Xcm;
+  } & Struct;
+  readonly type: 'WithdrawAsset' | 'ReserveAssetDeposit' | 'TeleportAsset' | 'QueryResponse' | 'TransferAsset' | 'TransferReserveAsset' | 'Transact' | 'HrmpNewChannelOpenRequest' | 'HrmpChannelAccepted' | 'HrmpChannelClosing' | 'RelayedFrom';
+}
+
+/** @name XcmV1Junction */
+export interface XcmV1Junction extends Enum {
+  readonly isParachain: boolean;
+  readonly asParachain: Compact<u32>;
+  readonly isAccountId32: boolean;
+  readonly asAccountId32: {
+    readonly network: XcmV0JunctionNetworkId;
+    readonly id: U8aFixed;
+  } & Struct;
+  readonly isAccountIndex64: boolean;
+  readonly asAccountIndex64: {
+    readonly network: XcmV0JunctionNetworkId;
+    readonly index: Compact<u64>;
+  } & Struct;
+  readonly isAccountKey20: boolean;
+  readonly asAccountKey20: {
+    readonly network: XcmV0JunctionNetworkId;
+    readonly key: U8aFixed;
+  } & Struct;
+  readonly isPalletInstance: boolean;
+  readonly asPalletInstance: u8;
+  readonly isGeneralIndex: boolean;
+  readonly asGeneralIndex: Compact<u128>;
+  readonly isGeneralKey: boolean;
+  readonly asGeneralKey: Bytes;
+  readonly isOnlyChild: boolean;
+  readonly isPlurality: boolean;
+  readonly asPlurality: {
+    readonly id: XcmV0JunctionBodyId;
+    readonly part: XcmV0JunctionBodyPart;
+  } & Struct;
+  readonly type: 'Parachain' | 'AccountId32' | 'AccountIndex64' | 'AccountKey20' | 'PalletInstance' | 'GeneralIndex' | 'GeneralKey' | 'OnlyChild' | 'Plurality';
+}
+
+/** @name XcmV1MultiAsset */
+export interface XcmV1MultiAsset extends Struct {
+  readonly id: XcmV1MultiassetAssetId;
+  readonly fun: XcmV1MultiassetFungibility;
+}
+
+/** @name XcmV1MultiassetAssetId */
+export interface XcmV1MultiassetAssetId extends Enum {
+  readonly isConcrete: boolean;
+  readonly asConcrete: XcmV1MultiLocation;
+  readonly isAbstract: boolean;
+  readonly asAbstract: Bytes;
+  readonly type: 'Concrete' | 'Abstract';
+}
+
+/** @name XcmV1MultiassetAssetInstance */
+export interface XcmV1MultiassetAssetInstance extends Enum {
+  readonly isUndefined: boolean;
+  readonly isIndex: boolean;
+  readonly asIndex: Compact<u128>;
+  readonly isArray4: boolean;
+  readonly asArray4: U8aFixed;
+  readonly isArray8: boolean;
+  readonly asArray8: U8aFixed;
+  readonly isArray16: boolean;
+  readonly asArray16: U8aFixed;
+  readonly isArray32: boolean;
+  readonly asArray32: U8aFixed;
+  readonly isBlob: boolean;
+  readonly asBlob: Bytes;
+  readonly type: 'Undefined' | 'Index' | 'Array4' | 'Array8' | 'Array16' | 'Array32' | 'Blob';
+}
+
+/** @name XcmV1MultiassetFungibility */
+export interface XcmV1MultiassetFungibility extends Enum {
+  readonly isFungible: boolean;
+  readonly asFungible: Compact<u128>;
+  readonly isNonFungible: boolean;
+  readonly asNonFungible: XcmV1MultiassetAssetInstance;
+  readonly type: 'Fungible' | 'NonFungible';
+}
+
+/** @name XcmV1MultiassetMultiAssetFilter */
+export interface XcmV1MultiassetMultiAssetFilter extends Enum {
+  readonly isDefinite: boolean;
+  readonly asDefinite: XcmV1MultiassetMultiAssets;
+  readonly isWild: boolean;
+  readonly asWild: XcmV1MultiassetWildMultiAsset;
+  readonly type: 'Definite' | 'Wild';
+}
+
+/** @name XcmV1MultiassetMultiAssets */
+export interface XcmV1MultiassetMultiAssets extends Vec<XcmV1MultiAsset> {}
+
+/** @name XcmV1MultiassetWildFungibility */
+export interface XcmV1MultiassetWildFungibility extends Enum {
+  readonly isFungible: boolean;
+  readonly isNonFungible: boolean;
+  readonly type: 'Fungible' | 'NonFungible';
+}
+
+/** @name XcmV1MultiassetWildMultiAsset */
+export interface XcmV1MultiassetWildMultiAsset extends Enum {
+  readonly isAll: boolean;
+  readonly isAllOf: boolean;
+  readonly asAllOf: {
+    readonly id: XcmV1MultiassetAssetId;
+    readonly fun: XcmV1MultiassetWildFungibility;
+  } & Struct;
+  readonly type: 'All' | 'AllOf';
+}
+
+/** @name XcmV1MultiLocation */
+export interface XcmV1MultiLocation extends Struct {
+  readonly parents: u8;
+  readonly interior: XcmV1MultilocationJunctions;
+}
+
+/** @name XcmV1MultilocationJunctions */
+export interface XcmV1MultilocationJunctions extends Enum {
+  readonly isHere: boolean;
+  readonly isX1: boolean;
+  readonly asX1: XcmV1Junction;
+  readonly isX2: boolean;
+  readonly asX2: ITuple<[XcmV1Junction, XcmV1Junction]>;
+  readonly isX3: boolean;
+  readonly asX3: ITuple<[XcmV1Junction, XcmV1Junction, XcmV1Junction]>;
+  readonly isX4: boolean;
+  readonly asX4: ITuple<[XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction]>;
+  readonly isX5: boolean;
+  readonly asX5: ITuple<[XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction]>;
+  readonly isX6: boolean;
+  readonly asX6: ITuple<[XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction]>;
+  readonly isX7: boolean;
+  readonly asX7: ITuple<[XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction]>;
+  readonly isX8: boolean;
+  readonly asX8: ITuple<[XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction, XcmV1Junction]>;
+  readonly type: 'Here' | 'X1' | 'X2' | 'X3' | 'X4' | 'X5' | 'X6' | 'X7' | 'X8';
+}
+
+/** @name XcmV1Order */
+export interface XcmV1Order extends Enum {
+  readonly isNoop: boolean;
+  readonly isDepositAsset: boolean;
+  readonly asDepositAsset: {
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+    readonly maxAssets: u32;
+    readonly beneficiary: XcmV1MultiLocation;
+  } & Struct;
+  readonly isDepositReserveAsset: boolean;
+  readonly asDepositReserveAsset: {
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+    readonly maxAssets: u32;
+    readonly dest: XcmV1MultiLocation;
+    readonly effects: Vec<XcmV1Order>;
+  } & Struct;
+  readonly isExchangeAsset: boolean;
+  readonly asExchangeAsset: {
+    readonly give: XcmV1MultiassetMultiAssetFilter;
+    readonly receive: XcmV1MultiassetMultiAssets;
+  } & Struct;
+  readonly isInitiateReserveWithdraw: boolean;
+  readonly asInitiateReserveWithdraw: {
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+    readonly reserve: XcmV1MultiLocation;
+    readonly effects: Vec<XcmV1Order>;
+  } & Struct;
+  readonly isInitiateTeleport: boolean;
+  readonly asInitiateTeleport: {
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+    readonly dest: XcmV1MultiLocation;
+    readonly effects: Vec<XcmV1Order>;
+  } & Struct;
+  readonly isQueryHolding: boolean;
+  readonly asQueryHolding: {
+    readonly queryId: Compact<u64>;
+    readonly dest: XcmV1MultiLocation;
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+  } & Struct;
+  readonly isBuyExecution: boolean;
+  readonly asBuyExecution: {
+    readonly fees: XcmV1MultiAsset;
+    readonly weight: u64;
+    readonly debt: u64;
+    readonly haltOnError: bool;
+    readonly instructions: Vec<XcmV1Xcm>;
+  } & Struct;
+  readonly type: 'Noop' | 'DepositAsset' | 'DepositReserveAsset' | 'ExchangeAsset' | 'InitiateReserveWithdraw' | 'InitiateTeleport' | 'QueryHolding' | 'BuyExecution';
+}
+
+/** @name XcmV1Response */
+export interface XcmV1Response extends Enum {
+  readonly isAssets: boolean;
+  readonly asAssets: XcmV1MultiassetMultiAssets;
+  readonly isVersion: boolean;
+  readonly asVersion: u32;
+  readonly type: 'Assets' | 'Version';
+}
+
+/** @name XcmV1Xcm */
+export interface XcmV1Xcm extends Enum {
+  readonly isWithdrawAsset: boolean;
+  readonly asWithdrawAsset: {
+    readonly assets: XcmV1MultiassetMultiAssets;
+    readonly effects: Vec<XcmV1Order>;
+  } & Struct;
+  readonly isReserveAssetDeposited: boolean;
+  readonly asReserveAssetDeposited: {
+    readonly assets: XcmV1MultiassetMultiAssets;
+    readonly effects: Vec<XcmV1Order>;
+  } & Struct;
+  readonly isReceiveTeleportedAsset: boolean;
+  readonly asReceiveTeleportedAsset: {
+    readonly assets: XcmV1MultiassetMultiAssets;
+    readonly effects: Vec<XcmV1Order>;
+  } & Struct;
+  readonly isQueryResponse: boolean;
+  readonly asQueryResponse: {
+    readonly queryId: Compact<u64>;
+    readonly response: XcmV1Response;
+  } & Struct;
+  readonly isTransferAsset: boolean;
+  readonly asTransferAsset: {
+    readonly assets: XcmV1MultiassetMultiAssets;
+    readonly beneficiary: XcmV1MultiLocation;
+  } & Struct;
+  readonly isTransferReserveAsset: boolean;
+  readonly asTransferReserveAsset: {
+    readonly assets: XcmV1MultiassetMultiAssets;
+    readonly dest: XcmV1MultiLocation;
+    readonly effects: Vec<XcmV1Order>;
+  } & Struct;
+  readonly isTransact: boolean;
+  readonly asTransact: {
+    readonly originType: XcmV0OriginKind;
+    readonly requireWeightAtMost: u64;
+    readonly call: XcmDoubleEncoded;
+  } & Struct;
+  readonly isHrmpNewChannelOpenRequest: boolean;
+  readonly asHrmpNewChannelOpenRequest: {
+    readonly sender: Compact<u32>;
+    readonly maxMessageSize: Compact<u32>;
+    readonly maxCapacity: Compact<u32>;
+  } & Struct;
+  readonly isHrmpChannelAccepted: boolean;
+  readonly asHrmpChannelAccepted: {
+    readonly recipient: Compact<u32>;
+  } & Struct;
+  readonly isHrmpChannelClosing: boolean;
+  readonly asHrmpChannelClosing: {
+    readonly initiator: Compact<u32>;
+    readonly sender: Compact<u32>;
+    readonly recipient: Compact<u32>;
+  } & Struct;
+  readonly isRelayedFrom: boolean;
+  readonly asRelayedFrom: {
+    readonly who: XcmV1MultilocationJunctions;
+    readonly message: XcmV1Xcm;
+  } & Struct;
+  readonly isSubscribeVersion: boolean;
+  readonly asSubscribeVersion: {
+    readonly queryId: Compact<u64>;
+    readonly maxResponseWeight: Compact<u64>;
+  } & Struct;
+  readonly isUnsubscribeVersion: boolean;
+  readonly type: 'WithdrawAsset' | 'ReserveAssetDeposited' | 'ReceiveTeleportedAsset' | 'QueryResponse' | 'TransferAsset' | 'TransferReserveAsset' | 'Transact' | 'HrmpNewChannelOpenRequest' | 'HrmpChannelAccepted' | 'HrmpChannelClosing' | 'RelayedFrom' | 'SubscribeVersion' | 'UnsubscribeVersion';
+}
+
+/** @name XcmV2Instruction */
+export interface XcmV2Instruction extends Enum {
+  readonly isWithdrawAsset: boolean;
+  readonly asWithdrawAsset: XcmV1MultiassetMultiAssets;
+  readonly isReserveAssetDeposited: boolean;
+  readonly asReserveAssetDeposited: XcmV1MultiassetMultiAssets;
+  readonly isReceiveTeleportedAsset: boolean;
+  readonly asReceiveTeleportedAsset: XcmV1MultiassetMultiAssets;
+  readonly isQueryResponse: boolean;
+  readonly asQueryResponse: {
+    readonly queryId: Compact<u64>;
+    readonly response: XcmV2Response;
+    readonly maxWeight: Compact<u64>;
+  } & Struct;
+  readonly isTransferAsset: boolean;
+  readonly asTransferAsset: {
+    readonly assets: XcmV1MultiassetMultiAssets;
+    readonly beneficiary: XcmV1MultiLocation;
+  } & Struct;
+  readonly isTransferReserveAsset: boolean;
+  readonly asTransferReserveAsset: {
+    readonly assets: XcmV1MultiassetMultiAssets;
+    readonly dest: XcmV1MultiLocation;
+    readonly xcm: XcmV2Xcm;
+  } & Struct;
+  readonly isTransact: boolean;
+  readonly asTransact: {
+    readonly originType: XcmV0OriginKind;
+    readonly requireWeightAtMost: Compact<u64>;
+    readonly call: XcmDoubleEncoded;
+  } & Struct;
+  readonly isHrmpNewChannelOpenRequest: boolean;
+  readonly asHrmpNewChannelOpenRequest: {
+    readonly sender: Compact<u32>;
+    readonly maxMessageSize: Compact<u32>;
+    readonly maxCapacity: Compact<u32>;
+  } & Struct;
+  readonly isHrmpChannelAccepted: boolean;
+  readonly asHrmpChannelAccepted: {
+    readonly recipient: Compact<u32>;
+  } & Struct;
+  readonly isHrmpChannelClosing: boolean;
+  readonly asHrmpChannelClosing: {
+    readonly initiator: Compact<u32>;
+    readonly sender: Compact<u32>;
+    readonly recipient: Compact<u32>;
+  } & Struct;
+  readonly isClearOrigin: boolean;
+  readonly isDescendOrigin: boolean;
+  readonly asDescendOrigin: XcmV1MultilocationJunctions;
+  readonly isReportError: boolean;
+  readonly asReportError: {
+    readonly queryId: Compact<u64>;
+    readonly dest: XcmV1MultiLocation;
+    readonly maxResponseWeight: Compact<u64>;
+  } & Struct;
+  readonly isDepositAsset: boolean;
+  readonly asDepositAsset: {
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+    readonly maxAssets: Compact<u32>;
+    readonly beneficiary: XcmV1MultiLocation;
+  } & Struct;
+  readonly isDepositReserveAsset: boolean;
+  readonly asDepositReserveAsset: {
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+    readonly maxAssets: Compact<u32>;
+    readonly dest: XcmV1MultiLocation;
+    readonly xcm: XcmV2Xcm;
+  } & Struct;
+  readonly isExchangeAsset: boolean;
+  readonly asExchangeAsset: {
+    readonly give: XcmV1MultiassetMultiAssetFilter;
+    readonly receive: XcmV1MultiassetMultiAssets;
+  } & Struct;
+  readonly isInitiateReserveWithdraw: boolean;
+  readonly asInitiateReserveWithdraw: {
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+    readonly reserve: XcmV1MultiLocation;
+    readonly xcm: XcmV2Xcm;
+  } & Struct;
+  readonly isInitiateTeleport: boolean;
+  readonly asInitiateTeleport: {
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+    readonly dest: XcmV1MultiLocation;
+    readonly xcm: XcmV2Xcm;
+  } & Struct;
+  readonly isQueryHolding: boolean;
+  readonly asQueryHolding: {
+    readonly queryId: Compact<u64>;
+    readonly dest: XcmV1MultiLocation;
+    readonly assets: XcmV1MultiassetMultiAssetFilter;
+    readonly maxResponseWeight: Compact<u64>;
+  } & Struct;
+  readonly isBuyExecution: boolean;
+  readonly asBuyExecution: {
+    readonly fees: XcmV1MultiAsset;
+    readonly weightLimit: XcmV2WeightLimit;
+  } & Struct;
+  readonly isRefundSurplus: boolean;
+  readonly isSetErrorHandler: boolean;
+  readonly asSetErrorHandler: XcmV2Xcm;
+  readonly isSetAppendix: boolean;
+  readonly asSetAppendix: XcmV2Xcm;
+  readonly isClearError: boolean;
+  readonly isClaimAsset: boolean;
+  readonly asClaimAsset: {
+    readonly assets: XcmV1MultiassetMultiAssets;
+    readonly ticket: XcmV1MultiLocation;
+  } & Struct;
+  readonly isTrap: boolean;
+  readonly asTrap: Compact<u64>;
+  readonly isSubscribeVersion: boolean;
+  readonly asSubscribeVersion: {
+    readonly queryId: Compact<u64>;
+    readonly maxResponseWeight: Compact<u64>;
+  } & Struct;
+  readonly isUnsubscribeVersion: boolean;
+  readonly type: 'WithdrawAsset' | 'ReserveAssetDeposited' | 'ReceiveTeleportedAsset' | 'QueryResponse' | 'TransferAsset' | 'TransferReserveAsset' | 'Transact' | 'HrmpNewChannelOpenRequest' | 'HrmpChannelAccepted' | 'HrmpChannelClosing' | 'ClearOrigin' | 'DescendOrigin' | 'ReportError' | 'DepositAsset' | 'DepositReserveAsset' | 'ExchangeAsset' | 'InitiateReserveWithdraw' | 'InitiateTeleport' | 'QueryHolding' | 'BuyExecution' | 'RefundSurplus' | 'SetErrorHandler' | 'SetAppendix' | 'ClearError' | 'ClaimAsset' | 'Trap' | 'SubscribeVersion' | 'UnsubscribeVersion';
+}
+
+/** @name XcmV2Response */
+export interface XcmV2Response extends Enum {
+  readonly isNull: boolean;
+  readonly isAssets: boolean;
+  readonly asAssets: XcmV1MultiassetMultiAssets;
+  readonly isExecutionResult: boolean;
+  readonly asExecutionResult: Option<ITuple<[u32, XcmV2TraitsError]>>;
+  readonly isVersion: boolean;
+  readonly asVersion: u32;
+  readonly type: 'Null' | 'Assets' | 'ExecutionResult' | 'Version';
+}
+
+/** @name XcmV2TraitsError */
+export interface XcmV2TraitsError extends Enum {
+  readonly isOverflow: boolean;
+  readonly isUnimplemented: boolean;
+  readonly isUntrustedReserveLocation: boolean;
+  readonly isUntrustedTeleportLocation: boolean;
+  readonly isMultiLocationFull: boolean;
+  readonly isMultiLocationNotInvertible: boolean;
+  readonly isBadOrigin: boolean;
+  readonly isInvalidLocation: boolean;
+  readonly isAssetNotFound: boolean;
+  readonly isFailedToTransactAsset: boolean;
+  readonly isNotWithdrawable: boolean;
+  readonly isLocationCannotHold: boolean;
+  readonly isExceedsMaxMessageSize: boolean;
+  readonly isDestinationUnsupported: boolean;
+  readonly isTransport: boolean;
+  readonly isUnroutable: boolean;
+  readonly isUnknownClaim: boolean;
+  readonly isFailedToDecode: boolean;
+  readonly isMaxWeightInvalid: boolean;
+  readonly isNotHoldingFees: boolean;
+  readonly isTooExpensive: boolean;
+  readonly isTrap: boolean;
+  readonly asTrap: u64;
+  readonly isUnhandledXcmVersion: boolean;
+  readonly isWeightLimitReached: boolean;
+  readonly asWeightLimitReached: u64;
+  readonly isBarrier: boolean;
+  readonly isWeightNotComputable: boolean;
+  readonly type: 'Overflow' | 'Unimplemented' | 'UntrustedReserveLocation' | 'UntrustedTeleportLocation' | 'MultiLocationFull' | 'MultiLocationNotInvertible' | 'BadOrigin' | 'InvalidLocation' | 'AssetNotFound' | 'FailedToTransactAsset' | 'NotWithdrawable' | 'LocationCannotHold' | 'ExceedsMaxMessageSize' | 'DestinationUnsupported' | 'Transport' | 'Unroutable' | 'UnknownClaim' | 'FailedToDecode' | 'MaxWeightInvalid' | 'NotHoldingFees' | 'TooExpensive' | 'Trap' | 'UnhandledXcmVersion' | 'WeightLimitReached' | 'Barrier' | 'WeightNotComputable';
+}
+
+/** @name XcmV2TraitsOutcome */
+export interface XcmV2TraitsOutcome extends Enum {
+  readonly isComplete: boolean;
+  readonly asComplete: u64;
+  readonly isIncomplete: boolean;
+  readonly asIncomplete: ITuple<[u64, XcmV2TraitsError]>;
+  readonly isError: boolean;
+  readonly asError: XcmV2TraitsError;
+  readonly type: 'Complete' | 'Incomplete' | 'Error';
+}
+
+/** @name XcmV2WeightLimit */
+export interface XcmV2WeightLimit extends Enum {
+  readonly isUnlimited: boolean;
+  readonly isLimited: boolean;
+  readonly asLimited: Compact<u64>;
+  readonly type: 'Unlimited' | 'Limited';
+}
+
+/** @name XcmV2Xcm */
+export interface XcmV2Xcm extends Vec<XcmV2Instruction> {}
+
+/** @name XcmVersionedMultiAssets */
+export interface XcmVersionedMultiAssets extends Enum {
+  readonly isV0: boolean;
+  readonly asV0: Vec<XcmV0MultiAsset>;
+  readonly isV1: boolean;
+  readonly asV1: XcmV1MultiassetMultiAssets;
+  readonly type: 'V0' | 'V1';
+}
+
+/** @name XcmVersionedMultiLocation */
+export interface XcmVersionedMultiLocation extends Enum {
+  readonly isV0: boolean;
+  readonly asV0: XcmV0MultiLocation;
+  readonly isV1: boolean;
+  readonly asV1: XcmV1MultiLocation;
+  readonly type: 'V0' | 'V1';
+}
+
+/** @name XcmVersionedXcm */
+export interface XcmVersionedXcm extends Enum {
+  readonly isV0: boolean;
+  readonly asV0: XcmV0Xcm;
+  readonly isV1: boolean;
+  readonly asV1: XcmV1Xcm;
+  readonly isV2: boolean;
+  readonly asV2: XcmV2Xcm;
+  readonly type: 'V0' | 'V1' | 'V2';
+}
+
+export type PHANTOM_RMRK = 'rmrk';
modifiedtests/src/interfaces/types-lookup.tsdiffbeforeafterboth
--- a/tests/src/interfaces/types-lookup.ts
+++ b/tests/src/interfaces/types-lookup.ts
@@ -4,7 +4,7 @@
 declare module '@polkadot/types/lookup' {
   import type { BTreeMap, BTreeSet, Bytes, Compact, Enum, Null, Option, Result, Struct, Text, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
   import type { ITuple } from '@polkadot/types-codec/types';
-  import type { AccountId32, Call, H160, H256, MultiAddress, Perbill } from '@polkadot/types/interfaces/runtime';
+  import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';
   import type { Event } from '@polkadot/types/interfaces/system';
 
   /** @name PolkadotPrimitivesV2PersistedValidationData (2) */
@@ -1582,12 +1582,9 @@
     readonly isDisabled: boolean;
     readonly isOwner: boolean;
     readonly isOwnerRestricted: boolean;
-    readonly asOwnerRestricted: FrameSupportStorageBoundedBTreeSet;
+    readonly asOwnerRestricted: BTreeSet<u32>;
     readonly type: 'Disabled' | 'Owner' | 'OwnerRestricted';
   }
-
-  /** @name FrameSupportStorageBoundedBTreeSet (171) */
-  export interface FrameSupportStorageBoundedBTreeSet extends BTreeSet<u32> {}
 
   /** @name UpDataStructsPropertyKeyPermission (177) */
   export interface UpDataStructsPropertyKeyPermission extends Struct {
@@ -2544,7 +2541,143 @@
     readonly properties: Vec<UpDataStructsProperty>;
   }
 
-  /** @name PalletCommonError (333) */
+  /** @name PhantomTypeUpDataStructsCollectionInfo (333) */
+  export interface PhantomTypeUpDataStructsCollectionInfo extends Vec<RmrkTypesCollectionInfo> {}
+
+  /** @name RmrkTypesCollectionInfo (334) */
+  export interface RmrkTypesCollectionInfo extends Struct {
+    readonly issuer: AccountId32;
+    readonly metadata: Bytes;
+    readonly max: Option<u32>;
+    readonly symbol: Bytes;
+    readonly nftsCount: u32;
+  }
+
+  /** @name PhantomTypeUpDataStructsNftInfo (338) */
+  export interface PhantomTypeUpDataStructsNftInfo extends Vec<RmrkTypesNftInfo> {}
+
+  /** @name RmrkTypesNftInfo (339) */
+  export interface RmrkTypesNftInfo extends Struct {
+    readonly owner: RmrkTypesAccountIdOrCollectionNftTuple;
+    readonly royalty: Option<RmrkTypesRoyaltyInfo>;
+    readonly metadata: Bytes;
+    readonly equipped: bool;
+    readonly pending: bool;
+  }
+
+  /** @name RmrkTypesAccountIdOrCollectionNftTuple (340) */
+  export interface RmrkTypesAccountIdOrCollectionNftTuple extends Enum {
+    readonly isAccountId: boolean;
+    readonly asAccountId: AccountId32;
+    readonly isCollectionAndNftTuple: boolean;
+    readonly asCollectionAndNftTuple: ITuple<[u32, u32]>;
+    readonly type: 'AccountId' | 'CollectionAndNftTuple';
+  }
+
+  /** @name RmrkTypesRoyaltyInfo (342) */
+  export interface RmrkTypesRoyaltyInfo extends Struct {
+    readonly recipient: AccountId32;
+    readonly amount: Permill;
+  }
+
+  /** @name PhantomTypeUpDataStructsResourceInfo (344) */
+  export interface PhantomTypeUpDataStructsResourceInfo extends Vec<RmrkTypesResourceInfo> {}
+
+  /** @name RmrkTypesResourceInfo (345) */
+  export interface RmrkTypesResourceInfo extends Struct {
+    readonly id: Bytes;
+    readonly pending: bool;
+    readonly pendingRemoval: bool;
+    readonly parts: Option<Vec<u32>>;
+    readonly base: Option<u32>;
+    readonly src: Option<Bytes>;
+    readonly metadata: Option<Bytes>;
+    readonly slot: Option<u32>;
+    readonly license: Option<Bytes>;
+    readonly thumb: Option<Bytes>;
+  }
+
+  /** @name PhantomTypeUpDataStructsPropertyInfo (351) */
+  export interface PhantomTypeUpDataStructsPropertyInfo extends Vec<RmrkTypesPropertyInfo> {}
+
+  /** @name RmrkTypesPropertyInfo (352) */
+  export interface RmrkTypesPropertyInfo extends Struct {
+    readonly key: Bytes;
+    readonly value: Bytes;
+  }
+
+  /** @name PhantomTypeUpDataStructsBaseInfo (356) */
+  export interface PhantomTypeUpDataStructsBaseInfo extends Vec<RmrkTypesBaseInfo> {}
+
+  /** @name RmrkTypesBaseInfo (357) */
+  export interface RmrkTypesBaseInfo extends Struct {
+    readonly issuer: AccountId32;
+    readonly baseType: Bytes;
+    readonly symbol: Bytes;
+  }
+
+  /** @name PhantomTypeUpDataStructsPartType (359) */
+  export interface PhantomTypeUpDataStructsPartType extends Vec<RmrkTypesPartType> {}
+
+  /** @name RmrkTypesPartType (360) */
+  export interface RmrkTypesPartType extends Enum {
+    readonly isFixedPart: boolean;
+    readonly asFixedPart: RmrkTypesFixedPart;
+    readonly isSlotPart: boolean;
+    readonly asSlotPart: RmrkTypesSlotPart;
+    readonly type: 'FixedPart' | 'SlotPart';
+  }
+
+  /** @name RmrkTypesFixedPart (362) */
+  export interface RmrkTypesFixedPart extends Struct {
+    readonly id: u32;
+    readonly z: u32;
+    readonly src: Bytes;
+  }
+
+  /** @name RmrkTypesSlotPart (363) */
+  export interface RmrkTypesSlotPart extends Struct {
+    readonly id: u32;
+    readonly equippable: RmrkTypesEquippableList;
+    readonly src: Bytes;
+    readonly z: u32;
+  }
+
+  /** @name RmrkTypesEquippableList (364) */
+  export interface RmrkTypesEquippableList extends Enum {
+    readonly isAll: boolean;
+    readonly isEmpty: boolean;
+    readonly isCustom: boolean;
+    readonly asCustom: Vec<u32>;
+    readonly type: 'All' | 'Empty' | 'Custom';
+  }
+
+  /** @name PhantomTypeUpDataStructsTheme (366) */
+  export interface PhantomTypeUpDataStructsTheme extends Vec<RmrkTypesTheme> {}
+
+  /** @name RmrkTypesTheme (367) */
+  export interface RmrkTypesTheme extends Struct {
+    readonly name: Bytes;
+    readonly properties: Vec<RmrkTypesThemeProperty>;
+    readonly inherit: bool;
+  }
+
+  /** @name RmrkTypesThemeProperty (369) */
+  export interface RmrkTypesThemeProperty extends Struct {
+    readonly key: Bytes;
+    readonly value: Bytes;
+  }
+
+  /** @name PhantomTypeUpDataStructsNftChild (371) */
+  export interface PhantomTypeUpDataStructsNftChild extends Vec<RmrkTypesNftChild> {}
+
+  /** @name RmrkTypesNftChild (372) */
+  export interface RmrkTypesNftChild extends Struct {
+    readonly collectionId: u32;
+    readonly nftId: u32;
+  }
+
+  /** @name PalletCommonError (374) */
   export interface PalletCommonError extends Enum {
     readonly isCollectionNotFound: boolean;
     readonly isMustBeTokenOwner: boolean;
@@ -2581,7 +2714,7 @@
     readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'NestingIsDisabled' | 'OnlyOwnerAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded' | 'NoSpaceForProperty' | 'PropertyLimitReached' | 'PropertyKeyIsTooLong' | 'InvalidCharacterInPropertyKey' | 'EmptyPropertyKey';
   }
 
-  /** @name PalletFungibleError (335) */
+  /** @name PalletFungibleError (376) */
   export interface PalletFungibleError extends Enum {
     readonly isNotFungibleDataUsedToMintFungibleCollectionToken: boolean;
     readonly isFungibleItemsHaveNoId: boolean;
@@ -2591,12 +2724,12 @@
     readonly type: 'NotFungibleDataUsedToMintFungibleCollectionToken' | 'FungibleItemsHaveNoId' | 'FungibleItemsDontHaveData' | 'FungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
   }
 
-  /** @name PalletRefungibleItemData (336) */
+  /** @name PalletRefungibleItemData (377) */
   export interface PalletRefungibleItemData extends Struct {
     readonly constData: Bytes;
   }
 
-  /** @name PalletRefungibleError (340) */
+  /** @name PalletRefungibleError (381) */
   export interface PalletRefungibleError extends Enum {
     readonly isNotRefungibleDataUsedToMintFungibleCollectionToken: boolean;
     readonly isWrongRefungiblePieces: boolean;
@@ -2605,20 +2738,20 @@
     readonly type: 'NotRefungibleDataUsedToMintFungibleCollectionToken' | 'WrongRefungiblePieces' | 'RefungibleDisallowsNesting' | 'SettingPropertiesNotAllowed';
   }
 
-  /** @name PalletNonfungibleItemData (341) */
+  /** @name PalletNonfungibleItemData (382) */
   export interface PalletNonfungibleItemData extends Struct {
     readonly constData: Bytes;
     readonly owner: PalletEvmAccountBasicCrossAccountIdRepr;
   }
 
-  /** @name PalletNonfungibleError (342) */
+  /** @name PalletNonfungibleError (383) */
   export interface PalletNonfungibleError extends Enum {
     readonly isNotNonfungibleDataUsedToMintFungibleCollectionToken: boolean;
     readonly isNonfungibleItemsHaveNoAmount: boolean;
     readonly type: 'NotNonfungibleDataUsedToMintFungibleCollectionToken' | 'NonfungibleItemsHaveNoAmount';
   }
 
-  /** @name PalletStructureError (343) */
+  /** @name PalletStructureError (384) */
   export interface PalletStructureError extends Enum {
     readonly isOuroborosDetected: boolean;
     readonly isDepthLimit: boolean;
@@ -2626,7 +2759,7 @@
     readonly type: 'OuroborosDetected' | 'DepthLimit' | 'TokenNotFound';
   }
 
-  /** @name PalletEvmError (346) */
+  /** @name PalletEvmError (387) */
   export interface PalletEvmError extends Enum {
     readonly isBalanceLow: boolean;
     readonly isFeeOverflow: boolean;
@@ -2637,7 +2770,7 @@
     readonly type: 'BalanceLow' | 'FeeOverflow' | 'PaymentOverflow' | 'WithdrawFailed' | 'GasPriceTooLow' | 'InvalidNonce';
   }
 
-  /** @name FpRpcTransactionStatus (349) */
+  /** @name FpRpcTransactionStatus (390) */
   export interface FpRpcTransactionStatus extends Struct {
     readonly transactionHash: H256;
     readonly transactionIndex: u32;
@@ -2648,10 +2781,10 @@
     readonly logsBloom: EthbloomBloom;
   }
 
-  /** @name EthbloomBloom (351) */
+  /** @name EthbloomBloom (392) */
   export interface EthbloomBloom extends U8aFixed {}
 
-  /** @name EthereumReceiptReceiptV3 (353) */
+  /** @name EthereumReceiptReceiptV3 (394) */
   export interface EthereumReceiptReceiptV3 extends Enum {
     readonly isLegacy: boolean;
     readonly asLegacy: EthereumReceiptEip658ReceiptData;
@@ -2662,7 +2795,7 @@
     readonly type: 'Legacy' | 'Eip2930' | 'Eip1559';
   }
 
-  /** @name EthereumReceiptEip658ReceiptData (354) */
+  /** @name EthereumReceiptEip658ReceiptData (395) */
   export interface EthereumReceiptEip658ReceiptData extends Struct {
     readonly statusCode: u8;
     readonly usedGas: U256;
@@ -2670,14 +2803,14 @@
     readonly logs: Vec<EthereumLog>;
   }
 
-  /** @name EthereumBlock (355) */
+  /** @name EthereumBlock (396) */
   export interface EthereumBlock extends Struct {
     readonly header: EthereumHeader;
     readonly transactions: Vec<EthereumTransactionTransactionV2>;
     readonly ommers: Vec<EthereumHeader>;
   }
 
-  /** @name EthereumHeader (356) */
+  /** @name EthereumHeader (397) */
   export interface EthereumHeader extends Struct {
     readonly parentHash: H256;
     readonly ommersHash: H256;
@@ -2696,24 +2829,24 @@
     readonly nonce: EthereumTypesHashH64;
   }
 
-  /** @name EthereumTypesHashH64 (357) */
+  /** @name EthereumTypesHashH64 (398) */
   export interface EthereumTypesHashH64 extends U8aFixed {}
 
-  /** @name PalletEthereumError (362) */
+  /** @name PalletEthereumError (403) */
   export interface PalletEthereumError extends Enum {
     readonly isInvalidSignature: boolean;
     readonly isPreLogExists: boolean;
     readonly type: 'InvalidSignature' | 'PreLogExists';
   }
 
-  /** @name PalletEvmCoderSubstrateError (363) */
+  /** @name PalletEvmCoderSubstrateError (404) */
   export interface PalletEvmCoderSubstrateError extends Enum {
     readonly isOutOfGas: boolean;
     readonly isOutOfFund: boolean;
     readonly type: 'OutOfGas' | 'OutOfFund';
   }
 
-  /** @name PalletEvmContractHelpersSponsoringModeT (364) */
+  /** @name PalletEvmContractHelpersSponsoringModeT (405) */
   export interface PalletEvmContractHelpersSponsoringModeT extends Enum {
     readonly isDisabled: boolean;
     readonly isAllowlisted: boolean;
@@ -2721,20 +2854,20 @@
     readonly type: 'Disabled' | 'Allowlisted' | 'Generous';
   }
 
-  /** @name PalletEvmContractHelpersError (366) */
+  /** @name PalletEvmContractHelpersError (407) */
   export interface PalletEvmContractHelpersError extends Enum {
     readonly isNoPermission: boolean;
     readonly type: 'NoPermission';
   }
 
-  /** @name PalletEvmMigrationError (367) */
+  /** @name PalletEvmMigrationError (408) */
   export interface PalletEvmMigrationError extends Enum {
     readonly isAccountNotEmpty: boolean;
     readonly isAccountIsNotMigrating: boolean;
     readonly type: 'AccountNotEmpty' | 'AccountIsNotMigrating';
   }
 
-  /** @name SpRuntimeMultiSignature (369) */
+  /** @name SpRuntimeMultiSignature (410) */
   export interface SpRuntimeMultiSignature extends Enum {
     readonly isEd25519: boolean;
     readonly asEd25519: SpCoreEd25519Signature;
@@ -2745,34 +2878,34 @@
     readonly type: 'Ed25519' | 'Sr25519' | 'Ecdsa';
   }
 
-  /** @name SpCoreEd25519Signature (370) */
+  /** @name SpCoreEd25519Signature (411) */
   export interface SpCoreEd25519Signature extends U8aFixed {}
 
-  /** @name SpCoreSr25519Signature (372) */
+  /** @name SpCoreSr25519Signature (413) */
   export interface SpCoreSr25519Signature extends U8aFixed {}
 
-  /** @name SpCoreEcdsaSignature (373) */
+  /** @name SpCoreEcdsaSignature (414) */
   export interface SpCoreEcdsaSignature extends U8aFixed {}
 
-  /** @name FrameSystemExtensionsCheckSpecVersion (376) */
+  /** @name FrameSystemExtensionsCheckSpecVersion (417) */
   export type FrameSystemExtensionsCheckSpecVersion = Null;
 
-  /** @name FrameSystemExtensionsCheckGenesis (377) */
+  /** @name FrameSystemExtensionsCheckGenesis (418) */
   export type FrameSystemExtensionsCheckGenesis = Null;
 
-  /** @name FrameSystemExtensionsCheckNonce (380) */
+  /** @name FrameSystemExtensionsCheckNonce (421) */
   export interface FrameSystemExtensionsCheckNonce extends Compact<u32> {}
 
-  /** @name FrameSystemExtensionsCheckWeight (381) */
+  /** @name FrameSystemExtensionsCheckWeight (422) */
   export type FrameSystemExtensionsCheckWeight = Null;
 
-  /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (382) */
+  /** @name PalletTemplateTransactionPaymentChargeTransactionPayment (423) */
   export interface PalletTemplateTransactionPaymentChargeTransactionPayment extends Compact<u128> {}
 
-  /** @name OpalRuntimeRuntime (383) */
+  /** @name OpalRuntimeRuntime (424) */
   export type OpalRuntimeRuntime = Null;
 
-  /** @name PalletEthereumFakeTransactionFinalizer (384) */
+  /** @name PalletEthereumFakeTransactionFinalizer (425) */
   export type PalletEthereumFakeTransactionFinalizer = Null;
 
 } // declare module
modifiedtests/src/interfaces/types.tsdiffbeforeafterboth
--- a/tests/src/interfaces/types.ts
+++ b/tests/src/interfaces/types.ts
@@ -2,3 +2,4 @@
 /* eslint-disable */
 
 export * from './unique/types';
+export * from './rmrk/types';
modifiedtests/src/interfaces/unique/types.tsdiffbeforeafterboth
--- a/tests/src/interfaces/unique/types.ts
+++ b/tests/src/interfaces/unique/types.ts
@@ -3,7 +3,7 @@
 
 import type { BTreeMap, BTreeSet, Bytes, Compact, Enum, Null, Option, Result, Struct, Text, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
 import type { ITuple } from '@polkadot/types-codec/types';
-import type { AccountId32, Call, H160, H256, MultiAddress, Perbill } from '@polkadot/types/interfaces/runtime';
+import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';
 import type { Event } from '@polkadot/types/interfaces/system';
 
 /** @name CumulusPalletDmpQueueCall */
@@ -445,9 +445,6 @@
 
 /** @name FrameSupportPalletId */
 export interface FrameSupportPalletId extends U8aFixed {}
-
-/** @name FrameSupportStorageBoundedBTreeSet */
-export interface FrameSupportStorageBoundedBTreeSet extends BTreeSet<u32> {}
 
 /** @name FrameSupportTokensMiscBalanceStatus */
 export interface FrameSupportTokensMiscBalanceStatus extends Enum {
@@ -1617,9 +1614,33 @@
   readonly type: 'Attempted' | 'Sent' | 'UnexpectedResponse' | 'ResponseReady' | 'Notified' | 'NotifyOverweight' | 'NotifyDispatchError' | 'NotifyDecodeFailed' | 'InvalidResponder' | 'InvalidResponderVersion' | 'ResponseTaken' | 'AssetsTrapped' | 'VersionChangeNotified' | 'SupportedVersionChanged' | 'NotifyTargetSendFail' | 'NotifyTargetMigrationFail';
 }
 
+/** @name PhantomTypeUpDataStructsBaseInfo */
+export interface PhantomTypeUpDataStructsBaseInfo extends Vec<Lookup357> {}
+
+/** @name PhantomTypeUpDataStructsCollectionInfo */
+export interface PhantomTypeUpDataStructsCollectionInfo extends Vec<Lookup334> {}
+
+/** @name PhantomTypeUpDataStructsNftChild */
+export interface PhantomTypeUpDataStructsNftChild extends Vec<Lookup372> {}
+
+/** @name PhantomTypeUpDataStructsNftInfo */
+export interface PhantomTypeUpDataStructsNftInfo extends Vec<Lookup339> {}
+
+/** @name PhantomTypeUpDataStructsPartType */
+export interface PhantomTypeUpDataStructsPartType extends Vec<Lookup360> {}
+
+/** @name PhantomTypeUpDataStructsPropertyInfo */
+export interface PhantomTypeUpDataStructsPropertyInfo extends Vec<Lookup352> {}
+
+/** @name PhantomTypeUpDataStructsResourceInfo */
+export interface PhantomTypeUpDataStructsResourceInfo extends Vec<Lookup345> {}
+
 /** @name PhantomTypeUpDataStructsRpcCollection */
 export interface PhantomTypeUpDataStructsRpcCollection extends Vec<Lookup331> {}
 
+/** @name PhantomTypeUpDataStructsTheme */
+export interface PhantomTypeUpDataStructsTheme extends Vec<Lookup367> {}
+
 /** @name PhantomTypeUpDataStructsTokenData */
 export interface PhantomTypeUpDataStructsTokenData extends Vec<Lookup327> {}
 
@@ -1686,6 +1707,118 @@
   readonly type: 'Present';
 }
 
+/** @name RmrkTypesAccountIdOrCollectionNftTuple */
+export interface RmrkTypesAccountIdOrCollectionNftTuple extends Enum {
+  readonly isAccountId: boolean;
+  readonly asAccountId: AccountId32;
+  readonly isCollectionAndNftTuple: boolean;
+  readonly asCollectionAndNftTuple: ITuple<[u32, u32]>;
+  readonly type: 'AccountId' | 'CollectionAndNftTuple';
+}
+
+/** @name RmrkTypesBaseInfo */
+export interface RmrkTypesBaseInfo extends Struct {
+  readonly issuer: AccountId32;
+  readonly baseType: Bytes;
+  readonly symbol: Bytes;
+}
+
+/** @name RmrkTypesCollectionInfo */
+export interface RmrkTypesCollectionInfo extends Struct {
+  readonly issuer: AccountId32;
+  readonly metadata: Bytes;
+  readonly max: Option<u32>;
+  readonly symbol: Bytes;
+  readonly nftsCount: u32;
+}
+
+/** @name RmrkTypesEquippableList */
+export interface RmrkTypesEquippableList extends Enum {
+  readonly isAll: boolean;
+  readonly isEmpty: boolean;
+  readonly isCustom: boolean;
+  readonly asCustom: Vec<u32>;
+  readonly type: 'All' | 'Empty' | 'Custom';
+}
+
+/** @name RmrkTypesFixedPart */
+export interface RmrkTypesFixedPart extends Struct {
+  readonly id: u32;
+  readonly z: u32;
+  readonly src: Bytes;
+}
+
+/** @name RmrkTypesNftChild */
+export interface RmrkTypesNftChild extends Struct {
+  readonly collectionId: u32;
+  readonly nftId: u32;
+}
+
+/** @name RmrkTypesNftInfo */
+export interface RmrkTypesNftInfo extends Struct {
+  readonly owner: RmrkTypesAccountIdOrCollectionNftTuple;
+  readonly royalty: Option<RmrkTypesRoyaltyInfo>;
+  readonly metadata: Bytes;
+  readonly equipped: bool;
+  readonly pending: bool;
+}
+
+/** @name RmrkTypesPartType */
+export interface RmrkTypesPartType extends Enum {
+  readonly isFixedPart: boolean;
+  readonly asFixedPart: RmrkTypesFixedPart;
+  readonly isSlotPart: boolean;
+  readonly asSlotPart: RmrkTypesSlotPart;
+  readonly type: 'FixedPart' | 'SlotPart';
+}
+
+/** @name RmrkTypesPropertyInfo */
+export interface RmrkTypesPropertyInfo extends Struct {
+  readonly key: Bytes;
+  readonly value: Bytes;
+}
+
+/** @name RmrkTypesResourceInfo */
+export interface RmrkTypesResourceInfo extends Struct {
+  readonly id: Bytes;
+  readonly pending: bool;
+  readonly pendingRemoval: bool;
+  readonly parts: Option<Vec<u32>>;
+  readonly base: Option<u32>;
+  readonly src: Option<Bytes>;
+  readonly metadata: Option<Bytes>;
+  readonly slot: Option<u32>;
+  readonly license: Option<Bytes>;
+  readonly thumb: Option<Bytes>;
+}
+
+/** @name RmrkTypesRoyaltyInfo */
+export interface RmrkTypesRoyaltyInfo extends Struct {
+  readonly recipient: AccountId32;
+  readonly amount: Permill;
+}
+
+/** @name RmrkTypesSlotPart */
+export interface RmrkTypesSlotPart extends Struct {
+  readonly id: u32;
+  readonly equippable: RmrkTypesEquippableList;
+  readonly src: Bytes;
+  readonly z: u32;
+}
+
+/** @name RmrkTypesTheme */
+export interface RmrkTypesTheme extends Struct {
+  readonly name: Bytes;
+  readonly properties: Vec<RmrkTypesThemeProperty>;
+  readonly inherit: bool;
+}
+
+/** @name RmrkTypesThemeProperty */
+export interface RmrkTypesThemeProperty extends Struct {
+  readonly key: Bytes;
+  readonly value: Bytes;
+}
+
 /** @name SpCoreEcdsaSignature */
 export interface SpCoreEcdsaSignature extends U8aFixed {}
 
@@ -1927,7 +2060,7 @@
   readonly isDisabled: boolean;
   readonly isOwner: boolean;
   readonly isOwnerRestricted: boolean;
-  readonly asOwnerRestricted: FrameSupportStorageBoundedBTreeSet;
+  readonly asOwnerRestricted: BTreeSet<u32>;
   readonly type: 'Disabled' | 'Owner' | 'OwnerRestricted';
 }
modifiedtests/src/substrate/substrate-api.tsdiffbeforeafterboth
--- a/tests/src/substrate/substrate-api.ts
+++ b/tests/src/substrate/substrate-api.ts
@@ -41,6 +41,7 @@
     },
     rpc: {
       unique: defs.unique.rpc,
+      rmrk: defs.rmrk.rpc,
       eth: {
         feeHistory: {
           description: 'Dummy',