git.delta.rocks / unique-network / refs/commits / 06c6a41ee252

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Primitives crate.18//! 19//! This crate contains amount of types, traits and constants.2021#![cfg_attr(not(feature = "std"), no_std)]2223use core::{24	convert::{TryFrom, TryInto},25	fmt,26};27use frame_support::{28	storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet},29	traits::Get,30	parameter_types,31};3233#[cfg(feature = "serde")]34use serde::{Serialize, Deserialize};3536use sp_core::U256;37use sp_runtime::{ArithmeticError, sp_std::prelude::Vec, Permill};38use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};39use frame_support::{BoundedVec, traits::ConstU32};40use derivative::Derivative;41use scale_info::TypeInfo;4243// RMRK44use rmrk_traits::{45	CollectionInfo, NftInfo, ResourceInfo, PropertyInfo, BaseInfo, PartType, Theme, ThemeProperty,46	ResourceTypes, BasicResource, ComposableResource, SlotResource, EquippableList,47};48pub use rmrk_traits::{49	primitives::{50		CollectionId as RmrkCollectionId, NftId as RmrkNftId, BaseId as RmrkBaseId,51		SlotId as RmrkSlotId, PartId as RmrkPartId, ResourceId as RmrkResourceId,52	},53	NftChild as RmrkNftChild, AccountIdOrCollectionNftTuple as RmrkAccountIdOrCollectionNftTuple,54	FixedPart as RmrkFixedPart, SlotPart as RmrkSlotPart,55};5657mod bounded;58pub mod budget;59pub mod mapping;60mod migration;6162/// Maximum of decimal points.63pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;6465/// Maximum pieces for refungible token.66pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;67pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;6869/// Maximum tokens for user.70pub const MAX_TOKEN_OWNERSHIP: u32 = if cfg!(not(feature = "limit-testing")) {71	100_00072} else {73	1074};7576/// Maximum for collections can be created.77pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {78	100_00079} else {80	1081};8283/// Maximum for various custom data of token.84pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {85	204886} else {87	1088};8990/// Maximum admins per collection.91pub const COLLECTION_ADMINS_LIMIT: u32 = 5;9293/// Maximum tokens per collection.94pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX;9596/// Maximum tokens per account.97pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {98	1_000_00099} else {100	10101};102103/// Default timeout for transfer sponsoring NFT item.104pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;105/// Default timeout for transfer sponsoring fungible item.106pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;107/// Default timeout for transfer sponsoring refungible item.108pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;109110/// Default timeout for sponsored approving.111pub const SPONSOR_APPROVE_TIMEOUT: u32 = 5;112113// Schema limits114pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 8192;115pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 8192;116pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 32768;117118// TODO: not used. Delete?119pub const COLLECTION_FIELD_LIMIT: u32 = CONST_ON_CHAIN_SCHEMA_LIMIT;120121/// Maximum length for collection name.122pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;123124/// Maximum length for collection description.125pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;126127/// Maximal token prefix length.128pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;129130/// Maximal lenght of property key.131pub const MAX_PROPERTY_KEY_LENGTH: u32 = 256;132133/// Maximal lenght of property value.134pub const MAX_PROPERTY_VALUE_LENGTH: u32 = 32768;135136/// Maximum properties that can be assigned to token.137pub const MAX_PROPERTIES_PER_ITEM: u32 = 64;138139/// Maximal lenght of extended property value.140pub const MAX_AUX_PROPERTY_VALUE_LENGTH: u32 = 2048;141142/// Maximum size for all collection properties.143pub const MAX_COLLECTION_PROPERTIES_SIZE: u32 = 40960;144145/// Maximum size for all token properties.146pub const MAX_TOKEN_PROPERTIES_SIZE: u32 = 32768;147148/// How much items can be created per single149/// create_many call.150pub const MAX_ITEMS_PER_BATCH: u32 = 200;151152/// Used for limit bounded types of token custom data.153pub type CustomDataLimit = ConstU32<CUSTOM_DATA_LIMIT>;154155/// Collection id.156#[derive(157	Encode,158	Decode,159	PartialEq,160	Eq,161	PartialOrd,162	Ord,163	Clone,164	Copy,165	Debug,166	Default,167	TypeInfo,168	MaxEncodedLen,169)]170#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]171pub struct CollectionId(pub u32);172impl EncodeLike<u32> for CollectionId {}173impl EncodeLike<CollectionId> for u32 {}174175/// Token id.176#[derive(177	Encode,178	Decode,179	PartialEq,180	Eq,181	PartialOrd,182	Ord,183	Clone,184	Copy,185	Debug,186	Default,187	TypeInfo,188	MaxEncodedLen,189)]190#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]191pub struct TokenId(pub u32);192impl EncodeLike<u32> for TokenId {}193impl EncodeLike<TokenId> for u32 {}194195impl TokenId {196	/// Try to get next token id.197	/// 198	/// If next id cause overflow, then [`ArithmeticError::Overflow`] returned.199	pub fn try_next(self) -> Result<TokenId, ArithmeticError> {200		self.0201			.checked_add(1)202			.ok_or(ArithmeticError::Overflow)203			.map(Self)204	}205}206207impl From<TokenId> for U256 {208	fn from(t: TokenId) -> Self {209		t.0.into()210	}211}212213impl TryFrom<U256> for TokenId {214	type Error = &'static str;215216	fn try_from(value: U256) -> Result<Self, Self::Error> {217		Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))218	}219}220221/// Token data.222#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]223#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]224pub struct TokenData<CrossAccountId> {225	/// Properties of token.226	pub properties: Vec<Property>,227228	/// Token owner.229	pub owner: Option<CrossAccountId>,230231	/// Token pieces.232	pub pieces: u128,233}234235// TODO: unused type236pub struct OverflowError;237impl From<OverflowError> for &'static str {238	fn from(_: OverflowError) -> Self {239		"overflow occured"240	}241}242243/// Alias for decimal points type.244pub type DecimalPoints = u8;245246/// Collection mode.247/// 248/// Collection can represent various types of tokens.249/// Each collection can contain only one type of tokens at a time.250/// This type helps to understand which tokens the collection contains.251#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]252#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]253pub enum CollectionMode {254	/// Non fungible tokens.255	NFT,256	/// Fungible tokens.257	Fungible(DecimalPoints),258	/// Refungible tokens.259	ReFungible,260}261262impl CollectionMode {263	/// Get collection mod as number.264	pub fn id(&self) -> u8 {265		match self {266			CollectionMode::NFT => 1,267			CollectionMode::Fungible(_) => 2,268			CollectionMode::ReFungible => 3,269		}270	}271}272273// TODO: unused trait274pub trait SponsoringResolve<AccountId, Call> {275	fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;276}277278/// Access mode for some token operations.279#[derive(Encode, Decode, Eq, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]280#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]281pub enum AccessMode {282	/// Access grant for owner and admins. Used as default.283	Normal,284	/// Like a [`Normal`](AccessMode::Normal) but also users in allow list.285	AllowList,286}287impl Default for AccessMode {288	fn default() -> Self {289		Self::Normal290	}291}292293// TODO: remove in future.294#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]295#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]296pub enum SchemaVersion {297	ImageURL,298	Unique,299}300impl Default for SchemaVersion {301	fn default() -> Self {302		Self::ImageURL303	}304}305306// TODO: unused type307#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]308#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]309pub struct Ownership<AccountId> {310	pub owner: AccountId,311	pub fraction: u128,312}313314/// The state of collection sponsorship.315#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]316#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]317pub enum SponsorshipState<AccountId> {318	/// The fees are applied to the transaction sender.319	Disabled,320	/// The sponsor is under consideration. Until the sponsor gives his consent,321	/// the fee will still be charged to sender.322	Unconfirmed(AccountId),323	/// Transactions are sponsored by specified account.324	Confirmed(AccountId),325}326327impl<AccountId> SponsorshipState<AccountId> {328	/// Get a sponsor of the collection who has confirmed his status.329	pub fn sponsor(&self) -> Option<&AccountId> {330		match self {331			Self::Confirmed(sponsor) => Some(sponsor),332			_ => None,333		}334	}335336	/// Get a sponsor of the collection who has pending or confirmed status.337	pub fn pending_sponsor(&self) -> Option<&AccountId> {338		match self {339			Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),340			_ => None,341		}342	}343344	/// Whether the sponsorship is confirmed.345	pub fn confirmed(&self) -> bool {346		matches!(self, Self::Confirmed(_))347	}348}349350impl<T> Default for SponsorshipState<T> {351	fn default() -> Self {352		Self::Disabled353	}354}355356pub type CollectionName = BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>;357pub type CollectionDescription = BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>;358pub type CollectionTokenPrefix = BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>;359360/// Base structure for represent collection.361/// 362/// Used to provide basic functionality for all types of collections.363/// 364/// #### Note365/// Collection parameters, used in storage (see [`RpcCollection`] for the RPC version).366#[struct_versioning::versioned(version = 2, upper)]367#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]368pub struct Collection<AccountId> {369	/// Collection owner account.370	pub owner: AccountId,371372	/// Collection mode.373	pub mode: CollectionMode,374375	/// Access mode.376	#[version(..2)]377	pub access: AccessMode,378379	/// Collection name.380	pub name: CollectionName,381382	/// Collection description.383	pub description: CollectionDescription,384385	/// Token prefix.386	pub token_prefix: CollectionTokenPrefix,387388	#[version(..2)]389	pub mint_mode: bool,390391	#[version(..2)]392	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,393394	#[version(..2)]395	pub schema_version: SchemaVersion,396397	/// The state of sponsorship of the collection.398	pub sponsorship: SponsorshipState<AccountId>,399400	/// Collection limits.401	pub limits: CollectionLimits,402403	/// Collection permissions.404	#[version(2.., upper(Default::default()))]405	pub permissions: CollectionPermissions,406407	/// Marks that this collection is not "unique", and managed from external.408	#[version(2.., upper(false))]409	pub external_collection: bool,410411	#[version(..2)]412	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,413414	#[version(..2)]415	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,416417	#[version(..2)]418	pub meta_update_permission: MetaUpdatePermission,419}420421/// Collection parameters, used in RPC calls (see [`Collection`] for the storage version).422#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]423#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]424pub struct RpcCollection<AccountId> {425	/// Collection owner account.426	pub owner: AccountId,427428	/// Collection mode.429	pub mode: CollectionMode,430431	/// Collection name.432	pub name: Vec<u16>,433434	/// Collection description.435	pub description: Vec<u16>,436437	/// Token prefix.438	pub token_prefix: Vec<u8>,439440	/// The state of sponsorship of the collection.441	pub sponsorship: SponsorshipState<AccountId>,442443	/// Collection limits.444	pub limits: CollectionLimits,445446	/// Collection permissions.447	pub permissions: CollectionPermissions,448449	/// Token property permissions.450	pub token_property_permissions: Vec<PropertyKeyPermission>,451452	/// Collection properties.453	pub properties: Vec<Property>,454455	/// Is collection read only.456	pub read_only: bool,457}458459/// Data used for create collection.460/// 461/// All fields are wrapped in [`Option`], where `None` means chain default.462#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Derivative, MaxEncodedLen)]463#[derivative(Debug, Default(bound = ""))]464pub struct CreateCollectionData<AccountId> {465	/// Collection mode.466	#[derivative(Default(value = "CollectionMode::NFT"))]467	pub mode: CollectionMode,468469	/// Access mode.470	pub access: Option<AccessMode>,471472	/// Collection name.473	pub name: CollectionName,474475	/// Collection description.476	pub description: CollectionDescription,477478	/// Token prefix.479	pub token_prefix: CollectionTokenPrefix,480481	/// Pending collection sponsor.482	pub pending_sponsor: Option<AccountId>,483484	/// Collection limits.485	pub limits: Option<CollectionLimits>,486487	/// Collection permissions.488	pub permissions: Option<CollectionPermissions>,489490	/// Token property permissions.491	pub token_property_permissions: CollectionPropertiesPermissionsVec,492493	/// Collection properties.494	pub properties: CollectionPropertiesVec,495}496497/// Bounded vector of properties permissions. Max length is [`MAX_PROPERTIES_PER_ITEM`].498// TODO: maybe rename to PropertiesPermissionsVec499pub type CollectionPropertiesPermissionsVec =500	BoundedVec<PropertyKeyPermission, ConstU32<MAX_PROPERTIES_PER_ITEM>>;501502/// Bounded vector of properties. Max length is [`MAX_PROPERTIES_PER_ITEM`].503pub type CollectionPropertiesVec = BoundedVec<Property, ConstU32<MAX_PROPERTIES_PER_ITEM>>;504505/// Limits and restrictions of a collection.506///507/// All fields are wrapped in [`Option`], where `None` means chain default.508/// 509/// Update with `pallet_common::Pallet::clamp_limits`.510// IMPORTANT: When adding/removing fields from this struct - don't forget to also511#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]512#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]513// When adding/removing fields from this struct - don't forget to also update with `pallet_common::Pallet::clamp_limits`.514// TODO: move `pallet_common::Pallet::clamp_limits` into `impl CollectionLimits`.515// TODO: may be remove [`Option`] and **pub** from fields and create struct with default values.516pub struct CollectionLimits {517	/// How many tokens can a user have on one account.518	/// * Default - [`ACCOUNT_TOKEN_OWNERSHIP_LIMIT`].519	/// * Limit - [`MAX_TOKEN_OWNERSHIP`].520	pub account_token_ownership_limit: Option<u32>,521522	/// How many bytes of data are available for sponsorship.523	/// * Default - [`CUSTOM_DATA_LIMIT`].524	/// * Limit - [`CUSTOM_DATA_LIMIT`].525	pub sponsored_data_size: Option<u32>,526527	// FIXME should we delete this or repurpose it?528	/// Times in how many blocks we sponsor data.529	/// 530	/// If is `Some(v)` then **setVariableMetadata** is sponsored if there is `v` block between transactions.531	/// 532	/// * Default - [`SponsoringDisabled`](SponsoringRateLimit::SponsoringDisabled).533	/// * Limit - [`MAX_SPONSOR_TIMEOUT`].534	///535	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]536	pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,537	/// Maximum amount of tokens inside the collection. Chain default: [`COLLECTION_TOKEN_LIMIT`]538539	/// How many tokens can be mined into this collection.540	/// 541	/// * Default - [`COLLECTION_TOKEN_LIMIT`].542	/// * Limit - [`COLLECTION_TOKEN_LIMIT`].543	pub token_limit: Option<u32>,544545	/// Timeouts for transfer sponsoring.546	/// 547	/// * Default548	///   - **Fungible** - [`FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT`]549	///   - **NFT** - [`NFT_SPONSOR_TRANSFER_TIMEOUT`]550	///   - **Refungible** - [`REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT`]551	/// * Limit - [`MAX_SPONSOR_TIMEOUT`].552	pub sponsor_transfer_timeout: Option<u32>,553	554	/// Timeout for sponsoring an approval in passed blocks.555	/// 556	/// * Default - [`SPONSOR_APPROVE_TIMEOUT`].557	/// * Limit - [`MAX_SPONSOR_TIMEOUT`].558	pub sponsor_approve_timeout: Option<u32>,559560	/// Whether the collection owner of the collection can send tokens (which belong to other users).561	/// 562	/// * Default - **false**.563	pub owner_can_transfer: Option<bool>,564565	/// Can the collection owner burn other people's tokens.566	/// 567	/// * Default - **true**.568	pub owner_can_destroy: Option<bool>,569	570	/// Is it possible to send tokens from this collection between users.571	/// 572	/// * Default - **true**.573	pub transfers_enabled: Option<bool>,574}575576impl CollectionLimits {577	/// Get effective value for [`account_token_ownership_limit`](self.account_token_ownership_limit).578	pub fn account_token_ownership_limit(&self) -> u32 {579		self.account_token_ownership_limit580			.unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)581			.min(MAX_TOKEN_OWNERSHIP)582	}583584	/// Get effective value for [`sponsored_data_size`](self.sponsored_data_size).585	pub fn sponsored_data_size(&self) -> u32 {586		self.sponsored_data_size587			.unwrap_or(CUSTOM_DATA_LIMIT)588			.min(CUSTOM_DATA_LIMIT)589	}590591	/// Get effective value for [`token_limit`](self.token_limit).592	pub fn token_limit(&self) -> u32 {593		self.token_limit594			.unwrap_or(COLLECTION_TOKEN_LIMIT)595			.min(COLLECTION_TOKEN_LIMIT)596	}597598	// TODO: may be replace u32 to mode?599	/// Get effective value for [`sponsor_transfer_timeout`](self.sponsor_transfer_timeout).600	pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {601		self.sponsor_transfer_timeout602			.unwrap_or(default)603			.min(MAX_SPONSOR_TIMEOUT)604	}605606	/// Get effective value for [`sponsor_approve_timeout`](self.sponsor_approve_timeout).607	pub fn sponsor_approve_timeout(&self) -> u32 {608		self.sponsor_approve_timeout609			.unwrap_or(SPONSOR_APPROVE_TIMEOUT)610			.min(MAX_SPONSOR_TIMEOUT)611	}612613	/// Get effective value for [`owner_can_transfer`](self.owner_can_transfer).614	pub fn owner_can_transfer(&self) -> bool {615		self.owner_can_transfer.unwrap_or(false)616	}617618	/// Get effective value for [`owner_can_transfer_instaled`](self.owner_can_transfer_instaled).619	pub fn owner_can_transfer_instaled(&self) -> bool {620		self.owner_can_transfer.is_some()621	}622623	/// Get effective value for [`owner_can_destroy`](self.owner_can_destroy).624	pub fn owner_can_destroy(&self) -> bool {625		self.owner_can_destroy.unwrap_or(true)626	}627628	/// Get effective value for [`transfers_enabled`](self.transfers_enabled).629	pub fn transfers_enabled(&self) -> bool {630		self.transfers_enabled.unwrap_or(true)631	}632633	/// Get effective value for [`sponsored_data_rate_limit`](self.sponsored_data_rate_limit).634	pub fn sponsored_data_rate_limit(&self) -> Option<u32> {635		match self636			.sponsored_data_rate_limit637			.unwrap_or(SponsoringRateLimit::SponsoringDisabled)638		{639			SponsoringRateLimit::SponsoringDisabled => None,640			SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),641		}642	}643}644645/// Permissions on certain operations within a collection.646/// 647/// Some fields are wrapped in [`Option`], where `None` means chain default.648/// 649/// Update with `pallet_common::Pallet::clamp_permissions`.650#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]651#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]652// When adding/removing fields from this struct - don't forget to also update `pallet_common::Pallet::clamp_permissions`.653// TODO: move `pallet_common::Pallet::clamp_permissions` into `impl CollectionPermissions`.654pub struct CollectionPermissions {655	/// Access mode.656	/// 657	/// * Default - [`AccessMode::Normal`].658	pub access: Option<AccessMode>,659660	/// Minting allowance.661	/// 662	/// * Default - **false**.663	pub mint_mode: Option<bool>,664665	/// Permissions for nesting.666	/// 667	/// * Default668	///   - `token_owner` - **false**669	///   - `collection_admin` - **false**670	///   - `restricted` - **None**671	pub nesting: Option<NestingPermissions>,672}673674impl CollectionPermissions {675	/// Get effective value for [`access`](self.access).676	pub fn access(&self) -> AccessMode {677		self.access.unwrap_or(AccessMode::Normal)678	}679680	/// Get effective value for [`mint_mode`](self.mint_mode).681	pub fn mint_mode(&self) -> bool {682		self.mint_mode.unwrap_or(false)683	}684685	/// Get effective value for [`nesting`](self.nesting).686	pub fn nesting(&self) -> &NestingPermissions {687		static DEFAULT: NestingPermissions = NestingPermissions {688			token_owner: false,689			collection_admin: false,690			restricted: None,691			#[cfg(feature = "runtime-benchmarks")]692			permissive: false,693		};694		self.nesting.as_ref().unwrap_or(&DEFAULT)695	}696}697698/// Inner set for collections allowed to nest.699type OwnerRestrictedSetInner = BoundedBTreeSet<CollectionId, ConstU32<16>>;700701/// Wraper for collections set allowing nest.702#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]703#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]704#[derivative(Debug)]705pub struct OwnerRestrictedSet(706	#[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]707	#[derivative(Debug(format_with = "bounded::set_debug"))]708	pub OwnerRestrictedSetInner,709);710711impl OwnerRestrictedSet {712	/// Create new set.713	pub fn new() -> Self {714		Self(Default::default())715	}716}717impl core::ops::Deref for OwnerRestrictedSet {718	type Target = OwnerRestrictedSetInner;719	fn deref(&self) -> &Self::Target {720		&self.0721	}722}723impl core::ops::DerefMut for OwnerRestrictedSet {724	fn deref_mut(&mut self) -> &mut Self::Target {725		&mut self.0726	}727}728729/// Part of collection permissions, if set, defines who is able to nest tokens into other tokens.730#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]731#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]732#[derivative(Debug)]733pub struct NestingPermissions {734	/// Owner of token can nest tokens under it.735	pub token_owner: bool,736	/// Admin of token collection can nest tokens under token.737	pub collection_admin: bool,738	/// If set - only tokens from specified collections can be nested.739	pub restricted: Option<OwnerRestrictedSet>,740741	#[cfg(feature = "runtime-benchmarks")]742	/// Anyone can nest tokens, mutually exclusive with `token_owner`, `admin`.743	pub permissive: bool,744}745746/// Enum denominating how often can sponsoring occur if it is enabled.747/// 748/// Used for [`collection limits`](CollectionLimits).749#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]750#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]751pub enum SponsoringRateLimit {752	/// Sponsoring is disabled, and the collection sponsor will not pay for transactions753	SponsoringDisabled,754	/// Once per how many blocks can sponsorship of a transaction type occur755	Blocks(u32),756}757758/// Data used to describe an NFT at creation.759#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]760#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]761#[derivative(Debug)]762pub struct CreateNftData {763	/// Key-value pairs used to describe the token as metadata764	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]765	#[derivative(Debug(format_with = "bounded::vec_debug"))]766	/// Properties that wil be assignet to created item.767	pub properties: CollectionPropertiesVec,768}769770/// Data used to describe a Fungible token at creation.771#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]772#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]773pub struct CreateFungibleData {774	/// Number of fungible coins minted775	pub value: u128,776}777778/// Data used to describe a Refungible token at creation.779#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]780#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]781#[derivative(Debug)]782pub struct CreateReFungibleData {783	/// Immutable metadata of the token784	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]785	#[derivative(Debug(format_with = "bounded::vec_debug"))]786	pub const_data: BoundedVec<u8, CustomDataLimit>,787788	/// Pieces of created token.789	pub pieces: u128,790791	/// Key-value pairs used to describe the token as metadata792	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]793	#[derivative(Debug(format_with = "bounded::vec_debug"))]794	pub properties: CollectionPropertiesVec,795}796797// TODO: remove this.798#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]799#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]800pub enum MetaUpdatePermission {801	ItemOwner,802	Admin,803	None,804}805806/// Enum holding data used for creation of all three item types.807/// Unified data for create item.808#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]809#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]810pub enum CreateItemData {811	/// Data for create NFT.812	NFT(CreateNftData),813	/// Data for create Fungible item.814	Fungible(CreateFungibleData),815	/// Data for create ReFungible item.816	ReFungible(CreateReFungibleData),817}818819/// Extended data for create NFT.820#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]821#[derivative(Debug)]822pub struct CreateNftExData<CrossAccountId> {823	/// Properties that wil be assignet to created item.824	#[derivative(Debug(format_with = "bounded::vec_debug"))]825	pub properties: CollectionPropertiesVec,826827	/// Owner of creating item.828	pub owner: CrossAccountId,829}830831/// Extended data for create ReFungible item.832#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]833#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]834pub struct CreateRefungibleExData<CrossAccountId> {835	/// Custom data stored in token.836	#[derivative(Debug(format_with = "bounded::vec_debug"))]837	pub const_data: BoundedVec<u8, CustomDataLimit>,838839	/// Users who will be assigned the specified number of token parts.840	#[derivative(Debug(format_with = "bounded::map_debug"))]841	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,842	#[derivative(Debug(format_with = "bounded::vec_debug"))]843	pub properties: CollectionPropertiesVec,844}845846/// Unified extended data for creating item.847#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]848#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]849pub enum CreateItemExData<CrossAccountId> {850	/// Extended data for create NFT.851	NFT(852		#[derivative(Debug(format_with = "bounded::vec_debug"))]853		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,854	),855856	/// Extended data for create Fungible item.857	Fungible(858		#[derivative(Debug(format_with = "bounded::map_debug"))]859		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,860	),861862	/// Extended data for create ReFungible item in case of863	/// many tokens, each may have only one owner864	RefungibleMultipleItems(865		#[derivative(Debug(format_with = "bounded::vec_debug"))]866		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,867	),868869	/// Extended data for create ReFungible item in case of870	/// single token, which may have many owners871	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),872}873874impl CreateItemData {875	/// Get size of custom data.876	pub fn data_size(&self) -> usize {877		match self {878			CreateItemData::ReFungible(data) => data.const_data.len(),879			_ => 0,880		}881	}882}883884impl From<CreateNftData> for CreateItemData {885	fn from(item: CreateNftData) -> Self {886		CreateItemData::NFT(item)887	}888}889890impl From<CreateReFungibleData> for CreateItemData {891	fn from(item: CreateReFungibleData) -> Self {892		CreateItemData::ReFungible(item)893	}894}895896impl From<CreateFungibleData> for CreateItemData {897	fn from(item: CreateFungibleData) -> Self {898		CreateItemData::Fungible(item)899	}900}901902/// Token's address, dictated by its collection and token IDs.903#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]904#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]905// todo possibly rename to be used generally as an address pair906pub struct TokenChild {907	/// Token id.908	pub token: TokenId,909910	/// Collection id.911	pub collection: CollectionId,912}913914/// Collection statistics.915#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]916#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]917pub struct CollectionStats {918	/// Number of created items.919	pub created: u32,920921	/// Number of burned items.922	pub destroyed: u32,923924	/// Number of current items.925	pub alive: u32,926}927928/// This type works like [`PhantomData`] but supports generating _scale-info_ descriptions to generate node metadata.929#[derive(Encode, Decode, Clone, Debug)]930#[cfg_attr(feature = "std", derive(PartialEq))]931pub struct PhantomType<T>(core::marker::PhantomData<T>);932933impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {934	type Identity = PhantomType<T>;935936	fn type_info() -> scale_info::Type {937		use scale_info::{938			Type, Path,939			build::{FieldsBuilder, UnnamedFields},940			type_params,941		};942		Type::builder()943			.path(Path::new("up_data_structs", "PhantomType"))944			.type_params(type_params!(T))945			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))946	}947}948impl<T> MaxEncodedLen for PhantomType<T> {949	fn max_encoded_len() -> usize {950		0951	}952}953954/// Bounded vector of bytes.955pub type BoundedBytes<S> = BoundedVec<u8, S>;956957/// Extra properties for external collections.958pub type AuxPropertyValue = BoundedBytes<ConstU32<MAX_AUX_PROPERTY_VALUE_LENGTH>>;959960/// Property key.961pub type PropertyKey = BoundedBytes<ConstU32<MAX_PROPERTY_KEY_LENGTH>>;962963/// Property value.964pub type PropertyValue = BoundedBytes<ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;965966/// Property permission.967#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]968#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]969pub struct PropertyPermission {970	/// Permission to change the property and property permission.971	/// 972	/// If it **false** then you can not change corresponding property even if [`collection_admin`] and [`token_owner`] are **true**.973	pub mutable: bool,974975	/// Change permission for the collection administrator.976	pub collection_admin: bool,977978	/// Permission to change the property for the owner of the token.979	pub token_owner: bool,980}981982impl PropertyPermission {983	/// Creates mutable property permission but changes restricted for collection admin and token owner.984	pub fn none() -> Self {985		Self {986			mutable: true,987			collection_admin: false,988			token_owner: false,989		}990	}991}992993/// Property is simpl key-value record.994#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]995#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]996pub struct Property {997	/// Property key.998	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]999	pub key: PropertyKey,10001001	/// Property value.1002	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]1003	pub value: PropertyValue,1004}10051006impl Into<(PropertyKey, PropertyValue)> for Property {1007	fn into(self) -> (PropertyKey, PropertyValue) {1008		(self.key, self.value)1009	}1010}10111012/// Record for proprty key permission.1013#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]1014#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]1015pub struct PropertyKeyPermission {1016	/// Key.1017	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]1018	pub key: PropertyKey,10191020	/// Permission.1021	pub permission: PropertyPermission,1022}10231024impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {1025	fn into(self) -> (PropertyKey, PropertyPermission) {1026		(self.key, self.permission)1027	}1028}10291030/// Errors for properties actions.1031#[derive(Debug)]1032pub enum PropertiesError {1033	/// The space allocated for properties has run out.1034	/// 1035	/// * Limit for colection - [`MAX_COLLECTION_PROPERTIES_SIZE`].1036	/// * Limit for token - [`MAX_TOKEN_PROPERTIES_SIZE`].1037	NoSpaceForProperty,10381039	/// The property limit has been reached.1040	/// 1041	/// * Limit - [`MAX_PROPERTIES_PER_ITEM`].1042	PropertyLimitReached,10431044	/// Property key contains not allowed character.1045	InvalidCharacterInPropertyKey,10461047	/// Property key length is too long.1048	/// 1049	/// * Limit - [`MAX_PROPERTY_KEY_LENGTH`].1050	PropertyKeyIsTooLong,10511052	/// Property key is empty.1053	EmptyPropertyKey,1054}10551056/// Marker for scope of property.1057/// 1058/// Scoped property can't be changed by user. Used for external collections.1059#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, Clone, Copy)]1060pub enum PropertyScope {1061	None,1062	Rmrk,1063}10641065impl PropertyScope {1066	/// Apply scope to property key.1067	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {1068		let scope_str: &[u8] = match self {1069			Self::None => return Ok(key),1070			Self::Rmrk => b"rmrk",1071		};10721073		[scope_str, b":", key.as_slice()]1074			.concat()1075			.try_into()1076			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)1077	}1078}10791080/// Trait for operate with properties.1081pub trait TrySetProperty: Sized {1082	type Value;10831084	/// Try to set property with scope.1085	fn try_scoped_set(1086		&mut self,1087		scope: PropertyScope,1088		key: PropertyKey,1089		value: Self::Value,1090	) -> Result<(), PropertiesError>;1091	1092	1093	/// Try to set property with scope from iterator.1094	fn try_scoped_set_from_iter<I, KV>(1095		&mut self,1096		scope: PropertyScope,1097		iter: I,1098	) -> Result<(), PropertiesError>1099	where1100		I: Iterator<Item = KV>,1101		KV: Into<(PropertyKey, Self::Value)>,1102	{1103		for kv in iter {1104			let (key, value) = kv.into();1105			self.try_scoped_set(scope, key, value)?;1106		}11071108		Ok(())1109	}11101111	/// Try to set property.1112	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {1113		self.try_scoped_set(PropertyScope::None, key, value)1114	}1115	1116	/// Try to set property from iterator.1117	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>1118	where1119		I: Iterator<Item = KV>,1120		KV: Into<(PropertyKey, Self::Value)>,1121	{1122		self.try_scoped_set_from_iter(PropertyScope::None, iter)1123	}1124}11251126/// Wrapped map for storing properties.1127#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]1128#[derivative(Default(bound = ""))]1129pub struct PropertiesMap<Value>(1130	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,1131);11321133impl<Value> PropertiesMap<Value> {1134	/// Create new property map.1135	pub fn new() -> Self {1136		Self(BoundedBTreeMap::new())1137	}11381139	/// Remove property from map.1140	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {1141		Self::check_property_key(key)?;11421143		Ok(self.0.remove(key))1144	}11451146	/// Get property with appropriate key from map.1147	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {1148		self.0.get(key)1149	}11501151	/// Check if map contains key.1152	pub fn contains_key(&self, key: &PropertyKey) -> bool {1153		self.0.contains_key(key)1154	}1155	1156	/// Check if map contains key with key validation.1157	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {1158		if key.is_empty() {1159			return Err(PropertiesError::EmptyPropertyKey);1160		}11611162		for byte in key.as_slice().iter() {1163			let byte = *byte;11641165			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' && byte != b'.' {1166				return Err(PropertiesError::InvalidCharacterInPropertyKey);1167			}1168		}11691170		Ok(())1171	}1172}11731174impl<Value> IntoIterator for PropertiesMap<Value> {1175	type Item = (PropertyKey, Value);1176	type IntoIter = <1177		BoundedBTreeMap<1178			PropertyKey,1179			Value,1180			ConstU32<MAX_PROPERTIES_PER_ITEM>1181		> as IntoIterator1182	>::IntoIter;11831184	fn into_iter(self) -> Self::IntoIter {1185		self.0.into_iter()1186	}1187}11881189impl<Value> TrySetProperty for PropertiesMap<Value> {1190	type Value = Value;11911192	fn try_scoped_set(1193		&mut self,1194		scope: PropertyScope,1195		key: PropertyKey,1196		value: Self::Value,1197	) -> Result<(), PropertiesError> {1198		Self::check_property_key(&key)?;11991200		let key = scope.apply(key)?;1201		self.01202			.try_insert(key, value)1203			.map_err(|_| PropertiesError::PropertyLimitReached)?;12041205		Ok(())1206	}1207}12081209/// Alias for property permissions map.1210pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;12111212/// Wrapper for properties map with consumed space control.1213#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]1214pub struct Properties {1215	map: PropertiesMap<PropertyValue>,1216	consumed_space: u32,1217	space_limit: u32,1218}12191220impl Properties {1221	/// Create new properies container.1222	pub fn new(space_limit: u32) -> Self {1223		Self {1224			map: PropertiesMap::new(),1225			consumed_space: 0,1226			space_limit,1227		}1228	}12291230	/// Remove propery with appropiate key.1231	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {1232		let value = self.map.remove(key)?;12331234		if let Some(ref value) = value {1235			let value_len = value.len() as u32;1236			self.consumed_space -= value_len;1237		}12381239		Ok(value)1240	}12411242	/// Get property with appropriate key.1243	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {1244		self.map.get(key)1245	}1246}12471248impl IntoIterator for Properties {1249	type Item = (PropertyKey, PropertyValue);1250	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;12511252	fn into_iter(self) -> Self::IntoIter {1253		self.map.into_iter()1254	}1255}12561257impl TrySetProperty for Properties {1258	type Value = PropertyValue;12591260	fn try_scoped_set(1261		&mut self,1262		scope: PropertyScope,1263		key: PropertyKey,1264		value: Self::Value,1265	) -> Result<(), PropertiesError> {1266		let value_len = value.len();12671268		if self.consumed_space as usize + value_len > self.space_limit as usize1269			&& !cfg!(feature = "runtime-benchmarks")1270		{1271			return Err(PropertiesError::NoSpaceForProperty);1272		}12731274		self.map.try_scoped_set(scope, key, value)?;12751276		self.consumed_space += value_len as u32;12771278		Ok(())1279	}1280}12811282/// Utility struct for using in `StorageMap`.1283pub struct CollectionProperties;12841285impl Get<Properties> for CollectionProperties {1286	fn get() -> Properties {1287		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)1288	}1289}12901291/// Utility struct for using in `StorageMap`.1292pub struct TokenProperties;12931294impl Get<Properties> for TokenProperties {1295	fn get() -> Properties {1296		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)1297	}1298}12991300// RMRK1301// todo document?1302parameter_types! {1303	#[derive(PartialEq, TypeInfo)]1304	pub const RmrkStringLimit: u32 = 128;1305	#[derive(PartialEq)]1306	pub const RmrkCollectionSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1307	#[derive(PartialEq)]1308	pub const RmrkResourceSymbolLimit: u32 = 10;1309	#[derive(PartialEq)]1310	pub const RmrkBaseSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1311	#[derive(PartialEq)]1312	pub const RmrkKeyLimit: u32 = 32;1313	#[derive(PartialEq)]1314	pub const RmrkValueLimit: u32 = 256;1315	#[derive(PartialEq)]1316	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;1317	#[derive(PartialEq)]1318	pub const MaxPropertiesPerTheme: u32 = 5;1319	#[derive(PartialEq)]1320	pub const RmrkPartsLimit: u32 = 25;1321	#[derive(PartialEq)]1322	pub const RmrkMaxPriorities: u32 = 25;1323	#[derive(PartialEq)]1324	pub const MaxResourcesOnMint: u32 = 100;1325}13261327impl From<RmrkCollectionId> for CollectionId {1328	fn from(id: RmrkCollectionId) -> Self {1329		Self(id)1330	}1331}13321333impl From<RmrkNftId> for TokenId {1334	fn from(id: RmrkNftId) -> Self {1335		Self(id)1336	}1337}13381339pub type RmrkCollectionInfo<AccountId> =1340	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;1341pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;1342pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;1343pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;1344pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;1345pub type BoundedEquippableCollectionIds =1346	BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>;1347pub type RmrkPartType = PartType<RmrkString, BoundedEquippableCollectionIds>;1348pub type RmrkEquippableList = EquippableList<BoundedEquippableCollectionIds>;1349pub type RmrkThemeProperty = ThemeProperty<RmrkString>;1350pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;1351pub type RmrkBoundedTheme = Theme<RmrkString, BoundedVec<RmrkThemeProperty, MaxPropertiesPerTheme>>;1352pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;13531354pub type RmrkBasicResource = BasicResource<RmrkString>;1355pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;1356pub type RmrkSlotResource = SlotResource<RmrkString>;13571358pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;1359pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;1360pub type RmrkBaseSymbol = BoundedVec<u8, RmrkBaseSymbolLimit>;1361pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;1362pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;1363pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;1364pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed13651366pub type RmrkRpcString = Vec<u8>;1367pub type RmrkThemeName = RmrkRpcString;1368pub type RmrkPropertyKey = RmrkRpcString;