git.delta.rocks / unique-network / refs/commits / 40cdf2739a9d

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	/// Number of pieces the RFT is split into784	pub pieces: u128,785786	/// Key-value pairs used to describe the token as metadata787	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]788	#[derivative(Debug(format_with = "bounded::vec_debug"))]789	pub properties: CollectionPropertiesVec,790}791792// TODO: remove this.793#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]794#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]795pub enum MetaUpdatePermission {796	ItemOwner,797	Admin,798	None,799}800801/// Enum holding data used for creation of all three item types.802/// Unified data for create item.803#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]804#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]805pub enum CreateItemData {806	/// Data for create NFT.807	NFT(CreateNftData),808	/// Data for create Fungible item.809	Fungible(CreateFungibleData),810	/// Data for create ReFungible item.811	ReFungible(CreateReFungibleData),812}813814/// Extended data for create NFT.815#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]816#[derivative(Debug)]817pub struct CreateNftExData<CrossAccountId> {818	/// Properties that wil be assignet to created item.819	#[derivative(Debug(format_with = "bounded::vec_debug"))]820	pub properties: CollectionPropertiesVec,821822	/// Owner of creating item.823	pub owner: CrossAccountId,824}825826/// Extended data for create ReFungible item.827#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]828#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]829pub struct CreateRefungibleExMultipleOwners<CrossAccountId> {830	#[derivative(Debug(format_with = "bounded::map_debug"))]831	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,832	#[derivative(Debug(format_with = "bounded::vec_debug"))]833	pub properties: CollectionPropertiesVec,834}835836/// Extended data for create ReFungible item.837#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]838#[derivative(Debug(bound = "CrossAccountId: fmt::Debug"))]839pub struct CreateRefungibleExSingleOwner<CrossAccountId> {840	pub user: CrossAccountId,841	pub pieces: u128,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<CreateRefungibleExSingleOwner<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(CreateRefungibleExMultipleOwners<CrossAccountId>),872}873874impl From<CreateNftData> for CreateItemData {875	fn from(item: CreateNftData) -> Self {876		CreateItemData::NFT(item)877	}878}879880impl From<CreateReFungibleData> for CreateItemData {881	fn from(item: CreateReFungibleData) -> Self {882		CreateItemData::ReFungible(item)883	}884}885886impl From<CreateFungibleData> for CreateItemData {887	fn from(item: CreateFungibleData) -> Self {888		CreateItemData::Fungible(item)889	}890}891892/// Token's address, dictated by its collection and token IDs.893#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]894#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]895// todo possibly rename to be used generally as an address pair896pub struct TokenChild {897	/// Token id.898	pub token: TokenId,899900	/// Collection id.901	pub collection: CollectionId,902}903904/// Collection statistics.905#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]906#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]907pub struct CollectionStats {908	/// Number of created items.909	pub created: u32,910911	/// Number of burned items.912	pub destroyed: u32,913914	/// Number of current items.915	pub alive: u32,916}917918/// This type works like [`PhantomData`] but supports generating _scale-info_ descriptions to generate node metadata.919#[derive(Encode, Decode, Clone, Debug)]920#[cfg_attr(feature = "std", derive(PartialEq))]921pub struct PhantomType<T>(core::marker::PhantomData<T>);922923impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {924	type Identity = PhantomType<T>;925926	fn type_info() -> scale_info::Type {927		use scale_info::{928			Type, Path,929			build::{FieldsBuilder, UnnamedFields},930			type_params,931		};932		Type::builder()933			.path(Path::new("up_data_structs", "PhantomType"))934			.type_params(type_params!(T))935			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))936	}937}938impl<T> MaxEncodedLen for PhantomType<T> {939	fn max_encoded_len() -> usize {940		0941	}942}943944/// Bounded vector of bytes.945pub type BoundedBytes<S> = BoundedVec<u8, S>;946947/// Extra properties for external collections.948pub type AuxPropertyValue = BoundedBytes<ConstU32<MAX_AUX_PROPERTY_VALUE_LENGTH>>;949950/// Property key.951pub type PropertyKey = BoundedBytes<ConstU32<MAX_PROPERTY_KEY_LENGTH>>;952953/// Property value.954pub type PropertyValue = BoundedBytes<ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;955956/// Property permission.957#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]958#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]959pub struct PropertyPermission {960	/// Permission to change the property and property permission.961	///962	/// If it **false** then you can not change corresponding property even if [`collection_admin`] and [`token_owner`] are **true**.963	pub mutable: bool,964965	/// Change permission for the collection administrator.966	pub collection_admin: bool,967968	/// Permission to change the property for the owner of the token.969	pub token_owner: bool,970}971972impl PropertyPermission {973	/// Creates mutable property permission but changes restricted for collection admin and token owner.974	pub fn none() -> Self {975		Self {976			mutable: true,977			collection_admin: false,978			token_owner: false,979		}980	}981}982983/// Property is simpl key-value record.984#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]985#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]986pub struct Property {987	/// Property key.988	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]989	pub key: PropertyKey,990991	/// Property value.992	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]993	pub value: PropertyValue,994}995996impl Into<(PropertyKey, PropertyValue)> for Property {997	fn into(self) -> (PropertyKey, PropertyValue) {998		(self.key, self.value)999	}1000}10011002/// Record for proprty key permission.1003#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]1004#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]1005pub struct PropertyKeyPermission {1006	/// Key.1007	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]1008	pub key: PropertyKey,10091010	/// Permission.1011	pub permission: PropertyPermission,1012}10131014impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {1015	fn into(self) -> (PropertyKey, PropertyPermission) {1016		(self.key, self.permission)1017	}1018}10191020/// Errors for properties actions.1021#[derive(Debug)]1022pub enum PropertiesError {1023	/// The space allocated for properties has run out.1024	///1025	/// * Limit for colection - [`MAX_COLLECTION_PROPERTIES_SIZE`].1026	/// * Limit for token - [`MAX_TOKEN_PROPERTIES_SIZE`].1027	NoSpaceForProperty,10281029	/// The property limit has been reached.1030	///1031	/// * Limit - [`MAX_PROPERTIES_PER_ITEM`].1032	PropertyLimitReached,10331034	/// Property key contains not allowed character.1035	InvalidCharacterInPropertyKey,10361037	/// Property key length is too long.1038	///1039	/// * Limit - [`MAX_PROPERTY_KEY_LENGTH`].1040	PropertyKeyIsTooLong,10411042	/// Property key is empty.1043	EmptyPropertyKey,1044}10451046/// Marker for scope of property.1047///1048/// Scoped property can't be changed by user. Used for external collections.1049#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, Clone, Copy)]1050pub enum PropertyScope {1051	None,1052	Rmrk,1053}10541055impl PropertyScope {1056	/// Apply scope to property key.1057	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {1058		let scope_str: &[u8] = match self {1059			Self::None => return Ok(key),1060			Self::Rmrk => b"rmrk",1061		};10621063		[scope_str, b":", key.as_slice()]1064			.concat()1065			.try_into()1066			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)1067	}1068}10691070/// Trait for operate with properties.1071pub trait TrySetProperty: Sized {1072	type Value;10731074	/// Try to set property with scope.1075	fn try_scoped_set(1076		&mut self,1077		scope: PropertyScope,1078		key: PropertyKey,1079		value: Self::Value,1080	) -> Result<(), PropertiesError>;10811082	/// Try to set property with scope from iterator.1083	fn try_scoped_set_from_iter<I, KV>(1084		&mut self,1085		scope: PropertyScope,1086		iter: I,1087	) -> Result<(), PropertiesError>1088	where1089		I: Iterator<Item = KV>,1090		KV: Into<(PropertyKey, Self::Value)>,1091	{1092		for kv in iter {1093			let (key, value) = kv.into();1094			self.try_scoped_set(scope, key, value)?;1095		}10961097		Ok(())1098	}10991100	/// Try to set property.1101	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {1102		self.try_scoped_set(PropertyScope::None, key, value)1103	}11041105	/// Try to set property from iterator.1106	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>1107	where1108		I: Iterator<Item = KV>,1109		KV: Into<(PropertyKey, Self::Value)>,1110	{1111		self.try_scoped_set_from_iter(PropertyScope::None, iter)1112	}1113}11141115/// Wrapped map for storing properties.1116#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]1117#[derivative(Default(bound = ""))]1118pub struct PropertiesMap<Value>(1119	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,1120);11211122impl<Value> PropertiesMap<Value> {1123	/// Create new property map.1124	pub fn new() -> Self {1125		Self(BoundedBTreeMap::new())1126	}11271128	/// Remove property from map.1129	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {1130		Self::check_property_key(key)?;11311132		Ok(self.0.remove(key))1133	}11341135	/// Get property with appropriate key from map.1136	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {1137		self.0.get(key)1138	}11391140	/// Check if map contains key.1141	pub fn contains_key(&self, key: &PropertyKey) -> bool {1142		self.0.contains_key(key)1143	}11441145	/// Check if map contains key with key validation.1146	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {1147		if key.is_empty() {1148			return Err(PropertiesError::EmptyPropertyKey);1149		}11501151		for byte in key.as_slice().iter() {1152			let byte = *byte;11531154			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' && byte != b'.' {1155				return Err(PropertiesError::InvalidCharacterInPropertyKey);1156			}1157		}11581159		Ok(())1160	}1161}11621163impl<Value> IntoIterator for PropertiesMap<Value> {1164	type Item = (PropertyKey, Value);1165	type IntoIter = <1166		BoundedBTreeMap<1167			PropertyKey,1168			Value,1169			ConstU32<MAX_PROPERTIES_PER_ITEM>1170		> as IntoIterator1171	>::IntoIter;11721173	fn into_iter(self) -> Self::IntoIter {1174		self.0.into_iter()1175	}1176}11771178impl<Value> TrySetProperty for PropertiesMap<Value> {1179	type Value = Value;11801181	fn try_scoped_set(1182		&mut self,1183		scope: PropertyScope,1184		key: PropertyKey,1185		value: Self::Value,1186	) -> Result<(), PropertiesError> {1187		Self::check_property_key(&key)?;11881189		let key = scope.apply(key)?;1190		self.01191			.try_insert(key, value)1192			.map_err(|_| PropertiesError::PropertyLimitReached)?;11931194		Ok(())1195	}1196}11971198/// Alias for property permissions map.1199pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;12001201/// Wrapper for properties map with consumed space control.1202#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]1203pub struct Properties {1204	map: PropertiesMap<PropertyValue>,1205	consumed_space: u32,1206	space_limit: u32,1207}12081209impl Properties {1210	/// Create new properies container.1211	pub fn new(space_limit: u32) -> Self {1212		Self {1213			map: PropertiesMap::new(),1214			consumed_space: 0,1215			space_limit,1216		}1217	}12181219	/// Remove propery with appropiate key.1220	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {1221		let value = self.map.remove(key)?;12221223		if let Some(ref value) = value {1224			let value_len = value.len() as u32;1225			self.consumed_space -= value_len;1226		}12271228		Ok(value)1229	}12301231	/// Get property with appropriate key.1232	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {1233		self.map.get(key)1234	}1235}12361237impl IntoIterator for Properties {1238	type Item = (PropertyKey, PropertyValue);1239	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;12401241	fn into_iter(self) -> Self::IntoIter {1242		self.map.into_iter()1243	}1244}12451246impl TrySetProperty for Properties {1247	type Value = PropertyValue;12481249	fn try_scoped_set(1250		&mut self,1251		scope: PropertyScope,1252		key: PropertyKey,1253		value: Self::Value,1254	) -> Result<(), PropertiesError> {1255		let value_len = value.len();12561257		if self.consumed_space as usize + value_len > self.space_limit as usize1258			&& !cfg!(feature = "runtime-benchmarks")1259		{1260			return Err(PropertiesError::NoSpaceForProperty);1261		}12621263		self.map.try_scoped_set(scope, key, value)?;12641265		self.consumed_space += value_len as u32;12661267		Ok(())1268	}1269}12701271/// Utility struct for using in `StorageMap`.1272pub struct CollectionProperties;12731274impl Get<Properties> for CollectionProperties {1275	fn get() -> Properties {1276		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)1277	}1278}12791280/// Utility struct for using in `StorageMap`.1281pub struct TokenProperties;12821283impl Get<Properties> for TokenProperties {1284	fn get() -> Properties {1285		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)1286	}1287}12881289// RMRK1290// todo document?1291parameter_types! {1292	#[derive(PartialEq, TypeInfo)]1293	pub const RmrkStringLimit: u32 = 128;1294	#[derive(PartialEq)]1295	pub const RmrkCollectionSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1296	#[derive(PartialEq)]1297	pub const RmrkResourceSymbolLimit: u32 = 10;1298	#[derive(PartialEq)]1299	pub const RmrkBaseSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1300	#[derive(PartialEq)]1301	pub const RmrkKeyLimit: u32 = 32;1302	#[derive(PartialEq)]1303	pub const RmrkValueLimit: u32 = 256;1304	#[derive(PartialEq)]1305	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;1306	#[derive(PartialEq)]1307	pub const MaxPropertiesPerTheme: u32 = 5;1308	#[derive(PartialEq)]1309	pub const RmrkPartsLimit: u32 = 25;1310	#[derive(PartialEq)]1311	pub const RmrkMaxPriorities: u32 = 25;1312	#[derive(PartialEq)]1313	pub const MaxResourcesOnMint: u32 = 100;1314}13151316impl From<RmrkCollectionId> for CollectionId {1317	fn from(id: RmrkCollectionId) -> Self {1318		Self(id)1319	}1320}13211322impl From<RmrkNftId> for TokenId {1323	fn from(id: RmrkNftId) -> Self {1324		Self(id)1325	}1326}13271328pub type RmrkCollectionInfo<AccountId> =1329	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;1330pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;1331pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;1332pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;1333pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;1334pub type BoundedEquippableCollectionIds =1335	BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>;1336pub type RmrkPartType = PartType<RmrkString, BoundedEquippableCollectionIds>;1337pub type RmrkEquippableList = EquippableList<BoundedEquippableCollectionIds>;1338pub type RmrkThemeProperty = ThemeProperty<RmrkString>;1339pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;1340pub type RmrkBoundedTheme = Theme<RmrkString, BoundedVec<RmrkThemeProperty, MaxPropertiesPerTheme>>;1341pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;13421343pub type RmrkBasicResource = BasicResource<RmrkString>;1344pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;1345pub type RmrkSlotResource = SlotResource<RmrkString>;13461347pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;1348pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;1349pub type RmrkBaseSymbol = BoundedVec<u8, RmrkBaseSymbolLimit>;1350pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;1351pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;1352pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;1353pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed13541355pub type RmrkRpcString = Vec<u8>;1356pub type RmrkThemeName = RmrkRpcString;1357pub type RmrkPropertyKey = RmrkRpcString;