git.delta.rocks / unique-network / refs/commits / 611e7535f9cc

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}288289/// Collection parameters, used in storage (see [`RpcCollection`] for the RPC version).290#[struct_versioning::versioned(version = 2, upper)]291#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]292pub struct Collection<AccountId> {293	pub owner: AccountId,294	pub mode: CollectionMode,295	#[version(..2)]296	pub access: AccessMode,297	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,298	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,299	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,300301	#[version(..2)]302	pub mint_mode: bool,303304	#[version(..2)]305	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,306307	#[version(..2)]308	pub schema_version: SchemaVersion,309	pub sponsorship: SponsorshipState<AccountId>,310311	pub limits: CollectionLimits,312313	#[version(2.., upper(Default::default()))]314	pub permissions: CollectionPermissions,315316	/// Marks that this collection is not "unique", and managed from external.317	#[version(2.., upper(false))]318	pub external_collection: bool,319320	#[version(..2)]321	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,322323	#[version(..2)]324	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,325326	#[version(..2)]327	pub meta_update_permission: MetaUpdatePermission,328}329330/// Collection parameters, used in RPC calls (see [`Collection`] for the storage version).331#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]332#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]333pub struct RpcCollection<AccountId> {334	pub owner: AccountId,335	pub mode: CollectionMode,336	pub name: Vec<u16>,337	pub description: Vec<u16>,338	pub token_prefix: Vec<u8>,339	pub sponsorship: SponsorshipState<AccountId>,340	pub limits: CollectionLimits,341	pub permissions: CollectionPermissions,342	pub token_property_permissions: Vec<PropertyKeyPermission>,343	pub properties: Vec<Property>,344	pub read_only: bool,345}346347#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Derivative, MaxEncodedLen)]348#[derivative(Debug, Default(bound = ""))]349pub struct CreateCollectionData<AccountId> {350	#[derivative(Default(value = "CollectionMode::NFT"))]351	pub mode: CollectionMode,352	pub access: Option<AccessMode>,353	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,354	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,355	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,356	pub pending_sponsor: Option<AccountId>,357	pub limits: Option<CollectionLimits>,358	pub permissions: Option<CollectionPermissions>,359	pub token_property_permissions: CollectionPropertiesPermissionsVec,360	pub properties: CollectionPropertiesVec,361}362363pub type CollectionPropertiesPermissionsVec =364	BoundedVec<PropertyKeyPermission, ConstU32<MAX_PROPERTIES_PER_ITEM>>;365366pub type CollectionPropertiesVec = BoundedVec<Property, ConstU32<MAX_PROPERTIES_PER_ITEM>>;367368/// Limits and restrictions of a collection.369/// All fields are wrapped in `Option`s, where None means chain default.370///371/// todo:doc links to chain defaults372// IMPORTANT: When adding/removing fields from this struct - don't forget to also373// update clamp_limits() in pallet-common.374#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]375#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]376pub struct CollectionLimits {377	/// Maximum number of owned tokens per account. Chain default: [`ACCOUNT_TOKEN_OWNERSHIP_LIMIT`]378	pub account_token_ownership_limit: Option<u32>,379	/// Maximum size of data in bytes of a sponsored transaction. Chain default: [`CUSTOM_DATA_LIMIT`]380	pub sponsored_data_size: Option<u32>,381382	/// FIXME should we delete this or repurpose it?383	/// None - setVariableMetadata is not sponsored384	/// Some(v) - setVariableMetadata is sponsored385	///           if there is v block between txs386	///387	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]388	pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,389	/// Maximum amount of tokens inside the collection. Chain default: [`COLLECTION_TOKEN_LIMIT`]390	pub token_limit: Option<u32>,391392	/// Timeout for sponsoring a token transfer in passed blocks. Chain default: [`MAX_SPONSOR_TIMEOUT`]393	pub sponsor_transfer_timeout: Option<u32>,394	/// Timeout for sponsoring an approval in passed blocks. Chain default: [`SPONSOR_APPROVE_TIMEOUT`]395	pub sponsor_approve_timeout: Option<u32>,396	/// Can a token be transferred by the owner. Chain default: `false`397	pub owner_can_transfer: Option<bool>,398	/// Can a token be burned by the owner. Chain default: `true`399	pub owner_can_destroy: Option<bool>,400	/// Can a token be transferred at all. Chain default: `true`401	pub transfers_enabled: Option<bool>,402}403404impl CollectionLimits {405	pub fn account_token_ownership_limit(&self) -> u32 {406		self.account_token_ownership_limit407			.unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)408			.min(MAX_TOKEN_OWNERSHIP)409	}410	pub fn sponsored_data_size(&self) -> u32 {411		self.sponsored_data_size412			.unwrap_or(CUSTOM_DATA_LIMIT)413			.min(CUSTOM_DATA_LIMIT)414	}415	pub fn token_limit(&self) -> u32 {416		self.token_limit417			.unwrap_or(COLLECTION_TOKEN_LIMIT)418			.min(COLLECTION_TOKEN_LIMIT)419	}420	pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {421		self.sponsor_transfer_timeout422			.unwrap_or(default)423			.min(MAX_SPONSOR_TIMEOUT)424	}425	pub fn sponsor_approve_timeout(&self) -> u32 {426		self.sponsor_approve_timeout427			.unwrap_or(SPONSOR_APPROVE_TIMEOUT)428			.min(MAX_SPONSOR_TIMEOUT)429	}430	pub fn owner_can_transfer(&self) -> bool {431		self.owner_can_transfer.unwrap_or(false)432	}433	pub fn owner_can_transfer_instaled(&self) -> bool {434		self.owner_can_transfer.is_some()435	}436	pub fn owner_can_destroy(&self) -> bool {437		self.owner_can_destroy.unwrap_or(true)438	}439	pub fn transfers_enabled(&self) -> bool {440		self.transfers_enabled.unwrap_or(true)441	}442	pub fn sponsored_data_rate_limit(&self) -> Option<u32> {443		match self444			.sponsored_data_rate_limit445			.unwrap_or(SponsoringRateLimit::SponsoringDisabled)446		{447			SponsoringRateLimit::SponsoringDisabled => None,448			SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),449		}450	}451}452453/// Permissions on certain operations within a collection.454/// All fields are wrapped in `Option`s, where None means chain default.455// IMPORTANT: When adding/removing fields from this struct - don't forget to also456// update clamp_limits() in pallet-common.457#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]458#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]459pub struct CollectionPermissions {460	pub access: Option<AccessMode>,461	pub mint_mode: Option<bool>,462	pub nesting: Option<NestingPermissions>,463}464465impl CollectionPermissions {466	pub fn access(&self) -> AccessMode {467		self.access.unwrap_or(AccessMode::Normal)468	}469	pub fn mint_mode(&self) -> bool {470		self.mint_mode.unwrap_or(false)471	}472	pub fn nesting(&self) -> &NestingPermissions {473		static DEFAULT: NestingPermissions = NestingPermissions {474			token_owner: false,475			collection_admin: false,476			restricted: None,477			#[cfg(feature = "runtime-benchmarks")]478			permissive: false,479		};480		self.nesting.as_ref().unwrap_or(&DEFAULT)481	}482}483484type OwnerRestrictedSetInner = BoundedBTreeSet<CollectionId, ConstU32<16>>;485486#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]487#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]488#[derivative(Debug)]489pub struct OwnerRestrictedSet(490	#[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]491	#[derivative(Debug(format_with = "bounded::set_debug"))]492	pub OwnerRestrictedSetInner,493);494impl OwnerRestrictedSet {495	pub fn new() -> Self {496		Self(Default::default())497	}498}499impl core::ops::Deref for OwnerRestrictedSet {500	type Target = OwnerRestrictedSetInner;501	fn deref(&self) -> &Self::Target {502		&self.0503	}504}505impl core::ops::DerefMut for OwnerRestrictedSet {506	fn deref_mut(&mut self) -> &mut Self::Target {507		&mut self.0508	}509}510511/// Part of collection permissions, if set, defines who is able to nest tokens into other tokens.512#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]513#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]514#[derivative(Debug)]515pub struct NestingPermissions {516	/// Owner of token can nest tokens under it517	pub token_owner: bool,518	/// Admin of token collection can nest tokens under token519	pub collection_admin: bool,520	/// If set - only tokens from specified collections can be nested521	pub restricted: Option<OwnerRestrictedSet>,522523	#[cfg(feature = "runtime-benchmarks")]524	/// Anyone can nest tokens, mutually exclusive with `token_owner`, `admin`525	pub permissive: bool,526}527528/// Enum denominating how often can sponsoring occur if it is enabled.529#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]530#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]531pub enum SponsoringRateLimit {532	/// Sponsoring is disabled, and the collection sponsor will not pay for transactions533	SponsoringDisabled,534	/// Once per how many blocks can sponsorship of a transaction type occur535	Blocks(u32),536}537538/// Data used to describe an NFT at creation.539#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]540#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]541#[derivative(Debug)]542pub struct CreateNftData {543	/// Key-value pairs used to describe the token as metadata544	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]545	#[derivative(Debug(format_with = "bounded::vec_debug"))]546	pub properties: CollectionPropertiesVec,547}548549/// Data used to describe a Fungible token at creation.550#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]551#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]552pub struct CreateFungibleData {553	/// Number of fungible coins minted554	pub value: u128,555}556557/// Data used to describe a Refungible token at creation.558#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]559#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]560#[derivative(Debug)]561pub struct CreateReFungibleData {562	/// Immutable metadata of the token563	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]564	#[derivative(Debug(format_with = "bounded::vec_debug"))]565	pub const_data: BoundedVec<u8, CustomDataLimit>,566	/// Number of pieces the RFT is split into567	pub pieces: u128,568}569570#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]571#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]572pub enum MetaUpdatePermission {573	ItemOwner,574	Admin,575	None,576}577578/// Enum holding data used for creation of all three item types.579#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]580#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]581pub enum CreateItemData {582	NFT(CreateNftData),583	Fungible(CreateFungibleData),584	ReFungible(CreateReFungibleData),585}586587/// Explicit NFT creation data with meta parameters.588#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]589#[derivative(Debug)]590pub struct CreateNftExData<CrossAccountId> {591	#[derivative(Debug(format_with = "bounded::vec_debug"))]592	pub properties: CollectionPropertiesVec,593	pub owner: CrossAccountId,594}595596/// Explicit RFT creation data with meta parameters.597#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]598#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]599pub struct CreateRefungibleExData<CrossAccountId> {600	#[derivative(Debug(format_with = "bounded::vec_debug"))]601	pub const_data: BoundedVec<u8, CustomDataLimit>,602	#[derivative(Debug(format_with = "bounded::map_debug"))]603	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,604}605606/// Explicit item creation data with meta parameters, namely the owner.607#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]608#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]609pub enum CreateItemExData<CrossAccountId> {610	NFT(611		#[derivative(Debug(format_with = "bounded::vec_debug"))]612		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,613	),614	Fungible(615		#[derivative(Debug(format_with = "bounded::map_debug"))]616		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,617	),618	/// Many tokens, each may have only one owner619	RefungibleMultipleItems(620		#[derivative(Debug(format_with = "bounded::vec_debug"))]621		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,622	),623	/// Single token, which may have many owners624	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),625}626627impl CreateItemData {628	pub fn data_size(&self) -> usize {629		match self {630			CreateItemData::ReFungible(data) => data.const_data.len(),631			_ => 0,632		}633	}634}635636impl From<CreateNftData> for CreateItemData {637	fn from(item: CreateNftData) -> Self {638		CreateItemData::NFT(item)639	}640}641642impl From<CreateReFungibleData> for CreateItemData {643	fn from(item: CreateReFungibleData) -> Self {644		CreateItemData::ReFungible(item)645	}646}647648impl From<CreateFungibleData> for CreateItemData {649	fn from(item: CreateFungibleData) -> Self {650		CreateItemData::Fungible(item)651	}652}653654/// Token's address, dictated by its collection and token IDs.655#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]656#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]657// todo possibly rename to be used generally as an address pair658pub struct TokenChild {659	pub token: TokenId,660	pub collection: CollectionId,661}662663#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]664#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]665pub struct CollectionStats {666	pub created: u32,667	pub destroyed: u32,668	pub alive: u32,669}670671#[derive(Encode, Decode, Clone, Debug)]672#[cfg_attr(feature = "std", derive(PartialEq))]673pub struct PhantomType<T>(core::marker::PhantomData<T>);674675impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {676	type Identity = PhantomType<T>;677678	fn type_info() -> scale_info::Type {679		use scale_info::{680			Type, Path,681			build::{FieldsBuilder, UnnamedFields},682			type_params,683		};684		Type::builder()685			.path(Path::new("up_data_structs", "PhantomType"))686			.type_params(type_params!(T))687			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))688	}689}690impl<T> MaxEncodedLen for PhantomType<T> {691	fn max_encoded_len() -> usize {692		0693	}694}695696pub type BoundedBytes<S> = BoundedVec<u8, S>;697698pub type AuxPropertyValue = BoundedBytes<ConstU32<MAX_AUX_PROPERTY_VALUE_LENGTH>>;699700pub type PropertyKey = BoundedBytes<ConstU32<MAX_PROPERTY_KEY_LENGTH>>;701pub type PropertyValue = BoundedBytes<ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;702703#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]704#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]705pub struct PropertyPermission {706	pub mutable: bool,707	pub collection_admin: bool,708	pub token_owner: bool,709}710711impl PropertyPermission {712	pub fn none() -> Self {713		Self {714			mutable: true,715			collection_admin: false,716			token_owner: false,717		}718	}719}720721#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]722#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]723pub struct Property {724	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]725	pub key: PropertyKey,726727	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]728	pub value: PropertyValue,729}730731impl Into<(PropertyKey, PropertyValue)> for Property {732	fn into(self) -> (PropertyKey, PropertyValue) {733		(self.key, self.value)734	}735}736737#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]738#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]739pub struct PropertyKeyPermission {740	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]741	pub key: PropertyKey,742743	pub permission: PropertyPermission,744}745746impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {747	fn into(self) -> (PropertyKey, PropertyPermission) {748		(self.key, self.permission)749	}750}751752#[derive(Debug)]753pub enum PropertiesError {754	NoSpaceForProperty,755	PropertyLimitReached,756	InvalidCharacterInPropertyKey,757	PropertyKeyIsTooLong,758	EmptyPropertyKey,759}760761#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, Clone, Copy)]762pub enum PropertyScope {763	None,764	Rmrk,765}766767impl PropertyScope {768	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {769		let scope_str: &[u8] = match self {770			Self::None => return Ok(key),771			Self::Rmrk => b"rmrk",772		};773774		[scope_str, b":", key.as_slice()]775			.concat()776			.try_into()777			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)778	}779}780781pub trait TrySetProperty: Sized {782	type Value;783784	fn try_scoped_set(785		&mut self,786		scope: PropertyScope,787		key: PropertyKey,788		value: Self::Value,789	) -> Result<(), PropertiesError>;790791	fn try_scoped_set_from_iter<I, KV>(792		&mut self,793		scope: PropertyScope,794		iter: I,795	) -> Result<(), PropertiesError>796	where797		I: Iterator<Item = KV>,798		KV: Into<(PropertyKey, Self::Value)>,799	{800		for kv in iter {801			let (key, value) = kv.into();802			self.try_scoped_set(scope, key, value)?;803		}804805		Ok(())806	}807808	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {809		self.try_scoped_set(PropertyScope::None, key, value)810	}811812	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>813	where814		I: Iterator<Item = KV>,815		KV: Into<(PropertyKey, Self::Value)>,816	{817		self.try_scoped_set_from_iter(PropertyScope::None, iter)818	}819}820821#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]822#[derivative(Default(bound = ""))]823pub struct PropertiesMap<Value>(824	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,825);826827impl<Value> PropertiesMap<Value> {828	pub fn new() -> Self {829		Self(BoundedBTreeMap::new())830	}831832	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {833		Self::check_property_key(key)?;834835		Ok(self.0.remove(key))836	}837838	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {839		self.0.get(key)840	}841842	pub fn contains_key(&self, key: &PropertyKey) -> bool {843		self.0.contains_key(key)844	}845846	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {847		if key.is_empty() {848			return Err(PropertiesError::EmptyPropertyKey);849		}850851		for byte in key.as_slice().iter() {852			let byte = *byte;853854			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' && byte != b'.' {855				return Err(PropertiesError::InvalidCharacterInPropertyKey);856			}857		}858859		Ok(())860	}861}862863impl<Value> IntoIterator for PropertiesMap<Value> {864	type Item = (PropertyKey, Value);865	type IntoIter = <866		BoundedBTreeMap<867			PropertyKey,868			Value,869			ConstU32<MAX_PROPERTIES_PER_ITEM>870		> as IntoIterator871	>::IntoIter;872873	fn into_iter(self) -> Self::IntoIter {874		self.0.into_iter()875	}876}877878impl<Value> TrySetProperty for PropertiesMap<Value> {879	type Value = Value;880881	fn try_scoped_set(882		&mut self,883		scope: PropertyScope,884		key: PropertyKey,885		value: Self::Value,886	) -> Result<(), PropertiesError> {887		Self::check_property_key(&key)?;888889		let key = scope.apply(key)?;890		self.0891			.try_insert(key, value)892			.map_err(|_| PropertiesError::PropertyLimitReached)?;893894		Ok(())895	}896}897898pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;899900#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]901pub struct Properties {902	map: PropertiesMap<PropertyValue>,903	consumed_space: u32,904	space_limit: u32,905}906907impl Properties {908	pub fn new(space_limit: u32) -> Self {909		Self {910			map: PropertiesMap::new(),911			consumed_space: 0,912			space_limit,913		}914	}915916	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {917		let value = self.map.remove(key)?;918919		if let Some(ref value) = value {920			let value_len = value.len() as u32;921			self.consumed_space -= value_len;922		}923924		Ok(value)925	}926927	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {928		self.map.get(key)929	}930}931932impl IntoIterator for Properties {933	type Item = (PropertyKey, PropertyValue);934	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;935936	fn into_iter(self) -> Self::IntoIter {937		self.map.into_iter()938	}939}940941impl TrySetProperty for Properties {942	type Value = PropertyValue;943944	fn try_scoped_set(945		&mut self,946		scope: PropertyScope,947		key: PropertyKey,948		value: Self::Value,949	) -> Result<(), PropertiesError> {950		let value_len = value.len();951952		if self.consumed_space as usize + value_len > self.space_limit as usize953			&& !cfg!(feature = "runtime-benchmarks")954		{955			return Err(PropertiesError::NoSpaceForProperty);956		}957958		self.map.try_scoped_set(scope, key, value)?;959960		self.consumed_space += value_len as u32;961962		Ok(())963	}964}965966pub struct CollectionProperties;967968impl Get<Properties> for CollectionProperties {969	fn get() -> Properties {970		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)971	}972}973974pub struct TokenProperties;975976impl Get<Properties> for TokenProperties {977	fn get() -> Properties {978		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)979	}980}981982// RMRK983// todo document?984parameter_types! {985	#[derive(PartialEq, TypeInfo)]986	pub const RmrkStringLimit: u32 = 128;987	#[derive(PartialEq)]988	pub const RmrkCollectionSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;989	#[derive(PartialEq)]990	pub const RmrkResourceSymbolLimit: u32 = 10;991	#[derive(PartialEq)]992	pub const RmrkBaseSymbolLimit: u32 = MAX_TOKEN_PREFIX_LENGTH;993	#[derive(PartialEq)]994	pub const RmrkKeyLimit: u32 = 32;995	#[derive(PartialEq)]996	pub const RmrkValueLimit: u32 = 256;997	#[derive(PartialEq)]998	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;999	#[derive(PartialEq)]1000	pub const MaxPropertiesPerTheme: u32 = 5;1001	#[derive(PartialEq)]1002	pub const RmrkPartsLimit: u32 = 25;1003	#[derive(PartialEq)]1004	pub const RmrkMaxPriorities: u32 = 25;1005	#[derive(PartialEq)]1006	pub const MaxResourcesOnMint: u32 = 100;1007}10081009impl From<RmrkCollectionId> for CollectionId {1010	fn from(id: RmrkCollectionId) -> Self {1011		Self(id)1012	}1013}10141015impl From<RmrkNftId> for TokenId {1016	fn from(id: RmrkNftId) -> Self {1017		Self(id)1018	}1019}10201021pub type RmrkCollectionInfo<AccountId> =1022	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;1023pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;1024pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;1025pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;1026pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;1027pub type BoundedEquippableCollectionIds =1028	BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>;1029pub type RmrkPartType = PartType<RmrkString, BoundedEquippableCollectionIds>;1030pub type RmrkEquippableList = EquippableList<BoundedEquippableCollectionIds>;1031pub type RmrkThemeProperty = ThemeProperty<RmrkString>;1032pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;1033pub type RmrkBoundedTheme = Theme<RmrkString, BoundedVec<RmrkThemeProperty, MaxPropertiesPerTheme>>;1034pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;10351036pub type RmrkBasicResource = BasicResource<RmrkString>;1037pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;1038pub type RmrkSlotResource = SlotResource<RmrkString>;10391040pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;1041pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;1042pub type RmrkBaseSymbol = BoundedVec<u8, RmrkBaseSymbolLimit>;1043pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;1044pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;1045pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;1046pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed10471048pub type RmrkRpcString = Vec<u8>;1049pub type RmrkThemeName = RmrkRpcString;1050pub type RmrkPropertyKey = RmrkRpcString;