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

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;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;6162pub const MAX_TOKEN_OWNERSHIP: u32 = if cfg!(not(feature = "limit-testing")) {63	100_00064} else {65	1066};67pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {68	100_00069} else {70	1071};72pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {73	204874} else {75	1076};77pub const COLLECTION_ADMINS_LIMIT: u32 = 5;78pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX;79pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {80	1_000_00081} else {82	1083};8485// Timeouts for item types in passed blocks86pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;87pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;88pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;8990pub const SPONSOR_APPROVE_TIMEOUT: u32 = 5;9192// Schema limits93pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 8192;94pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 8192;95pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 32768;9697pub const COLLECTION_FIELD_LIMIT: u32 = CONST_ON_CHAIN_SCHEMA_LIMIT;9899pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;100pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;101pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;102103pub const MAX_PROPERTY_KEY_LENGTH: u32 = 256;104pub const MAX_PROPERTY_VALUE_LENGTH: u32 = 32768;105pub const MAX_PROPERTIES_PER_ITEM: u32 = 64;106107pub const MAX_AUX_PROPERTY_VALUE_LENGTH: u32 = 2048;108109pub const MAX_COLLECTION_PROPERTIES_SIZE: u32 = 40960;110pub const MAX_TOKEN_PROPERTIES_SIZE: u32 = 32768;111112/// How much items can be created per single113/// create_many call114pub const MAX_ITEMS_PER_BATCH: u32 = 200;115116pub type CustomDataLimit = ConstU32<CUSTOM_DATA_LIMIT>;117118#[derive(119	Encode,120	Decode,121	PartialEq,122	Eq,123	PartialOrd,124	Ord,125	Clone,126	Copy,127	Debug,128	Default,129	TypeInfo,130	MaxEncodedLen,131)]132#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]133pub struct CollectionId(pub u32);134impl EncodeLike<u32> for CollectionId {}135impl EncodeLike<CollectionId> for u32 {}136137#[derive(138	Encode,139	Decode,140	PartialEq,141	Eq,142	PartialOrd,143	Ord,144	Clone,145	Copy,146	Debug,147	Default,148	TypeInfo,149	MaxEncodedLen,150)]151#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]152pub struct TokenId(pub u32);153impl EncodeLike<u32> for TokenId {}154impl EncodeLike<TokenId> for u32 {}155156impl TokenId {157	pub fn try_next(self) -> Result<TokenId, ArithmeticError> {158		self.0159			.checked_add(1)160			.ok_or(ArithmeticError::Overflow)161			.map(Self)162	}163}164165impl From<TokenId> for U256 {166	fn from(t: TokenId) -> Self {167		t.0.into()168	}169}170171impl TryFrom<U256> for TokenId {172	type Error = &'static str;173174	fn try_from(value: U256) -> Result<Self, Self::Error> {175		Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))176	}177}178179#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]180#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]181pub struct TokenData<CrossAccountId> {182	pub properties: Vec<Property>,183	pub owner: Option<CrossAccountId>,184	pub pieces: u128,185}186187pub struct OverflowError;188impl From<OverflowError> for &'static str {189	fn from(_: OverflowError) -> Self {190		"overflow occured"191	}192}193194pub type DecimalPoints = u8;195196#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]197#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]198pub enum CollectionMode {199	NFT,200	Fungible(DecimalPoints),201	ReFungible,202}203204impl CollectionMode {205	pub fn id(&self) -> u8 {206		match self {207			CollectionMode::NFT => 1,208			CollectionMode::Fungible(_) => 2,209			CollectionMode::ReFungible => 3,210		}211	}212}213214pub trait SponsoringResolve<AccountId, Call> {215	fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;216}217218#[derive(Encode, Decode, Eq, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]219#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]220pub enum AccessMode {221	Normal,222	AllowList,223}224impl Default for AccessMode {225	fn default() -> Self {226		Self::Normal227	}228}229230#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]231#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]232pub enum SchemaVersion {233	ImageURL,234	Unique,235}236impl Default for SchemaVersion {237	fn default() -> Self {238		Self::ImageURL239	}240}241242#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]243#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]244pub struct Ownership<AccountId> {245	pub owner: AccountId,246	pub fraction: u128,247}248249#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]250#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]251pub enum SponsorshipState<AccountId> {252	/// The fees are applied to the transaction sender253	Disabled,254	/// Pending confirmation from a sponsor-to-be255	Unconfirmed(AccountId),256	/// Transactions are sponsored by specified account257	Confirmed(AccountId),258}259260impl<AccountId> SponsorshipState<AccountId> {261	/// Get the acting sponsor account, if present262	pub fn sponsor(&self) -> Option<&AccountId> {263		match self {264			Self::Confirmed(sponsor) => Some(sponsor),265			_ => None,266		}267	}268269	/// Get the sponsor account currently pending confirmation, if present270	pub fn pending_sponsor(&self) -> Option<&AccountId> {271		match self {272			Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),273			_ => None,274		}275	}276277	/// Is sponsorship set and acting278	pub fn confirmed(&self) -> bool {279		matches!(self, Self::Confirmed(_))280	}281}282283impl<T> Default for SponsorshipState<T> {284	fn default() -> Self {285		Self::Disabled286	}287}288289pub type CollectionName = BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>;290pub type CollectionDescription = BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>;291pub type CollectionTokenPrefix = BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>;292293/// Collection parameters, used in storage (see [`RpcCollection`] for the RPC version).294#[struct_versioning::versioned(version = 2, upper)]295#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]296pub struct Collection<AccountId> {297	pub owner: AccountId,298	pub mode: CollectionMode,299	#[version(..2)]300	pub access: AccessMode,301	pub name: CollectionName,302	pub description: CollectionDescription,303	pub token_prefix: CollectionTokenPrefix,304305	#[version(..2)]306	pub mint_mode: bool,307308	#[version(..2)]309	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,310311	#[version(..2)]312	pub schema_version: SchemaVersion,313	pub sponsorship: SponsorshipState<AccountId>,314315	pub limits: CollectionLimits,316317	#[version(2.., upper(Default::default()))]318	pub permissions: CollectionPermissions,319320	/// Marks that this collection is not "unique", and managed from external.321	#[version(2.., upper(false))]322	pub external_collection: bool,323324	#[version(..2)]325	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,326327	#[version(..2)]328	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,329330	#[version(..2)]331	pub meta_update_permission: MetaUpdatePermission,332}333334/// Collection parameters, used in RPC calls (see [`Collection`] for the storage version).335#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]336#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]337pub struct RpcCollection<AccountId> {338	pub owner: AccountId,339	pub mode: CollectionMode,340	pub name: Vec<u16>,341	pub description: Vec<u16>,342	pub token_prefix: Vec<u8>,343	pub sponsorship: SponsorshipState<AccountId>,344	pub limits: CollectionLimits,345	pub permissions: CollectionPermissions,346	pub token_property_permissions: Vec<PropertyKeyPermission>,347	pub properties: Vec<Property>,348	pub read_only: bool,349}350351#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Derivative, MaxEncodedLen)]352#[derivative(Debug, Default(bound = ""))]353pub struct CreateCollectionData<AccountId> {354	#[derivative(Default(value = "CollectionMode::NFT"))]355	pub mode: CollectionMode,356	pub access: Option<AccessMode>,357	pub name: CollectionName,358	pub description: CollectionDescription,359	pub token_prefix: CollectionTokenPrefix,360	pub pending_sponsor: Option<AccountId>,361	pub limits: Option<CollectionLimits>,362	pub permissions: Option<CollectionPermissions>,363	pub token_property_permissions: CollectionPropertiesPermissionsVec,364	pub properties: CollectionPropertiesVec,365}366367pub type CollectionPropertiesPermissionsVec =368	BoundedVec<PropertyKeyPermission, ConstU32<MAX_PROPERTIES_PER_ITEM>>;369370pub type CollectionPropertiesVec = BoundedVec<Property, ConstU32<MAX_PROPERTIES_PER_ITEM>>;371372/// Limits and restrictions of a collection.373/// All fields are wrapped in `Option`s, where None means chain default.374///375/// todo:doc links to chain defaults376// IMPORTANT: When adding/removing fields from this struct - don't forget to also377// update clamp_limits() in pallet-common.378#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]379#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]380pub struct CollectionLimits {381	/// Maximum number of owned tokens per account. Chain default: [`ACCOUNT_TOKEN_OWNERSHIP_LIMIT`]382	pub account_token_ownership_limit: Option<u32>,383	/// Maximum size of data in bytes of a sponsored transaction. Chain default: [`CUSTOM_DATA_LIMIT`]384	pub sponsored_data_size: Option<u32>,385386	/// FIXME should we delete this or repurpose it?387	/// None - setVariableMetadata is not sponsored388	/// Some(v) - setVariableMetadata is sponsored389	///           if there is v block between txs390	///391	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]392	pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,393	/// Maximum amount of tokens inside the collection. Chain default: [`COLLECTION_TOKEN_LIMIT`]394	pub token_limit: Option<u32>,395396	/// Timeout for sponsoring a token transfer in passed blocks. Chain default:397	/// either [`NFT_SPONSOR_TRANSFER_TIMEOUT`], [`FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT`], or [`REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT`],398	/// depending on the collection type.399	pub sponsor_transfer_timeout: Option<u32>,400	/// Timeout for sponsoring an approval in passed blocks. Chain default: [`SPONSOR_APPROVE_TIMEOUT`]401	pub sponsor_approve_timeout: Option<u32>,402	/// Can a token be transferred by the owner. Chain default: `false`403	pub owner_can_transfer: Option<bool>,404	/// Can a token be burned by the owner. Chain default: `true`405	pub owner_can_destroy: Option<bool>,406	/// Can a token be transferred at all. Chain default: `true`407	pub transfers_enabled: Option<bool>,408}409410impl CollectionLimits {411	pub fn account_token_ownership_limit(&self) -> u32 {412		self.account_token_ownership_limit413			.unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)414			.min(MAX_TOKEN_OWNERSHIP)415	}416	pub fn sponsored_data_size(&self) -> u32 {417		self.sponsored_data_size418			.unwrap_or(CUSTOM_DATA_LIMIT)419			.min(CUSTOM_DATA_LIMIT)420	}421	pub fn token_limit(&self) -> u32 {422		self.token_limit423			.unwrap_or(COLLECTION_TOKEN_LIMIT)424			.min(COLLECTION_TOKEN_LIMIT)425	}426	pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {427		self.sponsor_transfer_timeout428			.unwrap_or(default)429			.min(MAX_SPONSOR_TIMEOUT)430	}431	pub fn sponsor_approve_timeout(&self) -> u32 {432		self.sponsor_approve_timeout433			.unwrap_or(SPONSOR_APPROVE_TIMEOUT)434			.min(MAX_SPONSOR_TIMEOUT)435	}436	pub fn owner_can_transfer(&self) -> bool {437		self.owner_can_transfer.unwrap_or(false)438	}439	pub fn owner_can_transfer_instaled(&self) -> bool {440		self.owner_can_transfer.is_some()441	}442	pub fn owner_can_destroy(&self) -> bool {443		self.owner_can_destroy.unwrap_or(true)444	}445	pub fn transfers_enabled(&self) -> bool {446		self.transfers_enabled.unwrap_or(true)447	}448	pub fn sponsored_data_rate_limit(&self) -> Option<u32> {449		match self450			.sponsored_data_rate_limit451			.unwrap_or(SponsoringRateLimit::SponsoringDisabled)452		{453			SponsoringRateLimit::SponsoringDisabled => None,454			SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),455		}456	}457}458459/// Permissions on certain operations within a collection.460/// All fields are wrapped in `Option`s, where None means chain default.461// IMPORTANT: When adding/removing fields from this struct - don't forget to also462// update clamp_limits() in pallet-common.463#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]464#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]465pub struct CollectionPermissions {466	pub access: Option<AccessMode>,467	pub mint_mode: Option<bool>,468	pub nesting: Option<NestingPermissions>,469}470471impl CollectionPermissions {472	pub fn access(&self) -> AccessMode {473		self.access.unwrap_or(AccessMode::Normal)474	}475	pub fn mint_mode(&self) -> bool {476		self.mint_mode.unwrap_or(false)477	}478	pub fn nesting(&self) -> &NestingPermissions {479		static DEFAULT: NestingPermissions = NestingPermissions {480			token_owner: false,481			collection_admin: false,482			restricted: None,483			#[cfg(feature = "runtime-benchmarks")]484			permissive: false,485		};486		self.nesting.as_ref().unwrap_or(&DEFAULT)487	}488}489490type OwnerRestrictedSetInner = BoundedBTreeSet<CollectionId, ConstU32<16>>;491492#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]493#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]494#[derivative(Debug)]495pub struct OwnerRestrictedSet(496	#[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]497	#[derivative(Debug(format_with = "bounded::set_debug"))]498	pub OwnerRestrictedSetInner,499);500impl OwnerRestrictedSet {501	pub fn new() -> Self {502		Self(Default::default())503	}504}505impl core::ops::Deref for OwnerRestrictedSet {506	type Target = OwnerRestrictedSetInner;507	fn deref(&self) -> &Self::Target {508		&self.0509	}510}511impl core::ops::DerefMut for OwnerRestrictedSet {512	fn deref_mut(&mut self) -> &mut Self::Target {513		&mut self.0514	}515}516517/// Part of collection permissions, if set, defines who is able to nest tokens into other tokens.518#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]519#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]520#[derivative(Debug)]521pub struct NestingPermissions {522	/// Owner of token can nest tokens under it523	pub token_owner: bool,524	/// Admin of token collection can nest tokens under token525	pub collection_admin: bool,526	/// If set - only tokens from specified collections can be nested527	pub restricted: Option<OwnerRestrictedSet>,528529	#[cfg(feature = "runtime-benchmarks")]530	/// Anyone can nest tokens, mutually exclusive with `token_owner`, `admin`531	pub permissive: bool,532}533534/// Enum denominating how often can sponsoring occur if it is enabled.535#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]536#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]537pub enum SponsoringRateLimit {538	/// Sponsoring is disabled, and the collection sponsor will not pay for transactions539	SponsoringDisabled,540	/// Once per how many blocks can sponsorship of a transaction type occur541	Blocks(u32),542}543544/// Data used to describe an NFT at creation.545#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]546#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]547#[derivative(Debug)]548pub struct CreateNftData {549	/// Key-value pairs used to describe the token as metadata550	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]551	#[derivative(Debug(format_with = "bounded::vec_debug"))]552	pub properties: CollectionPropertiesVec,553}554555/// Data used to describe a Fungible token at creation.556#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]557#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]558pub struct CreateFungibleData {559	/// Number of fungible coins minted560	pub value: u128,561}562563/// Data used to describe a Refungible token at creation.564#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]565#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]566#[derivative(Debug)]567pub struct CreateReFungibleData {568	/// Immutable metadata of the token569	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]570	#[derivative(Debug(format_with = "bounded::vec_debug"))]571	pub const_data: BoundedVec<u8, CustomDataLimit>,572573	/// Number of pieces the RFT is split into574	pub pieces: u128,575576	/// Key-value pairs used to describe the token as metadata577	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]578	#[derivative(Debug(format_with = "bounded::vec_debug"))]579	pub properties: CollectionPropertiesVec,580}581582#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]583#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]584pub enum MetaUpdatePermission {585	ItemOwner,586	Admin,587	None,588}589590/// Enum holding data used for creation of all three item types.591#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]592#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]593pub enum CreateItemData {594	NFT(CreateNftData),595	Fungible(CreateFungibleData),596	ReFungible(CreateReFungibleData),597}598599/// Explicit NFT creation data with meta parameters.600#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]601#[derivative(Debug)]602pub struct CreateNftExData<CrossAccountId> {603	#[derivative(Debug(format_with = "bounded::vec_debug"))]604	pub properties: CollectionPropertiesVec,605	pub owner: CrossAccountId,606}607608/// Explicit RFT creation data with meta parameters.609#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]610#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]611pub struct CreateRefungibleExData<CrossAccountId> {612	#[derivative(Debug(format_with = "bounded::vec_debug"))]613	pub const_data: BoundedVec<u8, CustomDataLimit>,614	#[derivative(Debug(format_with = "bounded::map_debug"))]615	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,616	#[derivative(Debug(format_with = "bounded::vec_debug"))]617	pub properties: CollectionPropertiesVec,618}619620/// Explicit item creation data with meta parameters, namely the owner.621#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]622#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]623pub enum CreateItemExData<CrossAccountId> {624	NFT(625		#[derivative(Debug(format_with = "bounded::vec_debug"))]626		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,627	),628	Fungible(629		#[derivative(Debug(format_with = "bounded::map_debug"))]630		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,631	),632	/// Many tokens, each may have only one owner633	RefungibleMultipleItems(634		#[derivative(Debug(format_with = "bounded::vec_debug"))]635		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,636	),637	/// Single token, which may have many owners638	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),639}640641impl CreateItemData {642	pub fn data_size(&self) -> usize {643		match self {644			CreateItemData::ReFungible(data) => data.const_data.len(),645			_ => 0,646		}647	}648}649650impl From<CreateNftData> for CreateItemData {651	fn from(item: CreateNftData) -> Self {652		CreateItemData::NFT(item)653	}654}655656impl From<CreateReFungibleData> for CreateItemData {657	fn from(item: CreateReFungibleData) -> Self {658		CreateItemData::ReFungible(item)659	}660}661662impl From<CreateFungibleData> for CreateItemData {663	fn from(item: CreateFungibleData) -> Self {664		CreateItemData::Fungible(item)665	}666}667668/// Token's address, dictated by its collection and token IDs.669#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]670#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]671// todo possibly rename to be used generally as an address pair672pub struct TokenChild {673	pub token: TokenId,674	pub collection: CollectionId,675}676677#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]678#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]679pub struct CollectionStats {680	pub created: u32,681	pub destroyed: u32,682	pub alive: u32,683}684685#[derive(Encode, Decode, Clone, Debug)]686#[cfg_attr(feature = "std", derive(PartialEq))]687pub struct PhantomType<T>(core::marker::PhantomData<T>);688689impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {690	type Identity = PhantomType<T>;691692	fn type_info() -> scale_info::Type {693		use scale_info::{694			Type, Path,695			build::{FieldsBuilder, UnnamedFields},696			type_params,697		};698		Type::builder()699			.path(Path::new("up_data_structs", "PhantomType"))700			.type_params(type_params!(T))701			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))702	}703}704impl<T> MaxEncodedLen for PhantomType<T> {705	fn max_encoded_len() -> usize {706		0707	}708}709710pub type BoundedBytes<S> = BoundedVec<u8, S>;711712pub type AuxPropertyValue = BoundedBytes<ConstU32<MAX_AUX_PROPERTY_VALUE_LENGTH>>;713714pub type PropertyKey = BoundedBytes<ConstU32<MAX_PROPERTY_KEY_LENGTH>>;715pub type PropertyValue = BoundedBytes<ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;716717#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]718#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]719pub struct PropertyPermission {720	pub mutable: bool,721	pub collection_admin: bool,722	pub token_owner: bool,723}724725impl PropertyPermission {726	pub fn none() -> Self {727		Self {728			mutable: true,729			collection_admin: false,730			token_owner: false,731		}732	}733}734735#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]736#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]737pub struct Property {738	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]739	pub key: PropertyKey,740741	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]742	pub value: PropertyValue,743}744745impl Into<(PropertyKey, PropertyValue)> for Property {746	fn into(self) -> (PropertyKey, PropertyValue) {747		(self.key, self.value)748	}749}750751#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]752#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]753pub struct PropertyKeyPermission {754	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]755	pub key: PropertyKey,756757	pub permission: PropertyPermission,758}759760impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {761	fn into(self) -> (PropertyKey, PropertyPermission) {762		(self.key, self.permission)763	}764}765766#[derive(Debug)]767pub enum PropertiesError {768	NoSpaceForProperty,769	PropertyLimitReached,770	InvalidCharacterInPropertyKey,771	PropertyKeyIsTooLong,772	EmptyPropertyKey,773}774775#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, Clone, Copy)]776pub enum PropertyScope {777	None,778	Rmrk,779}780781impl PropertyScope {782	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {783		let scope_str: &[u8] = match self {784			Self::None => return Ok(key),785			Self::Rmrk => b"rmrk",786		};787788		[scope_str, b":", key.as_slice()]789			.concat()790			.try_into()791			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)792	}793}794795pub trait TrySetProperty: Sized {796	type Value;797798	fn try_scoped_set(799		&mut self,800		scope: PropertyScope,801		key: PropertyKey,802		value: Self::Value,803	) -> Result<(), PropertiesError>;804805	fn try_scoped_set_from_iter<I, KV>(806		&mut self,807		scope: PropertyScope,808		iter: I,809	) -> Result<(), PropertiesError>810	where811		I: Iterator<Item = KV>,812		KV: Into<(PropertyKey, Self::Value)>,813	{814		for kv in iter {815			let (key, value) = kv.into();816			self.try_scoped_set(scope, key, value)?;817		}818819		Ok(())820	}821822	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {823		self.try_scoped_set(PropertyScope::None, key, value)824	}825826	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>827	where828		I: Iterator<Item = KV>,829		KV: Into<(PropertyKey, Self::Value)>,830	{831		self.try_scoped_set_from_iter(PropertyScope::None, iter)832	}833}834835#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]836#[derivative(Default(bound = ""))]837pub struct PropertiesMap<Value>(838	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,839);840841impl<Value> PropertiesMap<Value> {842	pub fn new() -> Self {843		Self(BoundedBTreeMap::new())844	}845846	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {847		Self::check_property_key(key)?;848849		Ok(self.0.remove(key))850	}851852	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {853		self.0.get(key)854	}855856	pub fn contains_key(&self, key: &PropertyKey) -> bool {857		self.0.contains_key(key)858	}859860	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {861		if key.is_empty() {862			return Err(PropertiesError::EmptyPropertyKey);863		}864865		for byte in key.as_slice().iter() {866			let byte = *byte;867868			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' && byte != b'.' {869				return Err(PropertiesError::InvalidCharacterInPropertyKey);870			}871		}872873		Ok(())874	}875}876877impl<Value> IntoIterator for PropertiesMap<Value> {878	type Item = (PropertyKey, Value);879	type IntoIter = <880		BoundedBTreeMap<881			PropertyKey,882			Value,883			ConstU32<MAX_PROPERTIES_PER_ITEM>884		> as IntoIterator885	>::IntoIter;886887	fn into_iter(self) -> Self::IntoIter {888		self.0.into_iter()889	}890}891892impl<Value> TrySetProperty for PropertiesMap<Value> {893	type Value = Value;894895	fn try_scoped_set(896		&mut self,897		scope: PropertyScope,898		key: PropertyKey,899		value: Self::Value,900	) -> Result<(), PropertiesError> {901		Self::check_property_key(&key)?;902903		let key = scope.apply(key)?;904		self.0905			.try_insert(key, value)906			.map_err(|_| PropertiesError::PropertyLimitReached)?;907908		Ok(())909	}910}911912pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;913914#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]915pub struct Properties {916	map: PropertiesMap<PropertyValue>,917	consumed_space: u32,918	space_limit: u32,919}920921impl Properties {922	pub fn new(space_limit: u32) -> Self {923		Self {924			map: PropertiesMap::new(),925			consumed_space: 0,926			space_limit,927		}928	}929930	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {931		let value = self.map.remove(key)?;932933		if let Some(ref value) = value {934			let value_len = value.len() as u32;935			self.consumed_space -= value_len;936		}937938		Ok(value)939	}940941	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {942		self.map.get(key)943	}944}945946impl IntoIterator for Properties {947	type Item = (PropertyKey, PropertyValue);948	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;949950	fn into_iter(self) -> Self::IntoIter {951		self.map.into_iter()952	}953}954955impl TrySetProperty for Properties {956	type Value = PropertyValue;957958	fn try_scoped_set(959		&mut self,960		scope: PropertyScope,961		key: PropertyKey,962		value: Self::Value,963	) -> Result<(), PropertiesError> {964		let value_len = value.len();965966		if self.consumed_space as usize + value_len > self.space_limit as usize967			&& !cfg!(feature = "runtime-benchmarks")968		{969			return Err(PropertiesError::NoSpaceForProperty);970		}971972		self.map.try_scoped_set(scope, key, value)?;973974		self.consumed_space += value_len as u32;975976		Ok(())977	}978}979980pub struct CollectionProperties;981982impl Get<Properties> for CollectionProperties {983	fn get() -> Properties {984		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)985	}986}987988pub struct TokenProperties;989990impl Get<Properties> for TokenProperties {991	fn get() -> Properties {992		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)993	}994}995996// RMRK997// todo document?998parameter_types! {999	#[derive(PartialEq, TypeInfo)]1000	pub const RmrkStringLimit: u32 = 128;1001	#[derive(PartialEq)]1002	pub const RmrkCollectionSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1003	#[derive(PartialEq)]1004	pub const RmrkResourceSymbolLimit: u32 = 10;1005	#[derive(PartialEq)]1006	pub const RmrkBaseSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;1007	#[derive(PartialEq)]1008	pub const RmrkKeyLimit: u32 = 32;1009	#[derive(PartialEq)]1010	pub const RmrkValueLimit: u32 = 256;1011	#[derive(PartialEq)]1012	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;1013	#[derive(PartialEq)]1014	pub const MaxPropertiesPerTheme: u32 = 5;1015	#[derive(PartialEq)]1016	pub const RmrkPartsLimit: u32 = 25;1017	#[derive(PartialEq)]1018	pub const RmrkMaxPriorities: u32 = 25;1019	#[derive(PartialEq)]1020	pub const MaxResourcesOnMint: u32 = 100;1021}10221023impl From<RmrkCollectionId> for CollectionId {1024	fn from(id: RmrkCollectionId) -> Self {1025		Self(id)1026	}1027}10281029impl From<RmrkNftId> for TokenId {1030	fn from(id: RmrkNftId) -> Self {1031		Self(id)1032	}1033}10341035pub type RmrkCollectionInfo<AccountId> =1036	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;1037pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;1038pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;1039pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;1040pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;1041pub type BoundedEquippableCollectionIds =1042	BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>;1043pub type RmrkPartType = PartType<RmrkString, BoundedEquippableCollectionIds>;1044pub type RmrkEquippableList = EquippableList<BoundedEquippableCollectionIds>;1045pub type RmrkThemeProperty = ThemeProperty<RmrkString>;1046pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;1047pub type RmrkBoundedTheme = Theme<RmrkString, BoundedVec<RmrkThemeProperty, MaxPropertiesPerTheme>>;1048pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;10491050pub type RmrkBasicResource = BasicResource<RmrkString>;1051pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;1052pub type RmrkSlotResource = SlotResource<RmrkString>;10531054pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;1055pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;1056pub type RmrkBaseSymbol = BoundedVec<u8, RmrkBaseSymbolLimit>;1057pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;1058pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;1059pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;1060pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed10611062pub type RmrkRpcString = Vec<u8>;1063pub type RmrkThemeName = RmrkRpcString;1064pub type RmrkPropertyKey = RmrkRpcString;