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

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,43};44pub use rmrk_traits::{45	primitives::{46		CollectionId as RmrkCollectionId, NftId as RmrkNftId, BaseId as RmrkBaseId,47		PartId as RmrkPartId, ResourceId as RmrkResourceId,48	},49	NftChild as RmrkNftChild, AccountIdOrCollectionNftTuple as RmrkAccountIdOrCollectionNftTuple,50	FixedPart as RmrkFixedPart, SlotPart as RmrkSlotPart, EquippableList as RmrkEquippableList,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_COLLECTION_PROPERTIES_SIZE: u32 = 40960;108pub const MAX_TOKEN_PROPERTIES_SIZE: u32 = 32768;109110// RMRK constants111pub const RMRK_STRING_LIMIT: u32 = 128;112pub const RMRK_COLLECTION_SYMBOL_LIMIT: u32 = 100;113pub const RMRK_RESOURCE_SYMBOL_LIMIT: u32 = 10;114pub const RMRK_KEY_LIMIT: u32 = 32;115pub const RMRK_VALUE_LIMIT: u32 = 256;116117/// How much items can be created per single118/// create_many call119pub const MAX_ITEMS_PER_BATCH: u32 = 200;120121pub type CustomDataLimit = ConstU32<CUSTOM_DATA_LIMIT>;122123#[derive(124	Encode,125	Decode,126	PartialEq,127	Eq,128	PartialOrd,129	Ord,130	Clone,131	Copy,132	Debug,133	Default,134	TypeInfo,135	MaxEncodedLen,136)]137#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]138pub struct CollectionId(pub u32);139impl EncodeLike<u32> for CollectionId {}140impl EncodeLike<CollectionId> for u32 {}141142#[derive(143	Encode,144	Decode,145	PartialEq,146	Eq,147	PartialOrd,148	Ord,149	Clone,150	Copy,151	Debug,152	Default,153	TypeInfo,154	MaxEncodedLen,155)]156#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]157pub struct TokenId(pub u32);158impl EncodeLike<u32> for TokenId {}159impl EncodeLike<TokenId> for u32 {}160161impl TokenId {162	pub fn try_next(self) -> Result<TokenId, ArithmeticError> {163		self.0164			.checked_add(1)165			.ok_or(ArithmeticError::Overflow)166			.map(Self)167	}168}169170impl From<TokenId> for U256 {171	fn from(t: TokenId) -> Self {172		t.0.into()173	}174}175176impl TryFrom<U256> for TokenId {177	type Error = &'static str;178179	fn try_from(value: U256) -> Result<Self, Self::Error> {180		Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))181	}182}183184#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]185#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]186pub struct TokenData<CrossAccountId> {187	pub properties: Vec<Property>,188	pub owner: Option<CrossAccountId>,189}190191pub struct OverflowError;192impl From<OverflowError> for &'static str {193	fn from(_: OverflowError) -> Self {194		"overflow occured"195	}196}197198pub type DecimalPoints = u8;199200#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]201#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]202pub enum CollectionMode {203	NFT,204	// decimal points205	Fungible(DecimalPoints),206	ReFungible,207}208209impl CollectionMode {210	pub fn id(&self) -> u8 {211		match self {212			CollectionMode::NFT => 1,213			CollectionMode::Fungible(_) => 2,214			CollectionMode::ReFungible => 3,215		}216	}217}218219pub trait SponsoringResolve<AccountId, Call> {220	fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;221}222223#[derive(Encode, Decode, Eq, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]224#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]225pub enum AccessMode {226	Normal,227	AllowList,228}229impl Default for AccessMode {230	fn default() -> Self {231		Self::Normal232	}233}234235#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]236#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]237pub enum SchemaVersion {238	ImageURL,239	Unique,240}241impl Default for SchemaVersion {242	fn default() -> Self {243		Self::ImageURL244	}245}246247#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]248#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]249pub struct Ownership<AccountId> {250	pub owner: AccountId,251	pub fraction: u128,252}253254#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]255#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]256pub enum SponsorshipState<AccountId> {257	/// The fees are applied to the transaction sender258	Disabled,259	Unconfirmed(AccountId),260	/// Transactions are sponsored by specified account261	Confirmed(AccountId),262}263264impl<AccountId> SponsorshipState<AccountId> {265	pub fn sponsor(&self) -> Option<&AccountId> {266		match self {267			Self::Confirmed(sponsor) => Some(sponsor),268			_ => None,269		}270	}271272	pub fn pending_sponsor(&self) -> Option<&AccountId> {273		match self {274			Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),275			_ => None,276		}277	}278279	pub fn confirmed(&self) -> bool {280		matches!(self, Self::Confirmed(_))281	}282}283284impl<T> Default for SponsorshipState<T> {285	fn default() -> Self {286		Self::Disabled287	}288}289290/// Used in storage291#[struct_versioning::versioned(version = 2, upper)]292#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]293pub struct Collection<AccountId> {294	pub owner: AccountId,295	pub mode: CollectionMode,296	#[version(..2)]297	pub access: AccessMode,298	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,299	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,300	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,301302	#[version(..2)]303	pub mint_mode: bool,304305	#[version(..2)]306	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,307308	#[version(..2)]309	pub schema_version: SchemaVersion,310	pub sponsorship: SponsorshipState<AccountId>,311312	pub limits: CollectionLimits,313314	#[version(2.., upper(Default::default()))]315	pub permissions: CollectionPermissions,316317	/// Marks that this collection is not "unique", and managed from external.318	#[version(2.., upper(false))]319	pub external_collection: bool,320321	#[version(..2)]322	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,323324	#[version(..2)]325	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,326327	#[version(..2)]328	pub meta_update_permission: MetaUpdatePermission,329}330331/// Used in RPC calls332#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]333#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]334pub struct RpcCollection<AccountId> {335	pub owner: AccountId,336	pub mode: CollectionMode,337	pub name: Vec<u16>,338	pub description: Vec<u16>,339	pub token_prefix: Vec<u8>,340	pub sponsorship: SponsorshipState<AccountId>,341	pub limits: CollectionLimits,342	pub permissions: CollectionPermissions,343	pub token_property_permissions: Vec<PropertyKeyPermission>,344	pub properties: Vec<Property>,345	pub read_only: bool,346}347348#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Derivative, MaxEncodedLen)]349#[derivative(Debug, Default(bound = ""))]350pub struct CreateCollectionData<AccountId> {351	#[derivative(Default(value = "CollectionMode::NFT"))]352	pub mode: CollectionMode,353	pub access: Option<AccessMode>,354	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,355	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,356	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,357	pub pending_sponsor: Option<AccountId>,358	pub limits: Option<CollectionLimits>,359	pub permissions: Option<CollectionPermissions>,360	pub token_property_permissions: CollectionPropertiesPermissionsVec,361	pub properties: CollectionPropertiesVec,362}363364pub type CollectionPropertiesPermissionsVec =365	BoundedVec<PropertyKeyPermission, ConstU32<MAX_PROPERTIES_PER_ITEM>>;366367pub type CollectionPropertiesVec = BoundedVec<Property, ConstU32<MAX_PROPERTIES_PER_ITEM>>;368369/// All fields are wrapped in `Option`s, where None means chain default370// When adding/removing fields from this struct - don't forget to also update clamp_limits371#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]372#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]373pub struct CollectionLimits {374	pub account_token_ownership_limit: Option<u32>,375	pub sponsored_data_size: Option<u32>,376377	/// FIXME should we delete this or repurpose it?378	/// None - setVariableMetadata is not sponsored379	/// Some(v) - setVariableMetadata is sponsored380	///           if there is v block between txs381	pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,382	pub token_limit: Option<u32>,383384	// Timeouts for item types in passed blocks385	pub sponsor_transfer_timeout: Option<u32>,386	pub sponsor_approve_timeout: Option<u32>,387	pub owner_can_transfer: Option<bool>,388	pub owner_can_destroy: Option<bool>,389	pub transfers_enabled: Option<bool>,390}391392impl CollectionLimits {393	pub fn account_token_ownership_limit(&self) -> u32 {394		self.account_token_ownership_limit395			.unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)396			.min(MAX_TOKEN_OWNERSHIP)397	}398	pub fn sponsored_data_size(&self) -> u32 {399		self.sponsored_data_size400			.unwrap_or(CUSTOM_DATA_LIMIT)401			.min(CUSTOM_DATA_LIMIT)402	}403	pub fn token_limit(&self) -> u32 {404		self.token_limit405			.unwrap_or(COLLECTION_TOKEN_LIMIT)406			.min(COLLECTION_TOKEN_LIMIT)407	}408	pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {409		self.sponsor_transfer_timeout410			.unwrap_or(default)411			.min(MAX_SPONSOR_TIMEOUT)412	}413	pub fn sponsor_approve_timeout(&self) -> u32 {414		self.sponsor_approve_timeout415			.unwrap_or(SPONSOR_APPROVE_TIMEOUT)416			.min(MAX_SPONSOR_TIMEOUT)417	}418	pub fn owner_can_transfer(&self) -> bool {419		self.owner_can_transfer.unwrap_or(true)420	}421	pub fn owner_can_destroy(&self) -> bool {422		self.owner_can_destroy.unwrap_or(true)423	}424	pub fn transfers_enabled(&self) -> bool {425		self.transfers_enabled.unwrap_or(true)426	}427	pub fn sponsored_data_rate_limit(&self) -> Option<u32> {428		match self429			.sponsored_data_rate_limit430			.unwrap_or(SponsoringRateLimit::SponsoringDisabled)431		{432			SponsoringRateLimit::SponsoringDisabled => None,433			SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),434		}435	}436}437438// When adding/removing fields from this struct - don't forget to also update clamp_limits439#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]440#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]441pub struct CollectionPermissions {442	pub access: Option<AccessMode>,443	pub mint_mode: Option<bool>,444	pub nesting: Option<NestingPermissions>,445}446447impl CollectionPermissions {448	pub fn access(&self) -> AccessMode {449		self.access.unwrap_or(AccessMode::Normal)450	}451	pub fn mint_mode(&self) -> bool {452		self.mint_mode.unwrap_or(false)453	}454	pub fn nesting(&self) -> &NestingPermissions {455		static DEFAULT: NestingPermissions = NestingPermissions {456			token_owner: false,457			admin: false,458			restricted: None,459460			permissive: false,461		};462		self.nesting.as_ref().unwrap_or(&DEFAULT)463	}464}465466type OwnerRestrictedSetInner = BoundedBTreeSet<CollectionId, ConstU32<16>>;467468#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]469#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]470#[derivative(Debug)]471pub struct OwnerRestrictedSet(472	#[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]473	#[derivative(Debug(format_with = "bounded::set_debug"))]474	pub OwnerRestrictedSetInner,475);476impl OwnerRestrictedSet {477	pub fn new() -> Self {478		Self(Default::default())479	}480}481impl core::ops::Deref for OwnerRestrictedSet {482	type Target = OwnerRestrictedSetInner;483	fn deref(&self) -> &Self::Target {484		&self.0485	}486}487impl core::ops::DerefMut for OwnerRestrictedSet {488	fn deref_mut(&mut self) -> &mut Self::Target {489		&mut self.0490	}491}492493#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]494#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]495#[derivative(Debug)]496pub struct NestingPermissions {497	/// Owner of token can nest tokens under it498	pub token_owner: bool,499	/// Admin of token collection can nest tokens under token500	pub admin: bool,501	/// If set - only tokens from specified collections can be nested502	pub restricted: Option<OwnerRestrictedSet>,503504	/// Anyone can nest tokens, mutually exclusive with `token_owner`, `admin`505	pub permissive: bool,506}507508#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]509#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]510pub enum SponsoringRateLimit {511	SponsoringDisabled,512	Blocks(u32),513}514515#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]516#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]517#[derivative(Debug)]518pub struct CreateNftData {519	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]520	#[derivative(Debug(format_with = "bounded::vec_debug"))]521	pub properties: CollectionPropertiesVec,522}523524#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]525#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]526pub struct CreateFungibleData {527	pub value: u128,528}529530#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]531#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]532#[derivative(Debug)]533pub struct CreateReFungibleData {534	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]535	#[derivative(Debug(format_with = "bounded::vec_debug"))]536	pub const_data: BoundedVec<u8, CustomDataLimit>,537	pub pieces: u128,538}539540#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]541#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]542pub enum MetaUpdatePermission {543	ItemOwner,544	Admin,545	None,546}547548#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]549#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]550pub enum CreateItemData {551	NFT(CreateNftData),552	Fungible(CreateFungibleData),553	ReFungible(CreateReFungibleData),554}555556#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]557#[derivative(Debug)]558pub struct CreateNftExData<CrossAccountId> {559	#[derivative(Debug(format_with = "bounded::vec_debug"))]560	pub properties: CollectionPropertiesVec,561	pub owner: CrossAccountId,562}563564#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]565#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]566pub struct CreateRefungibleExData<CrossAccountId> {567	#[derivative(Debug(format_with = "bounded::vec_debug"))]568	pub const_data: BoundedVec<u8, CustomDataLimit>,569	#[derivative(Debug(format_with = "bounded::map_debug"))]570	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,571}572573#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]574#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]575pub enum CreateItemExData<CrossAccountId> {576	NFT(577		#[derivative(Debug(format_with = "bounded::vec_debug"))]578		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,579	),580	Fungible(581		#[derivative(Debug(format_with = "bounded::map_debug"))]582		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,583	),584	/// Many tokens, each may have only one owner585	RefungibleMultipleItems(586		#[derivative(Debug(format_with = "bounded::vec_debug"))]587		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,588	),589	/// Single token, which may have many owners590	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),591}592593impl CreateItemData {594	pub fn data_size(&self) -> usize {595		match self {596			CreateItemData::ReFungible(data) => data.const_data.len(),597			_ => 0,598		}599	}600}601602impl From<CreateNftData> for CreateItemData {603	fn from(item: CreateNftData) -> Self {604		CreateItemData::NFT(item)605	}606}607608impl From<CreateReFungibleData> for CreateItemData {609	fn from(item: CreateReFungibleData) -> Self {610		CreateItemData::ReFungible(item)611	}612}613614impl From<CreateFungibleData> for CreateItemData {615	fn from(item: CreateFungibleData) -> Self {616		CreateItemData::Fungible(item)617	}618}619620#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]621#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]622// todo possibly rename to be used generally as an address pair623pub struct TokenChild {624	pub token: TokenId,625	pub collection: CollectionId,626}627628#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]629#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]630pub struct CollectionStats {631	pub created: u32,632	pub destroyed: u32,633	pub alive: u32,634}635636#[derive(Encode, Decode, Clone, Debug)]637#[cfg_attr(feature = "std", derive(PartialEq))]638pub struct PhantomType<T>(core::marker::PhantomData<T>);639640impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {641	type Identity = PhantomType<T>;642643	fn type_info() -> scale_info::Type {644		use scale_info::{645			Type, Path,646			build::{FieldsBuilder, UnnamedFields},647			type_params,648		};649		Type::builder()650			.path(Path::new("up_data_structs", "PhantomType"))651			.type_params(type_params!(T))652			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))653	}654}655impl<T> MaxEncodedLen for PhantomType<T> {656	fn max_encoded_len() -> usize {657		0658	}659}660661pub type PropertyKey = BoundedVec<u8, ConstU32<MAX_PROPERTY_KEY_LENGTH>>;662pub type PropertyValue = BoundedVec<u8, ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;663664#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]665#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]666pub struct PropertyPermission {667	pub mutable: bool,668	pub collection_admin: bool,669	pub token_owner: bool,670}671672impl PropertyPermission {673	pub fn none() -> Self {674		Self {675			mutable: true,676			collection_admin: false,677			token_owner: false,678		}679	}680}681682#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]683#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]684pub struct Property {685	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]686	pub key: PropertyKey,687688	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]689	pub value: PropertyValue,690}691692impl Into<(PropertyKey, PropertyValue)> for Property {693	fn into(self) -> (PropertyKey, PropertyValue) {694		(self.key, self.value)695	}696}697698#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]699#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]700pub struct PropertyKeyPermission {701	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]702	pub key: PropertyKey,703704	pub permission: PropertyPermission,705}706707impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {708	fn into(self) -> (PropertyKey, PropertyPermission) {709		(self.key, self.permission)710	}711}712713#[derive(Debug)]714pub enum PropertiesError {715	NoSpaceForProperty,716	PropertyLimitReached,717	InvalidCharacterInPropertyKey,718	PropertyKeyIsTooLong,719	EmptyPropertyKey,720}721722#[derive(Clone, Copy)]723pub enum PropertyScope {724	None,725	Rmrk,726}727728impl PropertyScope {729	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {730		let scope_str: &[u8] = match self {731			Self::None => return Ok(key),732			Self::Rmrk => b"rmrk",733		};734735		[scope_str, b":", key.as_slice()]736			.concat()737			.try_into()738			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)739	}740}741742pub trait TrySetProperty: Sized {743	type Value;744745	fn try_scoped_set(746		&mut self,747		scope: PropertyScope,748		key: PropertyKey,749		value: Self::Value,750	) -> Result<(), PropertiesError>;751752	fn try_scoped_set_from_iter<I, KV>(753		&mut self,754		scope: PropertyScope,755		iter: I,756	) -> Result<(), PropertiesError>757	where758		I: Iterator<Item = KV>,759		KV: Into<(PropertyKey, Self::Value)>,760	{761		for kv in iter {762			let (key, value) = kv.into();763			self.try_scoped_set(scope, key, value)?;764		}765766		Ok(())767	}768769	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {770		self.try_scoped_set(PropertyScope::None, key, value)771	}772773	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>774	where775		I: Iterator<Item = KV>,776		KV: Into<(PropertyKey, Self::Value)>,777	{778		self.try_scoped_set_from_iter(PropertyScope::None, iter)779	}780}781782#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]783#[derivative(Default(bound = ""))]784pub struct PropertiesMap<Value>(785	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,786);787788impl<Value> PropertiesMap<Value> {789	pub fn new() -> Self {790		Self(BoundedBTreeMap::new())791	}792793	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {794		Self::check_property_key(key)?;795796		Ok(self.0.remove(key))797	}798799	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {800		self.0.get(key)801	}802803	pub fn contains_key(&self, key: &PropertyKey) -> bool {804		self.0.contains_key(key)805	}806807	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {808		if key.is_empty() {809			return Err(PropertiesError::EmptyPropertyKey);810		}811812		for byte in key.as_slice().iter() {813			let byte = *byte;814815			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' && byte != b'.' {816				return Err(PropertiesError::InvalidCharacterInPropertyKey);817			}818		}819820		Ok(())821	}822}823824impl<Value> IntoIterator for PropertiesMap<Value> {825	type Item = (PropertyKey, Value);826	type IntoIter = <827		BoundedBTreeMap<828			PropertyKey,829			Value,830			ConstU32<MAX_PROPERTIES_PER_ITEM>831		> as IntoIterator832	>::IntoIter;833834	fn into_iter(self) -> Self::IntoIter {835		self.0.into_iter()836	}837}838839impl<Value> TrySetProperty for PropertiesMap<Value> {840	type Value = Value;841842	fn try_scoped_set(843		&mut self,844		scope: PropertyScope,845		key: PropertyKey,846		value: Self::Value,847	) -> Result<(), PropertiesError> {848		Self::check_property_key(&key)?;849850		let key = scope.apply(key)?;851		self.0852			.try_insert(key, value)853			.map_err(|_| PropertiesError::PropertyLimitReached)?;854855		Ok(())856	}857}858859pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;860861#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]862pub struct Properties {863	map: PropertiesMap<PropertyValue>,864	consumed_space: u32,865	space_limit: u32,866}867868impl Properties {869	pub fn new(space_limit: u32) -> Self {870		Self {871			map: PropertiesMap::new(),872			consumed_space: 0,873			space_limit,874		}875	}876877	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {878		let value = self.map.remove(key)?;879880		if let Some(ref value) = value {881			let value_len = value.len() as u32;882			self.consumed_space -= value_len;883		}884885		Ok(value)886	}887888	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {889		self.map.get(key)890	}891}892893impl IntoIterator for Properties {894	type Item = (PropertyKey, PropertyValue);895	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;896897	fn into_iter(self) -> Self::IntoIter {898		self.map.into_iter()899	}900}901902impl TrySetProperty for Properties {903	type Value = PropertyValue;904905	fn try_scoped_set(906		&mut self,907		scope: PropertyScope,908		key: PropertyKey,909		value: Self::Value,910	) -> Result<(), PropertiesError> {911		let value_len = value.len();912913		if self.consumed_space as usize + value_len > self.space_limit as usize914			&& !cfg!(feature = "runtime-benchmarks")915		{916			return Err(PropertiesError::NoSpaceForProperty);917		}918919		self.map.try_scoped_set(scope, key, value)?;920921		self.consumed_space += value_len as u32;922923		Ok(())924	}925}926927pub struct CollectionProperties;928929impl Get<Properties> for CollectionProperties {930	fn get() -> Properties {931		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)932	}933}934935pub struct TokenProperties;936937impl Get<Properties> for TokenProperties {938	fn get() -> Properties {939		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)940	}941}942943// RMRK944// todo document?945parameter_types! {946	#[derive(PartialEq, TypeInfo)]947	pub const RmrkStringLimit: u32 = 128;948	#[derive(PartialEq)]949	pub const RmrkCollectionSymbolLimit: u32 = 100;950	#[derive(PartialEq)]951	pub const RmrkResourceSymbolLimit: u32 = 10;952	#[derive(PartialEq)]953	pub const RmrkKeyLimit: u32 = 32;954	#[derive(PartialEq)]955	pub const RmrkValueLimit: u32 = 256;956	#[derive(PartialEq)]957	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;958	#[derive(PartialEq)]959	pub const RmrkPartsLimit: u32 = 3;960	#[derive(PartialEq)]961	pub const RmrkMaxPriorities: u32 = 3;962}963964impl From<RmrkCollectionId> for CollectionId {965	fn from(id: RmrkCollectionId) -> Self {966		Self(id)967	}968}969970impl From<RmrkNftId> for TokenId {971	fn from(id: RmrkNftId) -> Self {972		Self(id)973	}974}975976pub type RmrkCollectionInfo<AccountId> =977	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;978pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;979pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;980pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;981pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;982pub type RmrkPartType =983	PartType<RmrkString, BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>>;984pub type RmrkThemeProperty = ThemeProperty<RmrkString>;985pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;986pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;987988pub type RmrkBasicResource = BasicResource<RmrkString>;989pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;990pub type RmrkSlotResource = SlotResource<RmrkString>;991992pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;993pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;994pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;995pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;996pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;997pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed998999pub type RmrkRpcString = Vec<u8>;1000pub type RmrkThemeName = RmrkRpcString;1001pub type RmrkPropertyKey = RmrkRpcString;