git.delta.rocks / unique-network / refs/commits / 10c46cb7be24

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};3334use 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 {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)?;996997			target_collection.submit_logs()998		}9991000		/// Change ownership of the token.1001		///1002		/// # Permissions1003		///1004		/// * Collection Owner1005		/// * Collection Admin1006		/// * Current NFT owner1007		///1008		/// # Arguments1009		///1010		/// * recipient: Address of token recipient.1011		///1012		/// * collection_id.1013		///1014		/// * item_id: ID of the item1015		///     * Non-Fungible Mode: Required.1016		///     * Fungible Mode: Ignored.1017		///     * Re-Fungible Mode: Required.1018		///1019		/// * value: Amount to transfer.1020		///     * Non-Fungible Mode: Ignored1021		///     * Fungible Mode: Must specify transferred amount1022		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1023		#[weight = <SelfWeightOf<T>>::transfer()]1024		#[transactional]1025		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1026			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1027			let collection = Self::get_collection(collection_id)?;10281029			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10301031			collection.submit_logs()1032		}10331034		/// Set, change, or remove approved address to transfer the ownership of the NFT.1035		///1036		/// # Permissions1037		///1038		/// * Collection Owner1039		/// * Collection Admin1040		/// * Current NFT owner1041		///1042		/// # Arguments1043		///1044		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1045		///1046		/// * collection_id.1047		///1048		/// * item_id: ID of the item.1049		#[weight = <SelfWeightOf<T>>::approve()]1050		#[transactional]1051		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1052			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1053			let collection = Self::get_collection(collection_id)?;10541055			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10561057			collection.submit_logs()1058		}10591060		/// 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.1061		///1062		/// # Permissions1063		/// * Collection Owner1064		/// * Collection Admin1065		/// * Current NFT owner1066		/// * Address approved by current NFT owner1067		///1068		/// # Arguments1069		///1070		/// * from: Address that owns token.1071		///1072		/// * recipient: Address of token recipient.1073		///1074		/// * collection_id.1075		///1076		/// * item_id: ID of the item.1077		///1078		/// * value: Amount to transfer.1079		#[weight = <SelfWeightOf<T>>::transfer_from()]1080		#[transactional]1081		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1082			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1083			let collection = Self::get_collection(collection_id)?;10841085			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10861087			collection.submit_logs()1088		}1089		// #[weight = 0]1090		//     // let no_perm_mes = "You do not have permissions to modify this collection";1091		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1092		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1093		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10941095		//     // // on_nft_received  call10961097		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10981099		//     Ok(())1100		// }11011102		/// Set off-chain data schema.1103		///1104		/// # Permissions1105		///1106		/// * Collection Owner1107		/// * Collection Admin1108		///1109		/// # Arguments1110		///1111		/// * collection_id.1112		///1113		/// * schema: String representing the offchain data schema.1114		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1115		#[transactional]1116		pub fn set_variable_meta_data (1117			origin,1118			collection_id: CollectionId,1119			item_id: TokenId,1120			data: Vec<u8>1121		) -> DispatchResult {1122			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124			let collection = Self::get_collection(collection_id)?;1125			Self::meta_update_check(&sender, &collection, item_id)?;11261127			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11281129			Ok(())1130		}11311132		/// Set schema standard1133		/// ImageURL1134		/// Unique1135		///1136		/// # Permissions1137		///1138		/// * Collection Owner1139		/// * Collection Admin1140		///1141		/// # Arguments1142		///1143		/// * collection_id.1144		///1145		/// * schema: SchemaVersion: enum1146		#[weight = <SelfWeightOf<T>>::set_schema_version()]1147		#[transactional]1148		pub fn set_schema_version(1149			origin,1150			collection_id: CollectionId,1151			version: SchemaVersion1152		) -> DispatchResult {1153			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1154			let mut target_collection = Self::get_collection(collection_id)?;1155			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1156			target_collection.schema_version = version;1157			target_collection.save()1158		}11591160		/// Set off-chain data schema.1161		///1162		/// # Permissions1163		///1164		/// * Collection Owner1165		/// * Collection Admin1166		///1167		/// # Arguments1168		///1169		/// * collection_id.1170		///1171		/// * schema: String representing the offchain data schema.1172		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1173		#[transactional]1174		pub fn set_offchain_schema(1175			origin,1176			collection_id: CollectionId,1177			schema: Vec<u8>1178		) -> DispatchResult {1179			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1180			let mut target_collection = Self::get_collection(collection_id)?;1181			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11821183			// check schema limit1184			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11851186			target_collection.offchain_schema = schema;1187			target_collection.save()1188		}11891190		/// Set const on-chain data schema.1191		///1192		/// # Permissions1193		///1194		/// * Collection Owner1195		/// * Collection Admin1196		///1197		/// # Arguments1198		///1199		/// * collection_id.1200		///1201		/// * schema: String representing the const on-chain data schema.1202		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1203		#[transactional]1204		pub fn set_const_on_chain_schema (1205			origin,1206			collection_id: CollectionId,1207			schema: Vec<u8>1208		) -> DispatchResult {1209			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1210			let mut target_collection = Self::get_collection(collection_id)?;1211			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12121213			// check schema limit1214			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12151216			target_collection.const_on_chain_schema = schema;1217			target_collection.save()1218		}12191220		/// Set variable on-chain data schema.1221		///1222		/// # Permissions1223		///1224		/// * Collection Owner1225		/// * Collection Admin1226		///1227		/// # Arguments1228		///1229		/// * collection_id.1230		///1231		/// * schema: String representing the variable on-chain data schema.1232		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1233		#[transactional]1234		pub fn set_variable_on_chain_schema (1235			origin,1236			collection_id: CollectionId,1237			schema: Vec<u8>1238		) -> DispatchResult {1239			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1240			let mut target_collection = Self::get_collection(collection_id)?;1241			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12421243			// check schema limit1244			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12451246			target_collection.variable_on_chain_schema = schema;1247			target_collection.save()1248		}12491250		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1251		#[transactional]1252		pub fn set_collection_limits(1253			origin,1254			collection_id: u32,1255			new_limits: CollectionLimits<T::BlockNumber>,1256		) -> DispatchResult {1257			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1258			let mut target_collection = Self::get_collection(collection_id)?;1259			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1260			let old_limits = &target_collection.limits;12611262			// collection bounds1263			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1264				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1265				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1266				Error::<T>::CollectionLimitBoundsExceeded);12671268			// token_limit   check  prev1269			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1270			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12711272			ensure!(1273				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1274				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1275				Error::<T>::OwnerPermissionsCantBeReverted,1276			);12771278			target_collection.limits = new_limits;12791280			target_collection.save()1281		}1282	}1283}12841285impl<T: Config> Module<T> {1286	pub fn create_item_internal(1287		sender: &T::CrossAccountId,1288		collection: &CollectionHandle<T>,1289		owner: &T::CrossAccountId,1290		data: CreateItemData,1291	) -> DispatchResult {1292		ensure!(1293			owner != &T::CrossAccountId::from_eth(H160([0; 20])),1294			Error::<T>::AddressIsZero1295		);12961297		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1298		Self::validate_create_item_args(collection, &data)?;1299		Self::create_item_no_validation(collection, owner, data)?;13001301		Ok(())1302	}13031304	pub fn transfer_internal(1305		sender: &T::CrossAccountId,1306		recipient: &T::CrossAccountId,1307		target_collection: &CollectionHandle<T>,1308		item_id: TokenId,1309		value: u128,1310	) -> DispatchResult {1311		ensure!(1312			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1313			Error::<T>::AddressIsZero1314		);13151316		// Limits check1317		Self::is_correct_transfer(target_collection, recipient)?;13181319		// Transfer permissions check1320		ensure!(1321			Self::is_item_owner(sender, target_collection, item_id)?1322				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,1323			Error::<T>::NoPermission1324		);13251326		if target_collection.access == AccessMode::WhiteList {1327			Self::check_white_list(target_collection, sender)?;1328			Self::check_white_list(target_collection, recipient)?;1329		}13301331		match target_collection.mode {1332			CollectionMode::NFT => Self::transfer_nft(1333				target_collection,1334				item_id,1335				sender.clone(),1336				recipient.clone(),1337			)?,1338			CollectionMode::Fungible(_) => {1339				Self::transfer_fungible(target_collection, value, sender, recipient)?1340			}1341			CollectionMode::ReFungible => Self::transfer_refungible(1342				target_collection,1343				item_id,1344				value,1345				sender.clone(),1346				recipient.clone(),1347			)?,1348			_ => (),1349		};13501351		Self::deposit_event(RawEvent::Transfer(1352			target_collection.id,1353			item_id,1354			sender.clone(),1355			recipient.clone(),1356			value,1357		));13581359		Ok(())1360	}13611362	pub fn approve_internal(1363		sender: &T::CrossAccountId,1364		spender: &T::CrossAccountId,1365		collection: &CollectionHandle<T>,1366		item_id: TokenId,1367		amount: u128,1368	) -> DispatchResult {1369		Self::token_exists(collection, item_id)?;13701371		// Transfer permissions check1372		let bypasses_limits = collection.limits.owner_can_transfer1373			&& Self::is_owner_or_admin_permissions(collection, sender)?;13741375		let allowance_limit = if bypasses_limits {1376			None1377		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1378			Some(amount)1379		} else {1380			fail!(Error::<T>::NoPermission);1381		};13821383		if collection.access == AccessMode::WhiteList {1384			Self::check_white_list(collection, sender)?;1385			Self::check_white_list(collection, spender)?;1386		}13871388		collection.consume_sload()?;1389		let allowance: u128 = amount1390			.checked_add(<Allowances<T>>::get(1391				collection.id,1392				(item_id, sender.as_sub(), spender.as_sub()),1393			))1394			.ok_or(Error::<T>::NumOverflow)?;1395		if let Some(limit) = allowance_limit {1396			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1397		}1398		collection.consume_sstore()?;1399		<Allowances<T>>::insert(1400			collection.id,1401			(item_id, sender.as_sub(), spender.as_sub()),1402			allowance,1403		);14041405		if matches!(collection.mode, CollectionMode::NFT) {1406			// TODO: NFT: only one owner may exist for token in ERC7211407			collection.log(ERC721Events::Approval {1408				owner: *sender.as_eth(),1409				approved: *spender.as_eth(),1410				token_id: item_id.into(),1411			})?;1412		}14131414		if matches!(collection.mode, CollectionMode::Fungible(_)) {1415			// TODO: NFT: only one owner may exist for token in ERC201416			collection.log(ERC20Events::Approval {1417				owner: *sender.as_eth(),1418				spender: *spender.as_eth(),1419				value: allowance.into(),1420			})?;1421		}14221423		Self::deposit_event(RawEvent::Approved(1424			collection.id,1425			item_id,1426			sender.clone(),1427			spender.clone(),1428			allowance,1429		));1430		Ok(())1431	}14321433	pub fn transfer_from_internal(1434		sender: &T::CrossAccountId,1435		from: &T::CrossAccountId,1436		recipient: &T::CrossAccountId,1437		collection: &CollectionHandle<T>,1438		item_id: TokenId,1439		amount: u128,1440	) -> DispatchResult {1441		if sender == from {1442			// Transfer by `from`, because it is either equal to sender, or derived from him1443			return Self::transfer_internal(from, recipient, collection, item_id, amount);1444		}14451446		// Check approval1447		collection.consume_sload()?;1448		let approval: u128 =1449			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14501451		// Limits check1452		Self::is_correct_transfer(collection, recipient)?;14531454		// Transfer permissions check1455		ensure!(1456			approval >= amount1457				|| (collection.limits.owner_can_transfer1458					&& Self::is_owner_or_admin_permissions(collection, sender)?),1459			Error::<T>::NoPermission1460		);14611462		if collection.access == AccessMode::WhiteList {1463			Self::check_white_list(collection, sender)?;1464			Self::check_white_list(collection, recipient)?;1465		}14661467		// Reduce approval by transferred amount or remove if remaining approval drops to 01468		let allowance = approval.saturating_sub(amount);1469		collection.consume_sstore()?;1470		if allowance > 0 {1471			<Allowances<T>>::insert(1472				collection.id,1473				(item_id, from.as_sub(), sender.as_sub()),1474				allowance,1475			);1476		} else {1477			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1478		}14791480		match collection.mode {1481			CollectionMode::NFT => {1482				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1483			}1484			CollectionMode::Fungible(_) => {1485				Self::transfer_fungible(collection, amount, from, recipient)?1486			}1487			CollectionMode::ReFungible => Self::transfer_refungible(1488				collection,1489				item_id,1490				amount,1491				from.clone(),1492				recipient.clone(),1493			)?,1494			_ => (),1495		};14961497		if matches!(collection.mode, CollectionMode::Fungible(_)) {1498			collection.log(ERC20Events::Approval {1499				owner: *from.as_eth(),1500				spender: *sender.as_eth(),1501				value: allowance.into(),1502			})?;1503		}15041505		Ok(())1506	}15071508	pub fn set_variable_meta_data_internal(1509		sender: &T::CrossAccountId,1510		collection: &CollectionHandle<T>,1511		item_id: TokenId,1512		data: Vec<u8>,1513	) -> DispatchResult {1514		Self::token_exists(collection, item_id)?;15151516		ensure!(1517			CUSTOM_DATA_LIMIT >= data.len() as u32,1518			Error::<T>::TokenVariableDataLimitExceeded1519		);15201521		ensure!(1522			(Self::is_item_owner(sender, collection, item_id)?1523				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1524				|| (Self::is_owner_or_admin_permissions(collection, sender)?1525					&& collection.meta_update_permission == MetaUpdatePermission::Admin),1526			Error::<T>::NoPermission1527		);15281529		match collection.mode {1530			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1531			CollectionMode::ReFungible => {1532				Self::set_re_fungible_variable_data(collection, item_id, data)?1533			}1534			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1535			_ => fail!(Error::<T>::UnexpectedCollectionType),1536		};15371538		Ok(())1539	}15401541	pub fn meta_update_check(1542		sender: &T::CrossAccountId,1543		collection: &CollectionHandle<T>,1544		item_id: TokenId,1545	) -> DispatchResult {1546		match collection.meta_update_permission {1547			MetaUpdatePermission::ItemOwner => ensure!(1548				Self::is_item_owner(sender, collection, item_id)?,1549				Error::<T>::NoPermission1550			),1551			MetaUpdatePermission::Admin => ensure!(1552				Self::is_owner_or_admin_permissions(collection, sender)?,1553				Error::<T>::NoPermission1554			),1555			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1556		}15571558		Ok(())1559	}15601561	pub fn get_variable_metadata(1562		collection: &CollectionHandle<T>,1563		item_id: TokenId,1564	) -> Result<Vec<u8>, DispatchError> {1565		Ok(match collection.mode {1566			CollectionMode::NFT => {1567				<NftItemList<T>>::get(collection.id, item_id)1568					.ok_or(Error::<T>::TokenNotFound)?1569					.variable_data1570			}1571			CollectionMode::ReFungible => {1572				<ReFungibleItemList<T>>::get(collection.id, item_id)1573					.ok_or(Error::<T>::TokenNotFound)?1574					.variable_data1575			}1576			_ => fail!(Error::<T>::UnexpectedCollectionType),1577		})1578	}15791580	pub fn create_multiple_items_internal(1581		sender: &T::CrossAccountId,1582		collection: &CollectionHandle<T>,1583		owner: &T::CrossAccountId,1584		items_data: Vec<CreateItemData>,1585	) -> DispatchResult {1586		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15871588		for data in &items_data {1589			Self::validate_create_item_args(collection, data)?;1590		}1591		for data in &items_data {1592			Self::create_item_no_validation(collection, owner, data.clone())?;1593		}15941595		Ok(())1596	}15971598	pub fn burn_item_internal(1599		sender: &T::CrossAccountId,1600		collection: &CollectionHandle<T>,1601		item_id: TokenId,1602		value: u128,1603	) -> DispatchResult {1604		ensure!(1605			Self::is_item_owner(sender, collection, item_id)?1606				|| (collection.limits.owner_can_transfer1607					&& Self::is_owner_or_admin_permissions(collection, sender)?),1608			Error::<T>::NoPermission1609		);16101611		if collection.access == AccessMode::WhiteList {1612			Self::check_white_list(collection, sender)?;1613		}16141615		match collection.mode {1616			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1617			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1618			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1619			_ => (),1620		};16211622		Ok(())1623	}16241625	pub fn toggle_white_list_internal(1626		sender: &T::CrossAccountId,1627		collection: &CollectionHandle<T>,1628		address: &T::CrossAccountId,1629		whitelisted: bool,1630	) -> DispatchResult {1631		Self::check_owner_or_admin_permissions(collection, sender)?;16321633		if whitelisted {1634			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1635		} else {1636			<WhiteList<T>>::remove(collection.id, address.as_sub());1637		}16381639		Ok(())1640	}16411642	fn is_correct_transfer(1643		collection: &CollectionHandle<T>,1644		recipient: &T::CrossAccountId,1645	) -> DispatchResult {1646		let collection_id = collection.id;16471648		// check token limit and account token limit1649		collection.consume_sload()?;1650		let account_items: u32 =1651			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16521653		// zero limit means collection limit is disabled1654		// otherwise get lower value1655		let limit = if collection.limits.account_token_ownership_limit == 01656			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1657		{1658			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1659		} else {1660			collection.limits.account_token_ownership_limit1661		};16621663		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16641665		// preliminary transfer check1666		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16671668		Ok(())1669	}16701671	fn can_create_items_in_collection(1672		collection: &CollectionHandle<T>,1673		sender: &T::CrossAccountId,1674		owner: &T::CrossAccountId,1675		amount: u32,1676	) -> DispatchResult {1677		let collection_id = collection.id;16781679		// check token limit and account token limit1680		let total_items: u32 = ItemListIndex::get(collection_id)1681			.checked_add(amount)1682			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1683		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1684			as u32)1685			.checked_add(amount)1686			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;16871688		// zero limit means collection limit is disabled1689		// otherwise get lower value1690		let account_token_limit = if collection.limits.account_token_ownership_limit == 01691			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1692		{1693			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1694		} else {1695			collection.limits.account_token_ownership_limit1696		};16971698		ensure!(1699			collection.limits.token_limit >= total_items,1700			Error::<T>::CollectionTokenLimitExceeded1701		);1702		ensure!(1703			account_token_limit >= account_items,1704			Error::<T>::AccountTokenLimitExceeded1705		);17061707		if !Self::is_owner_or_admin_permissions(collection, sender)? {1708			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1709			Self::check_white_list(collection, owner)?;1710			Self::check_white_list(collection, sender)?;1711		}17121713		Ok(())1714	}17151716	fn validate_create_item_args(1717		target_collection: &CollectionHandle<T>,1718		data: &CreateItemData,1719	) -> DispatchResult {1720		match target_collection.mode {1721			CollectionMode::NFT => {1722				if !matches!(data, CreateItemData::NFT(_)) {1723					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1724				}1725			}1726			CollectionMode::Fungible(_) => {1727				if !matches!(data, CreateItemData::Fungible(_)) {1728					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1729				}1730			}1731			CollectionMode::ReFungible => {1732				if let CreateItemData::ReFungible(data) = data {1733					// Check refungibility limits1734					ensure!(1735						data.pieces <= MAX_REFUNGIBLE_PIECES,1736						Error::<T>::WrongRefungiblePieces1737					);1738					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1739				} else {1740					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1741				}1742			}1743			_ => {1744				fail!(Error::<T>::UnexpectedCollectionType);1745			}1746		};17471748		Ok(())1749	}17501751	fn create_item_no_validation(1752		collection: &CollectionHandle<T>,1753		owner: &T::CrossAccountId,1754		data: CreateItemData,1755	) -> DispatchResult {1756		match data {1757			CreateItemData::NFT(data) => {1758				let item = NftItemType {1759					owner: owner.clone(),1760					const_data: data.const_data.into_inner(),1761					variable_data: data.variable_data.into_inner(),1762				};17631764				Self::add_nft_item(collection, item)?;1765			}1766			CreateItemData::Fungible(data) => {1767				Self::add_fungible_item(collection, owner, data.value)?;1768			}1769			CreateItemData::ReFungible(data) => {1770				let owner_list = vec![Ownership {1771					owner: owner.clone(),1772					fraction: data.pieces,1773				}];17741775				let item = ReFungibleItemType {1776					owner: owner_list,1777					const_data: data.const_data.into_inner(),1778					variable_data: data.variable_data.into_inner(),1779				};17801781				Self::add_refungible_item(collection, item)?;1782			}1783		};17841785		Ok(())1786	}17871788	fn add_fungible_item(1789		collection: &CollectionHandle<T>,1790		owner: &T::CrossAccountId,1791		value: u128,1792	) -> DispatchResult {1793		let collection_id = collection.id;17941795		// Does new owner already have an account?1796		collection.consume_sload()?;1797		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17981799		// Mint1800		let item = FungibleItemType {1801			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1802		};1803		collection.consume_sstore()?;1804		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18051806		// Update balance1807		collection.consume_sload()?;1808		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1809			.checked_add(value)1810			.ok_or(Error::<T>::NumOverflow)?;1811		collection.consume_sstore()?;1812		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18131814		collection.log(ERC20Events::Transfer {1815			from: H160::default(),1816			to: *owner.as_eth(),1817			value: value.into(),1818		})?;1819		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1820		Ok(())1821	}18221823	fn add_refungible_item(1824		collection: &CollectionHandle<T>,1825		item: ReFungibleItemType<T::CrossAccountId>,1826	) -> DispatchResult {1827		let collection_id = collection.id;18281829		let current_index = <ItemListIndex>::get(collection_id)1830			.checked_add(1)1831			.ok_or(Error::<T>::NumOverflow)?;1832		let itemcopy = item.clone();18331834		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1835		let item_owner = item.owner.first().expect("only one owner is defined");18361837		let value = item_owner.fraction;1838		let owner = item_owner.owner.clone();18391840		Self::add_token_index(collection, current_index, &owner)?;18411842		<ItemListIndex>::insert(collection_id, current_index);1843		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18441845		// Update balance1846		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1847			.checked_add(value)1848			.ok_or(Error::<T>::NumOverflow)?;1849		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18501851		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1852		Ok(())1853	}18541855	fn add_nft_item(1856		collection: &CollectionHandle<T>,1857		item: NftItemType<T::CrossAccountId>,1858	) -> DispatchResult {1859		let collection_id = collection.id;18601861		let current_index = <ItemListIndex>::get(collection_id)1862			.checked_add(1)1863			.ok_or(Error::<T>::NumOverflow)?;18641865		let item_owner = item.owner.clone();1866		Self::add_token_index(collection, current_index, &item.owner)?;18671868		<ItemListIndex>::insert(collection_id, current_index);1869		<NftItemList<T>>::insert(collection_id, current_index, item);18701871		// Update balance1872		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1873			.checked_add(1)1874			.ok_or(Error::<T>::NumOverflow)?;1875		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18761877		collection.log(ERC721Events::Transfer {1878			from: H160::default(),1879			to: *item_owner.as_eth(),1880			token_id: current_index.into(),1881		})?;1882		Self::deposit_event(RawEvent::ItemCreated(1883			collection_id,1884			current_index,1885			item_owner,1886		));1887		Ok(())1888	}18891890	fn burn_refungible_item(1891		collection: &CollectionHandle<T>,1892		item_id: TokenId,1893		owner: &T::CrossAccountId,1894	) -> DispatchResult {1895		let collection_id = collection.id;18961897		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1898			.ok_or(Error::<T>::TokenNotFound)?;1899		let rft_balance = token1900			.owner1901			.iter()1902			.find(|&i| i.owner == *owner)1903			.ok_or(Error::<T>::TokenNotFound)?;1904		Self::remove_token_index(collection, item_id, owner)?;19051906		// update balance1907		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1908			.checked_sub(rft_balance.fraction)1909			.ok_or(Error::<T>::NumOverflow)?;1910		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19111912		// Re-create owners list with sender removed1913		let index = token1914			.owner1915			.iter()1916			.position(|i| i.owner == *owner)1917			.expect("owned item is exists");1918		token.owner.remove(index);1919		let owner_count = token.owner.len();19201921		// Burn the token completely if this was the last (only) owner1922		if owner_count == 0 {1923			<ReFungibleItemList<T>>::remove(collection_id, item_id);1924			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1925		} else {1926			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1927		}19281929		Ok(())1930	}19311932	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1933		let collection_id = collection.id;19341935		let item =1936			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1937		Self::remove_token_index(collection, item_id, &item.owner)?;19381939		// update balance1940		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1941			.checked_sub(1)1942			.ok_or(Error::<T>::NumOverflow)?;1943		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1944		<NftItemList<T>>::remove(collection_id, item_id);1945		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);19461947		collection.log(ERC721Events::Transfer {1948			from: *item.owner.as_eth(),1949			to: H160::default(),1950			token_id: item_id.into(),1951		})?;1952		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1953		Ok(())1954	}19551956	fn burn_fungible_item(1957		owner: &T::CrossAccountId,1958		collection: &CollectionHandle<T>,1959		value: u128,1960	) -> DispatchResult {1961		let collection_id = collection.id;19621963		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1964		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19651966		// update balance1967		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1968			.checked_sub(value)1969			.ok_or(Error::<T>::NumOverflow)?;1970		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19711972		if balance.value - value > 0 {1973			balance.value -= value;1974			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1975		} else {1976			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1977		}19781979		collection.log(ERC20Events::Transfer {1980			from: *owner.as_eth(),1981			to: H160::default(),1982			value: value.into(),1983		})?;1984		Ok(())1985	}19861987	pub fn get_collection(1988		collection_id: CollectionId,1989	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1990		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1991	}19921993	fn check_owner_permissions(1994		target_collection: &CollectionHandle<T>,1995		subject: &T::AccountId,1996	) -> DispatchResult {1997		ensure!(1998			*subject == target_collection.owner,1999			Error::<T>::NoPermission2000		);20012002		Ok(())2003	}20042005	fn is_owner_or_admin_permissions(2006		collection: &CollectionHandle<T>,2007		subject: &T::CrossAccountId,2008	) -> Result<bool, DispatchError> {2009		collection.consume_sload()?;2010		Ok(*subject.as_sub() == collection.owner2011			|| <AdminList<T>>::get(collection.id).contains(subject))2012	}20132014	fn check_owner_or_admin_permissions(2015		collection: &CollectionHandle<T>,2016		subject: &T::CrossAccountId,2017	) -> DispatchResult {2018		ensure!(2019			Self::is_owner_or_admin_permissions(collection, subject)?,2020			Error::<T>::NoPermission2021		);20222023		Ok(())2024	}20252026	fn owned_amount(2027		subject: &T::CrossAccountId,2028		collection: &CollectionHandle<T>,2029		item_id: TokenId,2030	) -> Result<Option<u128>, DispatchError> {2031		collection.consume_sload()?;2032		Ok(Self::owned_amount_unchecked(subject, collection, item_id))2033	}20342035	fn owned_amount_unchecked(2036		subject: &T::CrossAccountId,2037		target_collection: &CollectionHandle<T>,2038		item_id: TokenId,2039	) -> Option<u128> {2040		let collection_id = target_collection.id;20412042		match target_collection.mode {2043			CollectionMode::NFT => {2044				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2045			}2046			CollectionMode::Fungible(_) => {2047				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2048			}2049			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2050				.owner2051				.iter()2052				.find(|i| i.owner == *subject)2053				.map(|i| i.fraction),2054			CollectionMode::Invalid => None,2055		}2056	}20572058	fn is_item_owner(2059		subject: &T::CrossAccountId,2060		target_collection: &CollectionHandle<T>,2061		item_id: TokenId,2062	) -> Result<bool, DispatchError> {2063		Ok(match target_collection.mode {2064			CollectionMode::Fungible(_) => true,2065			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2066		})2067	}20682069	fn check_white_list(2070		collection: &CollectionHandle<T>,2071		address: &T::CrossAccountId,2072	) -> DispatchResult {2073		collection.consume_sload()?;2074		ensure!(2075			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),2076			Error::<T>::AddresNotInWhiteList,2077		);2078		Ok(())2079	}20802081	/// Check if token exists. In case of Fungible, check if there is an entry for2082	/// the owner in fungible balances double map2083	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2084		let collection_id = target_collection.id;2085		let exists = match target_collection.mode {2086			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2087			CollectionMode::Fungible(_) => true,2088			CollectionMode::ReFungible => {2089				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2090			}2091			_ => false,2092		};20932094		ensure!(exists, Error::<T>::TokenNotFound);2095		Ok(())2096	}20972098	fn transfer_fungible(2099		collection: &CollectionHandle<T>,2100		value: u128,2101		owner: &T::CrossAccountId,2102		recipient: &T::CrossAccountId,2103	) -> DispatchResult {2104		let collection_id = collection.id;21052106		collection.consume_sload()?;2107		collection.consume_sload()?;2108		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2109		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21102111		recipient_balance.value = recipient_balance2112			.value2113			.checked_add(value)2114			.ok_or(Error::<T>::NumOverflow)?;2115		balance.value = balance2116			.value2117			.checked_sub(value)2118			.ok_or(Error::<T>::TokenValueTooLow)?;21192120		// update balanceOf2121		collection.consume_sstore()?;2122		collection.consume_sstore()?;2123		if balance.value != 0 {2124			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2125		} else {2126			<Balance<T>>::remove(collection_id, owner.as_sub());2127		}2128		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21292130		// Reduce or remove sender2131		collection.consume_sstore()?;2132		collection.consume_sstore()?;2133		if balance.value != 0 {2134			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2135		} else {2136			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2137		}2138		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21392140		collection.log(ERC20Events::Transfer {2141			from: *owner.as_eth(),2142			to: *recipient.as_eth(),2143			value: value.into(),2144		})?;2145		Self::deposit_event(RawEvent::Transfer(2146			collection.id,2147			1,2148			owner.clone(),2149			recipient.clone(),2150			value,2151		));21522153		Ok(())2154	}21552156	fn transfer_refungible(2157		collection: &CollectionHandle<T>,2158		item_id: TokenId,2159		value: u128,2160		owner: T::CrossAccountId,2161		new_owner: T::CrossAccountId,2162	) -> DispatchResult {2163		let collection_id = collection.id;2164		collection.consume_sload()?;2165		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2166			.ok_or(Error::<T>::TokenNotFound)?;21672168		let item = full_item2169			.owner2170			.iter()2171			.find(|i| i.owner == owner)2172			.ok_or(Error::<T>::TokenNotFound)?;2173		let amount = item.fraction;21742175		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21762177		collection.consume_sload()?;2178		// update balance2179		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2180			.checked_sub(value)2181			.ok_or(Error::<T>::NumOverflow)?;2182		collection.consume_sstore()?;2183		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21842185		collection.consume_sload()?;2186		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2187			.checked_add(value)2188			.ok_or(Error::<T>::NumOverflow)?;2189		collection.consume_sstore()?;2190		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21912192		let old_owner = item.owner.clone();2193		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21942195		let mut new_full_item = full_item.clone();2196		// transfer2197		if amount == value && !new_owner_has_account {2198			// change owner2199			// new owner do not have account2200			new_full_item2201				.owner2202				.iter_mut()2203				.find(|i| i.owner == owner)2204				.expect("old owner does present in refungible")2205				.owner = new_owner.clone();2206			collection.consume_sstore()?;2207			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22082209			// update index collection2210			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2211		} else {2212			new_full_item2213				.owner2214				.iter_mut()2215				.find(|i| i.owner == owner)2216				.expect("old owner does present in refungible")2217				.fraction -= value;22182219			// separate amount2220			if new_owner_has_account {2221				// new owner has account2222				new_full_item2223					.owner2224					.iter_mut()2225					.find(|i| i.owner == new_owner)2226					.expect("new owner has account")2227					.fraction += value;2228			} else {2229				// new owner do not have account2230				new_full_item.owner.push(Ownership {2231					owner: new_owner.clone(),2232					fraction: value,2233				});2234				Self::add_token_index(collection, item_id, &new_owner)?;2235			}22362237			collection.consume_sstore()?;2238			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2239		}22402241		Self::deposit_event(RawEvent::Transfer(2242			collection.id,2243			item_id,2244			owner,2245			new_owner,2246			amount,2247		));22482249		Ok(())2250	}22512252	fn transfer_nft(2253		collection: &CollectionHandle<T>,2254		item_id: TokenId,2255		sender: T::CrossAccountId,2256		new_owner: T::CrossAccountId,2257	) -> DispatchResult {2258		let collection_id = collection.id;2259		collection.consume_sload()?;2260		let mut item =2261			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22622263		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22642265		collection.consume_sload()?;2266		// update balance2267		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2268			.checked_sub(1)2269			.ok_or(Error::<T>::NumOverflow)?;2270		collection.consume_sstore()?;2271		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22722273		collection.consume_sload()?;2274		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2275			.checked_add(1)2276			.ok_or(Error::<T>::NumOverflow)?;2277		collection.consume_sstore()?;2278		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22792280		// change owner2281		let old_owner = item.owner.clone();2282		item.owner = new_owner.clone();2283		collection.consume_sstore()?;2284		<NftItemList<T>>::insert(collection_id, item_id, item);22852286		// update index collection2287		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22882289		collection.log(ERC721Events::Transfer {2290			from: *sender.as_eth(),2291			to: *new_owner.as_eth(),2292			token_id: item_id.into(),2293		})?;2294		Self::deposit_event(RawEvent::Transfer(2295			collection.id,2296			item_id,2297			sender,2298			new_owner,2299			1,2300		));23012302		Ok(())2303	}23042305	fn set_re_fungible_variable_data(2306		collection: &CollectionHandle<T>,2307		item_id: TokenId,2308		data: Vec<u8>,2309	) -> DispatchResult {2310		let collection_id = collection.id;2311		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2312			.ok_or(Error::<T>::TokenNotFound)?;23132314		item.variable_data = data;23152316		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);23172318		Ok(())2319	}23202321	fn set_nft_variable_data(2322		collection: &CollectionHandle<T>,2323		item_id: TokenId,2324		data: Vec<u8>,2325	) -> DispatchResult {2326		let collection_id = collection.id;2327		let mut item =2328			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23292330		item.variable_data = data;23312332		<NftItemList<T>>::insert(collection_id, item_id, item);23332334		Ok(())2335	}23362337	#[allow(dead_code)]2338	fn init_collection(item: &Collection<T>) {2339		// check params2340		assert!(2341			item.decimal_points <= MAX_DECIMAL_POINTS,2342			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2343		);2344		assert!(2345			item.name.len() <= 64,2346			"Collection name can not be longer than 63 char"2347		);2348		assert!(2349			item.name.len() <= 256,2350			"Collection description can not be longer than 255 char"2351		);2352		assert!(2353			item.token_prefix.len() <= 16,2354			"Token prefix can not be longer than 15 char"2355		);23562357		// Generate next collection ID2358		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23592360		CreatedCollectionCount::put(next_id);2361	}23622363	#[allow(dead_code)]2364	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2365		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23662367		Self::add_token_index(2368			&CollectionHandle::get(collection_id).unwrap(),2369			current_index,2370			&item.owner,2371		)2372		.unwrap();23732374		<ItemListIndex>::insert(collection_id, current_index);23752376		// Update balance2377		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2378			.checked_add(1)2379			.unwrap();2380		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2381	}23822383	#[allow(dead_code)]2384	fn init_fungible_token(2385		collection_id: CollectionId,2386		owner: &T::CrossAccountId,2387		item: &FungibleItemType,2388	) {2389		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23902391		Self::add_token_index(2392			&CollectionHandle::get(collection_id).unwrap(),2393			current_index,2394			owner,2395		)2396		.unwrap();23972398		<ItemListIndex>::insert(collection_id, current_index);23992400		// Update balance2401		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2402			.checked_add(item.value)2403			.unwrap();2404		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2405	}24062407	#[allow(dead_code)]2408	fn init_refungible_token(2409		collection_id: CollectionId,2410		item: &ReFungibleItemType<T::CrossAccountId>,2411	) {2412		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24132414		let value = item.owner.first().unwrap().fraction;2415		let owner = item.owner.first().unwrap().owner.clone();24162417		Self::add_token_index(2418			&CollectionHandle::get(collection_id).unwrap(),2419			current_index,2420			&owner,2421		)2422		.unwrap();24232424		<ItemListIndex>::insert(collection_id, current_index);24252426		// Update balance2427		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2428			.checked_add(value)2429			.unwrap();2430		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2431	}24322433	fn add_token_index(2434		collection: &CollectionHandle<T>,2435		item_index: TokenId,2436		owner: &T::CrossAccountId,2437	) -> DispatchResult {2438		collection.consume_sload()?;2439		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2440		if list_exists {2441			collection.consume_sload()?;2442			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24432444			// bound Owned tokens by a single address in collection2445			let account_items: u32 = list.len() as u32;2446			ensure!(2447				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2448				Error::<T>::AddressOwnershipLimitExceeded2449			);24502451			let item_contains = list.contains(&item_index.clone());24522453			if !item_contains {2454				list.push(item_index);2455			}24562457			collection.consume_sstore()?;2458			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2459		} else {2460			let itm = vec![item_index];2461			collection.consume_sstore()?;2462			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2463		}24642465		Ok(())2466	}24672468	fn remove_token_index(2469		collection: &CollectionHandle<T>,2470		item_index: TokenId,2471		owner: &T::CrossAccountId,2472	) -> DispatchResult {2473		collection.consume_sload()?;2474		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2475		if list_exists {2476			collection.consume_sload()?;2477			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2478			let item_contains = list.contains(&item_index.clone());24792480			if item_contains {2481				list.retain(|&item| item != item_index);2482				collection.consume_sstore()?;2483				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2484			}2485		}24862487		Ok(())2488	}24892490	fn move_token_index(2491		collection: &CollectionHandle<T>,2492		item_index: TokenId,2493		old_owner: &T::CrossAccountId,2494		new_owner: &T::CrossAccountId,2495	) -> DispatchResult {2496		Self::remove_token_index(collection, item_index, old_owner)?;2497		Self::add_token_index(collection, item_index, new_owner)?;24982499		Ok(())2500	}2501}25022503sp_api::decl_runtime_apis! {2504	pub trait NftApi {2505		/// Used for ethereum integration2506		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2507	}2508}