git.delta.rocks / unique-network / refs/commits / 2ef3805aebca

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;3839pub mod rmrk;4041// RMRK42use rmrk::{43	CollectionInfo, NftInfo, ResourceInfo, PropertyInfo, BaseInfo, PartType, Theme, ThemeProperty,44	ResourceTypes, BasicResource, ComposableResource, SlotResource,45};46pub use rmrk::{47	primitives::{48		CollectionId as RmrkCollectionId, NftId as RmrkNftId, BaseId as RmrkBaseId,49		PartId as RmrkPartId, ResourceId as RmrkResourceId,50	},51	NftChild as RmrkNftChild, AccountIdOrCollectionNftTuple as RmrkAccountIdOrCollectionNftTuple,52	FixedPart as RmrkFixedPart, SlotPart as RmrkSlotPart, EquippableList as RmrkEquippableList,53};5455mod bounded;56pub mod budget;57pub mod mapping;58mod migration;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;6364pub const MAX_TOKEN_OWNERSHIP: u32 = if cfg!(not(feature = "limit-testing")) {65	100_00066} else {67	1068};69pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {70	100_00071} else {72	1073};74pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {75	204876} else {77	1078};79pub const COLLECTION_ADMINS_LIMIT: u32 = 5;80pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX;81pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {82	1_000_00083} else {84	1085};8687// Timeouts for item types in passed blocks88pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;89pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;90pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;9192pub const SPONSOR_APPROVE_TIMEOUT: u32 = 5;9394// Schema limits95pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 8192;96pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 8192;97pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 32768;9899pub const COLLECTION_FIELD_LIMIT: u32 = CONST_ON_CHAIN_SCHEMA_LIMIT;100101pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;102pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;103pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;104105pub const MAX_PROPERTY_KEY_LENGTH: u32 = 256;106pub const MAX_PROPERTY_VALUE_LENGTH: u32 = 32768;107pub const MAX_PROPERTIES_PER_ITEM: u32 = 64;108109pub const MAX_COLLECTION_PROPERTIES_SIZE: u32 = 40960;110pub const MAX_TOKEN_PROPERTIES_SIZE: u32 = 32768;111112// RMRK constants113pub const RMRK_STRING_LIMIT: u32 = 128;114pub const RMRK_COLLECTION_SYMBOL_LIMIT: u32 = 100;115pub const RMRK_RESOURCE_SYMBOL_LIMIT: u32 = 10;116pub const RMRK_KEY_LIMIT: u32 = 32;117pub const RMRK_VALUE_LIMIT: u32 = 256;118119/// How much items can be created per single120/// create_many call121pub const MAX_ITEMS_PER_BATCH: u32 = 200;122123pub type CustomDataLimit = ConstU32<CUSTOM_DATA_LIMIT>;124125#[derive(126	Encode,127	Decode,128	PartialEq,129	Eq,130	PartialOrd,131	Ord,132	Clone,133	Copy,134	Debug,135	Default,136	TypeInfo,137	MaxEncodedLen,138)]139#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]140pub struct CollectionId(pub u32);141impl EncodeLike<u32> for CollectionId {}142impl EncodeLike<CollectionId> for u32 {}143144#[derive(145	Encode,146	Decode,147	PartialEq,148	Eq,149	PartialOrd,150	Ord,151	Clone,152	Copy,153	Debug,154	Default,155	TypeInfo,156	MaxEncodedLen,157)]158#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]159pub struct TokenId(pub u32);160impl EncodeLike<u32> for TokenId {}161impl EncodeLike<TokenId> for u32 {}162163impl TokenId {164	pub fn try_next(self) -> Result<TokenId, ArithmeticError> {165		self.0166			.checked_add(1)167			.ok_or(ArithmeticError::Overflow)168			.map(Self)169	}170}171172impl From<TokenId> for U256 {173	fn from(t: TokenId) -> Self {174		t.0.into()175	}176}177178impl TryFrom<U256> for TokenId {179	type Error = &'static str;180181	fn try_from(value: U256) -> Result<Self, Self::Error> {182		Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))183	}184}185186#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]187#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]188pub struct TokenData<CrossAccountId> {189	pub properties: Vec<Property>,190	pub owner: Option<CrossAccountId>,191}192193pub struct OverflowError;194impl From<OverflowError> for &'static str {195	fn from(_: OverflowError) -> Self {196		"overflow occured"197	}198}199200pub type DecimalPoints = u8;201202#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]203#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]204pub enum CollectionMode {205	NFT,206	// decimal points207	Fungible(DecimalPoints),208	ReFungible,209}210211impl CollectionMode {212	pub fn id(&self) -> u8 {213		match self {214			CollectionMode::NFT => 1,215			CollectionMode::Fungible(_) => 2,216			CollectionMode::ReFungible => 3,217		}218	}219}220221pub trait SponsoringResolve<AccountId, Call> {222	fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;223}224225#[derive(Encode, Decode, Eq, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]226#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]227pub enum AccessMode {228	Normal,229	AllowList,230}231impl Default for AccessMode {232	fn default() -> Self {233		Self::Normal234	}235}236237#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]238#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]239pub enum SchemaVersion {240	ImageURL,241	Unique,242}243impl Default for SchemaVersion {244	fn default() -> Self {245		Self::ImageURL246	}247}248249#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]250#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]251pub struct Ownership<AccountId> {252	pub owner: AccountId,253	pub fraction: u128,254}255256#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]257#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]258pub enum SponsorshipState<AccountId> {259	/// The fees are applied to the transaction sender260	Disabled,261	Unconfirmed(AccountId),262	/// Transactions are sponsored by specified account263	Confirmed(AccountId),264}265266impl<AccountId> SponsorshipState<AccountId> {267	pub fn sponsor(&self) -> Option<&AccountId> {268		match self {269			Self::Confirmed(sponsor) => Some(sponsor),270			_ => None,271		}272	}273274	pub fn pending_sponsor(&self) -> Option<&AccountId> {275		match self {276			Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),277			_ => None,278		}279	}280281	pub fn confirmed(&self) -> bool {282		matches!(self, Self::Confirmed(_))283	}284}285286impl<T> Default for SponsorshipState<T> {287	fn default() -> Self {288		Self::Disabled289	}290}291292/// Used in storage293#[struct_versioning::versioned(version = 2, upper)]294#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]295pub struct Collection<AccountId> {296	pub owner: AccountId,297	pub mode: CollectionMode,298	#[version(..2)]299	pub access: AccessMode,300	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,301	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,302	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,303304	#[version(..2)]305	pub mint_mode: bool,306307	#[version(..2)]308	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,309310	#[version(..2)]311	pub schema_version: SchemaVersion,312	pub sponsorship: SponsorshipState<AccountId>,313314	pub limits: CollectionLimits,315316	#[version(2.., upper(Default::default()))]317	pub permissions: CollectionPermissions,318319	/// Marks that this collection is not "unique", and managed from external.320	#[version(2.., upper(false))]321	pub external_collection: bool,322323	#[version(..2)]324	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,325326	#[version(..2)]327	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,328329	#[version(..2)]330	pub meta_update_permission: MetaUpdatePermission,331}332333/// Used in RPC calls334#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]335#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]336pub struct RpcCollection<AccountId> {337	pub owner: AccountId,338	pub mode: CollectionMode,339	pub name: Vec<u16>,340	pub description: Vec<u16>,341	pub token_prefix: Vec<u8>,342	pub sponsorship: SponsorshipState<AccountId>,343	pub limits: CollectionLimits,344	pub permissions: CollectionPermissions,345	pub token_property_permissions: Vec<PropertyKeyPermission>,346	pub properties: Vec<Property>,347	pub read_only: bool,348}349350#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Derivative, MaxEncodedLen)]351#[derivative(Debug, Default(bound = ""))]352pub struct CreateCollectionData<AccountId> {353	#[derivative(Default(value = "CollectionMode::NFT"))]354	pub mode: CollectionMode,355	pub access: Option<AccessMode>,356	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,357	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,358	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,359	pub pending_sponsor: Option<AccountId>,360	pub limits: Option<CollectionLimits>,361	pub permissions: Option<CollectionPermissions>,362	pub token_property_permissions: CollectionPropertiesPermissionsVec,363	pub properties: CollectionPropertiesVec,364}365366pub type CollectionPropertiesPermissionsVec =367	BoundedVec<PropertyKeyPermission, ConstU32<MAX_PROPERTIES_PER_ITEM>>;368369pub type CollectionPropertiesVec = BoundedVec<Property, ConstU32<MAX_PROPERTIES_PER_ITEM>>;370371/// All fields are wrapped in `Option`s, where None means chain default372// When adding/removing fields from this struct - don't forget to also update clamp_limits373#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]374#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]375pub struct CollectionLimits {376	pub account_token_ownership_limit: Option<u32>,377	pub sponsored_data_size: Option<u32>,378379	/// FIXME should we delete this or repurpose it?380	/// None - setVariableMetadata is not sponsored381	/// Some(v) - setVariableMetadata is sponsored382	///           if there is v block between txs383	pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,384	pub token_limit: Option<u32>,385386	// Timeouts for item types in passed blocks387	pub sponsor_transfer_timeout: Option<u32>,388	pub sponsor_approve_timeout: Option<u32>,389	pub owner_can_transfer: Option<bool>,390	pub owner_can_destroy: Option<bool>,391	pub transfers_enabled: Option<bool>,392}393394impl CollectionLimits {395	pub fn account_token_ownership_limit(&self) -> u32 {396		self.account_token_ownership_limit397			.unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)398			.min(MAX_TOKEN_OWNERSHIP)399	}400	pub fn sponsored_data_size(&self) -> u32 {401		self.sponsored_data_size402			.unwrap_or(CUSTOM_DATA_LIMIT)403			.min(CUSTOM_DATA_LIMIT)404	}405	pub fn token_limit(&self) -> u32 {406		self.token_limit407			.unwrap_or(COLLECTION_TOKEN_LIMIT)408			.min(COLLECTION_TOKEN_LIMIT)409	}410	pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {411		self.sponsor_transfer_timeout412			.unwrap_or(default)413			.min(MAX_SPONSOR_TIMEOUT)414	}415	pub fn sponsor_approve_timeout(&self) -> u32 {416		self.sponsor_approve_timeout417			.unwrap_or(SPONSOR_APPROVE_TIMEOUT)418			.min(MAX_SPONSOR_TIMEOUT)419	}420	pub fn owner_can_transfer(&self) -> bool {421		self.owner_can_transfer.unwrap_or(true)422	}423	pub fn owner_can_destroy(&self) -> bool {424		self.owner_can_destroy.unwrap_or(true)425	}426	pub fn transfers_enabled(&self) -> bool {427		self.transfers_enabled.unwrap_or(true)428	}429	pub fn sponsored_data_rate_limit(&self) -> Option<u32> {430		match self431			.sponsored_data_rate_limit432			.unwrap_or(SponsoringRateLimit::SponsoringDisabled)433		{434			SponsoringRateLimit::SponsoringDisabled => None,435			SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),436		}437	}438}439440// When adding/removing fields from this struct - don't forget to also update clamp_limits441#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]442#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]443pub struct CollectionPermissions {444	pub access: Option<AccessMode>,445	pub mint_mode: Option<bool>,446	pub nesting: Option<NestingRule>,447}448449impl CollectionPermissions {450	pub fn access(&self) -> AccessMode {451		self.access.unwrap_or(AccessMode::Normal)452	}453	pub fn mint_mode(&self) -> bool {454		self.mint_mode.unwrap_or(false)455	}456	pub fn nesting(&self) -> &NestingRule {457		static DEFAULT: NestingRule = NestingRule::Disabled;458		self.nesting.as_ref().unwrap_or(&DEFAULT)459	}460}461462pub type OwnerRestrictedSet = BoundedBTreeSet<CollectionId, ConstU32<16>>;463464#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]465#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]466#[derivative(Debug)]467pub enum NestingRule {468	/// No one can nest tokens469	Disabled,470	/// Owner can nest any tokens471	Owner,472	/// Owner can nest tokens from specified collections473	OwnerRestricted(474		#[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]475		#[derivative(Debug(format_with = "bounded::set_debug"))]476		OwnerRestrictedSet,477	),478	/// Used for tests479	Permissive,480}481482#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]483#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]484pub enum SponsoringRateLimit {485	SponsoringDisabled,486	Blocks(u32),487}488489#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]490#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]491#[derivative(Debug)]492pub struct CreateNftData {493	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]494	#[derivative(Debug(format_with = "bounded::vec_debug"))]495	pub properties: CollectionPropertiesVec,496}497498#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]499#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]500pub struct CreateFungibleData {501	pub value: u128,502}503504#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]505#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]506#[derivative(Debug)]507pub struct CreateReFungibleData {508	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]509	#[derivative(Debug(format_with = "bounded::vec_debug"))]510	pub const_data: BoundedVec<u8, CustomDataLimit>,511	pub pieces: u128,512}513514#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]515#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]516pub enum MetaUpdatePermission {517	ItemOwner,518	Admin,519	None,520}521522#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]523#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]524pub enum CreateItemData {525	NFT(CreateNftData),526	Fungible(CreateFungibleData),527	ReFungible(CreateReFungibleData),528}529530#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]531#[derivative(Debug)]532pub struct CreateNftExData<CrossAccountId> {533	#[derivative(Debug(format_with = "bounded::vec_debug"))]534	pub properties: CollectionPropertiesVec,535	pub owner: CrossAccountId,536}537538#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]539#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]540pub struct CreateRefungibleExData<CrossAccountId> {541	#[derivative(Debug(format_with = "bounded::vec_debug"))]542	pub const_data: BoundedVec<u8, CustomDataLimit>,543	#[derivative(Debug(format_with = "bounded::map_debug"))]544	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,545}546547#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]548#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]549pub enum CreateItemExData<CrossAccountId> {550	NFT(551		#[derivative(Debug(format_with = "bounded::vec_debug"))]552		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,553	),554	Fungible(555		#[derivative(Debug(format_with = "bounded::map_debug"))]556		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,557	),558	/// Many tokens, each may have only one owner559	RefungibleMultipleItems(560		#[derivative(Debug(format_with = "bounded::vec_debug"))]561		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,562	),563	/// Single token, which may have many owners564	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),565}566567impl CreateItemData {568	pub fn data_size(&self) -> usize {569		match self {570			CreateItemData::ReFungible(data) => data.const_data.len(),571			_ => 0,572		}573	}574}575576impl From<CreateNftData> for CreateItemData {577	fn from(item: CreateNftData) -> Self {578		CreateItemData::NFT(item)579	}580}581582impl From<CreateReFungibleData> for CreateItemData {583	fn from(item: CreateReFungibleData) -> Self {584		CreateItemData::ReFungible(item)585	}586}587588impl From<CreateFungibleData> for CreateItemData {589	fn from(item: CreateFungibleData) -> Self {590		CreateItemData::Fungible(item)591	}592}593594#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]595#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]596// todo possibly rename to be used generally as an address pair597pub struct TokenChild {598	pub token: TokenId,599	pub collection: CollectionId,600}601602#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]603#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]604pub struct CollectionStats {605	pub created: u32,606	pub destroyed: u32,607	pub alive: u32,608}609610#[derive(Encode, Decode, Clone, Debug)]611#[cfg_attr(feature = "std", derive(PartialEq))]612pub struct PhantomType<T>(core::marker::PhantomData<T>);613614impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {615	type Identity = PhantomType<T>;616617	fn type_info() -> scale_info::Type {618		use scale_info::{619			Type, Path,620			build::{FieldsBuilder, UnnamedFields},621			type_params,622		};623		Type::builder()624			.path(Path::new("up_data_structs", "PhantomType"))625			.type_params(type_params!(T))626			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))627	}628}629impl<T> MaxEncodedLen for PhantomType<T> {630	fn max_encoded_len() -> usize {631		0632	}633}634635pub type PropertyKey = BoundedVec<u8, ConstU32<MAX_PROPERTY_KEY_LENGTH>>;636pub type PropertyValue = BoundedVec<u8, ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;637638#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]639#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]640pub struct PropertyPermission {641	pub mutable: bool,642	pub collection_admin: bool,643	pub token_owner: bool,644}645646impl PropertyPermission {647	pub fn none() -> Self {648		Self {649			mutable: true,650			collection_admin: false,651			token_owner: false,652		}653	}654}655656#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]657#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]658pub struct Property {659	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]660	pub key: PropertyKey,661662	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]663	pub value: PropertyValue,664}665666impl Into<(PropertyKey, PropertyValue)> for Property {667	fn into(self) -> (PropertyKey, PropertyValue) {668		(self.key, self.value)669	}670}671672#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]673#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]674pub struct PropertyKeyPermission {675	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]676	pub key: PropertyKey,677678	pub permission: PropertyPermission,679}680681impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {682	fn into(self) -> (PropertyKey, PropertyPermission) {683		(self.key, self.permission)684	}685}686687#[derive(Debug)]688pub enum PropertiesError {689	NoSpaceForProperty,690	PropertyLimitReached,691	InvalidCharacterInPropertyKey,692	PropertyKeyIsTooLong,693	EmptyPropertyKey,694}695696#[derive(Clone, Copy)]697pub enum PropertyScope {698	None,699	Rmrk,700}701702impl PropertyScope {703	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {704		let scope_str: &[u8] = match self {705			Self::None => return Ok(key),706			Self::Rmrk => b"rmrk",707		};708709		[scope_str, b":", key.as_slice()]710			.concat()711			.try_into()712			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)713	}714}715716pub trait TrySetProperty: Sized {717	type Value;718719	fn try_scoped_set(720		&mut self,721		scope: PropertyScope,722		key: PropertyKey,723		value: Self::Value,724	) -> Result<(), PropertiesError>;725726	fn try_scoped_set_from_iter<I, KV>(727		&mut self,728		scope: PropertyScope,729		iter: I,730	) -> Result<(), PropertiesError>731	where732		I: Iterator<Item = KV>,733		KV: Into<(PropertyKey, Self::Value)>,734	{735		for kv in iter {736			let (key, value) = kv.into();737			self.try_scoped_set(scope, key, value)?;738		}739740		Ok(())741	}742743	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {744		self.try_scoped_set(PropertyScope::None, key, value)745	}746747	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>748	where749		I: Iterator<Item = KV>,750		KV: Into<(PropertyKey, Self::Value)>,751	{752		self.try_scoped_set_from_iter(PropertyScope::None, iter)753	}754}755756#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]757#[derivative(Default(bound = ""))]758pub struct PropertiesMap<Value>(759	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,760);761762impl<Value> PropertiesMap<Value> {763	pub fn new() -> Self {764		Self(BoundedBTreeMap::new())765	}766767	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {768		Self::check_property_key(key)?;769770		Ok(self.0.remove(key))771	}772773	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {774		self.0.get(key)775	}776777	pub fn contains_key(&self, key: &PropertyKey) -> bool {778		self.0.contains_key(key)779	}780781	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {782		if key.is_empty() {783			return Err(PropertiesError::EmptyPropertyKey);784		}785786		for byte in key.as_slice().iter() {787			let byte = *byte;788789			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' {790				return Err(PropertiesError::InvalidCharacterInPropertyKey);791			}792		}793794		Ok(())795	}796}797798impl<Value> IntoIterator for PropertiesMap<Value> {799	type Item = (PropertyKey, Value);800	type IntoIter = <801		BoundedBTreeMap<802			PropertyKey,803			Value,804			ConstU32<MAX_PROPERTIES_PER_ITEM>805		> as IntoIterator806	>::IntoIter;807808	fn into_iter(self) -> Self::IntoIter {809		self.0.into_iter()810	}811}812813impl<Value> TrySetProperty for PropertiesMap<Value> {814	type Value = Value;815816	fn try_scoped_set(817		&mut self,818		scope: PropertyScope,819		key: PropertyKey,820		value: Self::Value,821	) -> Result<(), PropertiesError> {822		Self::check_property_key(&key)?;823824		let key = scope.apply(key)?;825		self.0826			.try_insert(key, value)827			.map_err(|_| PropertiesError::PropertyLimitReached)?;828829		Ok(())830	}831}832833pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;834835#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]836pub struct Properties {837	map: PropertiesMap<PropertyValue>,838	consumed_space: u32,839	space_limit: u32,840}841842impl Properties {843	pub fn new(space_limit: u32) -> Self {844		Self {845			map: PropertiesMap::new(),846			consumed_space: 0,847			space_limit,848		}849	}850851	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {852		let value = self.map.remove(key)?;853854		if let Some(ref value) = value {855			let value_len = value.len() as u32;856			self.consumed_space -= value_len;857		}858859		Ok(value)860	}861862	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {863		self.map.get(key)864	}865}866867impl IntoIterator for Properties {868	type Item = (PropertyKey, PropertyValue);869	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;870871	fn into_iter(self) -> Self::IntoIter {872		self.map.into_iter()873	}874}875876impl TrySetProperty for Properties {877	type Value = PropertyValue;878879	fn try_scoped_set(880		&mut self,881		scope: PropertyScope,882		key: PropertyKey,883		value: Self::Value,884	) -> Result<(), PropertiesError> {885		let value_len = value.len();886887		if self.consumed_space as usize + value_len > self.space_limit as usize888			&& !cfg!(feature = "runtime-benchmarks")889		{890			return Err(PropertiesError::NoSpaceForProperty);891		}892893		self.map.try_scoped_set(scope, key, value)?;894895		self.consumed_space += value_len as u32;896897		Ok(())898	}899}900901pub struct CollectionProperties;902903impl Get<Properties> for CollectionProperties {904	fn get() -> Properties {905		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)906	}907}908909pub struct TokenProperties;910911impl Get<Properties> for TokenProperties {912	fn get() -> Properties {913		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)914	}915}916917// RMRK918// todo document?919parameter_types! {920	#[derive(PartialEq, TypeInfo)]921	pub const RmrkStringLimit: u32 = 128;922	#[derive(PartialEq)]923	pub const RmrkCollectionSymbolLimit: u32 = 100;924	#[derive(PartialEq)]925	pub const RmrkResourceSymbolLimit: u32 = 10;926	#[derive(PartialEq)]927	pub const RmrkKeyLimit: u32 = 32;928	#[derive(PartialEq)]929	pub const RmrkValueLimit: u32 = 256;930	#[derive(PartialEq)]931	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;932	#[derive(PartialEq)]933	pub const RmrkPartsLimit: u32 = 3;934}935936impl From<RmrkCollectionId> for CollectionId {937	fn from(id: RmrkCollectionId) -> Self {938		Self(id)939	}940}941942impl From<RmrkNftId> for TokenId {943	fn from(id: RmrkNftId) -> Self {944		Self(id)945	}946}947948pub type RmrkCollectionInfo<AccountId> =949	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;950pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;951pub type RmrkResourceInfo = ResourceInfo<RmrkString, RmrkBoundedParts>;952pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;953pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;954pub type RmrkPartType =955	PartType<RmrkString, BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>>;956pub type RmrkThemeProperty = ThemeProperty<RmrkString>;957pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;958pub type RmrkResourceTypes = ResourceTypes<RmrkString, RmrkBoundedParts>;959960pub type RmrkBasicResource = BasicResource<RmrkString>;961pub type RmrkComposableResource = ComposableResource<RmrkString, RmrkBoundedParts>;962pub type RmrkSlotResource = SlotResource<RmrkString>;963964pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;965pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;966pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;967pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;968pub type RmrkBoundedResource = BoundedVec<u8, RmrkResourceSymbolLimit>;969pub type RmrkBoundedParts = BoundedVec<RmrkPartId, RmrkPartsLimit>; // todo make sure it is needed970971pub type RmrkRpcString = Vec<u8>;972pub type RmrkThemeName = RmrkRpcString;973pub type RmrkPropertyKey = RmrkRpcString;