--- a/Cargo.lock +++ b/Cargo.lock @@ -6335,6 +6335,7 @@ "pallet-common", "pallet-evm", "pallet-nonfungible", + "pallet-structure", "parity-scale-codec 3.1.2", "scale-info", "sp-core", --- a/pallets/proxy-rmrk-core/Cargo.toml +++ b/pallets/proxy-rmrk-core/Cargo.toml @@ -18,6 +18,7 @@ sp-core = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.22" } pallet-common = { default-features = false, path = '../common' } pallet-nonfungible = { default-features = false, path = "../../pallets/nonfungible" } +pallet-structure = { default-features = false, path = "../../pallets/structure" } up-data-structs = { default-features = false, path = '../../primitives/data-structs' } pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier", branch = "unique-polkadot-v0.9.22" } frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.22" } @@ -33,6 +34,7 @@ "up-data-structs/std", "pallet-common/std", "pallet-nonfungible/std", + "pallet-structure/std", "pallet-evm/std", 'frame-benchmarking/std', ] --- a/pallets/proxy-rmrk-core/src/lib.rs +++ b/pallets/proxy-rmrk-core/src/lib.rs @@ -25,6 +25,7 @@ Pallet as PalletCommon, Error as CommonError, CollectionHandle, CommonCollectionOperations, }; use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle, TokenData}; +use pallet_structure::Pallet as PalletStructure; use pallet_evm::account::CrossAccountId; use core::convert::AsRef; @@ -56,7 +57,7 @@ #[pallet::storage] #[pallet::getter(fn collection_index_map)] - pub type CollectionIndexMap = + pub type CollectionIndexMap = StorageMap<_, Twox64Concat, RmrkCollectionId, CollectionId, ValueQuery>; #[pallet::pallet] @@ -98,6 +99,10 @@ key: RmrkKeyString, value: RmrkValueString, }, + ResourceAdded { + nft_id: RmrkNftId, + resource_id: RmrkResourceId, + }, } #[pallet::error] @@ -106,7 +111,7 @@ CorruptedCollectionType, NftTypeEncodeError, RmrkPropertyKeyIsTooLong, - RmrkPropertyValueIsTooLong, + RmrkPropertyValueIsTooLong, // todo utilize that in RPCs /* RMRK compatible events */ CollectionNotEmpty, @@ -115,6 +120,7 @@ CollectionUnknown, NoPermission, CollectionFullOrLocked, + // todo add resource errors? } #[pallet::call] @@ -143,29 +149,21 @@ .map_err(|_| >::CollectionTokenPrefixLimitExceeded)?, ..Default::default() }; - - let collection_id_res = - >::init_collection(T::CrossAccountId::from_sub(sender.clone()), data); - - if let Err(DispatchError::Arithmetic(_)) = &collection_id_res { - return Err(>::NoAvailableCollectionId.into()); - } - let unique_collection_id = collection_id_res?; - let rmrk_collection_id = >::get(); - >::mutate(|n| *n += 1); - >::insert(rmrk_collection_id, unique_collection_id); - >::set_scoped_collection_properties( - unique_collection_id, - PropertyScope::Rmrk, + let unique_collection_id = Self::init_collection( + T::CrossAccountId::from_sub(sender.clone()), + data, [ Self::rmrk_property(Metadata, &metadata)?, Self::rmrk_property(CollectionType, &misc::CollectionType::Regular)?, ] .into_iter(), - )?; + )?; //collection_id_res?; + let rmrk_collection_id = >::get(); + + >::insert(rmrk_collection_id, unique_collection_id); Self::deposit_event(Event::CollectionCreated { issuer: sender, @@ -290,13 +288,26 @@ &sender, &cross_owner, &collection, - NftType::Regular, [ + Self::rmrk_property(TokenType, &NftType::Regular)?, Self::rmrk_property(RoyaltyInfo, &royalty_info)?, Self::rmrk_property(Metadata, &metadata)?, Self::rmrk_property(Equipped, &false)?, - Self::rmrk_property(ResourceCollection, &None::)?, - Self::rmrk_property(ResourcePriorities, &>::new())?, + Self::rmrk_property( + ResourceCollection, + &Self::init_collection( + sender.clone(), + CreateCollectionData { + ..Default::default() + }, + [Self::rmrk_property( + CollectionType, + &misc::CollectionType::Resource, + )?] + .into_iter(), + )?, + )?, // todo possibly add limits to the collection if rmrk warrants them + Self::rmrk_property(ResourcePriorities, &>::new())?, // todo create resource priorities? ] .into_iter(), ) @@ -392,6 +403,107 @@ Ok(()) } + + #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))] + #[transactional] + pub fn add_basic_resource( + origin: OriginFor, + collection_id: RmrkCollectionId, + nft_id: RmrkNftId, + resource: RmrkBasicResource, + ) -> DispatchResult { + let sender = ensure_signed(origin.clone())?; + + let resource_id = Self::resource_add( + sender, + Self::unique_collection_id(collection_id)?, + nft_id.into(), + [ + Self::rmrk_property(TokenType, &NftType::Resource)?, + Self::rmrk_property(ResourceType, &misc::ResourceType::Basic)?, + Self::rmrk_property(Src, &resource.src)?, + Self::rmrk_property(Metadata, &resource.metadata)?, + Self::rmrk_property(License, &resource.license)?, + Self::rmrk_property(Thumb, &resource.thumb)?, + ] + .into_iter(), + )?; + + Self::deposit_event(Event::ResourceAdded { + nft_id, + resource_id, + }); + Ok(()) + } + + #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))] + #[transactional] + pub fn add_composable_resource( + origin: OriginFor, + collection_id: RmrkCollectionId, + nft_id: RmrkNftId, + _resource_id: RmrkBoundedResource, + resource: RmrkComposableResource, + ) -> DispatchResult { + let sender = ensure_signed(origin.clone())?; + + let resource_id = Self::resource_add( + sender, + Self::unique_collection_id(collection_id)?, + nft_id.into(), + [ + Self::rmrk_property(TokenType, &NftType::Resource)?, + Self::rmrk_property(ResourceType, &misc::ResourceType::Composable)?, + Self::rmrk_property(Parts, &resource.parts)?, + Self::rmrk_property(Base, &resource.base)?, + Self::rmrk_property(Src, &resource.src)?, + Self::rmrk_property(Metadata, &resource.metadata)?, + Self::rmrk_property(License, &resource.license)?, + Self::rmrk_property(Thumb, &resource.thumb)?, + ] + .into_iter(), + )?; + + Self::deposit_event(Event::ResourceAdded { + nft_id, + resource_id, + }); + Ok(()) + } + + #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))] + #[transactional] + pub fn add_slot_resource( + origin: OriginFor, + collection_id: RmrkCollectionId, + nft_id: RmrkNftId, + resource: RmrkSlotResource, + ) -> DispatchResult { + let sender = ensure_signed(origin.clone())?; + + let resource_id = Self::resource_add( + sender, + Self::unique_collection_id(collection_id)?, + nft_id.into(), + [ + Self::rmrk_property(TokenType, &NftType::Resource)?, + Self::rmrk_property(ResourceType, &misc::ResourceType::Slot)?, + Self::rmrk_property(Base, &resource.base)?, + Self::rmrk_property(Src, &resource.src)?, + Self::rmrk_property(Metadata, &resource.metadata)?, + Self::rmrk_property(Slot, &resource.slot)?, + Self::rmrk_property(License, &resource.license)?, + Self::rmrk_property(Thumb, &resource.thumb)?, + ] + .into_iter(), + )?; + + Self::deposit_event(Event::ResourceAdded { + nft_id, + resource_id, + }); + Ok(()) + } } } @@ -422,14 +534,32 @@ Ok(property) } + fn init_collection( + sender: T::CrossAccountId, + data: CreateCollectionData, + properties: impl Iterator, + ) -> Result { + let collection_id = >::init_collection(sender, data); + + if let Err(DispatchError::Arithmetic(_)) = &collection_id { + return Err(>::NoAvailableCollectionId.into()); + } + + >::set_scoped_collection_properties( + collection_id?, + PropertyScope::Rmrk, + properties, + )?; + + collection_id + } + pub fn create_nft( sender: &T::CrossAccountId, owner: &T::CrossAccountId, collection: &NonfungibleHandle, - nft_type: NftType, properties: impl Iterator, ) -> Result { - todo!("store nft type"); let data = CreateNftExData { properties: BoundedVec::default(), owner: owner.clone(), @@ -465,6 +595,57 @@ Ok(()) } + fn resource_add( + sender: T::AccountId, + collection_id: CollectionId, + token_id: TokenId, + resource_properties: impl Iterator, + ) -> Result { + let collection = + Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?; + ensure!(collection.owner == sender, Error::::NoPermission); + + // Check NFT lock status // todo depends on market, maybe later + //ensure!(!Pallet::::is_locked(collection_id, nft_id), pallet_uniques::Error::::Locked); + + let sender = T::CrossAccountId::from_sub(sender); + let budget = budget::Value::new(10); + let pending = >::check_indirectly_owned( + sender.clone(), + collection_id, + token_id, + None, + &budget, + )?; + + let resource_collection_id: CollectionId = + Self::get_nft_property(collection_id, token_id, ResourceCollection)? + .decode_or_default(); + let resource_collection = + Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?; + + // todo probably add extra connections to bases, slots, etc., when RMRK starts to use them + + let resource_id = Self::create_nft( + &sender, // todo owner of the nft? + &sender, + &resource_collection, + resource_properties.chain( + [ + Self::rmrk_property(PendingResourceAccept, &pending)?, + Self::rmrk_property(PendingResourceRemoval, &false)?, + ] + .into_iter(), + ), + ) + .map_err(|err| match err { + DispatchError::Arithmetic(_) => >::NoAvailableNftId.into(), + err => Self::map_common_err_to_proxy(err), + })?; + + Ok(resource_id.0) + } + fn change_collection_owner( collection_id: CollectionId, collection_type: misc::CollectionType, @@ -493,8 +674,11 @@ >::get() } - pub fn unique_collection_id(rmrk_collection_id: RmrkCollectionId) -> Result { - >::try_get(rmrk_collection_id).map_err(|_| >::CollectionUnknown.into()) + pub fn unique_collection_id( + rmrk_collection_id: RmrkCollectionId, + ) -> Result { + >::try_get(rmrk_collection_id) + .map_err(|_| >::CollectionUnknown.into()) } pub fn get_nft_collection( @@ -513,10 +697,6 @@ >::try_get(collection_id).is_ok() } - pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool { - >::contains_key((collection_id, nft_id)) - } - pub fn get_collection_property( collection_id: CollectionId, key: RmrkProperty, @@ -553,6 +733,15 @@ Ok(()) } + pub fn get_typed_nft_collection( + collection_id: CollectionId, + collection_type: misc::CollectionType, + ) -> Result, DispatchError> { + Self::ensure_collection_type(collection_id, collection_type)?; + + Self::get_nft_collection(collection_id) + } + pub fn get_nft_property( collection_id: CollectionId, nft_id: TokenId, @@ -560,17 +749,23 @@ ) -> Result { let nft_property = >::token_properties((collection_id, nft_id)) .get(&Self::rmrk_property_key(key)?) - .ok_or(>::NoAvailableNftId)? + .ok_or(>::NoAvailableNftId)? // todo replace with better error .clone(); Ok(nft_property) } + pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool { + >::contains_key((collection_id, nft_id)) + } + pub fn get_nft_type( - _collection_id: CollectionId, - _token_id: TokenId, + collection_id: CollectionId, + token_id: TokenId, ) -> Result { - todo!("should get it from properties?") + Ok(Self::get_nft_property(collection_id, token_id, TokenType)?.decode_or_default()) + // todo throw error + // NftTypeEncodeError? } pub fn ensure_nft_type( @@ -673,15 +868,6 @@ }); Ok(properties) - } - - pub fn get_typed_nft_collection( - collection_id: CollectionId, - collection_type: misc::CollectionType, - ) -> Result, DispatchError> { - Self::ensure_collection_type(collection_id, collection_type)?; - - Self::get_nft_collection(collection_id) } fn map_common_err_to_proxy(err: DispatchError) -> DispatchError { --- a/pallets/proxy-rmrk-core/src/misc.rs +++ b/pallets/proxy-rmrk-core/src/misc.rs @@ -18,6 +18,7 @@ fn decode_or_default(&self) -> T; } +// todo fail if unwrap doesn't work impl RmrkDecode for BoundedVec { fn decode_or_default(&self) -> T { let mut value = self.as_slice(); @@ -30,6 +31,7 @@ fn rebind(&self) -> BoundedVec; } +// todo fail if unwrap doesn't work impl RmrkRebind for BoundedVec where BoundedVec: TryFrom>, @@ -46,11 +48,22 @@ Base, } -#[derive(Encode, Decode, PartialEq, Eq)] +// todo remove default? +#[derive(Encode, Decode, PartialEq, Eq, Default)] pub enum NftType { + #[default] Regular, Resource, FixedPart, SlotPart, Theme, } + +// todo remove default? +#[derive(Encode, Decode, PartialEq, Eq, Default)] +pub enum ResourceType { + #[default] + Basic, + Composable, + Slot, +} --- a/pallets/proxy-rmrk-core/src/property.rs +++ b/pallets/proxy-rmrk-core/src/property.rs @@ -4,6 +4,7 @@ pub enum RmrkProperty<'r> { Metadata, CollectionType, + TokenType, RoyaltyInfo, Equipped, ResourceCollection, @@ -47,6 +48,7 @@ match self { Self::Metadata => key!("metadata"), Self::CollectionType => key!("collection-type"), + Self::TokenType => key!("token-type"), Self::RoyaltyInfo => key!("royalty-info"), Self::Equipped => key!("equipped"), Self::ResourceCollection => key!("resource-collection"), --- a/pallets/proxy-rmrk-equip/src/lib.rs +++ b/pallets/proxy-rmrk-equip/src/lib.rs @@ -166,8 +166,8 @@ &sender, owner, &collection, - NftType::Theme, [ + >::rmrk_property(TokenType, &NftType::Theme)?, >::rmrk_property(ThemeName, &theme.name)?, >::rmrk_property(ThemeInherit, &theme.inherit)?, ] @@ -212,8 +212,8 @@ sender, owner, collection, - nft_type, [ + >::rmrk_property(TokenType, &nft_type)?, >::rmrk_property(Src, &src)?, >::rmrk_property(ZIndex, &z_index)?, ] --- a/primitives/data-structs/src/lib.rs +++ b/primitives/data-structs/src/lib.rs @@ -41,6 +41,7 @@ // RMRK use rmrk::{ CollectionInfo, NftInfo, ResourceInfo, PropertyInfo, BaseInfo, PartType, Theme, ThemeProperty, + ResourceTypes, BasicResource, ComposableResource, SlotResource, }; pub use rmrk::{ primitives::{ @@ -49,8 +50,6 @@ }, NftChild as RmrkNftChild, AccountIdOrCollectionNftTuple as RmrkAccountIdOrCollectionNftTuple, FixedPart as RmrkFixedPart, SlotPart as RmrkSlotPart, EquippableList as RmrkEquippableList, - BasicResource as RmrkBasicResource, ComposableResource as RmrkComposableResource, - SlotResource as RmrkSlotResource, }; mod bounded; @@ -942,23 +941,26 @@ pub type RmrkCollectionInfo = CollectionInfo; pub type RmrkInstanceInfo = NftInfo; -pub type RmrkResourceInfo = ResourceInfo; +pub type RmrkResourceInfo = ResourceInfo; pub type RmrkPropertyInfo = PropertyInfo; pub type RmrkBaseInfo = BaseInfo; pub type RmrkPartType = PartType>; pub type RmrkThemeProperty = ThemeProperty; pub type RmrkTheme = Theme>; +pub type RmrkResourceTypes = ResourceTypes; + +pub type RmrkBasicResource = BasicResource; +pub type RmrkComposableResource = ComposableResource; +pub type RmrkSlotResource = SlotResource; +pub type RmrkString = BoundedVec; pub type RmrkCollectionSymbol = BoundedVec; pub type RmrkKeyString = BoundedVec; pub type RmrkValueString = BoundedVec; - -type RmrkBoundedResource = BoundedVec; -type RmrkBoundedParts = BoundedVec; +pub type RmrkBoundedResource = BoundedVec; +pub type RmrkBoundedParts = BoundedVec; // todo make sure it is needed pub type RmrkRpcString = Vec; pub type RmrkThemeName = RmrkRpcString; pub type RmrkPropertyKey = RmrkRpcString; - -pub type RmrkString = BoundedVec; --- a/primitives/data-structs/src/rmrk.rs +++ b/primitives/data-structs/src/rmrk.rs @@ -282,17 +282,16 @@ #[cfg_attr( feature = "std", serde(bound = r#" - BoundedResource: AsRef<[u8]>, BoundedString: AsRef<[u8]>, BoundedParts: AsRef<[PartId]> "#) )] -pub struct ResourceInfo { +pub struct ResourceInfo { /// id is a 5-character string of reasonable uniqueness. /// The combination of base ID and resource id should be unique across the entire RMRK /// ecosystem which - #[cfg_attr(feature = "std", serde(with = "serialize::vec"))] - pub id: BoundedResource, + //#[cfg_attr(feature = "std", serde(with = "serialize::vec"))] + pub id: ResourceId, /// Resource pub resource: ResourceTypes, --- a/runtime/common/src/runtime_apis.rs +++ b/runtime/common/src/runtime_apis.rs @@ -152,6 +152,7 @@ Err(_) => return Ok(None), }; + // todo replace dispatch... calls with calls to rmrkcore and NFT collection. There's no point trying non-NFT collections let nfts_count = dispatch_unique_runtime!(collection_id.total_supply())?; Ok(Some(RmrkCollectionInfo { @@ -171,6 +172,7 @@ let nft_id = TokenId(nft_by_id); if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); } + // todo replace dispatch with collection let owner = match dispatch_unique_runtime!(collection_id.token_owner(nft_id))? { Some(owner) => match ::CrossTokenAddressMapping::address_to_token(&owner) { Some((col, tok)) => RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(col.0, tok.0), @@ -270,34 +272,51 @@ fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result, DispatchError> { use frame_support::BoundedVec; - use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, RmrkDecode}}; + use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType, RmrkDecode}}; + use pallet_common::CommonCollectionOperations; let collection_id = RmrkCore::unique_collection_id(collection_id)?; - if !RmrkCore::collection_exists(collection_id) { return Ok(Vec::new()); } // todo make sure the collection type doesn't matter + if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); } let nft_id = TokenId(nft_id); - if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Resource).is_err() { return Ok(Vec::new()); } + if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); } - let resource_collection_id: CollectionId = RmrkCore::get_nft_property(collection_id, nft_id, RmrkProperty::ResourceCollection) - .unwrap() + let res_collection_id: CollectionId = RmrkCore::get_nft_property(collection_id, nft_id, RmrkProperty::ResourceCollection)? .decode_or_default(); - if RmrkCore::ensure_collection_type(collection_id, CollectionType::Resource).is_err() { return Ok(Vec::new()); } + let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?; - let resources = pallet_nonfungible::TokenProperties::::iter_prefix((resource_collection_id,)) - .filter_map(|(resource_id, properties)| Some(RmrkResourceInfo { - id: BoundedVec::default(), // todo ResourceId property - pending: RmrkCore::get_nft_property(resource_collection_id, resource_id, RmrkProperty::PendingResourceAccept).unwrap().decode_or_default(), - pending_removal: RmrkCore::get_nft_property(resource_collection_id, resource_id, RmrkProperty::PendingResourceRemoval).unwrap().decode_or_default(), - resource: RmrkCore::get_nft_property(resource_collection_id, resource_id, RmrkProperty::ResourceType).unwrap().decode_or_default(),/* { - RmrkResourceTypes::Basic(resource) => RmrkResourceTypes::Basic(),/*(RmrkBasicResource { - src: RmrkCore::get_nft_property_inner(properties, RmrkProperty::Src).unwrap().decode_or_default(), - metadata: RmrkCore::get_nft_property_inner(properties, RmrkProperty::Metadata).unwrap().decode_or_default(), - license: RmrkCore::get_nft_property_inner(properties, RmrkProperty::License).unwrap().decode_or_default(), - thumb: RmrkCore::get_nft_property_inner(properties, RmrkProperty::Thumb).unwrap().decode_or_default(), - },*///BasicResource) - _ => todo!(), //RmrkResourceTypes::Composable(ComposableResource), - //RmrkResourceTypes::Slot(SlotResource), - },*/ + let resources = resource_collection + .collection_tokens() + .iter() + .filter_map(|(res_id)| Some(RmrkResourceInfo { + id: res_id.0, + pending: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).unwrap().decode_or_default(), + pending_removal: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).unwrap().decode_or_default(), + resource: match RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::ResourceType).unwrap().decode_or_default() { + ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource { + src: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Src).unwrap().decode_or_default(), + metadata: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Metadata).unwrap().decode_or_default(), + license: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::License).unwrap().decode_or_default(), + thumb: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Thumb).unwrap().decode_or_default(), + }), + ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource { + parts: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Parts).unwrap().decode_or_default(), + base: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Base).unwrap().decode_or_default(), + src: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Src).unwrap().decode_or_default(), + metadata: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Metadata).unwrap().decode_or_default(), + license: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::License).unwrap().decode_or_default(), + thumb: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Thumb).unwrap().decode_or_default(), + }), + ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource { + base: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Base).unwrap().decode_or_default(), + src: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Src).unwrap().decode_or_default(), + metadata: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Metadata).unwrap().decode_or_default(), + slot: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Slot).unwrap().decode_or_default(), + license: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::License).unwrap().decode_or_default(), + thumb: RmrkCore::get_nft_property(res_collection_id, *res_id, RmrkProperty::Thumb).unwrap().decode_or_default(), + }), + // todo refactor :| + }, })) .collect(); @@ -308,10 +327,10 @@ use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, RmrkDecode}}; let collection_id = RmrkCore::unique_collection_id(collection_id)?; - if !RmrkCore::collection_exists(collection_id) { return Ok(Vec::new()); } // todo ensure the collection type doesn't matter + if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); } let nft_id = TokenId(nft_id); - if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Resource).is_err() { return Ok(Vec::new()); } + if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); } /*let resource_collection_id: CollectionId = RmrkCore::get_nft_property(collection_id, nft_id, RmrkProperty::ResourceCollection) .unwrap() @@ -327,6 +346,7 @@ .sort_by_key(|(_, index)| *index) .into_iter().map(|(resource_id, _)| resource_id)*/ let priorities = RmrkCore::get_nft_property(collection_id, nft_id, RmrkProperty::ResourcePriorities)?.decode_or_default(); + // todo let it simply be default here after removing default from decode Ok(priorities) } --- a/tests/src/interfaces/augment-api-errors.ts +++ b/tests/src/interfaces/augment-api-errors.ts @@ -437,6 +437,33 @@ **/ [key: string]: AugmentedError; }; + rmrkCore: { + CollectionFullOrLocked: AugmentedError; + CollectionNotEmpty: AugmentedError; + CollectionUnknown: AugmentedError; + CorruptedCollectionType: AugmentedError; + NftTypeEncodeError: AugmentedError; + NoAvailableCollectionId: AugmentedError; + NoAvailableNftId: AugmentedError; + NoPermission: AugmentedError; + RmrkPropertyKeyIsTooLong: AugmentedError; + RmrkPropertyValueIsTooLong: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + rmrkEquip: { + BaseDoesntExist: AugmentedError; + NeedsDefaultThemeFirst: AugmentedError; + NoAvailableBaseId: AugmentedError; + NoAvailablePartId: AugmentedError; + PermissionError: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; structure: { /** * While searched for owner, encountered depth limit --- a/tests/src/interfaces/augment-api-events.ts +++ b/tests/src/interfaces/augment-api-events.ts @@ -396,6 +396,27 @@ **/ [key: string]: AugmentedEvent; }; + rmrkCore: { + CollectionCreated: AugmentedEvent; + CollectionDestroyed: AugmentedEvent; + CollectionLocked: AugmentedEvent; + IssuerChanged: AugmentedEvent; + NFTBurned: AugmentedEvent; + NftMinted: AugmentedEvent; + PropertySet: AugmentedEvent, Bytes, Bytes]>; + ResourceAdded: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + rmrkEquip: { + BaseCreated: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; structure: { /** * Executed call on behalf of token --- a/tests/src/interfaces/augment-api-query.ts +++ b/tests/src/interfaces/augment-api-query.ts @@ -415,6 +415,22 @@ **/ [key: string]: QueryableStorageEntry; }; + rmrkCore: { + collectionIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + collectionIndexMap: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + rmrkEquip: { + baseHasDefaultTheme: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + inernalPartId: AugmentedQuery Observable>, [u32, u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; structure: { /** * Generic query --- a/tests/src/interfaces/augment-api-rpc.ts +++ b/tests/src/interfaces/augment-api-rpc.ts @@ -22,7 +22,7 @@ import type { StorageKind } from '@polkadot/types/interfaces/offchain'; import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment'; import type { RpcMethods } from '@polkadot/types/interfaces/rpc'; -import type { AccountId, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime'; +import type { AccountId, AccountId32, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime'; import type { MigrationStatusResult, ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state'; import type { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo, SyncState } from '@polkadot/types/interfaces/system'; import type { IExtrinsic, Observable } from '@polkadot/types/types'; @@ -397,6 +397,60 @@ **/ queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable>; }; + 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>>; + /** + * Get base info + **/ + base: AugmentedRpc<(baseId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get all Base's parts + **/ + baseParts: AugmentedRpc<(baseId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get collection by id + **/ + collectionById: AugmentedRpc<(id: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get collection properties + **/ + collectionProperties: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, filterKeys?: Vec | (Text | string)[], at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get the latest created collection id + **/ + lastCollectionIdx: AugmentedRpc<(at?: Hash | string | Uint8Array) => Observable>; + /** + * Get NFT by collection id and NFT id + **/ + nftById: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get NFT children + **/ + nftChildren: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get NFT properties + **/ + nftProperties: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, filterKeys?: Vec | (Text | string)[], at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get NFT resource priorities + **/ + nftResourcePriorities: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get NFT resources + **/ + nftResources: AugmentedRpc<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get Base's theme names + **/ + themeNames: AugmentedRpc<(baseId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; + /** + * Get Theme's keys values + **/ + themes: AugmentedRpc<(baseId: u32 | AnyNumber | Uint8Array, themeName: Text | string, keys: Option> | null | object | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable>>; + }; rpc: { /** * Retrieves the list of RPC methods that are exposed by the node --- a/tests/src/interfaces/augment-api-tx.ts +++ b/tests/src/interfaces/augment-api-tx.ts @@ -4,8 +4,8 @@ import type { ApiTypes } from '@polkadot/api-base/types'; import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types-codec'; import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types'; -import type { AccountId32, Call, H160, H256, MultiAddress, Perbill } from '@polkadot/types/interfaces/runtime'; -import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; +import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime'; +import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsRmrkBasicResource, UpDataStructsRmrkComposableResource, UpDataStructsRmrkPartType, UpDataStructsRmrkSlotResource, UpDataStructsRmrkTheme, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; declare module '@polkadot/api-base/types/submittable' { export interface AugmentedSubmittables { @@ -346,6 +346,30 @@ **/ [key: string]: SubmittableExtrinsicFunction; }; + rmrkCore: { + addBasicResource: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: UpDataStructsRmrkBasicResource | { src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, u32, UpDataStructsRmrkBasicResource]>; + addComposableResource: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: Bytes | string | Uint8Array, resource: UpDataStructsRmrkComposableResource | { parts?: any; base?: any; src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, u32, Bytes, UpDataStructsRmrkComposableResource]>; + addSlotResource: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: UpDataStructsRmrkSlotResource | { base?: any; src?: any; metadata?: any; slot?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, u32, UpDataStructsRmrkSlotResource]>; + burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, MultiAddress]>; + createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option | null | object | string | Uint8Array, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes, Option, Bytes]>; + destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + mintNft: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option | null | object | string | Uint8Array, royaltyAmount: Option | null | object | string | Uint8Array, metadata: Bytes | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32, Option, Option, Bytes]>; + setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact | AnyNumber | Uint8Array, maybeNftId: Option | null | object | string | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Compact, Option, Bytes, Bytes]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + rmrkEquip: { + createBase: AugmentedSubmittable<(baseType: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, parts: Vec | (UpDataStructsRmrkPartType | { FixedPart: any } | { SlotPart: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Bytes, Bytes, Vec]>; + themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: UpDataStructsRmrkTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, UpDataStructsRmrkTheme]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; structure: { /** * Generic tx --- a/tests/src/interfaces/augment-types.ts +++ b/tests/src/interfaces/augment-types.ts @@ -788,6 +788,12 @@ PalletNonfungibleItemData: PalletNonfungibleItemData; PalletRefungibleError: PalletRefungibleError; PalletRefungibleItemData: PalletRefungibleItemData; + PalletRmrkCoreCall: PalletRmrkCoreCall; + PalletRmrkCoreError: PalletRmrkCoreError; + PalletRmrkCoreEvent: PalletRmrkCoreEvent; + PalletRmrkEquipCall: PalletRmrkEquipCall; + PalletRmrkEquipError: PalletRmrkEquipError; + PalletRmrkEquipEvent: PalletRmrkEquipEvent; PalletsOrigin: PalletsOrigin; PalletStorageMetadataLatest: PalletStorageMetadataLatest; PalletStorageMetadataV14: PalletStorageMetadataV14; --- a/tests/src/interfaces/default/types.ts +++ b/tests/src/interfaces/default/types.ts @@ -1129,6 +1129,169 @@ readonly constData: Bytes; } +/** @name PalletRmrkCoreCall */ +export interface PalletRmrkCoreCall extends Enum { + readonly isCreateCollection: boolean; + readonly asCreateCollection: { + readonly metadata: Bytes; + readonly max: Option; + readonly symbol: Bytes; + } & Struct; + readonly isDestroyCollection: boolean; + readonly asDestroyCollection: { + readonly collectionId: u32; + } & Struct; + readonly isChangeCollectionIssuer: boolean; + readonly asChangeCollectionIssuer: { + readonly collectionId: u32; + readonly newIssuer: MultiAddress; + } & Struct; + readonly isLockCollection: boolean; + readonly asLockCollection: { + readonly collectionId: u32; + } & Struct; + readonly isMintNft: boolean; + readonly asMintNft: { + readonly owner: AccountId32; + readonly collectionId: u32; + readonly recipient: Option; + readonly royaltyAmount: Option; + readonly metadata: Bytes; + } & Struct; + readonly isBurnNft: boolean; + readonly asBurnNft: { + readonly collectionId: u32; + readonly nftId: u32; + } & Struct; + readonly isSetProperty: boolean; + readonly asSetProperty: { + readonly rmrkCollectionId: Compact; + readonly maybeNftId: Option; + readonly key: Bytes; + readonly value: Bytes; + } & Struct; + readonly isAddBasicResource: boolean; + readonly asAddBasicResource: { + readonly collectionId: u32; + readonly nftId: u32; + readonly resource: UpDataStructsRmrkBasicResource; + } & Struct; + readonly isAddComposableResource: boolean; + readonly asAddComposableResource: { + readonly collectionId: u32; + readonly nftId: u32; + readonly resourceId: Bytes; + readonly resource: UpDataStructsRmrkComposableResource; + } & Struct; + readonly isAddSlotResource: boolean; + readonly asAddSlotResource: { + readonly collectionId: u32; + readonly nftId: u32; + readonly resource: UpDataStructsRmrkSlotResource; + } & Struct; + readonly type: 'CreateCollection' | 'DestroyCollection' | 'ChangeCollectionIssuer' | 'LockCollection' | 'MintNft' | 'BurnNft' | 'SetProperty' | 'AddBasicResource' | 'AddComposableResource' | 'AddSlotResource'; +} + +/** @name PalletRmrkCoreError */ +export interface PalletRmrkCoreError extends Enum { + readonly isCorruptedCollectionType: boolean; + readonly isNftTypeEncodeError: boolean; + readonly isRmrkPropertyKeyIsTooLong: boolean; + readonly isRmrkPropertyValueIsTooLong: boolean; + readonly isCollectionNotEmpty: boolean; + readonly isNoAvailableCollectionId: boolean; + readonly isNoAvailableNftId: boolean; + readonly isCollectionUnknown: boolean; + readonly isNoPermission: boolean; + readonly isCollectionFullOrLocked: boolean; + readonly type: 'CorruptedCollectionType' | 'NftTypeEncodeError' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'CollectionFullOrLocked'; +} + +/** @name PalletRmrkCoreEvent */ +export interface PalletRmrkCoreEvent extends Enum { + readonly isCollectionCreated: boolean; + readonly asCollectionCreated: { + readonly issuer: AccountId32; + readonly collectionId: u32; + } & Struct; + readonly isCollectionDestroyed: boolean; + readonly asCollectionDestroyed: { + readonly issuer: AccountId32; + readonly collectionId: u32; + } & Struct; + readonly isIssuerChanged: boolean; + readonly asIssuerChanged: { + readonly oldIssuer: AccountId32; + readonly newIssuer: AccountId32; + readonly collectionId: u32; + } & Struct; + readonly isCollectionLocked: boolean; + readonly asCollectionLocked: { + readonly issuer: AccountId32; + readonly collectionId: u32; + } & Struct; + readonly isNftMinted: boolean; + readonly asNftMinted: { + readonly owner: AccountId32; + readonly collectionId: u32; + readonly nftId: u32; + } & Struct; + readonly isNftBurned: boolean; + readonly asNftBurned: { + readonly owner: AccountId32; + readonly nftId: u32; + } & Struct; + readonly isPropertySet: boolean; + readonly asPropertySet: { + readonly collectionId: u32; + readonly maybeNftId: Option; + readonly key: Bytes; + readonly value: Bytes; + } & Struct; + readonly isResourceAdded: boolean; + readonly asResourceAdded: { + readonly nftId: u32; + readonly resourceId: u32; + } & Struct; + readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'IssuerChanged' | 'CollectionLocked' | 'NftMinted' | 'NftBurned' | 'PropertySet' | 'ResourceAdded'; +} + +/** @name PalletRmrkEquipCall */ +export interface PalletRmrkEquipCall extends Enum { + readonly isCreateBase: boolean; + readonly asCreateBase: { + readonly baseType: Bytes; + readonly symbol: Bytes; + readonly parts: Vec; + } & Struct; + readonly isThemeAdd: boolean; + readonly asThemeAdd: { + readonly baseId: u32; + readonly theme: UpDataStructsRmrkTheme; + } & Struct; + readonly type: 'CreateBase' | 'ThemeAdd'; +} + +/** @name PalletRmrkEquipError */ +export interface PalletRmrkEquipError extends Enum { + readonly isPermissionError: boolean; + readonly isNoAvailableBaseId: boolean; + readonly isNoAvailablePartId: boolean; + readonly isBaseDoesntExist: boolean; + readonly isNeedsDefaultThemeFirst: boolean; + readonly type: 'PermissionError' | 'NoAvailableBaseId' | 'NoAvailablePartId' | 'BaseDoesntExist' | 'NeedsDefaultThemeFirst'; +} + +/** @name PalletRmrkEquipEvent */ +export interface PalletRmrkEquipEvent extends Enum { + readonly isBaseCreated: boolean; + readonly asBaseCreated: { + readonly issuer: AccountId32; + readonly baseId: u32; + } & Struct; + readonly type: 'BaseCreated'; +} + /** @name PalletStructureCall */ export interface PalletStructureCall extends Null {} @@ -2014,7 +2177,7 @@ /** @name UpDataStructsRmrkResourceInfo */ export interface UpDataStructsRmrkResourceInfo extends Struct { - readonly id: Bytes; + readonly id: u32; readonly resource: UpDataStructsRmrkResourceTypes; readonly pending: bool; readonly pendingRemoval: bool; --- a/tests/src/interfaces/lookup.ts +++ b/tests/src/interfaces/lookup.ts @@ -1528,8 +1528,161 @@ **/ PalletStructureCall: 'Null', /** - * Lookup206: pallet_evm::pallet::Call + * Lookup206: pallet_rmrk_core::pallet::Call + **/ + PalletRmrkCoreCall: { + _enum: { + create_collection: { + metadata: 'Bytes', + max: 'Option', + symbol: 'Bytes', + }, + destroy_collection: { + collectionId: 'u32', + }, + change_collection_issuer: { + collectionId: 'u32', + newIssuer: 'MultiAddress', + }, + lock_collection: { + collectionId: 'u32', + }, + mint_nft: { + owner: 'AccountId32', + collectionId: 'u32', + recipient: 'Option', + royaltyAmount: 'Option', + metadata: 'Bytes', + }, + burn_nft: { + collectionId: 'u32', + nftId: 'u32', + }, + set_property: { + rmrkCollectionId: 'Compact', + maybeNftId: 'Option', + key: 'Bytes', + value: 'Bytes', + }, + add_basic_resource: { + collectionId: 'u32', + nftId: 'u32', + resource: 'UpDataStructsRmrkBasicResource', + }, + add_composable_resource: { + collectionId: 'u32', + nftId: 'u32', + resourceId: 'Bytes', + resource: 'UpDataStructsRmrkComposableResource', + }, + add_slot_resource: { + collectionId: 'u32', + nftId: 'u32', + resource: 'UpDataStructsRmrkSlotResource' + } + } + }, + /** + * Lookup212: up_data_structs::rmrk::BasicResource> + **/ + UpDataStructsRmrkBasicResource: { + src: 'Option', + metadata: 'Option', + license: 'Option', + thumb: 'Option' + }, + /** + * Lookup215: up_data_structs::rmrk::ComposableResource, frame_support::storage::bounded_vec::BoundedVec> + **/ + UpDataStructsRmrkComposableResource: { + parts: 'Vec', + base: 'u32', + src: 'Option', + metadata: 'Option', + license: 'Option', + thumb: 'Option' + }, + /** + * Lookup217: up_data_structs::rmrk::SlotResource> + **/ + UpDataStructsRmrkSlotResource: { + base: 'u32', + src: 'Option', + metadata: 'Option', + slot: 'u32', + license: 'Option', + thumb: 'Option' + }, + /** + * Lookup218: pallet_rmrk_equip::pallet::Call + **/ + PalletRmrkEquipCall: { + _enum: { + create_base: { + baseType: 'Bytes', + symbol: 'Bytes', + parts: 'Vec', + }, + theme_add: { + baseId: 'u32', + theme: 'UpDataStructsRmrkTheme' + } + } + }, + /** + * Lookup220: up_data_structs::rmrk::PartType, frame_support::storage::bounded_vec::BoundedVec> **/ + UpDataStructsRmrkPartType: { + _enum: { + FixedPart: 'UpDataStructsRmrkFixedPart', + SlotPart: 'UpDataStructsRmrkSlotPart' + } + }, + /** + * Lookup222: up_data_structs::rmrk::FixedPart> + **/ + UpDataStructsRmrkFixedPart: { + id: 'u32', + z: 'u32', + src: 'Bytes' + }, + /** + * Lookup223: up_data_structs::rmrk::SlotPart, frame_support::storage::bounded_vec::BoundedVec> + **/ + UpDataStructsRmrkSlotPart: { + id: 'u32', + equippable: 'UpDataStructsRmrkEquippableList', + src: 'Bytes', + z: 'u32' + }, + /** + * Lookup224: up_data_structs::rmrk::EquippableList> + **/ + UpDataStructsRmrkEquippableList: { + _enum: { + All: 'Null', + Empty: 'Null', + Custom: 'Vec' + } + }, + /** + * Lookup226: up_data_structs::rmrk::Theme, PropertyList> + **/ + UpDataStructsRmrkTheme: { + name: 'Bytes', + properties: 'Vec', + inherit: 'bool' + }, + /** + * Lookup228: up_data_structs::rmrk::ThemeProperty> + **/ + UpDataStructsRmrkThemeProperty: { + key: 'Bytes', + value: 'Bytes' + }, + /** + * Lookup229: pallet_evm::pallet::Call + **/ PalletEvmCall: { _enum: { withdraw: { @@ -1571,7 +1724,7 @@ } }, /** - * Lookup212: pallet_ethereum::pallet::Call + * Lookup235: pallet_ethereum::pallet::Call **/ PalletEthereumCall: { _enum: { @@ -1581,7 +1734,7 @@ } }, /** - * Lookup213: ethereum::transaction::TransactionV2 + * Lookup236: ethereum::transaction::TransactionV2 **/ EthereumTransactionTransactionV2: { _enum: { @@ -1591,7 +1744,7 @@ } }, /** - * Lookup214: ethereum::transaction::LegacyTransaction + * Lookup237: ethereum::transaction::LegacyTransaction **/ EthereumTransactionLegacyTransaction: { nonce: 'U256', @@ -1603,7 +1756,7 @@ signature: 'EthereumTransactionTransactionSignature' }, /** - * Lookup215: ethereum::transaction::TransactionAction + * Lookup238: ethereum::transaction::TransactionAction **/ EthereumTransactionTransactionAction: { _enum: { @@ -1612,7 +1765,7 @@ } }, /** - * Lookup216: ethereum::transaction::TransactionSignature + * Lookup239: ethereum::transaction::TransactionSignature **/ EthereumTransactionTransactionSignature: { v: 'u64', @@ -1620,7 +1773,7 @@ s: 'H256' }, /** - * Lookup218: ethereum::transaction::EIP2930Transaction + * Lookup241: ethereum::transaction::EIP2930Transaction **/ EthereumTransactionEip2930Transaction: { chainId: 'u64', @@ -1636,14 +1789,14 @@ s: 'H256' }, /** - * Lookup220: ethereum::transaction::AccessListItem + * Lookup243: ethereum::transaction::AccessListItem **/ EthereumTransactionAccessListItem: { address: 'H160', storageKeys: 'Vec' }, /** - * Lookup221: ethereum::transaction::EIP1559Transaction + * Lookup244: ethereum::transaction::EIP1559Transaction **/ EthereumTransactionEip1559Transaction: { chainId: 'u64', @@ -1660,7 +1813,7 @@ s: 'H256' }, /** - * Lookup222: pallet_evm_migration::pallet::Call + * Lookup245: pallet_evm_migration::pallet::Call **/ PalletEvmMigrationCall: { _enum: { @@ -1678,7 +1831,7 @@ } }, /** - * Lookup225: pallet_sudo::pallet::Event + * Lookup248: pallet_sudo::pallet::Event **/ PalletSudoEvent: { _enum: { @@ -1694,7 +1847,7 @@ } }, /** - * Lookup227: sp_runtime::DispatchError + * Lookup250: sp_runtime::DispatchError **/ SpRuntimeDispatchError: { _enum: { @@ -1711,38 +1864,38 @@ } }, /** - * Lookup228: sp_runtime::ModuleError + * Lookup251: sp_runtime::ModuleError **/ SpRuntimeModuleError: { index: 'u8', error: '[u8;4]' }, /** - * Lookup229: sp_runtime::TokenError + * Lookup252: sp_runtime::TokenError **/ SpRuntimeTokenError: { _enum: ['NoFunds', 'WouldDie', 'BelowMinimum', 'CannotCreate', 'UnknownAsset', 'Frozen', 'Unsupported'] }, /** - * Lookup230: sp_runtime::ArithmeticError + * Lookup253: sp_runtime::ArithmeticError **/ SpRuntimeArithmeticError: { _enum: ['Underflow', 'Overflow', 'DivisionByZero'] }, /** - * Lookup231: sp_runtime::TransactionalError + * Lookup254: sp_runtime::TransactionalError **/ SpRuntimeTransactionalError: { _enum: ['LimitReached', 'NoLayer'] }, /** - * Lookup232: pallet_sudo::pallet::Error + * Lookup255: pallet_sudo::pallet::Error **/ PalletSudoError: { _enum: ['RequireSudo'] }, /** - * Lookup233: frame_system::AccountInfo> + * Lookup256: frame_system::AccountInfo> **/ FrameSystemAccountInfo: { nonce: 'u32', @@ -1752,7 +1905,7 @@ data: 'PalletBalancesAccountData' }, /** - * Lookup234: frame_support::weights::PerDispatchClass + * Lookup257: frame_support::weights::PerDispatchClass **/ FrameSupportWeightsPerDispatchClassU64: { normal: 'u64', @@ -1760,13 +1913,13 @@ mandatory: 'u64' }, /** - * Lookup235: sp_runtime::generic::digest::Digest + * Lookup258: sp_runtime::generic::digest::Digest **/ SpRuntimeDigest: { logs: 'Vec' }, /** - * Lookup237: sp_runtime::generic::digest::DigestItem + * Lookup260: sp_runtime::generic::digest::DigestItem **/ SpRuntimeDigestDigestItem: { _enum: { @@ -1782,7 +1935,7 @@ } }, /** - * Lookup239: frame_system::EventRecord + * Lookup262: frame_system::EventRecord **/ FrameSystemEventRecord: { phase: 'FrameSystemPhase', @@ -1790,7 +1943,7 @@ topics: 'Vec' }, /** - * Lookup241: frame_system::pallet::Event + * Lookup264: frame_system::pallet::Event **/ FrameSystemEvent: { _enum: { @@ -1818,7 +1971,7 @@ } }, /** - * Lookup242: frame_support::weights::DispatchInfo + * Lookup265: frame_support::weights::DispatchInfo **/ FrameSupportWeightsDispatchInfo: { weight: 'u64', @@ -1826,19 +1979,19 @@ paysFee: 'FrameSupportWeightsPays' }, /** - * Lookup243: frame_support::weights::DispatchClass + * Lookup266: frame_support::weights::DispatchClass **/ FrameSupportWeightsDispatchClass: { _enum: ['Normal', 'Operational', 'Mandatory'] }, /** - * Lookup244: frame_support::weights::Pays + * Lookup267: frame_support::weights::Pays **/ FrameSupportWeightsPays: { _enum: ['Yes', 'No'] }, /** - * Lookup245: orml_vesting::module::Event + * Lookup268: orml_vesting::module::Event **/ OrmlVestingModuleEvent: { _enum: { @@ -1857,7 +2010,7 @@ } }, /** - * Lookup246: cumulus_pallet_xcmp_queue::pallet::Event + * Lookup269: cumulus_pallet_xcmp_queue::pallet::Event **/ CumulusPalletXcmpQueueEvent: { _enum: { @@ -1872,7 +2025,7 @@ } }, /** - * Lookup247: pallet_xcm::pallet::Event + * Lookup270: pallet_xcm::pallet::Event **/ PalletXcmEvent: { _enum: { @@ -1895,7 +2048,7 @@ } }, /** - * Lookup248: xcm::v2::traits::Outcome + * Lookup271: xcm::v2::traits::Outcome **/ XcmV2TraitsOutcome: { _enum: { @@ -1905,7 +2058,7 @@ } }, /** - * Lookup250: cumulus_pallet_xcm::pallet::Event + * Lookup273: cumulus_pallet_xcm::pallet::Event **/ CumulusPalletXcmEvent: { _enum: { @@ -1915,7 +2068,7 @@ } }, /** - * Lookup251: cumulus_pallet_dmp_queue::pallet::Event + * Lookup274: cumulus_pallet_dmp_queue::pallet::Event **/ CumulusPalletDmpQueueEvent: { _enum: { @@ -1928,7 +2081,7 @@ } }, /** - * Lookup252: pallet_unique::RawEvent> + * Lookup275: pallet_unique::RawEvent> **/ PalletUniqueRawEvent: { _enum: { @@ -1945,7 +2098,7 @@ } }, /** - * Lookup253: pallet_common::pallet::Event + * Lookup276: pallet_common::pallet::Event **/ PalletCommonEvent: { _enum: { @@ -1963,7 +2116,7 @@ } }, /** - * Lookup254: pallet_structure::pallet::Event + * Lookup277: pallet_structure::pallet::Event **/ PalletStructureEvent: { _enum: { @@ -1971,8 +2124,62 @@ } }, /** - * Lookup255: pallet_evm::pallet::Event + * Lookup278: pallet_rmrk_core::pallet::Event **/ + PalletRmrkCoreEvent: { + _enum: { + CollectionCreated: { + issuer: 'AccountId32', + collectionId: 'u32', + }, + CollectionDestroyed: { + issuer: 'AccountId32', + collectionId: 'u32', + }, + IssuerChanged: { + oldIssuer: 'AccountId32', + newIssuer: 'AccountId32', + collectionId: 'u32', + }, + CollectionLocked: { + issuer: 'AccountId32', + collectionId: 'u32', + }, + NftMinted: { + owner: 'AccountId32', + collectionId: 'u32', + nftId: 'u32', + }, + NFTBurned: { + owner: 'AccountId32', + nftId: 'u32', + }, + PropertySet: { + collectionId: 'u32', + maybeNftId: 'Option', + key: 'Bytes', + value: 'Bytes', + }, + ResourceAdded: { + nftId: 'u32', + resourceId: 'u32' + } + } + }, + /** + * Lookup279: pallet_rmrk_equip::pallet::Event + **/ + PalletRmrkEquipEvent: { + _enum: { + BaseCreated: { + issuer: 'AccountId32', + baseId: 'u32' + } + } + }, + /** + * Lookup280: pallet_evm::pallet::Event + **/ PalletEvmEvent: { _enum: { Log: 'EthereumLog', @@ -1985,7 +2192,7 @@ } }, /** - * Lookup256: ethereum::log::Log + * Lookup281: ethereum::log::Log **/ EthereumLog: { address: 'H160', @@ -1993,7 +2200,7 @@ data: 'Bytes' }, /** - * Lookup257: pallet_ethereum::pallet::Event + * Lookup282: pallet_ethereum::pallet::Event **/ PalletEthereumEvent: { _enum: { @@ -2001,7 +2208,7 @@ } }, /** - * Lookup258: evm_core::error::ExitReason + * Lookup283: evm_core::error::ExitReason **/ EvmCoreErrorExitReason: { _enum: { @@ -2012,13 +2219,13 @@ } }, /** - * Lookup259: evm_core::error::ExitSucceed + * Lookup284: evm_core::error::ExitSucceed **/ EvmCoreErrorExitSucceed: { _enum: ['Stopped', 'Returned', 'Suicided'] }, /** - * Lookup260: evm_core::error::ExitError + * Lookup285: evm_core::error::ExitError **/ EvmCoreErrorExitError: { _enum: { @@ -2040,13 +2247,13 @@ } }, /** - * Lookup263: evm_core::error::ExitRevert + * Lookup288: evm_core::error::ExitRevert **/ EvmCoreErrorExitRevert: { _enum: ['Reverted'] }, /** - * Lookup264: evm_core::error::ExitFatal + * Lookup289: evm_core::error::ExitFatal **/ EvmCoreErrorExitFatal: { _enum: { @@ -2057,7 +2264,7 @@ } }, /** - * Lookup265: frame_system::Phase + * Lookup290: frame_system::Phase **/ FrameSystemPhase: { _enum: { @@ -2067,14 +2274,14 @@ } }, /** - * Lookup267: frame_system::LastRuntimeUpgradeInfo + * Lookup292: frame_system::LastRuntimeUpgradeInfo **/ FrameSystemLastRuntimeUpgradeInfo: { specVersion: 'Compact', specName: 'Text' }, /** - * Lookup268: frame_system::limits::BlockWeights + * Lookup293: frame_system::limits::BlockWeights **/ FrameSystemLimitsBlockWeights: { baseBlock: 'u64', @@ -2082,7 +2289,7 @@ perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass' }, /** - * Lookup269: frame_support::weights::PerDispatchClass + * Lookup294: frame_support::weights::PerDispatchClass **/ FrameSupportWeightsPerDispatchClassWeightsPerClass: { normal: 'FrameSystemLimitsWeightsPerClass', @@ -2090,7 +2297,7 @@ mandatory: 'FrameSystemLimitsWeightsPerClass' }, /** - * Lookup270: frame_system::limits::WeightsPerClass + * Lookup295: frame_system::limits::WeightsPerClass **/ FrameSystemLimitsWeightsPerClass: { baseExtrinsic: 'u64', @@ -2099,13 +2306,13 @@ reserved: 'Option' }, /** - * Lookup272: frame_system::limits::BlockLength + * Lookup297: frame_system::limits::BlockLength **/ FrameSystemLimitsBlockLength: { max: 'FrameSupportWeightsPerDispatchClassU32' }, /** - * Lookup273: frame_support::weights::PerDispatchClass + * Lookup298: frame_support::weights::PerDispatchClass **/ FrameSupportWeightsPerDispatchClassU32: { normal: 'u32', @@ -2113,14 +2320,14 @@ mandatory: 'u32' }, /** - * Lookup274: frame_support::weights::RuntimeDbWeight + * Lookup299: frame_support::weights::RuntimeDbWeight **/ FrameSupportWeightsRuntimeDbWeight: { read: 'u64', write: 'u64' }, /** - * Lookup275: sp_version::RuntimeVersion + * Lookup300: sp_version::RuntimeVersion **/ SpVersionRuntimeVersion: { specName: 'Text', @@ -2133,19 +2340,19 @@ stateVersion: 'u8' }, /** - * Lookup279: frame_system::pallet::Error + * Lookup304: frame_system::pallet::Error **/ FrameSystemError: { _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered'] }, /** - * Lookup281: orml_vesting::module::Error + * Lookup306: orml_vesting::module::Error **/ OrmlVestingModuleError: { _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded'] }, /** - * Lookup283: cumulus_pallet_xcmp_queue::InboundChannelDetails + * Lookup308: cumulus_pallet_xcmp_queue::InboundChannelDetails **/ CumulusPalletXcmpQueueInboundChannelDetails: { sender: 'u32', @@ -2153,19 +2360,19 @@ messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>' }, /** - * Lookup284: cumulus_pallet_xcmp_queue::InboundState + * Lookup309: cumulus_pallet_xcmp_queue::InboundState **/ CumulusPalletXcmpQueueInboundState: { _enum: ['Ok', 'Suspended'] }, /** - * Lookup287: polkadot_parachain::primitives::XcmpMessageFormat + * Lookup312: polkadot_parachain::primitives::XcmpMessageFormat **/ PolkadotParachainPrimitivesXcmpMessageFormat: { _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals'] }, /** - * Lookup290: cumulus_pallet_xcmp_queue::OutboundChannelDetails + * Lookup315: cumulus_pallet_xcmp_queue::OutboundChannelDetails **/ CumulusPalletXcmpQueueOutboundChannelDetails: { recipient: 'u32', @@ -2175,13 +2382,13 @@ lastIndex: 'u16' }, /** - * Lookup291: cumulus_pallet_xcmp_queue::OutboundState + * Lookup316: cumulus_pallet_xcmp_queue::OutboundState **/ CumulusPalletXcmpQueueOutboundState: { _enum: ['Ok', 'Suspended'] }, /** - * Lookup293: cumulus_pallet_xcmp_queue::QueueConfigData + * Lookup318: cumulus_pallet_xcmp_queue::QueueConfigData **/ CumulusPalletXcmpQueueQueueConfigData: { suspendThreshold: 'u32', @@ -2192,29 +2399,29 @@ xcmpMaxIndividualWeight: 'u64' }, /** - * Lookup295: cumulus_pallet_xcmp_queue::pallet::Error + * Lookup320: cumulus_pallet_xcmp_queue::pallet::Error **/ CumulusPalletXcmpQueueError: { _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit'] }, /** - * Lookup296: pallet_xcm::pallet::Error + * Lookup321: pallet_xcm::pallet::Error **/ PalletXcmError: { _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed'] }, /** - * Lookup297: cumulus_pallet_xcm::pallet::Error + * Lookup322: cumulus_pallet_xcm::pallet::Error **/ CumulusPalletXcmError: 'Null', /** - * Lookup298: cumulus_pallet_dmp_queue::ConfigData + * Lookup323: cumulus_pallet_dmp_queue::ConfigData **/ CumulusPalletDmpQueueConfigData: { maxIndividual: 'u64' }, /** - * Lookup299: cumulus_pallet_dmp_queue::PageIndexData + * Lookup324: cumulus_pallet_dmp_queue::PageIndexData **/ CumulusPalletDmpQueuePageIndexData: { beginUsed: 'u32', @@ -2222,19 +2429,19 @@ overweightCount: 'u64' }, /** - * Lookup302: cumulus_pallet_dmp_queue::pallet::Error + * Lookup327: cumulus_pallet_dmp_queue::pallet::Error **/ CumulusPalletDmpQueueError: { _enum: ['Unknown', 'OverLimit'] }, /** - * Lookup306: pallet_unique::Error + * Lookup331: pallet_unique::Error **/ PalletUniqueError: { _enum: ['CollectionDecimalPointLimitExceeded', 'ConfirmUnsetSponsorFail', 'EmptyArgument'] }, /** - * Lookup307: up_data_structs::Collection + * Lookup332: up_data_structs::Collection **/ UpDataStructsCollection: { owner: 'AccountId32', @@ -2247,7 +2454,7 @@ permissions: 'UpDataStructsCollectionPermissions' }, /** - * Lookup308: up_data_structs::SponsorshipState + * Lookup333: up_data_structs::SponsorshipState **/ UpDataStructsSponsorshipState: { _enum: { @@ -2257,7 +2464,7 @@ } }, /** - * Lookup309: up_data_structs::Properties + * Lookup334: up_data_structs::Properties **/ UpDataStructsProperties: { map: 'UpDataStructsPropertiesMapBoundedVec', @@ -2265,15 +2472,15 @@ spaceLimit: 'u32' }, /** - * Lookup310: up_data_structs::PropertiesMap> + * Lookup335: up_data_structs::PropertiesMap> **/ UpDataStructsPropertiesMapBoundedVec: 'BTreeMap', /** - * Lookup315: up_data_structs::PropertiesMap + * Lookup340: up_data_structs::PropertiesMap **/ UpDataStructsPropertiesMapPropertyPermission: 'BTreeMap', /** - * Lookup322: up_data_structs::CollectionStats + * Lookup347: up_data_structs::CollectionStats **/ UpDataStructsCollectionStats: { created: 'u32', @@ -2353,7 +2560,7 @@ * Lookup336: up_data_structs::rmrk::ResourceInfo, frame_support::storage::bounded_vec::BoundedVec, frame_support::storage::bounded_vec::BoundedVec> **/ UpDataStructsRmrkResourceInfo: { - id: 'Bytes', + id: 'u32', resource: 'UpDataStructsRmrkResourceTypes', pending: 'bool', pendingRemoval: 'bool' --- a/tests/src/interfaces/registry.ts +++ b/tests/src/interfaces/registry.ts @@ -104,6 +104,12 @@ PalletNonfungibleItemData: PalletNonfungibleItemData; PalletRefungibleError: PalletRefungibleError; PalletRefungibleItemData: PalletRefungibleItemData; + PalletRmrkCoreCall: PalletRmrkCoreCall; + PalletRmrkCoreError: PalletRmrkCoreError; + PalletRmrkCoreEvent: PalletRmrkCoreEvent; + PalletRmrkEquipCall: PalletRmrkEquipCall; + PalletRmrkEquipError: PalletRmrkEquipError; + PalletRmrkEquipEvent: PalletRmrkEquipEvent; PalletStructureCall: PalletStructureCall; PalletStructureError: PalletStructureError; PalletStructureEvent: PalletStructureEvent; --- a/tests/src/interfaces/rmrk/definitions.ts +++ b/tests/src/interfaces/rmrk/definitions.ts @@ -58,7 +58,10 @@ ), collectionProperties: fn( 'Get collection properties', - [{name: 'collectionId', type: 'u32'}], + [ + {name: 'collectionId', type: 'u32'}, + {name: 'filterKeys', type: 'Vec', isOptional: true}, + ], 'Vec', ), nftProperties: fn( @@ -66,6 +69,7 @@ [ {name: 'collectionId', type: 'u32'}, {name: 'nftId', type: 'u32'}, + {name: 'filterKeys', type: 'Vec', isOptional: true}, ], 'Vec', ), --- a/tests/src/interfaces/types-lookup.ts +++ b/tests/src/interfaces/types-lookup.ts @@ -1649,7 +1649,160 @@ /** @name PalletStructureCall (205) */ export type PalletStructureCall = Null; - /** @name PalletEvmCall (206) */ + /** @name PalletRmrkCoreCall (206) */ + export interface PalletRmrkCoreCall extends Enum { + readonly isCreateCollection: boolean; + readonly asCreateCollection: { + readonly metadata: Bytes; + readonly max: Option; + readonly symbol: Bytes; + } & Struct; + readonly isDestroyCollection: boolean; + readonly asDestroyCollection: { + readonly collectionId: u32; + } & Struct; + readonly isChangeCollectionIssuer: boolean; + readonly asChangeCollectionIssuer: { + readonly collectionId: u32; + readonly newIssuer: MultiAddress; + } & Struct; + readonly isLockCollection: boolean; + readonly asLockCollection: { + readonly collectionId: u32; + } & Struct; + readonly isMintNft: boolean; + readonly asMintNft: { + readonly owner: AccountId32; + readonly collectionId: u32; + readonly recipient: Option; + readonly royaltyAmount: Option; + readonly metadata: Bytes; + } & Struct; + readonly isBurnNft: boolean; + readonly asBurnNft: { + readonly collectionId: u32; + readonly nftId: u32; + } & Struct; + readonly isSetProperty: boolean; + readonly asSetProperty: { + readonly rmrkCollectionId: Compact; + readonly maybeNftId: Option; + readonly key: Bytes; + readonly value: Bytes; + } & Struct; + readonly isAddBasicResource: boolean; + readonly asAddBasicResource: { + readonly collectionId: u32; + readonly nftId: u32; + readonly resource: UpDataStructsRmrkBasicResource; + } & Struct; + readonly isAddComposableResource: boolean; + readonly asAddComposableResource: { + readonly collectionId: u32; + readonly nftId: u32; + readonly resourceId: Bytes; + readonly resource: UpDataStructsRmrkComposableResource; + } & Struct; + readonly isAddSlotResource: boolean; + readonly asAddSlotResource: { + readonly collectionId: u32; + readonly nftId: u32; + readonly resource: UpDataStructsRmrkSlotResource; + } & Struct; + readonly type: 'CreateCollection' | 'DestroyCollection' | 'ChangeCollectionIssuer' | 'LockCollection' | 'MintNft' | 'BurnNft' | 'SetProperty' | 'AddBasicResource' | 'AddComposableResource' | 'AddSlotResource'; + } + + /** @name UpDataStructsRmrkBasicResource (212) */ + export interface UpDataStructsRmrkBasicResource extends Struct { + readonly src: Option; + readonly metadata: Option; + readonly license: Option; + readonly thumb: Option; + } + + /** @name UpDataStructsRmrkComposableResource (215) */ + export interface UpDataStructsRmrkComposableResource extends Struct { + readonly parts: Vec; + readonly base: u32; + readonly src: Option; + readonly metadata: Option; + readonly license: Option; + readonly thumb: Option; + } + + /** @name UpDataStructsRmrkSlotResource (217) */ + export interface UpDataStructsRmrkSlotResource extends Struct { + readonly base: u32; + readonly src: Option; + readonly metadata: Option; + readonly slot: u32; + readonly license: Option; + readonly thumb: Option; + } + + /** @name PalletRmrkEquipCall (218) */ + export interface PalletRmrkEquipCall extends Enum { + readonly isCreateBase: boolean; + readonly asCreateBase: { + readonly baseType: Bytes; + readonly symbol: Bytes; + readonly parts: Vec; + } & Struct; + readonly isThemeAdd: boolean; + readonly asThemeAdd: { + readonly baseId: u32; + readonly theme: UpDataStructsRmrkTheme; + } & Struct; + readonly type: 'CreateBase' | 'ThemeAdd'; + } + + /** @name UpDataStructsRmrkPartType (220) */ + export interface UpDataStructsRmrkPartType extends Enum { + readonly isFixedPart: boolean; + readonly asFixedPart: UpDataStructsRmrkFixedPart; + readonly isSlotPart: boolean; + readonly asSlotPart: UpDataStructsRmrkSlotPart; + readonly type: 'FixedPart' | 'SlotPart'; + } + + /** @name UpDataStructsRmrkFixedPart (222) */ + export interface UpDataStructsRmrkFixedPart extends Struct { + readonly id: u32; + readonly z: u32; + readonly src: Bytes; + } + + /** @name UpDataStructsRmrkSlotPart (223) */ + export interface UpDataStructsRmrkSlotPart extends Struct { + readonly id: u32; + readonly equippable: UpDataStructsRmrkEquippableList; + readonly src: Bytes; + readonly z: u32; + } + + /** @name UpDataStructsRmrkEquippableList (224) */ + export interface UpDataStructsRmrkEquippableList extends Enum { + readonly isAll: boolean; + readonly isEmpty: boolean; + readonly isCustom: boolean; + readonly asCustom: Vec; + readonly type: 'All' | 'Empty' | 'Custom'; + } + + /** @name UpDataStructsRmrkTheme (226) */ + export interface UpDataStructsRmrkTheme extends Struct { + readonly name: Bytes; + readonly properties: Vec; + readonly inherit: bool; + } + + /** @name UpDataStructsRmrkThemeProperty (228) */ + export interface UpDataStructsRmrkThemeProperty extends Struct { + readonly key: Bytes; + readonly value: Bytes; + } + + /** @name PalletEvmCall (229) */ export interface PalletEvmCall extends Enum { readonly isWithdraw: boolean; readonly asWithdraw: { @@ -1694,7 +1847,7 @@ readonly type: 'Withdraw' | 'Call' | 'Create' | 'Create2'; } - /** @name PalletEthereumCall (212) */ + /** @name PalletEthereumCall (235) */ export interface PalletEthereumCall extends Enum { readonly isTransact: boolean; readonly asTransact: { @@ -1703,7 +1856,7 @@ readonly type: 'Transact'; } - /** @name EthereumTransactionTransactionV2 (213) */ + /** @name EthereumTransactionTransactionV2 (236) */ export interface EthereumTransactionTransactionV2 extends Enum { readonly isLegacy: boolean; readonly asLegacy: EthereumTransactionLegacyTransaction; @@ -1714,7 +1867,7 @@ readonly type: 'Legacy' | 'Eip2930' | 'Eip1559'; } - /** @name EthereumTransactionLegacyTransaction (214) */ + /** @name EthereumTransactionLegacyTransaction (237) */ export interface EthereumTransactionLegacyTransaction extends Struct { readonly nonce: U256; readonly gasPrice: U256; @@ -1725,7 +1878,7 @@ readonly signature: EthereumTransactionTransactionSignature; } - /** @name EthereumTransactionTransactionAction (215) */ + /** @name EthereumTransactionTransactionAction (238) */ export interface EthereumTransactionTransactionAction extends Enum { readonly isCall: boolean; readonly asCall: H160; @@ -1733,14 +1886,14 @@ readonly type: 'Call' | 'Create'; } - /** @name EthereumTransactionTransactionSignature (216) */ + /** @name EthereumTransactionTransactionSignature (239) */ export interface EthereumTransactionTransactionSignature extends Struct { readonly v: u64; readonly r: H256; readonly s: H256; } - /** @name EthereumTransactionEip2930Transaction (218) */ + /** @name EthereumTransactionEip2930Transaction (241) */ export interface EthereumTransactionEip2930Transaction extends Struct { readonly chainId: u64; readonly nonce: U256; @@ -1755,13 +1908,13 @@ readonly s: H256; } - /** @name EthereumTransactionAccessListItem (220) */ + /** @name EthereumTransactionAccessListItem (243) */ export interface EthereumTransactionAccessListItem extends Struct { readonly address: H160; readonly storageKeys: Vec; } - /** @name EthereumTransactionEip1559Transaction (221) */ + /** @name EthereumTransactionEip1559Transaction (244) */ export interface EthereumTransactionEip1559Transaction extends Struct { readonly chainId: u64; readonly nonce: U256; @@ -1777,7 +1930,7 @@ readonly s: H256; } - /** @name PalletEvmMigrationCall (222) */ + /** @name PalletEvmMigrationCall (245) */ export interface PalletEvmMigrationCall extends Enum { readonly isBegin: boolean; readonly asBegin: { @@ -1796,7 +1949,7 @@ readonly type: 'Begin' | 'SetData' | 'Finish'; } - /** @name PalletSudoEvent (225) */ + /** @name PalletSudoEvent (248) */ export interface PalletSudoEvent extends Enum { readonly isSudid: boolean; readonly asSudid: { @@ -1813,7 +1966,7 @@ readonly type: 'Sudid' | 'KeyChanged' | 'SudoAsDone'; } - /** @name SpRuntimeDispatchError (227) */ + /** @name SpRuntimeDispatchError (250) */ export interface SpRuntimeDispatchError extends Enum { readonly isOther: boolean; readonly isCannotLookup: boolean; @@ -1832,13 +1985,13 @@ readonly type: 'Other' | 'CannotLookup' | 'BadOrigin' | 'Module' | 'ConsumerRemaining' | 'NoProviders' | 'TooManyConsumers' | 'Token' | 'Arithmetic' | 'Transactional'; } - /** @name SpRuntimeModuleError (228) */ + /** @name SpRuntimeModuleError (251) */ export interface SpRuntimeModuleError extends Struct { readonly index: u8; readonly error: U8aFixed; } - /** @name SpRuntimeTokenError (229) */ + /** @name SpRuntimeTokenError (252) */ export interface SpRuntimeTokenError extends Enum { readonly isNoFunds: boolean; readonly isWouldDie: boolean; @@ -1850,7 +2003,7 @@ readonly type: 'NoFunds' | 'WouldDie' | 'BelowMinimum' | 'CannotCreate' | 'UnknownAsset' | 'Frozen' | 'Unsupported'; } - /** @name SpRuntimeArithmeticError (230) */ + /** @name SpRuntimeArithmeticError (253) */ export interface SpRuntimeArithmeticError extends Enum { readonly isUnderflow: boolean; readonly isOverflow: boolean; @@ -1858,20 +2011,20 @@ readonly type: 'Underflow' | 'Overflow' | 'DivisionByZero'; } - /** @name SpRuntimeTransactionalError (231) */ + /** @name SpRuntimeTransactionalError (254) */ export interface SpRuntimeTransactionalError extends Enum { readonly isLimitReached: boolean; readonly isNoLayer: boolean; readonly type: 'LimitReached' | 'NoLayer'; } - /** @name PalletSudoError (232) */ + /** @name PalletSudoError (255) */ export interface PalletSudoError extends Enum { readonly isRequireSudo: boolean; readonly type: 'RequireSudo'; } - /** @name FrameSystemAccountInfo (233) */ + /** @name FrameSystemAccountInfo (256) */ export interface FrameSystemAccountInfo extends Struct { readonly nonce: u32; readonly consumers: u32; @@ -1880,19 +2033,19 @@ readonly data: PalletBalancesAccountData; } - /** @name FrameSupportWeightsPerDispatchClassU64 (234) */ + /** @name FrameSupportWeightsPerDispatchClassU64 (257) */ export interface FrameSupportWeightsPerDispatchClassU64 extends Struct { readonly normal: u64; readonly operational: u64; readonly mandatory: u64; } - /** @name SpRuntimeDigest (235) */ + /** @name SpRuntimeDigest (258) */ export interface SpRuntimeDigest extends Struct { readonly logs: Vec; } - /** @name SpRuntimeDigestDigestItem (237) */ + /** @name SpRuntimeDigestDigestItem (260) */ export interface SpRuntimeDigestDigestItem extends Enum { readonly isOther: boolean; readonly asOther: Bytes; @@ -1906,14 +2059,14 @@ readonly type: 'Other' | 'Consensus' | 'Seal' | 'PreRuntime' | 'RuntimeEnvironmentUpdated'; } - /** @name FrameSystemEventRecord (239) */ + /** @name FrameSystemEventRecord (262) */ export interface FrameSystemEventRecord extends Struct { readonly phase: FrameSystemPhase; readonly event: Event; readonly topics: Vec; } - /** @name FrameSystemEvent (241) */ + /** @name FrameSystemEvent (264) */ export interface FrameSystemEvent extends Enum { readonly isExtrinsicSuccess: boolean; readonly asExtrinsicSuccess: { @@ -1941,14 +2094,14 @@ readonly type: 'ExtrinsicSuccess' | 'ExtrinsicFailed' | 'CodeUpdated' | 'NewAccount' | 'KilledAccount' | 'Remarked'; } - /** @name FrameSupportWeightsDispatchInfo (242) */ + /** @name FrameSupportWeightsDispatchInfo (265) */ export interface FrameSupportWeightsDispatchInfo extends Struct { readonly weight: u64; readonly class: FrameSupportWeightsDispatchClass; readonly paysFee: FrameSupportWeightsPays; } - /** @name FrameSupportWeightsDispatchClass (243) */ + /** @name FrameSupportWeightsDispatchClass (266) */ export interface FrameSupportWeightsDispatchClass extends Enum { readonly isNormal: boolean; readonly isOperational: boolean; @@ -1956,14 +2109,14 @@ readonly type: 'Normal' | 'Operational' | 'Mandatory'; } - /** @name FrameSupportWeightsPays (244) */ + /** @name FrameSupportWeightsPays (267) */ export interface FrameSupportWeightsPays extends Enum { readonly isYes: boolean; readonly isNo: boolean; readonly type: 'Yes' | 'No'; } - /** @name OrmlVestingModuleEvent (245) */ + /** @name OrmlVestingModuleEvent (268) */ export interface OrmlVestingModuleEvent extends Enum { readonly isVestingScheduleAdded: boolean; readonly asVestingScheduleAdded: { @@ -1983,7 +2136,7 @@ readonly type: 'VestingScheduleAdded' | 'Claimed' | 'VestingSchedulesUpdated'; } - /** @name CumulusPalletXcmpQueueEvent (246) */ + /** @name CumulusPalletXcmpQueueEvent (269) */ export interface CumulusPalletXcmpQueueEvent extends Enum { readonly isSuccess: boolean; readonly asSuccess: Option; @@ -2004,7 +2157,7 @@ readonly type: 'Success' | 'Fail' | 'BadVersion' | 'BadFormat' | 'UpwardMessageSent' | 'XcmpMessageSent' | 'OverweightEnqueued' | 'OverweightServiced'; } - /** @name PalletXcmEvent (247) */ + /** @name PalletXcmEvent (270) */ export interface PalletXcmEvent extends Enum { readonly isAttempted: boolean; readonly asAttempted: XcmV2TraitsOutcome; @@ -2041,7 +2194,7 @@ readonly type: 'Attempted' | 'Sent' | 'UnexpectedResponse' | 'ResponseReady' | 'Notified' | 'NotifyOverweight' | 'NotifyDispatchError' | 'NotifyDecodeFailed' | 'InvalidResponder' | 'InvalidResponderVersion' | 'ResponseTaken' | 'AssetsTrapped' | 'VersionChangeNotified' | 'SupportedVersionChanged' | 'NotifyTargetSendFail' | 'NotifyTargetMigrationFail'; } - /** @name XcmV2TraitsOutcome (248) */ + /** @name XcmV2TraitsOutcome (271) */ export interface XcmV2TraitsOutcome extends Enum { readonly isComplete: boolean; readonly asComplete: u64; @@ -2052,7 +2205,7 @@ readonly type: 'Complete' | 'Incomplete' | 'Error'; } - /** @name CumulusPalletXcmEvent (250) */ + /** @name CumulusPalletXcmEvent (273) */ export interface CumulusPalletXcmEvent extends Enum { readonly isInvalidFormat: boolean; readonly asInvalidFormat: U8aFixed; @@ -2063,7 +2216,7 @@ readonly type: 'InvalidFormat' | 'UnsupportedVersion' | 'ExecutedDownward'; } - /** @name CumulusPalletDmpQueueEvent (251) */ + /** @name CumulusPalletDmpQueueEvent (274) */ export interface CumulusPalletDmpQueueEvent extends Enum { readonly isInvalidFormat: boolean; readonly asInvalidFormat: U8aFixed; @@ -2080,7 +2233,7 @@ readonly type: 'InvalidFormat' | 'UnsupportedVersion' | 'ExecutedDownward' | 'WeightExhausted' | 'OverweightEnqueued' | 'OverweightServiced'; } - /** @name PalletUniqueRawEvent (252) */ + /** @name PalletUniqueRawEvent (275) */ export interface PalletUniqueRawEvent extends Enum { readonly isCollectionSponsorRemoved: boolean; readonly asCollectionSponsorRemoved: u32; @@ -2105,7 +2258,7 @@ readonly type: 'CollectionSponsorRemoved' | 'CollectionAdminAdded' | 'CollectionOwnedChanged' | 'CollectionSponsorSet' | 'SponsorshipConfirmed' | 'CollectionAdminRemoved' | 'AllowListAddressRemoved' | 'AllowListAddressAdded' | 'CollectionLimitSet' | 'CollectionPermissionSet'; } - /** @name PalletCommonEvent (253) */ + /** @name PalletCommonEvent (276) */ export interface PalletCommonEvent extends Enum { readonly isCollectionCreated: boolean; readonly asCollectionCreated: ITuple<[u32, u8, AccountId32]>; @@ -2132,14 +2285,73 @@ readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'ItemCreated' | 'ItemDestroyed' | 'Transfer' | 'Approved' | 'CollectionPropertySet' | 'CollectionPropertyDeleted' | 'TokenPropertySet' | 'TokenPropertyDeleted' | 'PropertyPermissionSet'; } - /** @name PalletStructureEvent (254) */ + /** @name PalletStructureEvent (277) */ export interface PalletStructureEvent extends Enum { readonly isExecuted: boolean; readonly asExecuted: Result; readonly type: 'Executed'; } - /** @name PalletEvmEvent (255) */ + /** @name PalletRmrkCoreEvent (278) */ + export interface PalletRmrkCoreEvent extends Enum { + readonly isCollectionCreated: boolean; + readonly asCollectionCreated: { + readonly issuer: AccountId32; + readonly collectionId: u32; + } & Struct; + readonly isCollectionDestroyed: boolean; + readonly asCollectionDestroyed: { + readonly issuer: AccountId32; + readonly collectionId: u32; + } & Struct; + readonly isIssuerChanged: boolean; + readonly asIssuerChanged: { + readonly oldIssuer: AccountId32; + readonly newIssuer: AccountId32; + readonly collectionId: u32; + } & Struct; + readonly isCollectionLocked: boolean; + readonly asCollectionLocked: { + readonly issuer: AccountId32; + readonly collectionId: u32; + } & Struct; + readonly isNftMinted: boolean; + readonly asNftMinted: { + readonly owner: AccountId32; + readonly collectionId: u32; + readonly nftId: u32; + } & Struct; + readonly isNftBurned: boolean; + readonly asNftBurned: { + readonly owner: AccountId32; + readonly nftId: u32; + } & Struct; + readonly isPropertySet: boolean; + readonly asPropertySet: { + readonly collectionId: u32; + readonly maybeNftId: Option; + readonly key: Bytes; + readonly value: Bytes; + } & Struct; + readonly isResourceAdded: boolean; + readonly asResourceAdded: { + readonly nftId: u32; + readonly resourceId: u32; + } & Struct; + readonly type: 'CollectionCreated' | 'CollectionDestroyed' | 'IssuerChanged' | 'CollectionLocked' | 'NftMinted' | 'NftBurned' | 'PropertySet' | 'ResourceAdded'; + } + + /** @name PalletRmrkEquipEvent (279) */ + export interface PalletRmrkEquipEvent extends Enum { + readonly isBaseCreated: boolean; + readonly asBaseCreated: { + readonly issuer: AccountId32; + readonly baseId: u32; + } & Struct; + readonly type: 'BaseCreated'; + } + + /** @name PalletEvmEvent (280) */ export interface PalletEvmEvent extends Enum { readonly isLog: boolean; readonly asLog: EthereumLog; @@ -2158,21 +2370,21 @@ readonly type: 'Log' | 'Created' | 'CreatedFailed' | 'Executed' | 'ExecutedFailed' | 'BalanceDeposit' | 'BalanceWithdraw'; } - /** @name EthereumLog (256) */ + /** @name EthereumLog (281) */ export interface EthereumLog extends Struct { readonly address: H160; readonly topics: Vec; readonly data: Bytes; } - /** @name PalletEthereumEvent (257) */ + /** @name PalletEthereumEvent (282) */ export interface PalletEthereumEvent extends Enum { readonly isExecuted: boolean; readonly asExecuted: ITuple<[H160, H160, H256, EvmCoreErrorExitReason]>; readonly type: 'Executed'; } - /** @name EvmCoreErrorExitReason (258) */ + /** @name EvmCoreErrorExitReason (283) */ export interface EvmCoreErrorExitReason extends Enum { readonly isSucceed: boolean; readonly asSucceed: EvmCoreErrorExitSucceed; @@ -2185,7 +2397,7 @@ readonly type: 'Succeed' | 'Error' | 'Revert' | 'Fatal'; } - /** @name EvmCoreErrorExitSucceed (259) */ + /** @name EvmCoreErrorExitSucceed (284) */ export interface EvmCoreErrorExitSucceed extends Enum { readonly isStopped: boolean; readonly isReturned: boolean; @@ -2193,7 +2405,7 @@ readonly type: 'Stopped' | 'Returned' | 'Suicided'; } - /** @name EvmCoreErrorExitError (260) */ + /** @name EvmCoreErrorExitError (285) */ export interface EvmCoreErrorExitError extends Enum { readonly isStackUnderflow: boolean; readonly isStackOverflow: boolean; @@ -2214,13 +2426,13 @@ readonly type: 'StackUnderflow' | 'StackOverflow' | 'InvalidJump' | 'InvalidRange' | 'DesignatedInvalid' | 'CallTooDeep' | 'CreateCollision' | 'CreateContractLimit' | 'OutOfOffset' | 'OutOfGas' | 'OutOfFund' | 'PcUnderflow' | 'CreateEmpty' | 'Other' | 'InvalidCode'; } - /** @name EvmCoreErrorExitRevert (263) */ + /** @name EvmCoreErrorExitRevert (288) */ export interface EvmCoreErrorExitRevert extends Enum { readonly isReverted: boolean; readonly type: 'Reverted'; } - /** @name EvmCoreErrorExitFatal (264) */ + /** @name EvmCoreErrorExitFatal (289) */ export interface EvmCoreErrorExitFatal extends Enum { readonly isNotSupported: boolean; readonly isUnhandledInterrupt: boolean; @@ -2231,7 +2443,7 @@ readonly type: 'NotSupported' | 'UnhandledInterrupt' | 'CallErrorAsFatal' | 'Other'; } - /** @name FrameSystemPhase (265) */ + /** @name FrameSystemPhase (290) */ export interface FrameSystemPhase extends Enum { readonly isApplyExtrinsic: boolean; readonly asApplyExtrinsic: u32; @@ -2240,27 +2452,27 @@ readonly type: 'ApplyExtrinsic' | 'Finalization' | 'Initialization'; } - /** @name FrameSystemLastRuntimeUpgradeInfo (267) */ + /** @name FrameSystemLastRuntimeUpgradeInfo (292) */ export interface FrameSystemLastRuntimeUpgradeInfo extends Struct { readonly specVersion: Compact; readonly specName: Text; } - /** @name FrameSystemLimitsBlockWeights (268) */ + /** @name FrameSystemLimitsBlockWeights (293) */ export interface FrameSystemLimitsBlockWeights extends Struct { readonly baseBlock: u64; readonly maxBlock: u64; readonly perClass: FrameSupportWeightsPerDispatchClassWeightsPerClass; } - /** @name FrameSupportWeightsPerDispatchClassWeightsPerClass (269) */ + /** @name FrameSupportWeightsPerDispatchClassWeightsPerClass (294) */ export interface FrameSupportWeightsPerDispatchClassWeightsPerClass extends Struct { readonly normal: FrameSystemLimitsWeightsPerClass; readonly operational: FrameSystemLimitsWeightsPerClass; readonly mandatory: FrameSystemLimitsWeightsPerClass; } - /** @name FrameSystemLimitsWeightsPerClass (270) */ + /** @name FrameSystemLimitsWeightsPerClass (295) */ export interface FrameSystemLimitsWeightsPerClass extends Struct { readonly baseExtrinsic: u64; readonly maxExtrinsic: Option; @@ -2268,25 +2480,25 @@ readonly reserved: Option; } - /** @name FrameSystemLimitsBlockLength (272) */ + /** @name FrameSystemLimitsBlockLength (297) */ export interface FrameSystemLimitsBlockLength extends Struct { readonly max: FrameSupportWeightsPerDispatchClassU32; } - /** @name FrameSupportWeightsPerDispatchClassU32 (273) */ + /** @name FrameSupportWeightsPerDispatchClassU32 (298) */ export interface FrameSupportWeightsPerDispatchClassU32 extends Struct { readonly normal: u32; readonly operational: u32; readonly mandatory: u32; } - /** @name FrameSupportWeightsRuntimeDbWeight (274) */ + /** @name FrameSupportWeightsRuntimeDbWeight (299) */ export interface FrameSupportWeightsRuntimeDbWeight extends Struct { readonly read: u64; readonly write: u64; } - /** @name SpVersionRuntimeVersion (275) */ + /** @name SpVersionRuntimeVersion (300) */ export interface SpVersionRuntimeVersion extends Struct { readonly specName: Text; readonly implName: Text; @@ -2298,7 +2510,7 @@ readonly stateVersion: u8; } - /** @name FrameSystemError (279) */ + /** @name FrameSystemError (304) */ export interface FrameSystemError extends Enum { readonly isInvalidSpecName: boolean; readonly isSpecVersionNeedsToIncrease: boolean; @@ -2309,7 +2521,7 @@ readonly type: 'InvalidSpecName' | 'SpecVersionNeedsToIncrease' | 'FailedToExtractRuntimeVersion' | 'NonDefaultComposite' | 'NonZeroRefCount' | 'CallFiltered'; } - /** @name OrmlVestingModuleError (281) */ + /** @name OrmlVestingModuleError (306) */ export interface OrmlVestingModuleError extends Enum { readonly isZeroVestingPeriod: boolean; readonly isZeroVestingPeriodCount: boolean; @@ -2320,21 +2532,21 @@ readonly type: 'ZeroVestingPeriod' | 'ZeroVestingPeriodCount' | 'InsufficientBalanceToLock' | 'TooManyVestingSchedules' | 'AmountLow' | 'MaxVestingSchedulesExceeded'; } - /** @name CumulusPalletXcmpQueueInboundChannelDetails (283) */ + /** @name CumulusPalletXcmpQueueInboundChannelDetails (308) */ export interface CumulusPalletXcmpQueueInboundChannelDetails extends Struct { readonly sender: u32; readonly state: CumulusPalletXcmpQueueInboundState; readonly messageMetadata: Vec>; } - /** @name CumulusPalletXcmpQueueInboundState (284) */ + /** @name CumulusPalletXcmpQueueInboundState (309) */ export interface CumulusPalletXcmpQueueInboundState extends Enum { readonly isOk: boolean; readonly isSuspended: boolean; readonly type: 'Ok' | 'Suspended'; } - /** @name PolkadotParachainPrimitivesXcmpMessageFormat (287) */ + /** @name PolkadotParachainPrimitivesXcmpMessageFormat (312) */ export interface PolkadotParachainPrimitivesXcmpMessageFormat extends Enum { readonly isConcatenatedVersionedXcm: boolean; readonly isConcatenatedEncodedBlob: boolean; @@ -2342,7 +2554,7 @@ readonly type: 'ConcatenatedVersionedXcm' | 'ConcatenatedEncodedBlob' | 'Signals'; } - /** @name CumulusPalletXcmpQueueOutboundChannelDetails (290) */ + /** @name CumulusPalletXcmpQueueOutboundChannelDetails (315) */ export interface CumulusPalletXcmpQueueOutboundChannelDetails extends Struct { readonly recipient: u32; readonly state: CumulusPalletXcmpQueueOutboundState; @@ -2351,14 +2563,14 @@ readonly lastIndex: u16; } - /** @name CumulusPalletXcmpQueueOutboundState (291) */ + /** @name CumulusPalletXcmpQueueOutboundState (316) */ export interface CumulusPalletXcmpQueueOutboundState extends Enum { readonly isOk: boolean; readonly isSuspended: boolean; readonly type: 'Ok' | 'Suspended'; } - /** @name CumulusPalletXcmpQueueQueueConfigData (293) */ + /** @name CumulusPalletXcmpQueueQueueConfigData (318) */ export interface CumulusPalletXcmpQueueQueueConfigData extends Struct { readonly suspendThreshold: u32; readonly dropThreshold: u32; @@ -2368,7 +2580,7 @@ readonly xcmpMaxIndividualWeight: u64; } - /** @name CumulusPalletXcmpQueueError (295) */ + /** @name CumulusPalletXcmpQueueError (320) */ export interface CumulusPalletXcmpQueueError extends Enum { readonly isFailedToSend: boolean; readonly isBadXcmOrigin: boolean; @@ -2378,7 +2590,7 @@ readonly type: 'FailedToSend' | 'BadXcmOrigin' | 'BadXcm' | 'BadOverweightIndex' | 'WeightOverLimit'; } - /** @name PalletXcmError (296) */ + /** @name PalletXcmError (321) */ export interface PalletXcmError extends Enum { readonly isUnreachable: boolean; readonly isSendFailure: boolean; @@ -2396,29 +2608,29 @@ readonly type: 'Unreachable' | 'SendFailure' | 'Filtered' | 'UnweighableMessage' | 'DestinationNotInvertible' | 'Empty' | 'CannotReanchor' | 'TooManyAssets' | 'InvalidOrigin' | 'BadVersion' | 'BadLocation' | 'NoSubscription' | 'AlreadySubscribed'; } - /** @name CumulusPalletXcmError (297) */ + /** @name CumulusPalletXcmError (322) */ export type CumulusPalletXcmError = Null; - /** @name CumulusPalletDmpQueueConfigData (298) */ + /** @name CumulusPalletDmpQueueConfigData (323) */ export interface CumulusPalletDmpQueueConfigData extends Struct { readonly maxIndividual: u64; } - /** @name CumulusPalletDmpQueuePageIndexData (299) */ + /** @name CumulusPalletDmpQueuePageIndexData (324) */ export interface CumulusPalletDmpQueuePageIndexData extends Struct { readonly beginUsed: u32; readonly endUsed: u32; readonly overweightCount: u64; } - /** @name CumulusPalletDmpQueueError (302) */ + /** @name CumulusPalletDmpQueueError (327) */ export interface CumulusPalletDmpQueueError extends Enum { readonly isUnknown: boolean; readonly isOverLimit: boolean; readonly type: 'Unknown' | 'OverLimit'; } - /** @name PalletUniqueError (306) */ + /** @name PalletUniqueError (331) */ export interface PalletUniqueError extends Enum { readonly isCollectionDecimalPointLimitExceeded: boolean; readonly isConfirmUnsetSponsorFail: boolean; @@ -2426,7 +2638,7 @@ readonly type: 'CollectionDecimalPointLimitExceeded' | 'ConfirmUnsetSponsorFail' | 'EmptyArgument'; } - /** @name UpDataStructsCollection (307) */ + /** @name UpDataStructsCollection (332) */ export interface UpDataStructsCollection extends Struct { readonly owner: AccountId32; readonly mode: UpDataStructsCollectionMode; @@ -2438,7 +2650,7 @@ readonly permissions: UpDataStructsCollectionPermissions; } - /** @name UpDataStructsSponsorshipState (308) */ + /** @name UpDataStructsSponsorshipState (333) */ export interface UpDataStructsSponsorshipState extends Enum { readonly isDisabled: boolean; readonly isUnconfirmed: boolean; @@ -2448,20 +2660,20 @@ readonly type: 'Disabled' | 'Unconfirmed' | 'Confirmed'; } - /** @name UpDataStructsProperties (309) */ + /** @name UpDataStructsProperties (334) */ export interface UpDataStructsProperties extends Struct { readonly map: UpDataStructsPropertiesMapBoundedVec; readonly consumedSpace: u32; readonly spaceLimit: u32; } - /** @name UpDataStructsPropertiesMapBoundedVec (310) */ + /** @name UpDataStructsPropertiesMapBoundedVec (335) */ export interface UpDataStructsPropertiesMapBoundedVec extends BTreeMap {} - /** @name UpDataStructsPropertiesMapPropertyPermission (315) */ + /** @name UpDataStructsPropertiesMapPropertyPermission (340) */ export interface UpDataStructsPropertiesMapPropertyPermission extends BTreeMap {} - /** @name UpDataStructsCollectionStats (322) */ + /** @name UpDataStructsCollectionStats (347) */ export interface UpDataStructsCollectionStats extends Struct { readonly created: u32; readonly destroyed: u32; @@ -2532,7 +2744,7 @@ /** @name UpDataStructsRmrkResourceInfo (336) */ export interface UpDataStructsRmrkResourceInfo extends Struct { - readonly id: Bytes; + readonly id: u32; readonly resource: UpDataStructsRmrkResourceTypes; readonly pending: bool; readonly pendingRemoval: bool; --- a/tests/src/interfaces/types.ts +++ b/tests/src/interfaces/types.ts @@ -2,4 +2,5 @@ /* eslint-disable */ export * from './unique/types'; +export * from './rmrk/types'; export * from './default/types';