git.delta.rocks / unique-network / refs/commits / 26c4de6147e8

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#![cfg_attr(not(feature = "std"), no_std)]1819use core::{20	convert::{TryFrom, TryInto},21	fmt,22};23use frame_support::{24	storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet},25	traits::Get,26	parameter_types,27};2829#[cfg(feature = "serde")]30use serde::{Serialize, Deserialize};3132use sp_core::U256;33use sp_runtime::{ArithmeticError, sp_std::prelude::Vec, Permill};34use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};35use frame_support::{BoundedVec, traits::ConstU32};36use derivative::Derivative;37use scale_info::TypeInfo;3839// RMRK40use rmrk_traits::{41	CollectionInfo, NftInfo, ResourceInfo, PropertyInfo, BaseInfo, PartType, Theme, ThemeProperty,42	ResourceTypes, BasicResource, ComposableResource, SlotResource, EquippableList,43};44pub use rmrk_traits::{45	primitives::{46		CollectionId as RmrkCollectionId, NftId as RmrkNftId, BaseId as RmrkBaseId,47		SlotId as RmrkSlotId, PartId as RmrkPartId, ResourceId as RmrkResourceId,48	},49	NftChild as RmrkNftChild, AccountIdOrCollectionNftTuple as RmrkAccountIdOrCollectionNftTuple,50	FixedPart as RmrkFixedPart, SlotPart as RmrkSlotPart,51};5253mod bounded;54pub mod budget;55pub mod mapping;56mod migration;5758/// Maximum of decimal points.59pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;6061/// Maximum pieces for refungible token.62pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;63pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;6465/// Maximum tokens for user.66pub const MAX_TOKEN_OWNERSHIP: u32 = if cfg!(not(feature = "limit-testing")) {67	100_00068} else {69	1070};7172/// Maximum for collections can be created.73pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {74	100_00075} else {76	1077};7879/// Maximum for various custom data of token.80pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {81	204882} else {83	1084};85pub const COLLECTION_ADMINS_LIMIT: u32 = 5;86pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX;87pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {88	1_000_00089} else {90	1091};9293// Timeouts for item types in passed blocks94pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;95pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;96pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;9798pub const SPONSOR_APPROVE_TIMEOUT: u32 = 5;99100// Schema limits101pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 8192;102pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 8192;103pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 32768;104105pub const COLLECTION_FIELD_LIMIT: u32 = CONST_ON_CHAIN_SCHEMA_LIMIT;106107pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;108pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;109pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;110111pub const MAX_PROPERTY_KEY_LENGTH: u32 = 256;112pub const MAX_PROPERTY_VALUE_LENGTH: u32 = 32768;113pub const MAX_PROPERTIES_PER_ITEM: u32 = 64;114115pub const MAX_AUX_PROPERTY_VALUE_LENGTH: u32 = 2048;116117pub const MAX_COLLECTION_PROPERTIES_SIZE: u32 = 40960;118pub const MAX_TOKEN_PROPERTIES_SIZE: u32 = 32768;119120/// How much items can be created per single121/// create_many call122pub const MAX_ITEMS_PER_BATCH: u32 = 200;123124/// Used for limit bounded types of token custom data.125pub type CustomDataLimit = ConstU32<CUSTOM_DATA_LIMIT>;126127/// Collection id.128#[derive(129	Encode,130	Decode,131	PartialEq,132	Eq,133	PartialOrd,134	Ord,135	Clone,136	Copy,137	Debug,138	Default,139	TypeInfo,140	MaxEncodedLen,141)]142#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]143pub struct CollectionId(pub u32);144impl EncodeLike<u32> for CollectionId {}145impl EncodeLike<CollectionId> for u32 {}146147/// Token id148#[derive(149	Encode,150	Decode,151	PartialEq,152	Eq,153	PartialOrd,154	Ord,155	Clone,156	Copy,157	Debug,158	Default,159	TypeInfo,160	MaxEncodedLen,161)]162#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]163pub struct TokenId(pub u32);164impl EncodeLike<u32> for TokenId {}165impl EncodeLike<TokenId> for u32 {}166167impl TokenId {168	/// Try to get next token id.169	/// 170	/// If next id cause overflow, then [`ArithmeticError::Overflow`] returned.171	pub fn try_next(self) -> Result<TokenId, ArithmeticError> {172		self.0173			.checked_add(1)174			.ok_or(ArithmeticError::Overflow)175			.map(Self)176	}177}178179impl From<TokenId> for U256 {180	fn from(t: TokenId) -> Self {181		t.0.into()182	}183}184185impl TryFrom<U256> for TokenId {186	type Error = &'static str;187188	fn try_from(value: U256) -> Result<Self, Self::Error> {189		Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))190	}191}192193#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]194#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]195pub struct TokenData<CrossAccountId> {196	pub properties: Vec<Property>,197	pub owner: Option<CrossAccountId>,198	pub pieces: u128,199}200201// TODO: unused type202pub struct OverflowError;203impl From<OverflowError> for &'static str {204	fn from(_: OverflowError) -> Self {205		"overflow occured"206	}207}208209/// Alias for decimal points type.210pub type DecimalPoints = u8;211212/// Collection mode.213/// 214/// Collection can represent various types of tokens.215/// Each collection can contain only one type of tokens at a time.216/// This type helps to understand which tokens the collection contains.217#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]218#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]219pub enum CollectionMode {220	/// Non fungible tokens.221	NFT,222	/// Fungible tokens.223	Fungible(DecimalPoints),224	/// Refungible tokens.225	ReFungible,226}227228impl CollectionMode {229	/// Get collection mod as number.230	pub fn id(&self) -> u8 {231		match self {232			CollectionMode::NFT => 1,233			CollectionMode::Fungible(_) => 2,234			CollectionMode::ReFungible => 3,235		}236	}237}238239// TODO: unused trait240pub trait SponsoringResolve<AccountId, Call> {241	fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;242}243244/// Access mode for token.245#[derive(Encode, Decode, Eq, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]246#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]247pub enum AccessMode {248	/// Access grant for owner and admins. Used as default.249	Normal,250	/// Like a [`Normal`](AccessMode::Normal) but also users in allow list.251	AllowList,252}253impl Default for AccessMode {254	fn default() -> Self {255		Self::Normal256	}257}258259// TODO: remove in future.260#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]261#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]262pub enum SchemaVersion {263	ImageURL,264	Unique,265}266impl Default for SchemaVersion {267	fn default() -> Self {268		Self::ImageURL269	}270}271272// TODO: unused type273#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]274#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]275pub struct Ownership<AccountId> {276	pub owner: AccountId,277	pub fraction: u128,278}279280/// The state of collection sponsorship.281#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]282#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]283pub enum SponsorshipState<AccountId> {284	/// The fees are applied to the transaction sender.285	Disabled,286	/// The sponsor is under consideration. Until the sponsor gives his consent,287	/// the fee will still be charged to sender.288	Unconfirmed(AccountId),289	/// Transactions are sponsored by specified account.290	Confirmed(AccountId),291}292293impl<AccountId> SponsorshipState<AccountId> {294	/// Get a sponsor of the collection who has confirmed his status.295	pub fn sponsor(&self) -> Option<&AccountId> {296		match self {297			Self::Confirmed(sponsor) => Some(sponsor),298			_ => None,299		}300	}301302	/// Get a sponsor of the collection who has pending or confirmed status.303	pub fn pending_sponsor(&self) -> Option<&AccountId> {304		match self {305			Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),306			_ => None,307		}308	}309310	/// Whether the sponsorship is confirmed.311	pub fn confirmed(&self) -> bool {312		matches!(self, Self::Confirmed(_))313	}314}315316impl<T> Default for SponsorshipState<T> {317	fn default() -> Self {318		Self::Disabled319	}320}321322pub type CollectionName = BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>;323pub type CollectionDescription = BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>;324pub type CollectionTokenPrefix = BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>;325326/// Base structure for represent collection.327/// 328/// Used to provide basic functionality for all types of collections.329/// 330/// #### Note331/// Collection parameters, used in storage (see [`RpcCollection`] for the RPC version).332#[struct_versioning::versioned(version = 2, upper)]333#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]334pub struct Collection<AccountId> {335	/// Collection owner account.336	pub owner: AccountId,337338	/// Collection mode.339	pub mode: CollectionMode,340341	/// Access mode.342	#[version(..2)]343	pub access: AccessMode,344345	/// Collection name.346	pub name: CollectionName,347348	/// Collection description.349	pub description: CollectionDescription,350351	/// Token prefix.352	pub token_prefix: CollectionTokenPrefix,353354	#[version(..2)]355	pub mint_mode: bool,356357	#[version(..2)]358	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,359360	#[version(..2)]361	pub schema_version: SchemaVersion,362363	/// The state of sponsorship of the collection.364	pub sponsorship: SponsorshipState<AccountId>,365366	/// Collection limits.367	pub limits: CollectionLimits,368369	/// Collection permissions.370	#[version(2.., upper(Default::default()))]371	pub permissions: CollectionPermissions,372373	/// Marks that this collection is not "unique", and managed from external.374	#[version(2.., upper(false))]375	pub external_collection: bool,376377	#[version(..2)]378	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,379380	#[version(..2)]381	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,382383	#[version(..2)]384	pub meta_update_permission: MetaUpdatePermission,385}386387/// Collection parameters, used in RPC calls (see [`Collection`] for the storage version).388#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]389#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]390pub struct RpcCollection<AccountId> {391	/// Collection owner account.392	pub owner: AccountId,393394	/// Collection mode.395	pub mode: CollectionMode,396397	/// Collection name.398	pub name: Vec<u16>,399400	/// Collection description.401	pub description: Vec<u16>,402403	/// Token prefix.404	pub token_prefix: Vec<u8>,405406	/// The state of sponsorship of the collection.407	pub sponsorship: SponsorshipState<AccountId>,408409	/// Collection limits.410	pub limits: CollectionLimits,411412	/// Collection permissions.413	pub permissions: CollectionPermissions,414415	/// Token property permissions.416	pub token_property_permissions: Vec<PropertyKeyPermission>,417418	/// Collection properties.419	pub properties: Vec<Property>,420421	/// Is collection read only.422	pub read_only: bool,423}424425/// Data used for create collection.426/// 427/// All fields are wrapped in [`Option`], where `None` means chain default.428#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Derivative, MaxEncodedLen)]429#[derivative(Debug, Default(bound = ""))]430pub struct CreateCollectionData<AccountId> {431	/// Collection mode.432	#[derivative(Default(value = "CollectionMode::NFT"))]433	pub mode: CollectionMode,434435	/// Access mode.436	pub access: Option<AccessMode>,437438	/// Collection name.439	pub name: CollectionName,440441	/// Collection description.442	pub description: CollectionDescription,443444	/// Token prefix.445	pub token_prefix: CollectionTokenPrefix,446447	/// Pending collection sponsor.448	pub pending_sponsor: Option<AccountId>,449450	/// Collection limits.451	pub limits: Option<CollectionLimits>,452453	/// Collection permissions.454	pub permissions: Option<CollectionPermissions>,455456	/// Token property permissions.457	pub token_property_permissions: CollectionPropertiesPermissionsVec,458459	/// Collection properties.460	pub properties: CollectionPropertiesVec,461}462463/// Bounded vector of properties permissions. Max length is [`MAX_PROPERTIES_PER_ITEM`].464// TODO: maybe rename to PropertiesPermissionsVec465pub type CollectionPropertiesPermissionsVec =466	BoundedVec<PropertyKeyPermission, ConstU32<MAX_PROPERTIES_PER_ITEM>>;467468/// Bounded vector of properties. Max length is [`MAX_PROPERTIES_PER_ITEM`].469pub type CollectionPropertiesVec = BoundedVec<Property, ConstU32<MAX_PROPERTIES_PER_ITEM>>;470471/// Limits and restrictions of a collection.472///473/// All fields are wrapped in [`Option`], where `None` means chain default.474/// 475/// Update with `pallet_common::Pallet::clamp_limits`.476// IMPORTANT: When adding/removing fields from this struct - don't forget to also477// TODO: move `pallet_common::Pallet::clamp_limits() in pallet-common.` into `impl CollectionLimits`.478#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]479#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]480pub struct CollectionLimits {481	/// How many tokens can a user have on one account.482	/// * Default - [`ACCOUNT_TOKEN_OWNERSHIP_LIMIT`].483	/// * Limit - [`MAX_TOKEN_OWNERSHIP`].484	pub account_token_ownership_limit: Option<u32>,485486	/// Maximum size of data in bytes of a sponsored transaction.487	/// * Default - [`CUSTOM_DATA_LIMIT`].488	pub sponsored_data_size: Option<u32>,489490	/// FIXME should we delete this or repurpose it?491	/// None - setVariableMetadata is not sponsored492	/// Some(v) - setVariableMetadata is sponsored493	///           if there is v block between txs494	///495	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]496	pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,497	/// Maximum amount of tokens inside the collection. Chain default: [`COLLECTION_TOKEN_LIMIT`]498	pub token_limit: Option<u32>,499500	/// Timeout for sponsoring a token transfer in passed blocks. Chain default:501	/// either [`NFT_SPONSOR_TRANSFER_TIMEOUT`], [`FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT`], or [`REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT`],502	/// depending on the collection type.503	pub sponsor_transfer_timeout: Option<u32>,504	/// Timeout for sponsoring an approval in passed blocks. Chain default: [`SPONSOR_APPROVE_TIMEOUT`]505	pub sponsor_approve_timeout: Option<u32>,506	/// Can a token be transferred by the owner. Chain default: `false`507	pub owner_can_transfer: Option<bool>,508	/// Can a token be burned by the owner. Chain default: `true`509	pub owner_can_destroy: Option<bool>,510	/// Can a token be transferred at all. Chain default: `true`511	pub transfers_enabled: Option<bool>,512}513514impl CollectionLimits {515	pub fn account_token_ownership_limit(&self) -> u32 {516		self.account_token_ownership_limit517			.unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)518			.min(MAX_TOKEN_OWNERSHIP)519	}520	pub fn sponsored_data_size(&self) -> u32 {521		self.sponsored_data_size522			.unwrap_or(CUSTOM_DATA_LIMIT)523			.min(CUSTOM_DATA_LIMIT)524	}525	pub fn token_limit(&self) -> u32 {526		self.token_limit527			.unwrap_or(COLLECTION_TOKEN_LIMIT)528			.min(COLLECTION_TOKEN_LIMIT)529	}530	pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {531		self.sponsor_transfer_timeout532			.unwrap_or(default)533			.min(MAX_SPONSOR_TIMEOUT)534	}535	pub fn sponsor_approve_timeout(&self) -> u32 {536		self.sponsor_approve_timeout537			.unwrap_or(SPONSOR_APPROVE_TIMEOUT)538			.min(MAX_SPONSOR_TIMEOUT)539	}540	pub fn owner_can_transfer(&self) -> bool {541		self.owner_can_transfer.unwrap_or(false)542	}543	pub fn owner_can_transfer_instaled(&self) -> bool {544		self.owner_can_transfer.is_some()545	}546	pub fn owner_can_destroy(&self) -> bool {547		self.owner_can_destroy.unwrap_or(true)548	}549	pub fn transfers_enabled(&self) -> bool {550		self.transfers_enabled.unwrap_or(true)551	}552	pub fn sponsored_data_rate_limit(&self) -> Option<u32> {553		match self554			.sponsored_data_rate_limit555			.unwrap_or(SponsoringRateLimit::SponsoringDisabled)556		{557			SponsoringRateLimit::SponsoringDisabled => None,558			SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),559		}560	}561}562563/// Permissions on certain operations within a collection.564/// All fields are wrapped in `Option`s, where None means chain default.565// IMPORTANT: When adding/removing fields from this struct - don't forget to also566// update clamp_limits() in pallet-common.567#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]568#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]569pub struct CollectionPermissions {570	pub access: Option<AccessMode>,571	pub mint_mode: Option<bool>,572	pub nesting: Option<NestingPermissions>,573}574575impl CollectionPermissions {576	pub fn access(&self) -> AccessMode {577		self.access.unwrap_or(AccessMode::Normal)578	}579	pub fn mint_mode(&self) -> bool {580		self.mint_mode.unwrap_or(false)581	}582	pub fn nesting(&self) -> &NestingPermissions {583		static DEFAULT: NestingPermissions = NestingPermissions {584			token_owner: false,585			collection_admin: false,586			restricted: None,587			#[cfg(feature = "runtime-benchmarks")]588			permissive: false,589		};590		self.nesting.as_ref().unwrap_or(&DEFAULT)591	}592}593594type OwnerRestrictedSetInner = BoundedBTreeSet<CollectionId, ConstU32<16>>;595596#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]597#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]598#[derivative(Debug)]599pub struct OwnerRestrictedSet(600	#[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]601	#[derivative(Debug(format_with = "bounded::set_debug"))]602	pub OwnerRestrictedSetInner,603);604impl OwnerRestrictedSet {605	pub fn new() -> Self {606		Self(Default::default())607	}608}609impl core::ops::Deref for OwnerRestrictedSet {610	type Target = OwnerRestrictedSetInner;611	fn deref(&self) -> &Self::Target {612		&self.0613	}614}615impl core::ops::DerefMut for OwnerRestrictedSet {616	fn deref_mut(&mut self) -> &mut Self::Target {617		&mut self.0618	}619}620621/// Part of collection permissions, if set, defines who is able to nest tokens into other tokens.622#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]623#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]624#[derivative(Debug)]625pub struct NestingPermissions {626	/// Owner of token can nest tokens under it627	pub token_owner: bool,628	/// Admin of token collection can nest tokens under token629	pub collection_admin: bool,630	/// If set - only tokens from specified collections can be nested631	pub restricted: Option<OwnerRestrictedSet>,632633	#[cfg(feature = "runtime-benchmarks")]634	/// Anyone can nest tokens, mutually exclusive with `token_owner`, `admin`635	pub permissive: bool,636}637638/// Enum denominating how often can sponsoring occur if it is enabled.639#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]640#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]641pub enum SponsoringRateLimit {642	/// Sponsoring is disabled, and the collection sponsor will not pay for transactions643	SponsoringDisabled,644	/// Once per how many blocks can sponsorship of a transaction type occur645	Blocks(u32),646}647648/// Data used to describe an NFT at creation.649#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]650#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]651#[derivative(Debug)]652pub struct CreateNftData {653	/// Key-value pairs used to describe the token as metadata654	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]655	#[derivative(Debug(format_with = "bounded::vec_debug"))]656	pub properties: CollectionPropertiesVec,657}658659/// Data used to describe a Fungible token at creation.660#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]661#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]662pub struct CreateFungibleData {663	/// Number of fungible coins minted664	pub value: u128,665}666667/// Data used to describe a Refungible token at creation.668#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]669#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]670#[derivative(Debug)]671pub struct CreateReFungibleData {672	/// Immutable metadata of the token673	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]674	#[derivative(Debug(format_with = "bounded::vec_debug"))]675	pub const_data: BoundedVec<u8, CustomDataLimit>,676677	/// Number of pieces the RFT is split into678	pub pieces: u128,679680	/// Key-value pairs used to describe the token as metadata681	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]682	#[derivative(Debug(format_with = "bounded::vec_debug"))]683	pub properties: CollectionPropertiesVec,684}685686#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]687#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]688pub enum MetaUpdatePermission {689	ItemOwner,690	Admin,691	None,692}693694/// Enum holding data used for creation of all three item types.695#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]696#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]697pub enum CreateItemData {698	NFT(CreateNftData),699	Fungible(CreateFungibleData),700	ReFungible(CreateReFungibleData),701}702703/// Explicit NFT creation data with meta parameters.704#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]705#[derivative(Debug)]706pub struct CreateNftExData<CrossAccountId> {707	#[derivative(Debug(format_with = "bounded::vec_debug"))]708	pub properties: CollectionPropertiesVec,709	pub owner: CrossAccountId,710}711712/// Explicit RFT creation data with meta parameters.713#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]714#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]715pub struct CreateRefungibleExData<CrossAccountId> {716	#[derivative(Debug(format_with = "bounded::vec_debug"))]717	pub const_data: BoundedVec<u8, CustomDataLimit>,718	#[derivative(Debug(format_with = "bounded::map_debug"))]719	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,720	#[derivative(Debug(format_with = "bounded::vec_debug"))]721	pub properties: CollectionPropertiesVec,722}723724/// Explicit item creation data with meta parameters, namely the owner.725#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]726#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]727pub enum CreateItemExData<CrossAccountId> {728	NFT(729		#[derivative(Debug(format_with = "bounded::vec_debug"))]730		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,731	),732	Fungible(733		#[derivative(Debug(format_with = "bounded::map_debug"))]734		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,735	),736	/// Many tokens, each may have only one owner737	RefungibleMultipleItems(738		#[derivative(Debug(format_with = "bounded::vec_debug"))]739		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,740	),741	/// Single token, which may have many owners742	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),743}744745impl CreateItemData {746	pub fn data_size(&self) -> usize {747		match self {748			CreateItemData::ReFungible(data) => data.const_data.len(),749			_ => 0,750		}751	}752}753754impl From<CreateNftData> for CreateItemData {755	fn from(item: CreateNftData) -> Self {756		CreateItemData::NFT(item)757	}758}759760impl From<CreateReFungibleData> for CreateItemData {761	fn from(item: CreateReFungibleData) -> Self {762		CreateItemData::ReFungible(item)763	}764}765766impl From<CreateFungibleData> for CreateItemData {767	fn from(item: CreateFungibleData) -> Self {768		CreateItemData::Fungible(item)769	}770}771772/// Token's address, dictated by its collection and token IDs.773#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]774#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]775// todo possibly rename to be used generally as an address pair776pub struct TokenChild {777	pub token: TokenId,778	pub collection: CollectionId,779}780781#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]782#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]783pub struct CollectionStats {784	pub created: u32,785	pub destroyed: u32,786	pub alive: u32,787}788789#[derive(Encode, Decode, Clone, Debug)]790#[cfg_attr(feature = "std", derive(PartialEq))]791pub struct PhantomType<T>(core::marker::PhantomData<T>);792793impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {794	type Identity = PhantomType<T>;795796	fn type_info() -> scale_info::Type {797		use scale_info::{798			Type, Path,799			build::{FieldsBuilder, UnnamedFields},800			type_params,801		};802		Type::builder()803			.path(Path::new("up_data_structs", "PhantomType"))804			.type_params(type_params!(T))805			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))806	}807}808impl<T> MaxEncodedLen for PhantomType<T> {809	fn max_encoded_len() -> usize {810		0811	}812}813814pub type BoundedBytes<S> = BoundedVec<u8, S>;815816pub type AuxPropertyValue = BoundedBytes<ConstU32<MAX_AUX_PROPERTY_VALUE_LENGTH>>;817818pub type PropertyKey = BoundedBytes<ConstU32<MAX_PROPERTY_KEY_LENGTH>>;819pub type PropertyValue = BoundedBytes<ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;820821#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]822#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]823pub struct PropertyPermission {824	pub mutable: bool,825	pub collection_admin: bool,826	pub token_owner: bool,827}828829impl PropertyPermission {830	pub fn none() -> Self {831		Self {832			mutable: true,833			collection_admin: false,834			token_owner: false,835		}836	}837}838839#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]840#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]841pub struct Property {842	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]843	pub key: PropertyKey,844845	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]846	pub value: PropertyValue,847}848849impl Into<(PropertyKey, PropertyValue)> for Property {850	fn into(self) -> (PropertyKey, PropertyValue) {851		(self.key, self.value)852	}853}854855#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]856#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]857pub struct PropertyKeyPermission {858	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]859	pub key: PropertyKey,860861	pub permission: PropertyPermission,862}863864impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {865	fn into(self) -> (PropertyKey, PropertyPermission) {866		(self.key, self.permission)867	}868}869870#[derive(Debug)]871pub enum PropertiesError {872	NoSpaceForProperty,873	PropertyLimitReached,874	InvalidCharacterInPropertyKey,875	PropertyKeyIsTooLong,876	EmptyPropertyKey,877}878879#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, Clone, Copy)]880pub enum PropertyScope {881	None,882	Rmrk,883}884885impl PropertyScope {886	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {887		let scope_str: &[u8] = match self {888			Self::None => return Ok(key),889			Self::Rmrk => b"rmrk",890		};891892		[scope_str, b":", key.as_slice()]893			.concat()894			.try_into()895			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)896	}897}898899pub trait TrySetProperty: Sized {900	type Value;901902	fn try_scoped_set(903		&mut self,904		scope: PropertyScope,905		key: PropertyKey,906		value: Self::Value,907	) -> Result<(), PropertiesError>;908909	fn try_scoped_set_from_iter<I, KV>(910		&mut self,911		scope: PropertyScope,912		iter: I,913	) -> Result<(), PropertiesError>914	where915		I: Iterator<Item = KV>,916		KV: Into<(PropertyKey, Self::Value)>,917	{918		for kv in iter {919			let (key, value) = kv.into();920			self.try_scoped_set(scope, key, value)?;921		}922923		Ok(())924	}925926	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {927		self.try_scoped_set(PropertyScope::None, key, value)928	}929930	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>931	where932		I: Iterator<Item = KV>,933		KV: Into<(PropertyKey, Self::Value)>,934	{935		self.try_scoped_set_from_iter(PropertyScope::None, iter)936	}937}938939#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]940#[derivative(Default(bound = ""))]941pub struct PropertiesMap<Value>(942	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,943);944945impl<Value> PropertiesMap<Value> {946	pub fn new() -> Self {947		Self(BoundedBTreeMap::new())948	}949950	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {951		Self::check_property_key(key)?;952953		Ok(self.0.remove(key))954	}955956	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {957		self.0.get(key)958	}959960	pub fn contains_key(&self, key: &PropertyKey) -> bool {961		self.0.contains_key(key)962	}963964	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {965		if key.is_empty() {966			return Err(PropertiesError::EmptyPropertyKey);967		}968969		for byte in key.as_slice().iter() {970			let byte = *byte;971972			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' && byte != b'.' {973				return Err(PropertiesError::InvalidCharacterInPropertyKey);974			}975		}976977		Ok(())978	}979}980981impl<Value> IntoIterator for PropertiesMap<Value> {982	type Item = (PropertyKey, Value);983	type IntoIter = <984		BoundedBTreeMap<985			PropertyKey,986			Value,987			ConstU32<MAX_PROPERTIES_PER_ITEM>988		> as IntoIterator989	>::IntoIter;990991	fn into_iter(self) -> Self::IntoIter {992		self.0.into_iter()993	}994}995996impl<Value> TrySetProperty for PropertiesMap<Value> {997	type Value = Value;998999	fn try_scoped_set(1000		&mut self,1001		scope: PropertyScope,1002		key: PropertyKey,1003		value: Self::Value,1004	) -> Result<(), PropertiesError> {1005		Self::check_property_key(&key)?;10061007		let key = scope.apply(key)?;1008		self.01009			.try_insert(key, value)1010			.map_err(|_| PropertiesError::PropertyLimitReached)?;10111012		Ok(())1013	}1014}10151016pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;10171018#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]1019pub struct Properties {1020	map: PropertiesMap<PropertyValue>,1021	consumed_space: u32,1022	space_limit: u32,1023}10241025impl Properties {1026	pub fn new(space_limit: u32) -> Self {1027		Self {1028			map: PropertiesMap::new(),1029			consumed_space: 0,1030			space_limit,1031		}1032	}10331034	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {1035		let value = self.map.remove(key)?;10361037		if let Some(ref value) = value {1038			let value_len = value.len() as u32;1039			self.consumed_space -= value_len;1040		}10411042		Ok(value)1043	}10441045	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {1046		self.map.get(key)1047	}1048}10491050impl IntoIterator for Properties {1051	type Item = (PropertyKey, PropertyValue);1052	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;10531054	fn into_iter(self) -> Self::IntoIter {1055		self.map.into_iter()1056	}1057}10581059impl TrySetProperty for Properties {1060	type Value = PropertyValue;10611062	fn try_scoped_set(1063		&mut self,1064		scope: PropertyScope,1065		key: PropertyKey,1066		value: Self::Value,1067	) -> Result<(), PropertiesError> {1068		let value_len = value.len();10691070		if self.consumed_space as usize + value_len > self.space_limit as usize1071			&& !cfg!(feature = "runtime-benchmarks")1072		{1073			return Err(PropertiesError::NoSpaceForProperty);1074		}10751076		self.map.try_scoped_set(scope, key, value)?;10771078		self.consumed_space += value_len as u32;10791080		Ok(())1081	}1082}10831084pub struct CollectionProperties;10851086impl Get<Properties> for CollectionProperties {1087	fn get() -> Properties {1088		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)1089	}1090}10911092pub struct TokenProperties;10931094impl Get<Properties> for TokenProperties {1095	fn get() -> Properties {1096		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)1097	}1098}10991100// RMRK1101// todo document?1102parameter_types! {1103	#[derive(PartialEq, TypeInfo)]1104	pub const RmrkStringLimit: u32 = 128;1105	#[derive(PartialEq)]1106	pub const RmrkCollectionSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1107	#[derive(PartialEq)]1108	pub const RmrkResourceSymbolLimit: u32 = 10;1109	#[derive(PartialEq)]1110	pub const RmrkBaseSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1111	#[derive(PartialEq)]1112	pub const RmrkKeyLimit: u32 = 32;1113	#[derive(PartialEq)]1114	pub const RmrkValueLimit: u32 = 256;1115	#[derive(PartialEq)]1116	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;1117	#[derive(PartialEq)]1118	pub const MaxPropertiesPerTheme: u32 = 5;1119	#[derive(PartialEq)]1120	pub const RmrkPartsLimit: u32 = 25;1121	#[derive(PartialEq)]1122	pub const RmrkMaxPriorities: u32 = 25;1123	#[derive(PartialEq)]1124	pub const MaxResourcesOnMint: u32 = 100;1125}11261127impl From<RmrkCollectionId> for CollectionId {1128	fn from(id: RmrkCollectionId) -> Self {1129		Self(id)1130	}1131}11321133impl From<RmrkNftId> for TokenId {1134	fn from(id: RmrkNftId) -> Self {1135		Self(id)1136	}1137}11381139pub type RmrkCollectionInfo<AccountId> =1140	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;1141pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;1142pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;1143pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;1144pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;1145pub type BoundedEquippableCollectionIds =1146	BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>;1147pub type RmrkPartType = PartType<RmrkString, BoundedEquippableCollectionIds>;1148pub type RmrkEquippableList = EquippableList<BoundedEquippableCollectionIds>;1149pub type RmrkThemeProperty = ThemeProperty<RmrkString>;1150pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;1151pub type RmrkBoundedTheme = Theme<RmrkString, BoundedVec<RmrkThemeProperty, MaxPropertiesPerTheme>>;1152pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;11531154pub type RmrkBasicResource = BasicResource<RmrkString>;1155pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;1156pub type RmrkSlotResource = SlotResource<RmrkString>;11571158pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;1159pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;1160pub type RmrkBaseSymbol = BoundedVec<u8, RmrkBaseSymbolLimit>;1161pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;1162pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;1163pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;1164pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed11651166pub type RmrkRpcString = Vec<u8>;1167pub type RmrkThemeName = RmrkRpcString;1168pub type RmrkPropertyKey = RmrkRpcString;