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

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 CreateRefungibleExData<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/// Unified extended data for creating item.837#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]838#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]839pub enum CreateItemExData<CrossAccountId> {840	/// Extended data for create NFT.841	NFT(842		#[derivative(Debug(format_with = "bounded::vec_debug"))]843		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,844	),845846	/// Extended data for create Fungible item.847	Fungible(848		#[derivative(Debug(format_with = "bounded::map_debug"))]849		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,850	),851852	/// Extended data for create ReFungible item in case of853	/// many tokens, each may have only one owner854	RefungibleMultipleItems(855		#[derivative(Debug(format_with = "bounded::vec_debug"))]856		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,857	),858859	/// Extended data for create ReFungible item in case of860	/// single token, which may have many owners861	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),862}863864impl From<CreateNftData> for CreateItemData {865	fn from(item: CreateNftData) -> Self {866		CreateItemData::NFT(item)867	}868}869870impl From<CreateReFungibleData> for CreateItemData {871	fn from(item: CreateReFungibleData) -> Self {872		CreateItemData::ReFungible(item)873	}874}875876impl From<CreateFungibleData> for CreateItemData {877	fn from(item: CreateFungibleData) -> Self {878		CreateItemData::Fungible(item)879	}880}881882/// Token's address, dictated by its collection and token IDs.883#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]884#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]885// todo possibly rename to be used generally as an address pair886pub struct TokenChild {887	/// Token id.888	pub token: TokenId,889890	/// Collection id.891	pub collection: CollectionId,892}893894/// Collection statistics.895#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]896#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]897pub struct CollectionStats {898	/// Number of created items.899	pub created: u32,900901	/// Number of burned items.902	pub destroyed: u32,903904	/// Number of current items.905	pub alive: u32,906}907908/// This type works like [`PhantomData`] but supports generating _scale-info_ descriptions to generate node metadata.909#[derive(Encode, Decode, Clone, Debug)]910#[cfg_attr(feature = "std", derive(PartialEq))]911pub struct PhantomType<T>(core::marker::PhantomData<T>);912913impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {914	type Identity = PhantomType<T>;915916	fn type_info() -> scale_info::Type {917		use scale_info::{918			Type, Path,919			build::{FieldsBuilder, UnnamedFields},920			type_params,921		};922		Type::builder()923			.path(Path::new("up_data_structs", "PhantomType"))924			.type_params(type_params!(T))925			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))926	}927}928impl<T> MaxEncodedLen for PhantomType<T> {929	fn max_encoded_len() -> usize {930		0931	}932}933934/// Bounded vector of bytes.935pub type BoundedBytes<S> = BoundedVec<u8, S>;936937/// Extra properties for external collections.938pub type AuxPropertyValue = BoundedBytes<ConstU32<MAX_AUX_PROPERTY_VALUE_LENGTH>>;939940/// Property key.941pub type PropertyKey = BoundedBytes<ConstU32<MAX_PROPERTY_KEY_LENGTH>>;942943/// Property value.944pub type PropertyValue = BoundedBytes<ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;945946/// Property permission.947#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]948#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]949pub struct PropertyPermission {950	/// Permission to change the property and property permission.951	///952	/// If it **false** then you can not change corresponding property even if [`collection_admin`] and [`token_owner`] are **true**.953	pub mutable: bool,954955	/// Change permission for the collection administrator.956	pub collection_admin: bool,957958	/// Permission to change the property for the owner of the token.959	pub token_owner: bool,960}961962impl PropertyPermission {963	/// Creates mutable property permission but changes restricted for collection admin and token owner.964	pub fn none() -> Self {965		Self {966			mutable: true,967			collection_admin: false,968			token_owner: false,969		}970	}971}972973/// Property is simpl key-value record.974#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]975#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]976pub struct Property {977	/// Property key.978	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]979	pub key: PropertyKey,980981	/// Property value.982	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]983	pub value: PropertyValue,984}985986impl Into<(PropertyKey, PropertyValue)> for Property {987	fn into(self) -> (PropertyKey, PropertyValue) {988		(self.key, self.value)989	}990}991992/// Record for proprty key permission.993#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]994#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]995pub struct PropertyKeyPermission {996	/// Key.997	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]998	pub key: PropertyKey,9991000	/// Permission.1001	pub permission: PropertyPermission,1002}10031004impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {1005	fn into(self) -> (PropertyKey, PropertyPermission) {1006		(self.key, self.permission)1007	}1008}10091010/// Errors for properties actions.1011#[derive(Debug)]1012pub enum PropertiesError {1013	/// The space allocated for properties has run out.1014	///1015	/// * Limit for colection - [`MAX_COLLECTION_PROPERTIES_SIZE`].1016	/// * Limit for token - [`MAX_TOKEN_PROPERTIES_SIZE`].1017	NoSpaceForProperty,10181019	/// The property limit has been reached.1020	///1021	/// * Limit - [`MAX_PROPERTIES_PER_ITEM`].1022	PropertyLimitReached,10231024	/// Property key contains not allowed character.1025	InvalidCharacterInPropertyKey,10261027	/// Property key length is too long.1028	///1029	/// * Limit - [`MAX_PROPERTY_KEY_LENGTH`].1030	PropertyKeyIsTooLong,10311032	/// Property key is empty.1033	EmptyPropertyKey,1034}10351036/// Marker for scope of property.1037///1038/// Scoped property can't be changed by user. Used for external collections.1039#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, Clone, Copy)]1040pub enum PropertyScope {1041	None,1042	Rmrk,1043}10441045impl PropertyScope {1046	/// Apply scope to property key.1047	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {1048		let scope_str: &[u8] = match self {1049			Self::None => return Ok(key),1050			Self::Rmrk => b"rmrk",1051		};10521053		[scope_str, b":", key.as_slice()]1054			.concat()1055			.try_into()1056			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)1057	}1058}10591060/// Trait for operate with properties.1061pub trait TrySetProperty: Sized {1062	type Value;10631064	/// Try to set property with scope.1065	fn try_scoped_set(1066		&mut self,1067		scope: PropertyScope,1068		key: PropertyKey,1069		value: Self::Value,1070	) -> Result<(), PropertiesError>;10711072	/// Try to set property with scope from iterator.1073	fn try_scoped_set_from_iter<I, KV>(1074		&mut self,1075		scope: PropertyScope,1076		iter: I,1077	) -> Result<(), PropertiesError>1078	where1079		I: Iterator<Item = KV>,1080		KV: Into<(PropertyKey, Self::Value)>,1081	{1082		for kv in iter {1083			let (key, value) = kv.into();1084			self.try_scoped_set(scope, key, value)?;1085		}10861087		Ok(())1088	}10891090	/// Try to set property.1091	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {1092		self.try_scoped_set(PropertyScope::None, key, value)1093	}10941095	/// Try to set property from iterator.1096	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>1097	where1098		I: Iterator<Item = KV>,1099		KV: Into<(PropertyKey, Self::Value)>,1100	{1101		self.try_scoped_set_from_iter(PropertyScope::None, iter)1102	}1103}11041105/// Wrapped map for storing properties.1106#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]1107#[derivative(Default(bound = ""))]1108pub struct PropertiesMap<Value>(1109	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,1110);11111112impl<Value> PropertiesMap<Value> {1113	/// Create new property map.1114	pub fn new() -> Self {1115		Self(BoundedBTreeMap::new())1116	}11171118	/// Remove property from map.1119	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {1120		Self::check_property_key(key)?;11211122		Ok(self.0.remove(key))1123	}11241125	/// Get property with appropriate key from map.1126	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {1127		self.0.get(key)1128	}11291130	/// Check if map contains key.1131	pub fn contains_key(&self, key: &PropertyKey) -> bool {1132		self.0.contains_key(key)1133	}11341135	/// Check if map contains key with key validation.1136	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {1137		if key.is_empty() {1138			return Err(PropertiesError::EmptyPropertyKey);1139		}11401141		for byte in key.as_slice().iter() {1142			let byte = *byte;11431144			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' && byte != b'.' {1145				return Err(PropertiesError::InvalidCharacterInPropertyKey);1146			}1147		}11481149		Ok(())1150	}1151}11521153impl<Value> IntoIterator for PropertiesMap<Value> {1154	type Item = (PropertyKey, Value);1155	type IntoIter = <1156		BoundedBTreeMap<1157			PropertyKey,1158			Value,1159			ConstU32<MAX_PROPERTIES_PER_ITEM>1160		> as IntoIterator1161	>::IntoIter;11621163	fn into_iter(self) -> Self::IntoIter {1164		self.0.into_iter()1165	}1166}11671168impl<Value> TrySetProperty for PropertiesMap<Value> {1169	type Value = Value;11701171	fn try_scoped_set(1172		&mut self,1173		scope: PropertyScope,1174		key: PropertyKey,1175		value: Self::Value,1176	) -> Result<(), PropertiesError> {1177		Self::check_property_key(&key)?;11781179		let key = scope.apply(key)?;1180		self.01181			.try_insert(key, value)1182			.map_err(|_| PropertiesError::PropertyLimitReached)?;11831184		Ok(())1185	}1186}11871188/// Alias for property permissions map.1189pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;11901191/// Wrapper for properties map with consumed space control.1192#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]1193pub struct Properties {1194	map: PropertiesMap<PropertyValue>,1195	consumed_space: u32,1196	space_limit: u32,1197}11981199impl Properties {1200	/// Create new properies container.1201	pub fn new(space_limit: u32) -> Self {1202		Self {1203			map: PropertiesMap::new(),1204			consumed_space: 0,1205			space_limit,1206		}1207	}12081209	/// Remove propery with appropiate key.1210	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {1211		let value = self.map.remove(key)?;12121213		if let Some(ref value) = value {1214			let value_len = value.len() as u32;1215			self.consumed_space -= value_len;1216		}12171218		Ok(value)1219	}12201221	/// Get property with appropriate key.1222	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {1223		self.map.get(key)1224	}1225}12261227impl IntoIterator for Properties {1228	type Item = (PropertyKey, PropertyValue);1229	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;12301231	fn into_iter(self) -> Self::IntoIter {1232		self.map.into_iter()1233	}1234}12351236impl TrySetProperty for Properties {1237	type Value = PropertyValue;12381239	fn try_scoped_set(1240		&mut self,1241		scope: PropertyScope,1242		key: PropertyKey,1243		value: Self::Value,1244	) -> Result<(), PropertiesError> {1245		let value_len = value.len();12461247		if self.consumed_space as usize + value_len > self.space_limit as usize1248			&& !cfg!(feature = "runtime-benchmarks")1249		{1250			return Err(PropertiesError::NoSpaceForProperty);1251		}12521253		self.map.try_scoped_set(scope, key, value)?;12541255		self.consumed_space += value_len as u32;12561257		Ok(())1258	}1259}12601261/// Utility struct for using in `StorageMap`.1262pub struct CollectionProperties;12631264impl Get<Properties> for CollectionProperties {1265	fn get() -> Properties {1266		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)1267	}1268}12691270/// Utility struct for using in `StorageMap`.1271pub struct TokenProperties;12721273impl Get<Properties> for TokenProperties {1274	fn get() -> Properties {1275		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)1276	}1277}12781279// RMRK1280// todo document?1281parameter_types! {1282	#[derive(PartialEq, TypeInfo)]1283	pub const RmrkStringLimit: u32 = 128;1284	#[derive(PartialEq)]1285	pub const RmrkCollectionSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1286	#[derive(PartialEq)]1287	pub const RmrkResourceSymbolLimit: u32 = 10;1288	#[derive(PartialEq)]1289	pub const RmrkBaseSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1290	#[derive(PartialEq)]1291	pub const RmrkKeyLimit: u32 = 32;1292	#[derive(PartialEq)]1293	pub const RmrkValueLimit: u32 = 256;1294	#[derive(PartialEq)]1295	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;1296	#[derive(PartialEq)]1297	pub const MaxPropertiesPerTheme: u32 = 5;1298	#[derive(PartialEq)]1299	pub const RmrkPartsLimit: u32 = 25;1300	#[derive(PartialEq)]1301	pub const RmrkMaxPriorities: u32 = 25;1302	#[derive(PartialEq)]1303	pub const MaxResourcesOnMint: u32 = 100;1304}13051306impl From<RmrkCollectionId> for CollectionId {1307	fn from(id: RmrkCollectionId) -> Self {1308		Self(id)1309	}1310}13111312impl From<RmrkNftId> for TokenId {1313	fn from(id: RmrkNftId) -> Self {1314		Self(id)1315	}1316}13171318pub type RmrkCollectionInfo<AccountId> =1319	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;1320pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;1321pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;1322pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;1323pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;1324pub type BoundedEquippableCollectionIds =1325	BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>;1326pub type RmrkPartType = PartType<RmrkString, BoundedEquippableCollectionIds>;1327pub type RmrkEquippableList = EquippableList<BoundedEquippableCollectionIds>;1328pub type RmrkThemeProperty = ThemeProperty<RmrkString>;1329pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;1330pub type RmrkBoundedTheme = Theme<RmrkString, BoundedVec<RmrkThemeProperty, MaxPropertiesPerTheme>>;1331pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;13321333pub type RmrkBasicResource = BasicResource<RmrkString>;1334pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;1335pub type RmrkSlotResource = SlotResource<RmrkString>;13361337pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;1338pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;1339pub type RmrkBaseSymbol = BoundedVec<u8, RmrkBaseSymbolLimit>;1340pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;1341pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;1342pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;1343pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed13441345pub type RmrkRpcString = Vec<u8>;1346pub type RmrkThemeName = RmrkRpcString;1347pub type RmrkPropertyKey = RmrkRpcString;