git.delta.rocks / unique-network / refs/commits / 7c4183b4cb3a

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};45pub use rmrk::{46	primitives::{47		CollectionId as RmrkCollectionId, NftId as RmrkNftId, BaseId as RmrkBaseId,48		PartId as RmrkPartId, ResourceId as RmrkResourceId,49	},50	NftChild as RmrkNftChild, AccountIdOrCollectionNftTuple as RmrkAccountIdOrCollectionNftTuple,51	FixedPart as RmrkFixedPart, SlotPart as RmrkSlotPart, EquippableList as RmrkEquippableList,52};5354mod bounded;55pub mod budget;56pub mod mapping;57mod migration;5859pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;60pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;61pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;6263pub const MAX_TOKEN_OWNERSHIP: u32 = if cfg!(not(feature = "limit-testing")) {64	100_00065} else {66	1067};68pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {69	100_00070} else {71	1072};73pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {74	204875} else {76	1077};78pub const COLLECTION_ADMINS_LIMIT: u32 = 5;79pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX;80pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {81	1_000_00082} else {83	1084};8586// Timeouts for item types in passed blocks87pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;88pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;89pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;9091pub const SPONSOR_APPROVE_TIMEOUT: u32 = 5;9293// Schema limits94pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 8192;95pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 8192;96pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 32768;9798pub const COLLECTION_FIELD_LIMIT: u32 = CONST_ON_CHAIN_SCHEMA_LIMIT;99100pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;101pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;102pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;103104pub const MAX_PROPERTY_KEY_LENGTH: u32 = 256;105pub const MAX_PROPERTY_VALUE_LENGTH: u32 = 32768;106pub const MAX_PROPERTIES_PER_ITEM: u32 = 64;107108pub const MAX_COLLECTION_PROPERTIES_SIZE: u32 = 40960;109pub const MAX_TOKEN_PROPERTIES_SIZE: u32 = 32768;110111// RMRK constants112pub const RMRK_STRING_LIMIT: u32 = 128;113pub const RMRK_COLLECTION_SYMBOL_LIMIT: u32 = 100;114pub const RMRK_RESOURCE_SYMBOL_LIMIT: u32 = 10;115pub const RMRK_KEY_LIMIT: u32 = 32;116pub const RMRK_VALUE_LIMIT: u32 = 256;117118/// How much items can be created per single119/// create_many call120pub const MAX_ITEMS_PER_BATCH: u32 = 200;121122pub type CustomDataLimit = ConstU32<CUSTOM_DATA_LIMIT>;123124#[derive(125	Encode,126	Decode,127	PartialEq,128	Eq,129	PartialOrd,130	Ord,131	Clone,132	Copy,133	Debug,134	Default,135	TypeInfo,136	MaxEncodedLen,137)]138#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]139pub struct CollectionId(pub u32);140impl EncodeLike<u32> for CollectionId {}141impl EncodeLike<CollectionId> for u32 {}142143#[derive(144	Encode,145	Decode,146	PartialEq,147	Eq,148	PartialOrd,149	Ord,150	Clone,151	Copy,152	Debug,153	Default,154	TypeInfo,155	MaxEncodedLen,156)]157#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]158pub struct TokenId(pub u32);159impl EncodeLike<u32> for TokenId {}160impl EncodeLike<TokenId> for u32 {}161162impl TokenId {163	pub fn try_next(self) -> Result<TokenId, ArithmeticError> {164		self.0165			.checked_add(1)166			.ok_or(ArithmeticError::Overflow)167			.map(Self)168	}169}170171impl From<TokenId> for U256 {172	fn from(t: TokenId) -> Self {173		t.0.into()174	}175}176177impl TryFrom<U256> for TokenId {178	type Error = &'static str;179180	fn try_from(value: U256) -> Result<Self, Self::Error> {181		Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))182	}183}184185#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]186#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]187pub struct TokenData<CrossAccountId> {188	pub const_data: Vec<u8>,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, 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	pub access: AccessMode,299	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,300	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,301	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,302	pub mint_mode: bool,303304	#[version(..2)]305	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,306307	pub schema_version: SchemaVersion,308	pub sponsorship: SponsorshipState<AccountId>,309310	#[version(..2)]311	pub limits: CollectionLimitsVersion1, // Collection private restrictions312	#[version(2.., upper(limits.into()))]313	pub limits: CollectionLimitsVersion2,314315	#[version(..2)]316	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,317318	#[version(..2)]319	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,320321	#[version(..2)]322	pub meta_update_permission: MetaUpdatePermission,323}324325/// Used in RPC calls326#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]327#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]328pub struct RpcCollection<AccountId> {329	pub owner: AccountId,330	pub mode: CollectionMode,331	pub access: AccessMode,332	pub name: Vec<u16>,333	pub description: Vec<u16>,334	pub token_prefix: Vec<u8>,335	pub mint_mode: bool,336	pub offchain_schema: Vec<u8>,337	pub schema_version: SchemaVersion,338	pub sponsorship: SponsorshipState<AccountId>,339	pub limits: CollectionLimits,340	pub const_on_chain_schema: Vec<u8>,341	pub token_property_permissions: Vec<PropertyKeyPermission>,342	pub properties: Vec<Property>,343}344345#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]346#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]347pub enum CollectionField {348	ConstOnChainSchema,349	OffchainSchema,350}351352#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Derivative, MaxEncodedLen)]353#[derivative(Debug, Default(bound = ""))]354pub struct CreateCollectionData<AccountId> {355	#[derivative(Default(value = "CollectionMode::NFT"))]356	pub mode: CollectionMode,357	pub access: Option<AccessMode>,358	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,359	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,360	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,361	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,362	pub schema_version: Option<SchemaVersion>,363	pub pending_sponsor: Option<AccountId>,364	pub limits: Option<CollectionLimits>,365	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,366	pub token_property_permissions: CollectionPropertiesPermissionsVec,367	pub properties: CollectionPropertiesVec,368}369370pub type CollectionPropertiesPermissionsVec =371	BoundedVec<PropertyKeyPermission, ConstU32<MAX_PROPERTIES_PER_ITEM>>;372373pub type CollectionPropertiesVec =374	BoundedVec<Property, ConstU32<MAX_PROPERTIES_PER_ITEM>>;375376/// All fields are wrapped in `Option`s, where None means chain default377#[struct_versioning::versioned(version = 2, upper)]378#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]379#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]380pub struct CollectionLimits {381	pub account_token_ownership_limit: Option<u32>,382	pub sponsored_data_size: Option<u32>,383384	/// FIXME should we delete this or repurpose it?385	/// None - setVariableMetadata is not sponsored386	/// Some(v) - setVariableMetadata is sponsored387	///           if there is v block between txs388	pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,389	pub token_limit: Option<u32>,390391	// Timeouts for item types in passed blocks392	pub sponsor_transfer_timeout: Option<u32>,393	pub sponsor_approve_timeout: Option<u32>,394	pub owner_can_transfer: Option<bool>,395	pub owner_can_destroy: Option<bool>,396	pub transfers_enabled: Option<bool>,397398	#[version(2.., upper(None))]399	pub nesting_rule: Option<NestingRule>,400}401402impl CollectionLimits {403	pub fn account_token_ownership_limit(&self) -> u32 {404		self.account_token_ownership_limit405			.unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)406			.min(MAX_TOKEN_OWNERSHIP)407	}408	pub fn sponsored_data_size(&self) -> u32 {409		self.sponsored_data_size410			.unwrap_or(CUSTOM_DATA_LIMIT)411			.min(CUSTOM_DATA_LIMIT)412	}413	pub fn token_limit(&self) -> u32 {414		self.token_limit415			.unwrap_or(COLLECTION_TOKEN_LIMIT)416			.min(COLLECTION_TOKEN_LIMIT)417	}418	pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {419		self.sponsor_transfer_timeout420			.unwrap_or(default)421			.min(MAX_SPONSOR_TIMEOUT)422	}423	pub fn sponsor_approve_timeout(&self) -> u32 {424		self.sponsor_approve_timeout425			.unwrap_or(SPONSOR_APPROVE_TIMEOUT)426			.min(MAX_SPONSOR_TIMEOUT)427	}428	pub fn owner_can_transfer(&self) -> bool {429		self.owner_can_transfer.unwrap_or(true)430	}431	pub fn owner_can_destroy(&self) -> bool {432		self.owner_can_destroy.unwrap_or(true)433	}434	pub fn transfers_enabled(&self) -> bool {435		self.transfers_enabled.unwrap_or(true)436	}437	pub fn sponsored_data_rate_limit(&self) -> Option<u32> {438		match self439			.sponsored_data_rate_limit440			.unwrap_or(SponsoringRateLimit::SponsoringDisabled)441		{442			SponsoringRateLimit::SponsoringDisabled => None,443			SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),444		}445	}446	pub fn nesting_rule(&self) -> &NestingRule {447		static DEFAULT: NestingRule = NestingRule::Disabled;448		self.nesting_rule.as_ref().unwrap_or(&DEFAULT)449	}450}451452#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen, Derivative)]453#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]454#[derivative(Debug)]455pub enum NestingRule {456	/// No one can nest tokens457	Disabled,458	/// Owner can nest any tokens459	Owner,460	/// Owner can nest tokens from specified collections461	OwnerRestricted(462		#[cfg_attr(feature = "serde1", serde(with = "bounded::set_serde"))]463		#[derivative(Debug(format_with = "bounded::set_debug"))]464		BoundedBTreeSet<CollectionId, ConstU32<16>>,465	),466}467468#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]469#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]470pub enum SponsoringRateLimit {471	SponsoringDisabled,472	Blocks(u32),473}474475#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]476#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]477#[derivative(Debug)]478pub struct CreateNftData {479	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]480	#[derivative(Debug(format_with = "bounded::vec_debug"))]481	pub const_data: BoundedVec<u8, CustomDataLimit>,482483	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]484	#[derivative(Debug(format_with = "bounded::vec_debug"))]485	pub properties: CollectionPropertiesVec,486}487488#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]489#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]490pub struct CreateFungibleData {491	pub value: u128,492}493494#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]495#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]496#[derivative(Debug)]497pub struct CreateReFungibleData {498	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]499	#[derivative(Debug(format_with = "bounded::vec_debug"))]500	pub const_data: BoundedVec<u8, CustomDataLimit>,501	pub pieces: u128,502}503504#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]505pub enum MetaUpdatePermission {506	ItemOwner,507	Admin,508	None,509}510511#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]512#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]513pub enum CreateItemData {514	NFT(CreateNftData),515	Fungible(CreateFungibleData),516	ReFungible(CreateReFungibleData),517}518519#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]520#[derivative(Debug)]521pub struct CreateNftExData<CrossAccountId> {522	#[derivative(Debug(format_with = "bounded::vec_debug"))]523	pub const_data: BoundedVec<u8, CustomDataLimit>,524	#[derivative(Debug(format_with = "bounded::vec_debug"))]525	pub properties: CollectionPropertiesVec,526	pub owner: CrossAccountId,527}528529#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]530#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]531pub struct CreateRefungibleExData<CrossAccountId> {532	#[derivative(Debug(format_with = "bounded::vec_debug"))]533	pub const_data: BoundedVec<u8, CustomDataLimit>,534	#[derivative(Debug(format_with = "bounded::map_debug"))]535	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,536}537538#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]539#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]540pub enum CreateItemExData<CrossAccountId> {541	NFT(542		#[derivative(Debug(format_with = "bounded::vec_debug"))]543		BoundedVec<CreateNftExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,544	),545	Fungible(546		#[derivative(Debug(format_with = "bounded::map_debug"))]547		BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,548	),549	/// Many tokens, each may have only one owner550	RefungibleMultipleItems(551		#[derivative(Debug(format_with = "bounded::vec_debug"))]552		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,553	),554	/// Single token, which may have many owners555	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),556}557558impl CreateItemData {559	pub fn data_size(&self) -> usize {560		match self {561			CreateItemData::NFT(data) => data.const_data.len(),562			CreateItemData::ReFungible(data) => data.const_data.len(),563			_ => 0,564		}565	}566}567568impl From<CreateNftData> for CreateItemData {569	fn from(item: CreateNftData) -> Self {570		CreateItemData::NFT(item)571	}572}573574impl From<CreateReFungibleData> for CreateItemData {575	fn from(item: CreateReFungibleData) -> Self {576		CreateItemData::ReFungible(item)577	}578}579580impl From<CreateFungibleData> for CreateItemData {581	fn from(item: CreateFungibleData) -> Self {582		CreateItemData::Fungible(item)583	}584}585586#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]587#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]588pub struct CollectionStats {589	pub created: u32,590	pub destroyed: u32,591	pub alive: u32,592}593594#[derive(Encode, Decode, Clone, Debug)]595#[cfg_attr(feature = "std", derive(PartialEq))]596pub struct PhantomType<T>(core::marker::PhantomData<T>);597598impl<T: TypeInfo + 'static> TypeInfo for PhantomType<T> {599	type Identity = PhantomType<T>;600601	fn type_info() -> scale_info::Type {602		use scale_info::{603			Type, Path,604			build::{FieldsBuilder, UnnamedFields},605			type_params,606		};607		Type::builder()608			.path(Path::new("up_data_structs", "PhantomType"))609			.type_params(type_params!(T))610			.composite(<FieldsBuilder<UnnamedFields>>::default().field(|b| b.ty::<[T; 0]>()))611	}612}613impl<T> MaxEncodedLen for PhantomType<T> {614	fn max_encoded_len() -> usize {615		0616	}617}618619pub type PropertyKey = BoundedVec<u8, ConstU32<MAX_PROPERTY_KEY_LENGTH>>;620pub type PropertyValue = BoundedVec<u8, ConstU32<MAX_PROPERTY_VALUE_LENGTH>>;621622#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]623#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]624pub struct PropertyPermission {625	pub mutable: bool,626	pub collection_admin: bool,627	pub token_owner: bool,628}629630impl PropertyPermission {631	pub fn none() -> Self {632		Self {633			mutable: true,634			collection_admin: false,635			token_owner: false,636		}637	}638}639640#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, MaxEncodedLen)]641#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]642pub struct Property {643	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]644	pub key: PropertyKey,645646	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]647	pub value: PropertyValue,648}649650impl Into<(PropertyKey, PropertyValue)> for Property {651	fn into(self) -> (PropertyKey, PropertyValue) {652		(self.key, self.value)653	}654}655656#[derive(Encode, Decode, TypeInfo, Debug, MaxEncodedLen, PartialEq, Clone)]657#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]658pub struct PropertyKeyPermission {659	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]660	pub key: PropertyKey,661662	pub permission: PropertyPermission,663}664665impl Into<(PropertyKey, PropertyPermission)> for PropertyKeyPermission {666	fn into(self) -> (PropertyKey, PropertyPermission) {667		(self.key, self.permission)668	}669}670671#[derive(Debug)]672pub enum PropertiesError {673	NoSpaceForProperty,674	PropertyLimitReached,675	InvalidCharacterInPropertyKey,676	PropertyKeyIsTooLong,677	EmptyPropertyKey,678}679680#[derive(Clone, Copy)]681pub enum PropertyScope {682	None,683	Rmrk,684}685686impl PropertyScope {687	pub fn apply(self, key: PropertyKey) -> Result<PropertyKey, PropertiesError> {688		let scope_str: &[u8] = match self {689			Self::None => return Ok(key),690			Self::Rmrk => b"rmrk",691		};692693		[scope_str, b":", key.as_slice()]694			.concat()695			.try_into()696			.map_err(|_| PropertiesError::PropertyKeyIsTooLong)697	}698}699700pub trait TrySetProperty: Sized {701	type Value;702703	fn try_scoped_set(704		&mut self,705		scope: PropertyScope,706		key: PropertyKey,707		value: Self::Value,708	) -> Result<(), PropertiesError>;709710	fn try_scoped_set_from_iter<I, KV>(711		&mut self,712		scope: PropertyScope,713		iter: I,714	) -> Result<(), PropertiesError>715	where716		I: Iterator<Item = KV>,717		KV: Into<(PropertyKey, Self::Value)>,718	{719		for kv in iter {720			let (key, value) = kv.into();721			self.try_scoped_set(scope, key, value)?;722		}723724		Ok(())725	}726727	fn try_set(&mut self, key: PropertyKey, value: Self::Value) -> Result<(), PropertiesError> {728		self.try_scoped_set(PropertyScope::None, key, value)729	}730731	fn try_set_from_iter<I, KV>(&mut self, iter: I) -> Result<(), PropertiesError>732	where733		I: Iterator<Item = KV>,734		KV: Into<(PropertyKey, Self::Value)>,735	{736		self.try_scoped_set_from_iter(PropertyScope::None, iter)737	}738}739740#[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]741#[derivative(Default(bound = ""))]742pub struct PropertiesMap<Value>(743	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,744);745746impl<Value> PropertiesMap<Value> {747	pub fn new() -> Self {748		Self(BoundedBTreeMap::new())749	}750751	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<Value>, PropertiesError> {752		Self::check_property_key(key)?;753754		Ok(self.0.remove(key))755	}756757	pub fn get(&self, key: &PropertyKey) -> Option<&Value> {758		self.0.get(key)759	}760761	fn check_property_key(key: &PropertyKey) -> Result<(), PropertiesError> {762		if key.is_empty() {763			return Err(PropertiesError::EmptyPropertyKey);764		}765766		for byte in key.as_slice().iter() {767			let byte = *byte;768769			if !byte.is_ascii_alphanumeric() && byte != b'_' && byte != b'-' {770				return Err(PropertiesError::InvalidCharacterInPropertyKey);771			}772		}773774		Ok(())775	}776}777778impl<Value> IntoIterator for PropertiesMap<Value> {779	type Item = (PropertyKey, Value);780	type IntoIter = <781		BoundedBTreeMap<782			PropertyKey,783			Value,784			ConstU32<MAX_PROPERTIES_PER_ITEM>785		> as IntoIterator786	>::IntoIter;787788	fn into_iter(self) -> Self::IntoIter {789        self.0.into_iter()790    }791}792793impl<Value> TrySetProperty for PropertiesMap<Value> {794	type Value = Value;795796	fn try_scoped_set(797		&mut self,798		scope: PropertyScope,799		key: PropertyKey,800		value: Self::Value,801	) -> Result<(), PropertiesError> {802		Self::check_property_key(&key)?;803804		let key = scope.apply(key)?;805		self.0806			.try_insert(key, value)807			.map_err(|_| PropertiesError::PropertyLimitReached)?;808809		Ok(())810	}811}812813pub type PropertiesPermissionMap = PropertiesMap<PropertyPermission>;814815#[derive(Encode, Decode, TypeInfo, Clone, PartialEq, MaxEncodedLen)]816pub struct Properties {817	map: PropertiesMap<PropertyValue>,818	consumed_space: u32,819	space_limit: u32,820}821822impl Properties {823	pub fn new(space_limit: u32) -> Self {824		Self {825			map: PropertiesMap::new(),826			consumed_space: 0,827			space_limit,828		}829	}830831	pub fn remove(&mut self, key: &PropertyKey) -> Result<Option<PropertyValue>, PropertiesError> {832		let value = self.map.remove(key)?;833834		if let Some(ref value) = value {835			let value_len = value.len() as u32;836			self.consumed_space -= value_len;837		}838839		Ok(value)840	}841842	pub fn get(&self, key: &PropertyKey) -> Option<&PropertyValue> {843		self.map.get(key)844	}845}846847impl IntoIterator for Properties {848	type Item = (PropertyKey, PropertyValue);849	type IntoIter = <PropertiesMap<PropertyValue> as IntoIterator>::IntoIter;850851	fn into_iter(self) -> Self::IntoIter {852        self.map.into_iter()853    }854}855856impl TrySetProperty for Properties {857	type Value = PropertyValue;858859	fn try_scoped_set(860		&mut self,861		scope: PropertyScope,862		key: PropertyKey,863		value: Self::Value,864	) -> Result<(), PropertiesError> {865		let value_len = value.len();866867		if self.consumed_space as usize + value_len > self.space_limit as usize868			&& !cfg!(feature = "runtime-benchmarks")869		{870			return Err(PropertiesError::NoSpaceForProperty);871		}872873		self.map.try_scoped_set(scope, key, value)?;874875		self.consumed_space += value_len as u32;876877		Ok(())878	}879}880881pub struct CollectionProperties;882883impl Get<Properties> for CollectionProperties {884	fn get() -> Properties {885		Properties::new(MAX_COLLECTION_PROPERTIES_SIZE)886	}887}888889pub struct TokenProperties;890891impl Get<Properties> for TokenProperties {892	fn get() -> Properties {893		Properties::new(MAX_TOKEN_PROPERTIES_SIZE)894	}895}896897// RMRK898// todo document?899parameter_types! {900	#[derive(PartialEq, TypeInfo)]901	pub const RmrkStringLimit: u32 = 128;902	#[derive(PartialEq)]903	pub const RmrkCollectionSymbolLimit: u32 = 100;904	#[derive(PartialEq)]905	pub const RmrkResourceSymbolLimit: u32 = 10;906	#[derive(PartialEq)]907	pub const RmrkKeyLimit: u32 = 32;908	#[derive(PartialEq)]909	pub const RmrkValueLimit: u32 = 256;910	#[derive(PartialEq)]911	pub const RmrkMaxCollectionsEquippablePerPart: u32 = 100;912	#[derive(PartialEq)]913	pub const RmrkPartsLimit: u32 = 3;914}915916impl From<RmrkCollectionId> for CollectionId {917	fn from(id: RmrkCollectionId) -> Self {918		Self(id)919	}920}921922impl From<RmrkNftId> for TokenId {923	fn from(id: RmrkNftId) -> Self {924		Self(id)925	}926}927928pub type RmrkCollectionSymbol = BoundedVec<u8, RmrkCollectionSymbolLimit>;929pub type RmrkCollectionInfo<AccountId> =930	CollectionInfo<RmrkString, RmrkCollectionSymbol, AccountId>;931pub type RmrkInstanceInfo<AccountId> = NftInfo<AccountId, Permill, RmrkString>;932pub type RmrkResourceInfo = ResourceInfo<933	BoundedVec<u8, RmrkResourceSymbolLimit>,934	RmrkString,935	BoundedVec<RmrkPartId, RmrkPartsLimit>,936>;937pub type RmrkKeyString = BoundedVec<u8, RmrkKeyLimit>;938pub type RmrkValueString = BoundedVec<u8, RmrkValueLimit>;939pub type RmrkPropertyInfo = PropertyInfo<RmrkKeyString, RmrkValueString>;940pub type RmrkBaseInfo<AccountId> = BaseInfo<AccountId, RmrkString>;941pub type RmrkPartType =942	PartType<RmrkString, BoundedVec<RmrkCollectionId, RmrkMaxCollectionsEquippablePerPart>>;943pub type RmrkThemeProperty = ThemeProperty<RmrkString>;944pub type RmrkTheme = Theme<RmrkString, Vec<RmrkThemeProperty>>;945946pub type RmrkRpcString = Vec<u8>;947pub type RmrkThemeName = RmrkRpcString;948pub type RmrkPropertyKey = RmrkRpcString;949950pub type RmrkString = BoundedVec<u8, RmrkStringLimit>;