git.delta.rocks / unique-network / refs/commits / 9e39d67c9d24

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 CreateItemData {865	/// Get size of custom data.866	pub fn data_size(&self) -> usize {867		0868	}869}870871impl From<CreateNftData> for CreateItemData {872	fn from(item: CreateNftData) -> Self {873		CreateItemData::NFT(item)874	}875}876877impl From<CreateReFungibleData> for CreateItemData {878	fn from(item: CreateReFungibleData) -> Self {879		CreateItemData::ReFungible(item)880	}881}882883impl From<CreateFungibleData> for CreateItemData {884	fn from(item: CreateFungibleData) -> Self {885		CreateItemData::Fungible(item)886	}887}888889/// Token's address, dictated by its collection and token IDs.890#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]891#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]892// todo possibly rename to be used generally as an address pair893pub struct TokenChild {894	/// Token id.895	pub token: TokenId,896897	/// Collection id.898	pub collection: CollectionId,899}900901/// Collection statistics.902#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]903#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]904pub struct CollectionStats {905	/// Number of created items.906	pub created: u32,907908	/// Number of burned items.909	pub destroyed: u32,910911	/// Number of current items.912	pub alive: u32,913}914915/// This type works like [`PhantomData`] but supports generating _scale-info_ descriptions to generate node metadata.916#[derive(Encode, Decode, Clone, Debug)]917#[cfg_attr(feature = "std", derive(PartialEq))]918pub struct PhantomType<T>(core::marker::PhantomData<T>);919920impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {921	type Identity = PhantomType<T>;922923	fn type_info() -> scale_info::Type {924		use scale_info::{925			Type, Path,926			build::{FieldsBuilder, UnnamedFields},927			type_params,928		};929		Type::builder()930			.path(Path::new("up_data_structs", "PhantomType"))931			.type_params(type_params!(T))932			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))933	}934}935impl<T> MaxEncodedLen for PhantomType<T> {936	fn max_encoded_len() -> usize {937		0938	}939}940941/// Bounded vector of bytes.942pub type BoundedBytes<S> = BoundedVec<u8, S>;943944/// Extra properties for external collections.945pub type AuxPropertyValue = BoundedBytes<ConstU32<MAX_AUX_PROPERTY_VALUE_LENGTH>>;946947/// Property key.948pub type PropertyKey = BoundedBytes<ConstU32<MAX_PROPERTY_KEY_LENGTH>>;949950/// Property value.951pub type PropertyValue = BoundedBytes<ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;952953/// Property permission.954#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]955#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]956pub struct PropertyPermission {957	/// Permission to change the property and property permission.958	///959	/// If it **false** then you can not change corresponding property even if [`collection_admin`] and [`token_owner`] are **true**.960	pub mutable: bool,961962	/// Change permission for the collection administrator.963	pub collection_admin: bool,964965	/// Permission to change the property for the owner of the token.966	pub token_owner: bool,967}968969impl PropertyPermission {970	/// Creates mutable property permission but changes restricted for collection admin and token owner.971	pub fn none() -> Self {972		Self {973			mutable: true,974			collection_admin: false,975			token_owner: false,976		}977	}978}979980/// Property is simpl key-value record.981#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]982#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]983pub struct Property {984	/// Property key.985	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]986	pub key: PropertyKey,987988	/// Property value.989	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]990	pub value: PropertyValue,991}992993impl Into<(PropertyKey, PropertyValue)> for Property {994	fn into(self) -> (PropertyKey, PropertyValue) {995		(self.key, self.value)996	}997}998999/// Record for proprty key permission.1000#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]1001#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]1002pub struct PropertyKeyPermission {1003	/// Key.1004	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]1005	pub key: PropertyKey,10061007	/// Permission.1008	pub permission: PropertyPermission,1009}10101011impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {1012	fn into(self) -> (PropertyKey, PropertyPermission) {1013		(self.key, self.permission)1014	}1015}10161017/// Errors for properties actions.1018#[derive(Debug)]1019pub enum PropertiesError {1020	/// The space allocated for properties has run out.1021	///1022	/// * Limit for colection - [`MAX_COLLECTION_PROPERTIES_SIZE`].1023	/// * Limit for token - [`MAX_TOKEN_PROPERTIES_SIZE`].1024	NoSpaceForProperty,10251026	/// The property limit has been reached.1027	///1028	/// * Limit - [`MAX_PROPERTIES_PER_ITEM`].1029	PropertyLimitReached,10301031	/// Property key contains not allowed character.1032	InvalidCharacterInPropertyKey,10331034	/// Property key length is too long.1035	///1036	/// * Limit - [`MAX_PROPERTY_KEY_LENGTH`].1037	PropertyKeyIsTooLong,10381039	/// Property key is empty.1040	EmptyPropertyKey,1041}10421043/// Marker for scope of property.1044///1045/// Scoped property can't be changed by user. Used for external collections.1046#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, Clone, Copy)]1047pub enum PropertyScope {1048	None,1049	Rmrk,1050}10511052impl PropertyScope {1053	/// Apply scope to property key.1054	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {1055		let scope_str: &[u8] = match self {1056			Self::None => return Ok(key),1057			Self::Rmrk => b"rmrk",1058		};10591060		[scope_str, b":", key.as_slice()]1061			.concat()1062			.try_into()1063			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)1064	}1065}10661067/// Trait for operate with properties.1068pub trait TrySetProperty: Sized {1069	type Value;10701071	/// Try to set property with scope.1072	fn try_scoped_set(1073		&mut self,1074		scope: PropertyScope,1075		key: PropertyKey,1076		value: Self::Value,1077	) -> Result<(), PropertiesError>;10781079	/// Try to set property with scope from iterator.1080	fn try_scoped_set_from_iter<I, KV>(1081		&mut self,1082		scope: PropertyScope,1083		iter: I,1084	) -> Result<(), PropertiesError>1085	where1086		I: Iterator<Item = KV>,1087		KV: Into<(PropertyKey, Self::Value)>,1088	{1089		for kv in iter {1090			let (key, value) = kv.into();1091			self.try_scoped_set(scope, key, value)?;1092		}10931094		Ok(())1095	}10961097	/// Try to set property.1098	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {1099		self.try_scoped_set(PropertyScope::None, key, value)1100	}11011102	/// Try to set property from iterator.1103	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>1104	where1105		I: Iterator<Item = KV>,1106		KV: Into<(PropertyKey, Self::Value)>,1107	{1108		self.try_scoped_set_from_iter(PropertyScope::None, iter)1109	}1110}11111112/// Wrapped map for storing properties.1113#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]1114#[derivative(Default(bound = ""))]1115pub struct PropertiesMap<Value>(1116	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,1117);11181119impl<Value> PropertiesMap<Value> {1120	/// Create new property map.1121	pub fn new() -> Self {1122		Self(BoundedBTreeMap::new())1123	}11241125	/// Remove property from map.1126	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {1127		Self::check_property_key(key)?;11281129		Ok(self.0.remove(key))1130	}11311132	/// Get property with appropriate key from map.1133	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {1134		self.0.get(key)1135	}11361137	/// Check if map contains key.1138	pub fn contains_key(&self, key: &PropertyKey) -> bool {1139		self.0.contains_key(key)1140	}11411142	/// Check if map contains key with key validation.1143	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {1144		if key.is_empty() {1145			return Err(PropertiesError::EmptyPropertyKey);1146		}11471148		for byte in key.as_slice().iter() {1149			let byte = *byte;11501151			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' && byte != b'.' {1152				return Err(PropertiesError::InvalidCharacterInPropertyKey);1153			}1154		}11551156		Ok(())1157	}1158}11591160impl<Value> IntoIterator for PropertiesMap<Value> {1161	type Item = (PropertyKey, Value);1162	type IntoIter = <1163		BoundedBTreeMap<1164			PropertyKey,1165			Value,1166			ConstU32<MAX_PROPERTIES_PER_ITEM>1167		> as IntoIterator1168	>::IntoIter;11691170	fn into_iter(self) -> Self::IntoIter {1171		self.0.into_iter()1172	}1173}11741175impl<Value> TrySetProperty for PropertiesMap<Value> {1176	type Value = Value;11771178	fn try_scoped_set(1179		&mut self,1180		scope: PropertyScope,1181		key: PropertyKey,1182		value: Self::Value,1183	) -> Result<(), PropertiesError> {1184		Self::check_property_key(&key)?;11851186		let key = scope.apply(key)?;1187		self.01188			.try_insert(key, value)1189			.map_err(|_| PropertiesError::PropertyLimitReached)?;11901191		Ok(())1192	}1193}11941195/// Alias for property permissions map.1196pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;11971198/// Wrapper for properties map with consumed space control.1199#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]1200pub struct Properties {1201	map: PropertiesMap<PropertyValue>,1202	consumed_space: u32,1203	space_limit: u32,1204}12051206impl Properties {1207	/// Create new properies container.1208	pub fn new(space_limit: u32) -> Self {1209		Self {1210			map: PropertiesMap::new(),1211			consumed_space: 0,1212			space_limit,1213		}1214	}12151216	/// Remove propery with appropiate key.1217	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {1218		let value = self.map.remove(key)?;12191220		if let Some(ref value) = value {1221			let value_len = value.len() as u32;1222			self.consumed_space -= value_len;1223		}12241225		Ok(value)1226	}12271228	/// Get property with appropriate key.1229	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {1230		self.map.get(key)1231	}1232}12331234impl IntoIterator for Properties {1235	type Item = (PropertyKey, PropertyValue);1236	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;12371238	fn into_iter(self) -> Self::IntoIter {1239		self.map.into_iter()1240	}1241}12421243impl TrySetProperty for Properties {1244	type Value = PropertyValue;12451246	fn try_scoped_set(1247		&mut self,1248		scope: PropertyScope,1249		key: PropertyKey,1250		value: Self::Value,1251	) -> Result<(), PropertiesError> {1252		let value_len = value.len();12531254		if self.consumed_space as usize + value_len > self.space_limit as usize1255			&& !cfg!(feature = "runtime-benchmarks")1256		{1257			return Err(PropertiesError::NoSpaceForProperty);1258		}12591260		self.map.try_scoped_set(scope, key, value)?;12611262		self.consumed_space += value_len as u32;12631264		Ok(())1265	}1266}12671268/// Utility struct for using in `StorageMap`.1269pub struct CollectionProperties;12701271impl Get<Properties> for CollectionProperties {1272	fn get() -> Properties {1273		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)1274	}1275}12761277/// Utility struct for using in `StorageMap`.1278pub struct TokenProperties;12791280impl Get<Properties> for TokenProperties {1281	fn get() -> Properties {1282		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)1283	}1284}12851286// RMRK1287// todo document?1288parameter_types! {1289	#[derive(PartialEq, TypeInfo)]1290	pub const RmrkStringLimit: u32 = 128;1291	#[derive(PartialEq)]1292	pub const RmrkCollectionSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1293	#[derive(PartialEq)]1294	pub const RmrkResourceSymbolLimit: u32 = 10;1295	#[derive(PartialEq)]1296	pub const RmrkBaseSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1297	#[derive(PartialEq)]1298	pub const RmrkKeyLimit: u32 = 32;1299	#[derive(PartialEq)]1300	pub const RmrkValueLimit: u32 = 256;1301	#[derive(PartialEq)]1302	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;1303	#[derive(PartialEq)]1304	pub const MaxPropertiesPerTheme: u32 = 5;1305	#[derive(PartialEq)]1306	pub const RmrkPartsLimit: u32 = 25;1307	#[derive(PartialEq)]1308	pub const RmrkMaxPriorities: u32 = 25;1309	#[derive(PartialEq)]1310	pub const MaxResourcesOnMint: u32 = 100;1311}13121313impl From<RmrkCollectionId> for CollectionId {1314	fn from(id: RmrkCollectionId) -> Self {1315		Self(id)1316	}1317}13181319impl From<RmrkNftId> for TokenId {1320	fn from(id: RmrkNftId) -> Self {1321		Self(id)1322	}1323}13241325pub type RmrkCollectionInfo<AccountId> =1326	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;1327pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;1328pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;1329pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;1330pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;1331pub type BoundedEquippableCollectionIds =1332	BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>;1333pub type RmrkPartType = PartType<RmrkString, BoundedEquippableCollectionIds>;1334pub type RmrkEquippableList = EquippableList<BoundedEquippableCollectionIds>;1335pub type RmrkThemeProperty = ThemeProperty<RmrkString>;1336pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;1337pub type RmrkBoundedTheme = Theme<RmrkString, BoundedVec<RmrkThemeProperty, MaxPropertiesPerTheme>>;1338pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;13391340pub type RmrkBasicResource = BasicResource<RmrkString>;1341pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;1342pub type RmrkSlotResource = SlotResource<RmrkString>;13431344pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;1345pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;1346pub type RmrkBaseSymbol = BoundedVec<u8, RmrkBaseSymbolLimit>;1347pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;1348pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;1349pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;1350pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed13511352pub type RmrkRpcString = Vec<u8>;1353pub type RmrkThemeName = RmrkRpcString;1354pub type RmrkPropertyKey = RmrkRpcString;