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

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9	clippy::too_many_arguments,10	clippy::unnecessary_mut_passed,11	clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19	construct_runtime, decl_event, decl_module, decl_storage, decl_error,20	dispatch::DispatchResult,21	ensure, fail, parameter_types,22	traits::{23		Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24		Randomness, IsSubType, WithdrawReasons,25	},26	weights::{27		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29		WeightToFeePolynomial, DispatchClass,30	},31	StorageValue, transactional,32};33use scale_info::TypeInfo;34use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41	CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46	MetaUpdatePermission, FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70	/// Error for non-fungible-token module.71	pub enum Error for Module<T: Config> {72		/// Total collections bound exceeded.73		TotalCollectionsLimitExceeded,74		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75		CollectionDecimalPointLimitExceeded,76		/// Collection name can not be longer than 63 char.77		CollectionNameLimitExceeded,78		/// Collection description can not be longer than 255 char.79		CollectionDescriptionLimitExceeded,80		/// Token prefix can not be longer than 15 char.81		CollectionTokenPrefixLimitExceeded,82		/// This collection does not exist.83		CollectionNotFound,84		/// Item not exists.85		TokenNotFound,86		/// Admin not found87		AdminNotFound,88		/// Arithmetic calculation overflow.89		NumOverflow,90		/// Account already has admin role.91		AlreadyAdmin,92		/// You do not own this collection.93		NoPermission,94		/// This address is not set as sponsor, use setCollectionSponsor first.95		ConfirmUnsetSponsorFail,96		/// Collection is not in mint mode.97		PublicMintingNotAllowed,98		/// Sender parameter and item owner must be equal.99		MustBeTokenOwner,100		/// Item balance not enough.101		TokenValueTooLow,102		/// Size of item is too large.103		NftSizeLimitExceeded,104		/// No approve found105		ApproveNotFound,106		/// Requested value more than approved.107		TokenValueNotEnough,108		/// Only approved addresses can call this method.109		ApproveRequired,110		/// Address is not in white list.111		AddresNotInWhiteList,112		/// Number of collection admins bound exceeded.113		CollectionAdminsLimitExceeded,114		/// Owned tokens by a single address bound exceeded.115		AddressOwnershipLimitExceeded,116		/// Length of items properties must be greater than 0.117		EmptyArgument,118		/// const_data exceeded data limit.119		TokenConstDataLimitExceeded,120		/// variable_data exceeded data limit.121		TokenVariableDataLimitExceeded,122		/// Not NFT item data used to mint in NFT collection.123		NotNftDataUsedToMintNftCollectionToken,124		/// Not Fungible item data used to mint in Fungible collection.125		NotFungibleDataUsedToMintFungibleCollectionToken,126		/// Not Re Fungible item data used to mint in Re Fungible collection.127		NotReFungibleDataUsedToMintReFungibleCollectionToken,128		/// Unexpected collection type.129		UnexpectedCollectionType,130		/// Can't store metadata in fungible tokens.131		CantStoreMetadataInFungibleTokens,132		/// Collection token limit exceeded133		CollectionTokenLimitExceeded,134		/// Account token limit exceeded per collection135		AccountTokenLimitExceeded,136		/// Collection limit bounds per collection exceeded137		CollectionLimitBoundsExceeded,138		/// Tried to enable permissions which are only permitted to be disabled139		OwnerPermissionsCantBeReverted,140		/// Schema data size limit bound exceeded141		SchemaDataLimitExceeded,142		/// Maximum refungibility exceeded143		WrongRefungiblePieces,144		/// createRefungible should be called with one owner145		BadCreateRefungibleCall,146		/// Gas limit exceeded147		OutOfGas,148		/// Metadata update denied by collection settings149		MetadataUpdateDenied,150		/// Metadata update flag become unmutable with None option151		MetadataFlagFrozen,152		/// Collection settings not allowing items transferring153		TransferNotAllowed,154		/// Can't transfer tokens to ethereum zero address155		AddressIsZero,156	}157}158159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]160pub struct CollectionHandle<T: Config> {161	pub id: CollectionId,162	collection: Collection<T>,163	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,164}165impl<T: Config> CollectionHandle<T> {166	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {167		<CollectionById<T>>::get(id).map(|collection| Self {168			id,169			collection,170			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(171				eth::collection_id_to_address(id),172				gas_limit,173			),174		})175	}176	pub fn get(id: CollectionId) -> Option<Self> {177		Self::get_with_gas_limit(id, u64::MAX)178	}179	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {180		self.recorder.log_sub(log)181	}182	#[allow(dead_code)]183	fn consume_gas(&self, gas: u64) -> DispatchResult {184		self.recorder.consume_gas_sub(gas)185	}186	fn consume_sload(&self) -> DispatchResult {187		self.recorder.consume_sload_sub()188	}189	fn consume_sstore(&self) -> DispatchResult {190		self.recorder.consume_sstore_sub()191	}192	pub fn submit_logs(self) -> DispatchResult {193		self.recorder.submit_logs()194	}195	pub fn save(self) -> DispatchResult {196		self.recorder.submit_logs()?;197		<CollectionById<T>>::insert(self.id, self.collection);198		Ok(())199	}200}201impl<T: Config> Deref for CollectionHandle<T> {202	type Target = Collection<T>;203204	fn deref(&self) -> &Self::Target {205		&self.collection206	}207}208209impl<T: Config> DerefMut for CollectionHandle<T> {210	fn deref_mut(&mut self) -> &mut Self::Target {211		&mut self.collection212	}213}214215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized + TypeInfo {216	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;217218	/// Weight information for extrinsics in this pallet.219	type WeightInfo: WeightInfo;220221	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;222	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;223224	type CrossAccountId: CrossAccountId<Self::AccountId>;225	type Currency: Currency<Self::AccountId>;226	type CollectionCreationPrice: Get<227		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,228	>;229	type TreasuryAccountId: Get<Self::AccountId>;230}231232type SelfWeightOf<T> = <T as Config>::WeightInfo;233234trait WeightInfoHelpers: WeightInfo {235	fn transfer() -> Weight {236		Self::transfer_nft()237			.max(Self::transfer_fungible())238			.max(Self::transfer_refungible())239	}240	fn transfer_from() -> Weight {241		Self::transfer_from_nft()242			.max(Self::transfer_from_fungible())243			.max(Self::transfer_from_refungible())244	}245	fn approve() -> Weight {246		// TODO: refungible, fungible247		Self::approve_nft()248	}249	fn set_variable_meta_data(data: u32) -> Weight {250		// TODO: refungible251		Self::set_variable_meta_data_nft(data)252	}253	fn create_item(data: u32) -> Weight {254		Self::create_item_nft(data)255			.max(Self::create_item_fungible())256			.max(Self::create_item_refungible(data))257	}258	fn create_multiple_items(amount: u32) -> Weight {259		Self::create_multiple_items_nft(amount)260			.max(Self::create_multiple_items_fungible(amount))261			.max(Self::create_multiple_items_refungible(amount))262	}263	fn burn_item() -> Weight {264		// TODO: refungible, fungible265		Self::burn_item_nft()266	}267}268impl<T: WeightInfo> WeightInfoHelpers for T {}269270// # Used definitions271//272// ## User control levels273//274// chain-controlled - key is uncontrolled by user275//                    i.e autoincrementing index276//                    can use non-cryptographic hash277// real - key is controlled by user278//        but it is hard to generate enough colliding values, i.e owner of signed txs279//        can use non-cryptographic hash280// controlled - key is completly controlled by users281//              i.e maps with mutable keys282//              should use cryptographic hash283//284// ## User control level downgrade reasons285//286// ?1 - chain-controlled -> controlled287//      collections/tokens can be destroyed, resulting in massive holes288// ?2 - chain-controlled -> controlled289//      same as ?1, but can be only added, resulting in easier exploitation290// ?3 - real -> controlled291//      no confirmation required, so addresses can be easily generated292decl_storage! {293	trait Store for Module<T: Config> as Nft {294295		//#region Private members296		/// Id of next collection297		CreatedCollectionCount: u32;298		/// Used for migrations299		ChainVersion: u64;300		/// Id of last collection token301		/// Collection id (controlled?1)302		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;303		//#endregion304305		//#region Bound counters306		/// Amount of collections destroyed, used for total amount tracking with307		/// CreatedCollectionCount308		DestroyedCollectionCount: u32;309		//#endregion310311		//#region Basic collections312		/// Collection info313		/// Collection id (controlled?1)314		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;315		/// List of collection admins316		/// Collection id (controlled?2)317		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;318		/// Whitelisted collection users319		/// Collection id (controlled?2), user id (controlled?3)320		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;321		//#endregion322323		/// How many of collection items user have324		/// Collection id (controlled?2), account id (real)325		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;326327		/// Amount of items which spender can transfer out of owners account (via transferFrom)328		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))329		/// TODO: Off chain worker should remove from this map when token gets removed330		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;331332		//#region Item collections333		/// Collection id (controlled?2), token id (controlled?1)334		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;335		/// Collection id (controlled?2), owner (controlled?2)336		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;337		/// Collection id (controlled?2), token id (controlled?1)338		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;339		//#endregion340341		//#region Index list342		/// Collection id (controlled?2), tokens owner (controlled?2)343		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;344		//#endregion345346		//#region Tokens transfer rate limit baskets347		/// (Collection id (controlled?2), who created (real))348		/// TODO: Off chain worker should remove from this map when collection gets removed349		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;350		/// Collection id (controlled?2), token id (controlled?2)351		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352		/// Collection id (controlled?2), owning user (real)353		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;354		/// Collection id (controlled?2), token id (controlled?2)355		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;356		//#endregion357358		/// Variable metadata sponsoring359		/// Collection id (controlled?2), token id (controlled?2)360		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;361	}362	add_extra_genesis {363		build(|config: &GenesisConfig<T>| {364			// Modification of storage365			for (_num, _c) in &config.collection_id {366				<Module<T>>::init_collection(_c);367			}368369			for (_num, _c, _i) in &config.nft_item_id {370				<Module<T>>::init_nft_token(*_c, _i);371			}372373			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {374				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);375			}376377			for (_num, _c, _i) in &config.refungible_item_id {378				<Module<T>>::init_refungible_token(*_c, _i);379			}380		})381	}382}383384decl_event!(385	pub enum Event<T>386	where387		AccountId = <T as frame_system::Config>::AccountId,388		CrossAccountId = <T as Config>::CrossAccountId,389	{390		/// New collection was created391		///392		/// # Arguments393		///394		/// * collection_id: Globally unique identifier of newly created collection.395		///396		/// * mode: [CollectionMode] converted into u8.397		///398		/// * account_id: Collection owner.399		CollectionCreated(CollectionId, u8, AccountId),400401		/// New item was created.402		///403		/// # Arguments404		///405		/// * collection_id: Id of the collection where item was created.406		///407		/// * item_id: Id of an item. Unique within the collection.408		///409		/// * recipient: Owner of newly created item410		ItemCreated(CollectionId, TokenId, CrossAccountId),411412		/// Collection item was burned.413		///414		/// # Arguments415		///416		/// collection_id.417		///418		/// item_id: Identifier of burned NFT.419		ItemDestroyed(CollectionId, TokenId),420421		/// Item was transferred422		///423		/// * collection_id: Id of collection to which item is belong424		///425		/// * item_id: Id of an item426		///427		/// * sender: Original owner of item428		///429		/// * recipient: New owner of item430		///431		/// * amount: Always 1 for NFT432		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),433434		/// * collection_id435		///436		/// * item_id437		///438		/// * sender439		///440		/// * spender441		///442		/// * amount443		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),444	}445);446447decl_module! {448	pub struct Module<T: Config> for enum Call449	where450		origin: T::Origin451	{452		fn deposit_event() = default;453		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;454		type Error = Error<T>;455456		fn on_initialize(_now: T::BlockNumber) -> Weight {457			0458		}459460		/// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.461		///462		/// # Permissions463		///464		/// * Anyone.465		///466		/// # Arguments467		///468		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.469		///470		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.471		///472		/// * token_prefix: UTF-8 string with token prefix.473		///474		/// * mode: [CollectionMode] collection type and type dependent data.475		// returns collection ID476		#[weight = <SelfWeightOf<T>>::create_collection()]477		#[transactional]478		pub fn create_collection(origin,479								 collection_name: Vec<u16>,480								 collection_description: Vec<u16>,481								 token_prefix: Vec<u8>,482								 mode: CollectionMode) -> DispatchResult {483484			// Anyone can create a collection485			let who = ensure_signed(origin)?;486487			// Take a (non-refundable) deposit of collection creation488			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();489			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(490				&T::TreasuryAccountId::get(),491				T::CollectionCreationPrice::get(),492			));493			<T as Config>::Currency::settle(494				&who,495				imbalance,496				WithdrawReasons::TRANSFER,497				ExistenceRequirement::KeepAlive,498			).map_err(|_| Error::<T>::NoPermission)?;499500			let decimal_points = match mode {501				CollectionMode::Fungible(points) => points,502				_ => 0503			};504505			let created_count = CreatedCollectionCount::get();506			let destroyed_count = DestroyedCollectionCount::get();507508			// bound Total number of collections509			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);510511			// check params512			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);513			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);514			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);515			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);516517			// Generate next collection ID518			let next_id = created_count519				.checked_add(1)520				.ok_or(Error::<T>::NumOverflow)?;521522			CreatedCollectionCount::put(next_id);523524			let limits = CollectionLimits {525				sponsored_data_size: CUSTOM_DATA_LIMIT,526				..Default::default()527			};528529			// Create new collection530			let new_collection = Collection {531				owner: who.clone(),532				name: collection_name,533				mode: mode.clone(),534				mint_mode: false,535				access: AccessMode::Normal,536				description: collection_description,537				decimal_points,538				token_prefix,539				offchain_schema: Vec::new(),540				schema_version: SchemaVersion::ImageURL,541				sponsorship: SponsorshipState::Disabled,542				variable_on_chain_schema: Vec::new(),543				const_on_chain_schema: Vec::new(),544				limits,545				meta_update_permission: MetaUpdatePermission::default(),546				transfers_enabled: true,547			};548549			// Add new collection to map550			<CollectionById<T>>::insert(next_id, new_collection);551552			// call event553			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));554555			Ok(())556		}557558		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.559		///560		/// # Permissions561		///562		/// * Collection Owner.563		///564		/// # Arguments565		///566		/// * collection_id: collection to destroy.567		#[weight = <SelfWeightOf<T>>::destroy_collection()]568		#[transactional]569		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {570571			let sender = ensure_signed(origin)?;572			let collection = Self::get_collection(collection_id)?;573			Self::check_owner_permissions(&collection, &sender)?;574			if !collection.limits.owner_can_destroy {575				fail!(Error::<T>::NoPermission);576			}577578			<AddressTokens<T>>::remove_prefix(collection_id, None);579			<Allowances<T>>::remove_prefix(collection_id, None);580			<Balance<T>>::remove_prefix(collection_id, None);581			<ItemListIndex>::remove(collection_id);582			<AdminList<T>>::remove(collection_id);583			<CollectionById<T>>::remove(collection_id);584			<WhiteList<T>>::remove_prefix(collection_id, None);585586			<NftItemList<T>>::remove_prefix(collection_id, None);587			<FungibleItemList<T>>::remove_prefix(collection_id, None);588			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);589590			<NftTransferBasket<T>>::remove_prefix(collection_id, None);591			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);592			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);593594			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);595596			DestroyedCollectionCount::put(DestroyedCollectionCount::get()597				.checked_add(1)598				.ok_or(Error::<T>::NumOverflow)?);599600			Ok(())601		}602603		/// Add an address to white list.604		///605		/// # Permissions606		///607		/// * Collection Owner608		/// * Collection Admin609		///610		/// # Arguments611		///612		/// * collection_id.613		///614		/// * address.615		#[weight = <SelfWeightOf<T>>::add_to_white_list()]616		#[transactional]617		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{618619			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);620			let collection = Self::get_collection(collection_id)?;621622			Self::toggle_white_list_internal(623				&sender,624				&collection,625				&address,626				true,627			)?;628629			Ok(())630		}631632		/// Remove an address from white list.633		///634		/// # Permissions635		///636		/// * Collection Owner637		/// * Collection Admin638		///639		/// # Arguments640		///641		/// * collection_id.642		///643		/// * address.644		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]645		#[transactional]646		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{647648			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);649			let collection = Self::get_collection(collection_id)?;650651			Self::toggle_white_list_internal(652				&sender,653				&collection,654				&address,655				false,656			)?;657658			Ok(())659		}660661		/// Toggle between normal and white list access for the methods with access for `Anyone`.662		///663		/// # Permissions664		///665		/// * Collection Owner.666		///667		/// # Arguments668		///669		/// * collection_id.670		///671		/// * mode: [AccessMode]672		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]673		#[transactional]674		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult675		{676			let sender = ensure_signed(origin)?;677678			let mut target_collection = Self::get_collection(collection_id)?;679			Self::check_owner_permissions(&target_collection, &sender)?;680			target_collection.access = mode;681			target_collection.save()682		}683684		/// Allows Anyone to create tokens if:685		/// * White List is enabled, and686		/// * Address is added to white list, and687		/// * This method was called with True parameter688		///689		/// # Permissions690		/// * Collection Owner691		///692		/// # Arguments693		///694		/// * collection_id.695		///696		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.697		#[weight = <SelfWeightOf<T>>::set_mint_permission()]698		#[transactional]699		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult700		{701			let sender = ensure_signed(origin)?;702703			let mut target_collection = Self::get_collection(collection_id)?;704			Self::check_owner_permissions(&target_collection, &sender)?;705			target_collection.mint_mode = mint_permission;706			target_collection.save()707		}708709		/// Change the owner of the collection.710		///711		/// # Permissions712		///713		/// * Collection Owner.714		///715		/// # Arguments716		///717		/// * collection_id.718		///719		/// * new_owner.720		#[weight = <SelfWeightOf<T>>::change_collection_owner()]721		#[transactional]722		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {723724			let sender = ensure_signed(origin)?;725			let mut target_collection = Self::get_collection(collection_id)?;726			Self::check_owner_permissions(&target_collection, &sender)?;727			target_collection.owner = new_owner;728			target_collection.save()729		}730731		/// Adds an admin of the Collection.732		/// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.733		///734		/// # Permissions735		///736		/// * Collection Owner.737		/// * Collection Admin.738		///739		/// # Arguments740		///741		/// * collection_id: ID of the Collection to add admin for.742		///743		/// * new_admin_id: Address of new admin to add.744		#[weight = <SelfWeightOf<T>>::add_collection_admin()]745		#[transactional]746		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {747			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);748			let collection = Self::get_collection(collection_id)?;749			Self::check_owner_or_admin_permissions(&collection, &sender)?;750			let mut admin_arr = <AdminList<T>>::get(collection_id);751752			match admin_arr.binary_search(&new_admin_id) {753				Ok(_) => {},754				Err(idx) => {755					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);756					admin_arr.insert(idx, new_admin_id);757					<AdminList<T>>::insert(collection_id, admin_arr);758				}759			}760			Ok(())761		}762763		/// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.764		///765		/// # Permissions766		///767		/// * Collection Owner.768		/// * Collection Admin.769		///770		/// # Arguments771		///772		/// * collection_id: ID of the Collection to remove admin for.773		///774		/// * account_id: Address of admin to remove.775		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]776		#[transactional]777		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {778			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);779			let collection = Self::get_collection(collection_id)?;780			Self::check_owner_or_admin_permissions(&collection, &sender)?;781			let mut admin_arr = <AdminList<T>>::get(collection_id);782783			if let Ok(idx) = admin_arr.binary_search(&account_id) {784				admin_arr.remove(idx);785				<AdminList<T>>::insert(collection_id, admin_arr);786			}787			Ok(())788		}789790		/// # Permissions791		///792		/// * Collection Owner793		///794		/// # Arguments795		///796		/// * collection_id.797		///798		/// * new_sponsor.799		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]800		#[transactional]801		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {802			let sender = ensure_signed(origin)?;803			let mut target_collection = Self::get_collection(collection_id)?;804			Self::check_owner_permissions(&target_collection, &sender)?;805806			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);807			target_collection.save()808		}809810		/// # Permissions811		///812		/// * Sponsor.813		///814		/// # Arguments815		///816		/// * collection_id.817		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]818		#[transactional]819		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {820			let sender = ensure_signed(origin)?;821822			let mut target_collection = Self::get_collection(collection_id)?;823			ensure!(824				target_collection.sponsorship.pending_sponsor() == Some(&sender),825				Error::<T>::ConfirmUnsetSponsorFail826			);827828			target_collection.sponsorship = SponsorshipState::Confirmed(sender);829			target_collection.save()830		}831832		/// Switch back to pay-per-own-transaction model.833		///834		/// # Permissions835		///836		/// * Collection owner.837		///838		/// # Arguments839		///840		/// * collection_id.841		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]842		#[transactional]843		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844			let sender = ensure_signed(origin)?;845846			let mut target_collection = Self::get_collection(collection_id)?;847			Self::check_owner_permissions(&target_collection, &sender)?;848849			target_collection.sponsorship = SponsorshipState::Disabled;850			target_collection.save()851		}852853		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.854		///855		/// # Permissions856		///857		/// * Collection Owner.858		/// * Collection Admin.859		/// * Anyone if860		///     * White List is enabled, and861		///     * Address is added to white list, and862		///     * MintPermission is enabled (see SetMintPermission method)863		///864		/// # Arguments865		///866		/// * collection_id: ID of the collection.867		///868		/// * owner: Address, initial owner of the NFT.869		///870		/// * data: Token data to store on chain.871		// #[weight =872		// (130_000_000 as Weight)873		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))874		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))875		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]876877		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]878		#[transactional]879		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {880			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881			let collection = Self::get_collection(collection_id)?;882883			Self::create_item_internal(&sender, &collection, &owner, data)?;884885			collection.submit_logs()886		}887888		/// This method creates multiple items in a collection created with CreateCollection method.889		///890		/// # Permissions891		///892		/// * Collection Owner.893		/// * Collection Admin.894		/// * Anyone if895		///     * White List is enabled, and896		///     * Address is added to white list, and897		///     * MintPermission is enabled (see SetMintPermission method)898		///899		/// # Arguments900		///901		/// * collection_id: ID of the collection.902		///903		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].904		///905		/// * owner: Address, initial owner of the NFT.906		#[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]907		#[transactional]908		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {909910			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);911			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);912			let collection = Self::get_collection(collection_id)?;913914			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;915916			collection.submit_logs()917		}918919		// TODO! transaction weight920921		/// Set transfers_enabled value for particular collection922		///923		/// # Permissions924		///925		/// * Collection Owner.926		///927		/// # Arguments928		///929		/// * collection_id: ID of the collection.930		///931		/// * value: New flag value.932		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]933		#[transactional]934		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {935936			let sender = ensure_signed(origin)?;937			let mut target_collection = Self::get_collection(collection_id)?;938939			Self::check_owner_permissions(&target_collection, &sender)?;940941			target_collection.transfers_enabled = value;942			target_collection.save()943		}944945		// TODO! transaction weight946		/// Set meta_update_permission value for particular collection947		///948		/// # Permissions949		///950		/// * Collection Owner.951		///952		/// # Arguments953		///954		/// * collection_id: ID of the collection.955		///956		/// * value: New flag value.957		#[weight = <T as Config>::WeightInfo::burn_item()]958		#[transactional]959		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {960961			let sender = ensure_signed(origin)?;962			let mut target_collection = Self::get_collection(collection_id)?;963964			ensure!(965				target_collection.meta_update_permission != MetaUpdatePermission::None,966				Error::<T>::MetadataFlagFrozen967			);968			Self::check_owner_permissions(&target_collection, &sender)?;969970			target_collection.meta_update_permission = value;971972			target_collection.save()973		}974975		/// Destroys a concrete instance of NFT.976		///977		/// # Permissions978		///979		/// * Collection Owner.980		/// * Collection Admin.981		/// * Current NFT Owner.982		///983		/// # Arguments984		///985		/// * collection_id: ID of the collection.986		///987		/// * item_id: ID of NFT to burn.988		#[weight = <SelfWeightOf<T>>::burn_item()]989		#[transactional]990		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991992			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993			let target_collection = Self::get_collection(collection_id)?;994995			Self::burn_item_internal(&sender, &target_collection, item_id, value, true)?;996997			target_collection.submit_logs()998		}9991000		/// Destroys a concrete instance of NFT on behalf of the owner1001		/// See also: [`approve`]1002		///1003		/// # Permissions1004		///1005		/// * Collection Owner.1006		/// * Collection Admin.1007		/// * Current NFT Owner.1008		///1009		/// # Arguments1010		///1011		/// * collection_id: ID of the collection.1012		///1013		/// * item_id: ID of NFT to burn.1014		///1015		/// * from: owner of item1016		#[weight = <SelfWeightOf<T>>::burn_item()]1017		#[transactional]1018		pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResult {10191020			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1021			let target_collection = Self::get_collection(collection_id)?;10221023			Self::burn_from_internal(&sender, &target_collection, &from, item_id, value)?;10241025			target_collection.submit_logs()1026		}10271028		/// Change ownership of the token.1029		///1030		/// # Permissions1031		///1032		/// * Collection Owner1033		/// * Collection Admin1034		/// * Current NFT owner1035		///1036		/// # Arguments1037		///1038		/// * recipient: Address of token recipient.1039		///1040		/// * collection_id.1041		///1042		/// * item_id: ID of the item1043		///     * Non-Fungible Mode: Required.1044		///     * Fungible Mode: Ignored.1045		///     * Re-Fungible Mode: Required.1046		///1047		/// * value: Amount to transfer.1048		///     * Non-Fungible Mode: Ignored1049		///     * Fungible Mode: Must specify transferred amount1050		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1051		#[weight = <SelfWeightOf<T>>::transfer()]1052		#[transactional]1053		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1054			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1055			let collection = Self::get_collection(collection_id)?;10561057			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10581059			collection.submit_logs()1060		}10611062		/// Set, change, or remove approved address to transfer the ownership of the NFT.1063		///1064		/// # Permissions1065		///1066		/// * Collection Owner1067		/// * Collection Admin1068		/// * Current NFT owner1069		///1070		/// # Arguments1071		///1072		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1073		///1074		/// * collection_id.1075		///1076		/// * item_id: ID of the item.1077		#[weight = <SelfWeightOf<T>>::approve()]1078		#[transactional]1079		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1080			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1081			let collection = Self::get_collection(collection_id)?;10821083			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10841085			collection.submit_logs()1086		}10871088		/// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1089		///1090		/// # Permissions1091		/// * Collection Owner1092		/// * Collection Admin1093		/// * Current NFT owner1094		/// * Address approved by current NFT owner1095		///1096		/// # Arguments1097		///1098		/// * from: Address that owns token.1099		///1100		/// * recipient: Address of token recipient.1101		///1102		/// * collection_id.1103		///1104		/// * item_id: ID of the item.1105		///1106		/// * value: Amount to transfer.1107		#[weight = <SelfWeightOf<T>>::transfer_from()]1108		#[transactional]1109		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1110			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1111			let collection = Self::get_collection(collection_id)?;11121113			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;11141115			collection.submit_logs()1116		}1117		// #[weight = 0]1118		//     // let no_perm_mes = "You do not have permissions to modify this collection";1119		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1120		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1121		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);11221123		//     // // on_nft_received  call11241125		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;11261127		//     Ok(())1128		// }11291130		/// Set off-chain data schema.1131		///1132		/// # Permissions1133		///1134		/// * Collection Owner1135		/// * Collection Admin1136		///1137		/// # Arguments1138		///1139		/// * collection_id.1140		///1141		/// * schema: String representing the offchain data schema.1142		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1143		#[transactional]1144		pub fn set_variable_meta_data (1145			origin,1146			collection_id: CollectionId,1147			item_id: TokenId,1148			data: Vec<u8>1149		) -> DispatchResult {1150			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11511152			let collection = Self::get_collection(collection_id)?;1153			Self::meta_update_check(&sender, &collection, item_id)?;11541155			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11561157			Ok(())1158		}11591160		/// Set schema standard1161		/// ImageURL1162		/// Unique1163		///1164		/// # Permissions1165		///1166		/// * Collection Owner1167		/// * Collection Admin1168		///1169		/// # Arguments1170		///1171		/// * collection_id.1172		///1173		/// * schema: SchemaVersion: enum1174		#[weight = <SelfWeightOf<T>>::set_schema_version()]1175		#[transactional]1176		pub fn set_schema_version(1177			origin,1178			collection_id: CollectionId,1179			version: SchemaVersion1180		) -> DispatchResult {1181			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1182			let mut target_collection = Self::get_collection(collection_id)?;1183			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1184			target_collection.schema_version = version;1185			target_collection.save()1186		}11871188		/// Set off-chain data schema.1189		///1190		/// # Permissions1191		///1192		/// * Collection Owner1193		/// * Collection Admin1194		///1195		/// # Arguments1196		///1197		/// * collection_id.1198		///1199		/// * schema: String representing the offchain data schema.1200		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1201		#[transactional]1202		pub fn set_offchain_schema(1203			origin,1204			collection_id: CollectionId,1205			schema: Vec<u8>1206		) -> DispatchResult {1207			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1208			let mut target_collection = Self::get_collection(collection_id)?;1209			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12101211			// check schema limit1212			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");12131214			target_collection.offchain_schema = schema;1215			target_collection.save()1216		}12171218		/// Set const on-chain data schema.1219		///1220		/// # Permissions1221		///1222		/// * Collection Owner1223		/// * Collection Admin1224		///1225		/// # Arguments1226		///1227		/// * collection_id.1228		///1229		/// * schema: String representing the const on-chain data schema.1230		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1231		#[transactional]1232		pub fn set_const_on_chain_schema (1233			origin,1234			collection_id: CollectionId,1235			schema: Vec<u8>1236		) -> DispatchResult {1237			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1238			let mut target_collection = Self::get_collection(collection_id)?;1239			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12401241			// check schema limit1242			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12431244			target_collection.const_on_chain_schema = schema;1245			target_collection.save()1246		}12471248		/// Set variable on-chain data schema.1249		///1250		/// # Permissions1251		///1252		/// * Collection Owner1253		/// * Collection Admin1254		///1255		/// # Arguments1256		///1257		/// * collection_id.1258		///1259		/// * schema: String representing the variable on-chain data schema.1260		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1261		#[transactional]1262		pub fn set_variable_on_chain_schema (1263			origin,1264			collection_id: CollectionId,1265			schema: Vec<u8>1266		) -> DispatchResult {1267			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1268			let mut target_collection = Self::get_collection(collection_id)?;1269			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12701271			// check schema limit1272			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12731274			target_collection.variable_on_chain_schema = schema;1275			target_collection.save()1276		}12771278		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1279		#[transactional]1280		pub fn set_collection_limits(1281			origin,1282			collection_id: u32,1283			new_limits: CollectionLimits<T::BlockNumber>,1284		) -> DispatchResult {1285			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1286			let mut target_collection = Self::get_collection(collection_id)?;1287			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1288			let old_limits = &target_collection.limits;12891290			// collection bounds1291			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1292				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1293				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1294				Error::<T>::CollectionLimitBoundsExceeded);12951296			// token_limit   check  prev1297			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1298			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12991300			ensure!(1301				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1302				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1303				Error::<T>::OwnerPermissionsCantBeReverted,1304			);13051306			target_collection.limits = new_limits;13071308			target_collection.save()1309		}1310	}1311}13121313impl<T: Config> Module<T> {1314	pub fn create_item_internal(1315		sender: &T::CrossAccountId,1316		collection: &CollectionHandle<T>,1317		owner: &T::CrossAccountId,1318		data: CreateItemData,1319	) -> DispatchResult {1320		ensure!(1321			owner != &T::CrossAccountId::from_eth(H160([0; 20])),1322			Error::<T>::AddressIsZero1323		);13241325		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1326		Self::validate_create_item_args(collection, &data)?;1327		Self::create_item_no_validation(collection, owner, data)?;13281329		Ok(())1330	}13311332	pub fn transfer_internal(1333		sender: &T::CrossAccountId,1334		recipient: &T::CrossAccountId,1335		target_collection: &CollectionHandle<T>,1336		item_id: TokenId,1337		value: u128,1338	) -> DispatchResult {1339		ensure!(1340			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1341			Error::<T>::AddressIsZero1342		);13431344		// Limits check1345		Self::is_correct_transfer(target_collection, recipient)?;13461347		// Transfer permissions check1348		ensure!(1349			Self::is_item_owner(sender, target_collection, item_id)?1350				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,1351			Error::<T>::NoPermission1352		);13531354		if target_collection.access == AccessMode::WhiteList {1355			Self::check_white_list(target_collection, sender)?;1356			Self::check_white_list(target_collection, recipient)?;1357		}13581359		match target_collection.mode {1360			CollectionMode::NFT => Self::transfer_nft(1361				target_collection,1362				item_id,1363				sender.clone(),1364				recipient.clone(),1365			)?,1366			CollectionMode::Fungible(_) => {1367				Self::transfer_fungible(target_collection, value, sender, recipient)?1368			}1369			CollectionMode::ReFungible => Self::transfer_refungible(1370				target_collection,1371				item_id,1372				value,1373				sender.clone(),1374				recipient.clone(),1375			)?,1376		};13771378		Self::deposit_event(RawEvent::Transfer(1379			target_collection.id,1380			item_id,1381			sender.clone(),1382			recipient.clone(),1383			value,1384		));13851386		Ok(())1387	}13881389	pub fn approve_internal(1390		sender: &T::CrossAccountId,1391		spender: &T::CrossAccountId,1392		collection: &CollectionHandle<T>,1393		item_id: TokenId,1394		amount: u128,1395	) -> DispatchResult {1396		Self::token_exists(collection, item_id)?;13971398		// Transfer permissions check1399		let bypasses_limits = collection.limits.owner_can_transfer1400			&& Self::is_owner_or_admin_permissions(collection, sender)?;14011402		let allowance_limit = if bypasses_limits {1403			None1404		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1405			Some(amount)1406		} else {1407			fail!(Error::<T>::NoPermission);1408		};14091410		if collection.access == AccessMode::WhiteList {1411			Self::check_white_list(collection, sender)?;1412			Self::check_white_list(collection, spender)?;1413		}14141415		collection.consume_sload()?;1416		let allowance: u128 = amount1417			.checked_add(<Allowances<T>>::get(1418				collection.id,1419				(item_id, sender.as_sub(), spender.as_sub()),1420			))1421			.ok_or(Error::<T>::NumOverflow)?;1422		if let Some(limit) = allowance_limit {1423			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1424		}1425		collection.consume_sstore()?;1426		<Allowances<T>>::insert(1427			collection.id,1428			(item_id, sender.as_sub(), spender.as_sub()),1429			allowance,1430		);14311432		if matches!(collection.mode, CollectionMode::NFT) {1433			// TODO: NFT: only one owner may exist for token in ERC7211434			collection.log(ERC721Events::Approval {1435				owner: *sender.as_eth(),1436				approved: *spender.as_eth(),1437				token_id: item_id.into(),1438			})?;1439		}14401441		if matches!(collection.mode, CollectionMode::Fungible(_)) {1442			// TODO: NFT: only one owner may exist for token in ERC201443			collection.log(ERC20Events::Approval {1444				owner: *sender.as_eth(),1445				spender: *spender.as_eth(),1446				value: allowance.into(),1447			})?;1448		}14491450		Self::deposit_event(RawEvent::Approved(1451			collection.id,1452			item_id,1453			sender.clone(),1454			spender.clone(),1455			allowance,1456		));1457		Ok(())1458	}14591460	pub fn transfer_from_internal(1461		sender: &T::CrossAccountId,1462		from: &T::CrossAccountId,1463		recipient: &T::CrossAccountId,1464		collection: &CollectionHandle<T>,1465		item_id: TokenId,1466		amount: u128,1467	) -> DispatchResult {1468		if sender == from {1469			// Transfer by `from`, because it is either equal to sender, or derived from him1470			return Self::transfer_internal(from, recipient, collection, item_id, amount);1471		}14721473		// Check approval1474		collection.consume_sload()?;1475		let approval: u128 =1476			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14771478		// Limits check1479		Self::is_correct_transfer(collection, recipient)?;14801481		// Transfer permissions check1482		ensure!(1483			approval >= amount1484				|| (collection.limits.owner_can_transfer1485					&& Self::is_owner_or_admin_permissions(collection, sender)?),1486			Error::<T>::NoPermission1487		);14881489		if collection.access == AccessMode::WhiteList {1490			Self::check_white_list(collection, sender)?;1491			Self::check_white_list(collection, recipient)?;1492		}14931494		// Reduce approval by transferred amount or remove if remaining approval drops to 01495		let allowance = approval.saturating_sub(amount);1496		collection.consume_sstore()?;1497		if allowance > 0 {1498			<Allowances<T>>::insert(1499				collection.id,1500				(item_id, from.as_sub(), sender.as_sub()),1501				allowance,1502			);1503		} else {1504			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1505		}15061507		match collection.mode {1508			CollectionMode::NFT => {1509				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1510			}1511			CollectionMode::Fungible(_) => {1512				Self::transfer_fungible(collection, amount, from, recipient)?1513			}1514			CollectionMode::ReFungible => Self::transfer_refungible(1515				collection,1516				item_id,1517				amount,1518				from.clone(),1519				recipient.clone(),1520			)?,1521		};15221523		if matches!(collection.mode, CollectionMode::Fungible(_)) {1524			collection.log(ERC20Events::Approval {1525				owner: *from.as_eth(),1526				spender: *sender.as_eth(),1527				value: allowance.into(),1528			})?;1529		}15301531		Ok(())1532	}15331534	pub fn set_variable_meta_data_internal(1535		sender: &T::CrossAccountId,1536		collection: &CollectionHandle<T>,1537		item_id: TokenId,1538		data: Vec<u8>,1539	) -> DispatchResult {1540		Self::token_exists(collection, item_id)?;15411542		ensure!(1543			CUSTOM_DATA_LIMIT >= data.len() as u32,1544			Error::<T>::TokenVariableDataLimitExceeded1545		);15461547		ensure!(1548			(Self::is_item_owner(sender, collection, item_id)?1549				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1550				|| (Self::is_owner_or_admin_permissions(collection, sender)?1551					&& collection.meta_update_permission == MetaUpdatePermission::Admin),1552			Error::<T>::NoPermission1553		);15541555		match collection.mode {1556			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1557			CollectionMode::ReFungible => {1558				Self::set_re_fungible_variable_data(collection, item_id, data)?1559			}1560			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1561		};15621563		Ok(())1564	}15651566	pub fn meta_update_check(1567		sender: &T::CrossAccountId,1568		collection: &CollectionHandle<T>,1569		item_id: TokenId,1570	) -> DispatchResult {1571		match collection.meta_update_permission {1572			MetaUpdatePermission::ItemOwner => ensure!(1573				Self::is_item_owner(sender, collection, item_id)?,1574				Error::<T>::NoPermission1575			),1576			MetaUpdatePermission::Admin => ensure!(1577				Self::is_owner_or_admin_permissions(collection, sender)?,1578				Error::<T>::NoPermission1579			),1580			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1581		}15821583		Ok(())1584	}15851586	pub fn get_variable_metadata(1587		collection: &CollectionHandle<T>,1588		item_id: TokenId,1589	) -> Result<Vec<u8>, DispatchError> {1590		Ok(match collection.mode {1591			CollectionMode::NFT => {1592				<NftItemList<T>>::get(collection.id, item_id)1593					.ok_or(Error::<T>::TokenNotFound)?1594					.variable_data1595			}1596			CollectionMode::ReFungible => {1597				<ReFungibleItemList<T>>::get(collection.id, item_id)1598					.ok_or(Error::<T>::TokenNotFound)?1599					.variable_data1600			}1601			_ => fail!(Error::<T>::UnexpectedCollectionType),1602		})1603	}16041605	pub fn create_multiple_items_internal(1606		sender: &T::CrossAccountId,1607		collection: &CollectionHandle<T>,1608		owner: &T::CrossAccountId,1609		items_data: Vec<CreateItemData>,1610	) -> DispatchResult {1611		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;16121613		for data in &items_data {1614			Self::validate_create_item_args(collection, data)?;1615		}1616		for data in &items_data {1617			Self::create_item_no_validation(collection, owner, data.clone())?;1618		}16191620		Ok(())1621	}16221623	pub fn burn_item_internal(1624		owner: &T::CrossAccountId,1625		collection: &CollectionHandle<T>,1626		item_id: TokenId,1627		value: u128,1628		allow_escalation: bool,1629	) -> DispatchResult {1630		ensure!(1631			Self::is_item_owner(owner, collection, item_id)?1632				|| (allow_escalation1633					&& collection.limits.owner_can_transfer1634					&& Self::is_owner_or_admin_permissions(collection, owner)?),1635			Error::<T>::NoPermission1636		);16371638		if collection.access == AccessMode::WhiteList {1639			Self::check_white_list(collection, owner)?;1640		}16411642		match collection.mode {1643			CollectionMode::NFT => match value {1644				1 => Self::burn_nft_item(collection, item_id)?,1645				0 => (),1646				_ => fail!(<Error<T>>::TokenValueTooLow),1647			},1648			CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, owner, value)?,1649			CollectionMode::ReFungible => {1650				Self::burn_refungible_item(collection, item_id, owner, value)?1651			}1652			_ => (),1653		};16541655		Ok(())1656	}16571658	pub fn burn_from_internal(1659		sender: &T::CrossAccountId,1660		collection: &CollectionHandle<T>,1661		from: &T::CrossAccountId,1662		item_id: TokenId,1663		amount: u128,1664	) -> DispatchResult {1665		if sender == from {1666			// Transfer by `from`, because it is either equal to sender, or derived from him1667			return Self::burn_item_internal(from, collection, item_id, amount, true);1668		}16691670		// Check approval1671		collection.consume_sload()?;1672		let approval: u128 =1673			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));16741675		// Transfer permissions check1676		ensure!(1677			approval >= amount1678				|| (collection.limits.owner_can_transfer1679					&& Self::is_owner_or_admin_permissions(collection, sender)?),1680			Error::<T>::NoPermission1681		);16821683		if collection.access == AccessMode::WhiteList {1684			Self::check_white_list(collection, sender)?;1685		}16861687		// Reduce approval by transferred amount or remove if remaining approval drops to 01688		let allowance = approval.saturating_sub(amount);1689		collection.consume_sstore()?;1690		if allowance > 0 {1691			<Allowances<T>>::insert(1692				collection.id,1693				(item_id, from.as_sub(), sender.as_sub()),1694				allowance,1695			);1696		} else {1697			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1698		}16991700		// Escalation is disallowed here, because we need to be sure that passed owner is real1701		Self::burn_item_internal(from, collection, item_id, amount, false)?;17021703		if matches!(collection.mode, CollectionMode::Fungible(_)) {1704			collection.log(ERC20Events::Approval {1705				owner: *from.as_eth(),1706				spender: *sender.as_eth(),1707				value: allowance.into(),1708			})?;1709		}17101711		Ok(())1712	}17131714	pub fn toggle_white_list_internal(1715		sender: &T::CrossAccountId,1716		collection: &CollectionHandle<T>,1717		address: &T::CrossAccountId,1718		whitelisted: bool,1719	) -> DispatchResult {1720		Self::check_owner_or_admin_permissions(collection, sender)?;17211722		if whitelisted {1723			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1724		} else {1725			<WhiteList<T>>::remove(collection.id, address.as_sub());1726		}17271728		Ok(())1729	}17301731	fn is_correct_transfer(1732		collection: &CollectionHandle<T>,1733		recipient: &T::CrossAccountId,1734	) -> DispatchResult {1735		let collection_id = collection.id;17361737		// check token limit and account token limit1738		collection.consume_sload()?;1739		let account_items: u32 =1740			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;17411742		// zero limit means collection limit is disabled1743		// otherwise get lower value1744		let limit = if collection.limits.account_token_ownership_limit == 01745			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1746		{1747			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1748		} else {1749			collection.limits.account_token_ownership_limit1750		};17511752		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);17531754		// preliminary transfer check1755		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);17561757		Ok(())1758	}17591760	fn can_create_items_in_collection(1761		collection: &CollectionHandle<T>,1762		sender: &T::CrossAccountId,1763		owner: &T::CrossAccountId,1764		amount: u32,1765	) -> DispatchResult {1766		let collection_id = collection.id;17671768		// check token limit and account token limit1769		let total_items: u32 = ItemListIndex::get(collection_id)1770			.checked_add(amount)1771			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1772		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1773			as u32)1774			.checked_add(amount)1775			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;17761777		// zero limit means collection limit is disabled1778		// otherwise get lower value1779		let account_token_limit = if collection.limits.account_token_ownership_limit == 01780			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1781		{1782			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1783		} else {1784			collection.limits.account_token_ownership_limit1785		};17861787		ensure!(1788			collection.limits.token_limit >= total_items,1789			Error::<T>::CollectionTokenLimitExceeded1790		);1791		ensure!(1792			account_token_limit >= account_items,1793			Error::<T>::AccountTokenLimitExceeded1794		);17951796		if !Self::is_owner_or_admin_permissions(collection, sender)? {1797			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1798			Self::check_white_list(collection, owner)?;1799			Self::check_white_list(collection, sender)?;1800		}18011802		Ok(())1803	}18041805	fn validate_create_item_args(1806		target_collection: &CollectionHandle<T>,1807		data: &CreateItemData,1808	) -> DispatchResult {1809		match target_collection.mode {1810			CollectionMode::NFT => {1811				if !matches!(data, CreateItemData::NFT(_)) {1812					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1813				}1814			}1815			CollectionMode::Fungible(_) => {1816				if !matches!(data, CreateItemData::Fungible(_)) {1817					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1818				}1819			}1820			CollectionMode::ReFungible => {1821				if let CreateItemData::ReFungible(data) = data {1822					// Check refungibility limits1823					ensure!(1824						data.pieces <= MAX_REFUNGIBLE_PIECES,1825						Error::<T>::WrongRefungiblePieces1826					);1827					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1828				} else {1829					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1830				}1831			}1832		};18331834		Ok(())1835	}18361837	fn create_item_no_validation(1838		collection: &CollectionHandle<T>,1839		owner: &T::CrossAccountId,1840		data: CreateItemData,1841	) -> DispatchResult {1842		match data {1843			CreateItemData::NFT(data) => {1844				let item = NftItemType {1845					owner: owner.clone(),1846					const_data: data.const_data.into_inner(),1847					variable_data: data.variable_data.into_inner(),1848				};18491850				Self::add_nft_item(collection, item)?;1851			}1852			CreateItemData::Fungible(data) => {1853				Self::add_fungible_item(collection, owner, data.value)?;1854			}1855			CreateItemData::ReFungible(data) => {1856				let owner_list = vec![Ownership {1857					owner: owner.clone(),1858					fraction: data.pieces,1859				}];18601861				let item = ReFungibleItemType {1862					owner: owner_list,1863					const_data: data.const_data.into_inner(),1864					variable_data: data.variable_data.into_inner(),1865				};18661867				Self::add_refungible_item(collection, item)?;1868			}1869		};18701871		Ok(())1872	}18731874	fn add_fungible_item(1875		collection: &CollectionHandle<T>,1876		owner: &T::CrossAccountId,1877		value: u128,1878	) -> DispatchResult {1879		let collection_id = collection.id;18801881		// Does new owner already have an account?1882		collection.consume_sload()?;1883		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;18841885		// Mint1886		let item = FungibleItemType {1887			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1888		};1889		collection.consume_sstore()?;1890		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18911892		// Update balance1893		collection.consume_sload()?;1894		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1895			.checked_add(value)1896			.ok_or(Error::<T>::NumOverflow)?;1897		collection.consume_sstore()?;1898		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18991900		collection.log(ERC20Events::Transfer {1901			from: H160::default(),1902			to: *owner.as_eth(),1903			value: value.into(),1904		})?;1905		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1906		Ok(())1907	}19081909	fn add_refungible_item(1910		collection: &CollectionHandle<T>,1911		item: ReFungibleItemType<T::CrossAccountId>,1912	) -> DispatchResult {1913		let collection_id = collection.id;19141915		let current_index = <ItemListIndex>::get(collection_id)1916			.checked_add(1)1917			.ok_or(Error::<T>::NumOverflow)?;1918		let itemcopy = item.clone();19191920		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1921		let item_owner = item.owner.first().expect("only one owner is defined");19221923		let value = item_owner.fraction;1924		let owner = item_owner.owner.clone();19251926		Self::add_token_index(collection, current_index, &owner)?;19271928		<ItemListIndex>::insert(collection_id, current_index);1929		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19301931		// Update balance1932		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1933			.checked_add(value)1934			.ok_or(Error::<T>::NumOverflow)?;1935		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19361937		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1938		Ok(())1939	}19401941	fn add_nft_item(1942		collection: &CollectionHandle<T>,1943		item: NftItemType<T::CrossAccountId>,1944	) -> DispatchResult {1945		let collection_id = collection.id;19461947		let current_index = <ItemListIndex>::get(collection_id)1948			.checked_add(1)1949			.ok_or(Error::<T>::NumOverflow)?;19501951		let item_owner = item.owner.clone();1952		Self::add_token_index(collection, current_index, &item.owner)?;19531954		<ItemListIndex>::insert(collection_id, current_index);1955		<NftItemList<T>>::insert(collection_id, current_index, item);19561957		// Update balance1958		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1959			.checked_add(1)1960			.ok_or(Error::<T>::NumOverflow)?;1961		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);19621963		collection.log(ERC721Events::Transfer {1964			from: H160::default(),1965			to: *item_owner.as_eth(),1966			token_id: current_index.into(),1967		})?;1968		Self::deposit_event(RawEvent::ItemCreated(1969			collection_id,1970			current_index,1971			item_owner,1972		));1973		Ok(())1974	}19751976	fn burn_refungible_item(1977		collection: &CollectionHandle<T>,1978		item_id: TokenId,1979		owner: &T::CrossAccountId,1980		value: u128,1981	) -> DispatchResult {1982		let collection_id = collection.id;19831984		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1985			.ok_or(Error::<T>::TokenNotFound)?;1986		let mut rft_balance = token1987			.owner1988			.iter()1989			.find(|&i| i.owner == *owner)1990			.ok_or(Error::<T>::TokenNotFound)?1991			.clone();1992		Self::remove_token_index(collection, item_id, owner)?;19931994		// update balance1995		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1996			.checked_sub(value)1997			.ok_or(Error::<T>::NumOverflow)?;1998		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19992000		rft_balance.fraction = (rft_balance.fraction)2001			.checked_sub(value)2002			.ok_or(Error::<T>::NumOverflow)?;20032004		let index = token2005			.owner2006			.iter()2007			.position(|i| i.owner == *owner)2008			.expect("owned item is exists");2009		if rft_balance.fraction == 0 {2010			// Re-create owners list with sender removed2011			token.owner.remove(index);2012		} else {2013			token.owner[index] = rft_balance;2014		}20152016		let owner_count = token.owner.len();20172018		// Burn the token completely if this was the last (only) owner2019		if owner_count == 0 {2020			<ReFungibleItemList<T>>::remove(collection_id, item_id);2021			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);2022		} else {2023			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);2024		}20252026		Ok(())2027	}20282029	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2030		let collection_id = collection.id;20312032		let item =2033			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;2034		Self::remove_token_index(collection, item_id, &item.owner)?;20352036		// update balance2037		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2038			.checked_sub(1)2039			.ok_or(Error::<T>::NumOverflow)?;2040		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2041		<NftItemList<T>>::remove(collection_id, item_id);2042		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);20432044		collection.log(ERC721Events::Transfer {2045			from: *item.owner.as_eth(),2046			to: H160::default(),2047			token_id: item_id.into(),2048		})?;2049		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));2050		Ok(())2051	}20522053	fn burn_fungible_item(2054		collection: &CollectionHandle<T>,2055		owner: &T::CrossAccountId,2056		value: u128,2057	) -> DispatchResult {2058		let collection_id = collection.id;20592060		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2061		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20622063		// update balance2064		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2065			.checked_sub(value)2066			.ok_or(Error::<T>::NumOverflow)?;2067		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20682069		if balance.value - value > 0 {2070			balance.value -= value;2071			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2072		} else {2073			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2074		}20752076		collection.log(ERC20Events::Transfer {2077			from: *owner.as_eth(),2078			to: H160::default(),2079			value: value.into(),2080		})?;2081		Ok(())2082	}20832084	pub fn get_collection(2085		collection_id: CollectionId,2086	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2087		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)2088	}20892090	fn check_owner_permissions(2091		target_collection: &CollectionHandle<T>,2092		subject: &T::AccountId,2093	) -> DispatchResult {2094		ensure!(2095			*subject == target_collection.owner,2096			Error::<T>::NoPermission2097		);20982099		Ok(())2100	}21012102	fn is_owner_or_admin_permissions(2103		collection: &CollectionHandle<T>,2104		subject: &T::CrossAccountId,2105	) -> Result<bool, DispatchError> {2106		collection.consume_sload()?;2107		Ok(*subject.as_sub() == collection.owner2108			|| <AdminList<T>>::get(collection.id).contains(subject))2109	}21102111	fn check_owner_or_admin_permissions(2112		collection: &CollectionHandle<T>,2113		subject: &T::CrossAccountId,2114	) -> DispatchResult {2115		ensure!(2116			Self::is_owner_or_admin_permissions(collection, subject)?,2117			Error::<T>::NoPermission2118		);21192120		Ok(())2121	}21222123	fn owned_amount(2124		subject: &T::CrossAccountId,2125		collection: &CollectionHandle<T>,2126		item_id: TokenId,2127	) -> Result<Option<u128>, DispatchError> {2128		collection.consume_sload()?;2129		Ok(Self::owned_amount_unchecked(subject, collection, item_id))2130	}21312132	fn owned_amount_unchecked(2133		subject: &T::CrossAccountId,2134		target_collection: &CollectionHandle<T>,2135		item_id: TokenId,2136	) -> Option<u128> {2137		let collection_id = target_collection.id;21382139		match target_collection.mode {2140			CollectionMode::NFT => {2141				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2142			}2143			CollectionMode::Fungible(_) => {2144				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2145			}2146			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2147				.owner2148				.iter()2149				.find(|i| i.owner == *subject)2150				.map(|i| i.fraction),2151		}2152	}21532154	fn is_item_owner(2155		subject: &T::CrossAccountId,2156		target_collection: &CollectionHandle<T>,2157		item_id: TokenId,2158	) -> Result<bool, DispatchError> {2159		Ok(match target_collection.mode {2160			CollectionMode::Fungible(_) => true,2161			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2162		})2163	}21642165	fn check_white_list(2166		collection: &CollectionHandle<T>,2167		address: &T::CrossAccountId,2168	) -> DispatchResult {2169		collection.consume_sload()?;2170		ensure!(2171			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),2172			Error::<T>::AddresNotInWhiteList,2173		);2174		Ok(())2175	}21762177	/// Check if token exists. In case of Fungible, check if there is an entry for2178	/// the owner in fungible balances double map2179	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2180		let collection_id = target_collection.id;2181		let exists = match target_collection.mode {2182			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2183			CollectionMode::Fungible(_) => true,2184			CollectionMode::ReFungible => {2185				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2186			}2187		};21882189		ensure!(exists, Error::<T>::TokenNotFound);2190		Ok(())2191	}21922193	fn transfer_fungible(2194		collection: &CollectionHandle<T>,2195		value: u128,2196		owner: &T::CrossAccountId,2197		recipient: &T::CrossAccountId,2198	) -> DispatchResult {2199		let collection_id = collection.id;22002201		collection.consume_sload()?;2202		collection.consume_sload()?;2203		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2204		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());22052206		recipient_balance.value = recipient_balance2207			.value2208			.checked_add(value)2209			.ok_or(Error::<T>::NumOverflow)?;2210		balance.value = balance2211			.value2212			.checked_sub(value)2213			.ok_or(Error::<T>::TokenValueTooLow)?;22142215		// update balanceOf2216		collection.consume_sstore()?;2217		collection.consume_sstore()?;2218		if balance.value != 0 {2219			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2220		} else {2221			<Balance<T>>::remove(collection_id, owner.as_sub());2222		}2223		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);22242225		// Reduce or remove sender2226		collection.consume_sstore()?;2227		collection.consume_sstore()?;2228		if balance.value != 0 {2229			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2230		} else {2231			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2232		}2233		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);22342235		collection.log(ERC20Events::Transfer {2236			from: *owner.as_eth(),2237			to: *recipient.as_eth(),2238			value: value.into(),2239		})?;2240		Self::deposit_event(RawEvent::Transfer(2241			collection.id,2242			1,2243			owner.clone(),2244			recipient.clone(),2245			value,2246		));22472248		Ok(())2249	}22502251	fn transfer_refungible(2252		collection: &CollectionHandle<T>,2253		item_id: TokenId,2254		value: u128,2255		owner: T::CrossAccountId,2256		new_owner: T::CrossAccountId,2257	) -> DispatchResult {2258		let collection_id = collection.id;2259		collection.consume_sload()?;2260		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2261			.ok_or(Error::<T>::TokenNotFound)?;22622263		let item = full_item2264			.owner2265			.iter()2266			.find(|i| i.owner == owner)2267			.ok_or(Error::<T>::TokenNotFound)?;2268		let amount = item.fraction;22692270		ensure!(amount >= value, Error::<T>::TokenValueTooLow);22712272		collection.consume_sload()?;2273		// update balance2274		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2275			.checked_sub(value)2276			.ok_or(Error::<T>::NumOverflow)?;2277		collection.consume_sstore()?;2278		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22792280		collection.consume_sload()?;2281		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2282			.checked_add(value)2283			.ok_or(Error::<T>::NumOverflow)?;2284		collection.consume_sstore()?;2285		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22862287		let old_owner = item.owner.clone();2288		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22892290		let mut new_full_item = full_item.clone();2291		// transfer2292		if amount == value && !new_owner_has_account {2293			// change owner2294			// new owner do not have account2295			new_full_item2296				.owner2297				.iter_mut()2298				.find(|i| i.owner == owner)2299				.expect("old owner does present in refungible")2300				.owner = new_owner.clone();2301			collection.consume_sstore()?;2302			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23032304			// update index collection2305			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2306		} else {2307			new_full_item2308				.owner2309				.iter_mut()2310				.find(|i| i.owner == owner)2311				.expect("old owner does present in refungible")2312				.fraction -= value;23132314			// separate amount2315			if new_owner_has_account {2316				// new owner has account2317				new_full_item2318					.owner2319					.iter_mut()2320					.find(|i| i.owner == new_owner)2321					.expect("new owner has account")2322					.fraction += value;2323			} else {2324				// new owner do not have account2325				new_full_item.owner.push(Ownership {2326					owner: new_owner.clone(),2327					fraction: value,2328				});2329				Self::add_token_index(collection, item_id, &new_owner)?;2330			}23312332			collection.consume_sstore()?;2333			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2334		}23352336		Self::deposit_event(RawEvent::Transfer(2337			collection.id,2338			item_id,2339			owner,2340			new_owner,2341			amount,2342		));23432344		Ok(())2345	}23462347	fn transfer_nft(2348		collection: &CollectionHandle<T>,2349		item_id: TokenId,2350		sender: T::CrossAccountId,2351		new_owner: T::CrossAccountId,2352	) -> DispatchResult {2353		let collection_id = collection.id;2354		collection.consume_sload()?;2355		let mut item =2356			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23572358		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);23592360		collection.consume_sload()?;2361		// update balance2362		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2363			.checked_sub(1)2364			.ok_or(Error::<T>::NumOverflow)?;2365		collection.consume_sstore()?;2366		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);23672368		collection.consume_sload()?;2369		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2370			.checked_add(1)2371			.ok_or(Error::<T>::NumOverflow)?;2372		collection.consume_sstore()?;2373		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);23742375		// change owner2376		let old_owner = item.owner.clone();2377		item.owner = new_owner.clone();2378		collection.consume_sstore()?;2379		<NftItemList<T>>::insert(collection_id, item_id, item);23802381		// update index collection2382		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;23832384		collection.log(ERC721Events::Transfer {2385			from: *sender.as_eth(),2386			to: *new_owner.as_eth(),2387			token_id: item_id.into(),2388		})?;2389		Self::deposit_event(RawEvent::Transfer(2390			collection.id,2391			item_id,2392			sender,2393			new_owner,2394			1,2395		));23962397		Ok(())2398	}23992400	fn set_re_fungible_variable_data(2401		collection: &CollectionHandle<T>,2402		item_id: TokenId,2403		data: Vec<u8>,2404	) -> DispatchResult {2405		let collection_id = collection.id;2406		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2407			.ok_or(Error::<T>::TokenNotFound)?;24082409		item.variable_data = data;24102411		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);24122413		Ok(())2414	}24152416	fn set_nft_variable_data(2417		collection: &CollectionHandle<T>,2418		item_id: TokenId,2419		data: Vec<u8>,2420	) -> DispatchResult {2421		let collection_id = collection.id;2422		let mut item =2423			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;24242425		item.variable_data = data;24262427		<NftItemList<T>>::insert(collection_id, item_id, item);24282429		Ok(())2430	}24312432	#[allow(dead_code)]2433	fn init_collection(item: &Collection<T>) {2434		// check params2435		assert!(2436			item.decimal_points <= MAX_DECIMAL_POINTS,2437			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2438		);2439		assert!(2440			item.name.len() <= 64,2441			"Collection name can not be longer than 63 char"2442		);2443		assert!(2444			item.name.len() <= 256,2445			"Collection description can not be longer than 255 char"2446		);2447		assert!(2448			item.token_prefix.len() <= 16,2449			"Token prefix can not be longer than 15 char"2450		);24512452		// Generate next collection ID2453		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();24542455		CreatedCollectionCount::put(next_id);2456	}24572458	#[allow(dead_code)]2459	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2460		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24612462		Self::add_token_index(2463			&CollectionHandle::get(collection_id).unwrap(),2464			current_index,2465			&item.owner,2466		)2467		.unwrap();24682469		<ItemListIndex>::insert(collection_id, current_index);24702471		// Update balance2472		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2473			.checked_add(1)2474			.unwrap();2475		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2476	}24772478	#[allow(dead_code)]2479	fn init_fungible_token(2480		collection_id: CollectionId,2481		owner: &T::CrossAccountId,2482		item: &FungibleItemType,2483	) {2484		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24852486		Self::add_token_index(2487			&CollectionHandle::get(collection_id).unwrap(),2488			current_index,2489			owner,2490		)2491		.unwrap();24922493		<ItemListIndex>::insert(collection_id, current_index);24942495		// Update balance2496		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2497			.checked_add(item.value)2498			.unwrap();2499		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2500	}25012502	#[allow(dead_code)]2503	fn init_refungible_token(2504		collection_id: CollectionId,2505		item: &ReFungibleItemType<T::CrossAccountId>,2506	) {2507		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();25082509		let value = item.owner.first().unwrap().fraction;2510		let owner = item.owner.first().unwrap().owner.clone();25112512		Self::add_token_index(2513			&CollectionHandle::get(collection_id).unwrap(),2514			current_index,2515			&owner,2516		)2517		.unwrap();25182519		<ItemListIndex>::insert(collection_id, current_index);25202521		// Update balance2522		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2523			.checked_add(value)2524			.unwrap();2525		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2526	}25272528	fn add_token_index(2529		collection: &CollectionHandle<T>,2530		item_index: TokenId,2531		owner: &T::CrossAccountId,2532	) -> DispatchResult {2533		collection.consume_sload()?;2534		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2535		if list_exists {2536			collection.consume_sload()?;2537			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());25382539			// bound Owned tokens by a single address in collection2540			let account_items: u32 = list.len() as u32;2541			ensure!(2542				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2543				Error::<T>::AddressOwnershipLimitExceeded2544			);25452546			let item_contains = list.contains(&item_index.clone());25472548			if !item_contains {2549				list.push(item_index);2550			}25512552			collection.consume_sstore()?;2553			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2554		} else {2555			let itm = vec![item_index];2556			collection.consume_sstore()?;2557			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2558		}25592560		Ok(())2561	}25622563	fn remove_token_index(2564		collection: &CollectionHandle<T>,2565		item_index: TokenId,2566		owner: &T::CrossAccountId,2567	) -> DispatchResult {2568		collection.consume_sload()?;2569		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2570		if list_exists {2571			collection.consume_sload()?;2572			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2573			let item_contains = list.contains(&item_index.clone());25742575			if item_contains {2576				list.retain(|&item| item != item_index);2577				collection.consume_sstore()?;2578				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2579			}2580		}25812582		Ok(())2583	}25842585	fn move_token_index(2586		collection: &CollectionHandle<T>,2587		item_index: TokenId,2588		old_owner: &T::CrossAccountId,2589		new_owner: &T::CrossAccountId,2590	) -> DispatchResult {2591		Self::remove_token_index(collection, item_index, old_owner)?;2592		Self::add_token_index(collection, item_index, new_owner)?;25932594		Ok(())2595	}2596}25972598sp_api::decl_runtime_apis! {2599	pub trait NftApi {2600		/// Used for ethereum integration2601		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2602	}2603}