git.delta.rocks / unique-network / refs/commits / 19daf00a26e2

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 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>,553554	/// 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>,569570	/// 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>;10911092	/// Try to set property with scope from iterator.1093	fn try_scoped_set_from_iter<I, KV>(1094		&mut self,1095		scope: PropertyScope,1096		iter: I,1097	) -> Result<(), PropertiesError>1098	where1099		I: Iterator<Item = KV>,1100		KV: Into<(PropertyKey, Self::Value)>,1101	{1102		for kv in iter {1103			let (key, value) = kv.into();1104			self.try_scoped_set(scope, key, value)?;1105		}11061107		Ok(())1108	}11091110	/// Try to set property.1111	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {1112		self.try_scoped_set(PropertyScope::None, key, value)1113	}11141115	/// Try to set property from iterator.1116	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>1117	where1118		I: Iterator<Item = KV>,1119		KV: Into<(PropertyKey, Self::Value)>,1120	{1121		self.try_scoped_set_from_iter(PropertyScope::None, iter)1122	}1123}11241125/// Wrapped map for storing properties.1126#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]1127#[derivative(Default(bound = ""))]1128pub struct PropertiesMap<Value>(1129	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,1130);11311132impl<Value> PropertiesMap<Value> {1133	/// Create new property map.1134	pub fn new() -> Self {1135		Self(BoundedBTreeMap::new())1136	}11371138	/// Remove property from map.1139	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {1140		Self::check_property_key(key)?;11411142		Ok(self.0.remove(key))1143	}11441145	/// Get property with appropriate key from map.1146	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {1147		self.0.get(key)1148	}11491150	/// Check if map contains key.1151	pub fn contains_key(&self, key: &PropertyKey) -> bool {1152		self.0.contains_key(key)1153	}11541155	/// Check if map contains key with key validation.1156	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {1157		if key.is_empty() {1158			return Err(PropertiesError::EmptyPropertyKey);1159		}11601161		for byte in key.as_slice().iter() {1162			let byte = *byte;11631164			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' && byte != b'.' {1165				return Err(PropertiesError::InvalidCharacterInPropertyKey);1166			}1167		}11681169		Ok(())1170	}1171}11721173impl<Value> IntoIterator for PropertiesMap<Value> {1174	type Item = (PropertyKey, Value);1175	type IntoIter = <1176		BoundedBTreeMap<1177			PropertyKey,1178			Value,1179			ConstU32<MAX_PROPERTIES_PER_ITEM>1180		> as IntoIterator1181	>::IntoIter;11821183	fn into_iter(self) -> Self::IntoIter {1184		self.0.into_iter()1185	}1186}11871188impl<Value> TrySetProperty for PropertiesMap<Value> {1189	type Value = Value;11901191	fn try_scoped_set(1192		&mut self,1193		scope: PropertyScope,1194		key: PropertyKey,1195		value: Self::Value,1196	) -> Result<(), PropertiesError> {1197		Self::check_property_key(&key)?;11981199		let key = scope.apply(key)?;1200		self.01201			.try_insert(key, value)1202			.map_err(|_| PropertiesError::PropertyLimitReached)?;12031204		Ok(())1205	}1206}12071208/// Alias for property permissions map.1209pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;12101211/// Wrapper for properties map with consumed space control.1212#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]1213pub struct Properties {1214	map: PropertiesMap<PropertyValue>,1215	consumed_space: u32,1216	space_limit: u32,1217}12181219impl Properties {1220	/// Create new properies container.1221	pub fn new(space_limit: u32) -> Self {1222		Self {1223			map: PropertiesMap::new(),1224			consumed_space: 0,1225			space_limit,1226		}1227	}12281229	/// Remove propery with appropiate key.1230	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {1231		let value = self.map.remove(key)?;12321233		if let Some(ref value) = value {1234			let value_len = value.len() as u32;1235			self.consumed_space -= value_len;1236		}12371238		Ok(value)1239	}12401241	/// Get property with appropriate key.1242	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {1243		self.map.get(key)1244	}1245}12461247impl IntoIterator for Properties {1248	type Item = (PropertyKey, PropertyValue);1249	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;12501251	fn into_iter(self) -> Self::IntoIter {1252		self.map.into_iter()1253	}1254}12551256impl TrySetProperty for Properties {1257	type Value = PropertyValue;12581259	fn try_scoped_set(1260		&mut self,1261		scope: PropertyScope,1262		key: PropertyKey,1263		value: Self::Value,1264	) -> Result<(), PropertiesError> {1265		let value_len = value.len();12661267		if self.consumed_space as usize + value_len > self.space_limit as usize1268			&& !cfg!(feature = "runtime-benchmarks")1269		{1270			return Err(PropertiesError::NoSpaceForProperty);1271		}12721273		self.map.try_scoped_set(scope, key, value)?;12741275		self.consumed_space += value_len as u32;12761277		Ok(())1278	}1279}12801281/// Utility struct for using in `StorageMap`.1282pub struct CollectionProperties;12831284impl Get<Properties> for CollectionProperties {1285	fn get() -> Properties {1286		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)1287	}1288}12891290/// Utility struct for using in `StorageMap`.1291pub struct TokenProperties;12921293impl Get<Properties> for TokenProperties {1294	fn get() -> Properties {1295		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)1296	}1297}12981299// RMRK1300// todo document?1301parameter_types! {1302	#[derive(PartialEq, TypeInfo)]1303	pub const RmrkStringLimit: u32 = 128;1304	#[derive(PartialEq)]1305	pub const RmrkCollectionSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1306	#[derive(PartialEq)]1307	pub const RmrkResourceSymbolLimit: u32 = 10;1308	#[derive(PartialEq)]1309	pub const RmrkBaseSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1310	#[derive(PartialEq)]1311	pub const RmrkKeyLimit: u32 = 32;1312	#[derive(PartialEq)]1313	pub const RmrkValueLimit: u32 = 256;1314	#[derive(PartialEq)]1315	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;1316	#[derive(PartialEq)]1317	pub const MaxPropertiesPerTheme: u32 = 5;1318	#[derive(PartialEq)]1319	pub const RmrkPartsLimit: u32 = 25;1320	#[derive(PartialEq)]1321	pub const RmrkMaxPriorities: u32 = 25;1322	#[derive(PartialEq)]1323	pub const MaxResourcesOnMint: u32 = 100;1324}13251326impl From<RmrkCollectionId> for CollectionId {1327	fn from(id: RmrkCollectionId) -> Self {1328		Self(id)1329	}1330}13311332impl From<RmrkNftId> for TokenId {1333	fn from(id: RmrkNftId) -> Self {1334		Self(id)1335	}1336}13371338pub type RmrkCollectionInfo<AccountId> =1339	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;1340pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;1341pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;1342pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;1343pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;1344pub type BoundedEquippableCollectionIds =1345	BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>;1346pub type RmrkPartType = PartType<RmrkString, BoundedEquippableCollectionIds>;1347pub type RmrkEquippableList = EquippableList<BoundedEquippableCollectionIds>;1348pub type RmrkThemeProperty = ThemeProperty<RmrkString>;1349pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;1350pub type RmrkBoundedTheme = Theme<RmrkString, BoundedVec<RmrkThemeProperty, MaxPropertiesPerTheme>>;1351pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;13521353pub type RmrkBasicResource = BasicResource<RmrkString>;1354pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;1355pub type RmrkSlotResource = SlotResource<RmrkString>;13561357pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;1358pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;1359pub type RmrkBaseSymbol = BoundedVec<u8, RmrkBaseSymbolLimit>;1360pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;1361pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;1362pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;1363pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed13641365pub type RmrkRpcString = Vec<u8>;1366pub type RmrkThemeName = RmrkRpcString;1367pub type RmrkPropertyKey = RmrkRpcString;