git.delta.rocks / unique-network / refs/commits / 390a1544bccf

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, item_owner: T::CrossAccountId, 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, &item_owner, 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		};13491350		Self::deposit_event(RawEvent::Transfer(1351			target_collection.id,1352			item_id,1353			sender.clone(),1354			recipient.clone(),1355			value,1356		));13571358		Ok(())1359	}13601361	pub fn approve_internal(1362		sender: &T::CrossAccountId,1363		spender: &T::CrossAccountId,1364		collection: &CollectionHandle<T>,1365		item_id: TokenId,1366		amount: u128,1367	) -> DispatchResult {1368		Self::token_exists(collection, item_id)?;13691370		// Transfer permissions check1371		let bypasses_limits = collection.limits.owner_can_transfer1372			&& Self::is_owner_or_admin_permissions(collection, sender)?;13731374		let allowance_limit = if bypasses_limits {1375			None1376		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1377			Some(amount)1378		} else {1379			fail!(Error::<T>::NoPermission);1380		};13811382		if collection.access == AccessMode::WhiteList {1383			Self::check_white_list(collection, sender)?;1384			Self::check_white_list(collection, spender)?;1385		}13861387		collection.consume_sload()?;1388		let allowance: u128 = amount1389			.checked_add(<Allowances<T>>::get(1390				collection.id,1391				(item_id, sender.as_sub(), spender.as_sub()),1392			))1393			.ok_or(Error::<T>::NumOverflow)?;1394		if let Some(limit) = allowance_limit {1395			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1396		}1397		collection.consume_sstore()?;1398		<Allowances<T>>::insert(1399			collection.id,1400			(item_id, sender.as_sub(), spender.as_sub()),1401			allowance,1402		);14031404		if matches!(collection.mode, CollectionMode::NFT) {1405			// TODO: NFT: only one owner may exist for token in ERC7211406			collection.log(ERC721Events::Approval {1407				owner: *sender.as_eth(),1408				approved: *spender.as_eth(),1409				token_id: item_id.into(),1410			})?;1411		}14121413		if matches!(collection.mode, CollectionMode::Fungible(_)) {1414			// TODO: NFT: only one owner may exist for token in ERC201415			collection.log(ERC20Events::Approval {1416				owner: *sender.as_eth(),1417				spender: *spender.as_eth(),1418				value: allowance.into(),1419			})?;1420		}14211422		Self::deposit_event(RawEvent::Approved(1423			collection.id,1424			item_id,1425			sender.clone(),1426			spender.clone(),1427			allowance,1428		));1429		Ok(())1430	}14311432	pub fn transfer_from_internal(1433		sender: &T::CrossAccountId,1434		from: &T::CrossAccountId,1435		recipient: &T::CrossAccountId,1436		collection: &CollectionHandle<T>,1437		item_id: TokenId,1438		amount: u128,1439	) -> DispatchResult {1440		if sender == from {1441			// Transfer by `from`, because it is either equal to sender, or derived from him1442			return Self::transfer_internal(from, recipient, collection, item_id, amount);1443		}14441445		// Check approval1446		collection.consume_sload()?;1447		let approval: u128 =1448			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14491450		// Limits check1451		Self::is_correct_transfer(collection, recipient)?;14521453		// Transfer permissions check1454		ensure!(1455			approval >= amount1456				|| (collection.limits.owner_can_transfer1457					&& Self::is_owner_or_admin_permissions(collection, sender)?),1458			Error::<T>::NoPermission1459		);14601461		if collection.access == AccessMode::WhiteList {1462			Self::check_white_list(collection, sender)?;1463			Self::check_white_list(collection, recipient)?;1464		}14651466		// Reduce approval by transferred amount or remove if remaining approval drops to 01467		let allowance = approval.saturating_sub(amount);1468		collection.consume_sstore()?;1469		if allowance > 0 {1470			<Allowances<T>>::insert(1471				collection.id,1472				(item_id, from.as_sub(), sender.as_sub()),1473				allowance,1474			);1475		} else {1476			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1477		}14781479		match collection.mode {1480			CollectionMode::NFT => {1481				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1482			}1483			CollectionMode::Fungible(_) => {1484				Self::transfer_fungible(collection, amount, from, recipient)?1485			}1486			CollectionMode::ReFungible => Self::transfer_refungible(1487				collection,1488				item_id,1489				amount,1490				from.clone(),1491				recipient.clone(),1492			)?,1493		};14941495		if matches!(collection.mode, CollectionMode::Fungible(_)) {1496			collection.log(ERC20Events::Approval {1497				owner: *from.as_eth(),1498				spender: *sender.as_eth(),1499				value: allowance.into(),1500			})?;1501		}15021503		Ok(())1504	}15051506	pub fn set_variable_meta_data_internal(1507		sender: &T::CrossAccountId,1508		collection: &CollectionHandle<T>,1509		item_id: TokenId,1510		data: Vec<u8>,1511	) -> DispatchResult {1512		Self::token_exists(collection, item_id)?;15131514		ensure!(1515			CUSTOM_DATA_LIMIT >= data.len() as u32,1516			Error::<T>::TokenVariableDataLimitExceeded1517		);15181519		ensure!(1520			(Self::is_item_owner(sender, collection, item_id)?1521				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1522				|| (Self::is_owner_or_admin_permissions(collection, sender)?1523					&& collection.meta_update_permission == MetaUpdatePermission::Admin),1524			Error::<T>::NoPermission1525		);15261527		match collection.mode {1528			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1529			CollectionMode::ReFungible => {1530				Self::set_re_fungible_variable_data(collection, item_id, data)?1531			}1532			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1533		};15341535		Ok(())1536	}15371538	pub fn meta_update_check(1539		sender: &T::CrossAccountId,1540		collection: &CollectionHandle<T>,1541		item_id: TokenId,1542	) -> DispatchResult {1543		match collection.meta_update_permission {1544			MetaUpdatePermission::ItemOwner => ensure!(1545				Self::is_item_owner(sender, collection, item_id)?,1546				Error::<T>::NoPermission1547			),1548			MetaUpdatePermission::Admin => ensure!(1549				Self::is_owner_or_admin_permissions(collection, sender)?,1550				Error::<T>::NoPermission1551			),1552			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1553		}15541555		Ok(())1556	}15571558	pub fn get_variable_metadata(1559		collection: &CollectionHandle<T>,1560		item_id: TokenId,1561	) -> Result<Vec<u8>, DispatchError> {1562		Ok(match collection.mode {1563			CollectionMode::NFT => {1564				<NftItemList<T>>::get(collection.id, item_id)1565					.ok_or(Error::<T>::TokenNotFound)?1566					.variable_data1567			}1568			CollectionMode::ReFungible => {1569				<ReFungibleItemList<T>>::get(collection.id, item_id)1570					.ok_or(Error::<T>::TokenNotFound)?1571					.variable_data1572			}1573			_ => fail!(Error::<T>::UnexpectedCollectionType),1574		})1575	}15761577	pub fn create_multiple_items_internal(1578		sender: &T::CrossAccountId,1579		collection: &CollectionHandle<T>,1580		owner: &T::CrossAccountId,1581		items_data: Vec<CreateItemData>,1582	) -> DispatchResult {1583		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15841585		for data in &items_data {1586			Self::validate_create_item_args(collection, data)?;1587		}1588		for data in &items_data {1589			Self::create_item_no_validation(collection, owner, data.clone())?;1590		}15911592		Ok(())1593	}15941595	pub fn burn_item_internal(1596		sender: &T::CrossAccountId,1597		collection: &CollectionHandle<T>,1598		item_id: TokenId,1599		item_owner: &T::CrossAccountId,1600		value: u128,1601	) -> DispatchResult {1602		ensure!(1603			Self::is_item_owner(sender, collection, item_id)?1604				|| (collection.limits.owner_can_transfer1605					&& Self::is_owner_or_admin_permissions(collection, sender)?),1606			Error::<T>::NoPermission1607		);16081609		if collection.access == AccessMode::WhiteList {1610			Self::check_white_list(collection, sender)?;1611		}16121613		match collection.mode {1614			CollectionMode::NFT => match value {1615				1 => Self::burn_nft_item(collection, item_id)?,1616				0 => (),1617				_ => fail!(<Error<T>>::TokenValueTooLow),1618			},1619			CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, owner, value)?,1620			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, owner, value)?,1621			_ => (),1622		};16231624		Ok(())1625	}16261627	pub fn toggle_white_list_internal(1628		sender: &T::CrossAccountId,1629		collection: &CollectionHandle<T>,1630		address: &T::CrossAccountId,1631		whitelisted: bool,1632	) -> DispatchResult {1633		Self::check_owner_or_admin_permissions(collection, sender)?;16341635		if whitelisted {1636			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1637		} else {1638			<WhiteList<T>>::remove(collection.id, address.as_sub());1639		}16401641		Ok(())1642	}16431644	fn is_correct_transfer(1645		collection: &CollectionHandle<T>,1646		recipient: &T::CrossAccountId,1647	) -> DispatchResult {1648		let collection_id = collection.id;16491650		// check token limit and account token limit1651		collection.consume_sload()?;1652		let account_items: u32 =1653			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16541655		// zero limit means collection limit is disabled1656		// otherwise get lower value1657		let limit = if collection.limits.account_token_ownership_limit == 01658			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1659		{1660			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1661		} else {1662			collection.limits.account_token_ownership_limit1663		};16641665		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16661667		// preliminary transfer check1668		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16691670		Ok(())1671	}16721673	fn can_create_items_in_collection(1674		collection: &CollectionHandle<T>,1675		sender: &T::CrossAccountId,1676		owner: &T::CrossAccountId,1677		amount: u32,1678	) -> DispatchResult {1679		let collection_id = collection.id;16801681		// check token limit and account token limit1682		let total_items: u32 = ItemListIndex::get(collection_id)1683			.checked_add(amount)1684			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1685		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1686			as u32)1687			.checked_add(amount)1688			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;16891690		// zero limit means collection limit is disabled1691		// otherwise get lower value1692		let account_token_limit = if collection.limits.account_token_ownership_limit == 01693			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1694		{1695			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1696		} else {1697			collection.limits.account_token_ownership_limit1698		};16991700		ensure!(1701			collection.limits.token_limit >= total_items,1702			Error::<T>::CollectionTokenLimitExceeded1703		);1704		ensure!(1705			account_token_limit >= account_items,1706			Error::<T>::AccountTokenLimitExceeded1707		);17081709		if !Self::is_owner_or_admin_permissions(collection, sender)? {1710			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1711			Self::check_white_list(collection, owner)?;1712			Self::check_white_list(collection, sender)?;1713		}17141715		Ok(())1716	}17171718	fn validate_create_item_args(1719		target_collection: &CollectionHandle<T>,1720		data: &CreateItemData,1721	) -> DispatchResult {1722		match target_collection.mode {1723			CollectionMode::NFT => {1724				if !matches!(data, CreateItemData::NFT(_)) {1725					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1726				}1727			}1728			CollectionMode::Fungible(_) => {1729				if !matches!(data, CreateItemData::Fungible(_)) {1730					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1731				}1732			}1733			CollectionMode::ReFungible => {1734				if let CreateItemData::ReFungible(data) = data {1735					// Check refungibility limits1736					ensure!(1737						data.pieces <= MAX_REFUNGIBLE_PIECES,1738						Error::<T>::WrongRefungiblePieces1739					);1740					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1741				} else {1742					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1743				}1744			}1745		};17461747		Ok(())1748	}17491750	fn create_item_no_validation(1751		collection: &CollectionHandle<T>,1752		owner: &T::CrossAccountId,1753		data: CreateItemData,1754	) -> DispatchResult {1755		match data {1756			CreateItemData::NFT(data) => {1757				let item = NftItemType {1758					owner: owner.clone(),1759					const_data: data.const_data.into_inner(),1760					variable_data: data.variable_data.into_inner(),1761				};17621763				Self::add_nft_item(collection, item)?;1764			}1765			CreateItemData::Fungible(data) => {1766				Self::add_fungible_item(collection, owner, data.value)?;1767			}1768			CreateItemData::ReFungible(data) => {1769				let owner_list = vec![Ownership {1770					owner: owner.clone(),1771					fraction: data.pieces,1772				}];17731774				let item = ReFungibleItemType {1775					owner: owner_list,1776					const_data: data.const_data.into_inner(),1777					variable_data: data.variable_data.into_inner(),1778				};17791780				Self::add_refungible_item(collection, item)?;1781			}1782		};17831784		Ok(())1785	}17861787	fn add_fungible_item(1788		collection: &CollectionHandle<T>,1789		owner: &T::CrossAccountId,1790		value: u128,1791	) -> DispatchResult {1792		let collection_id = collection.id;17931794		// Does new owner already have an account?1795		collection.consume_sload()?;1796		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17971798		// Mint1799		let item = FungibleItemType {1800			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1801		};1802		collection.consume_sstore()?;1803		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18041805		// Update balance1806		collection.consume_sload()?;1807		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1808			.checked_add(value)1809			.ok_or(Error::<T>::NumOverflow)?;1810		collection.consume_sstore()?;1811		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18121813		collection.log(ERC20Events::Transfer {1814			from: H160::default(),1815			to: *owner.as_eth(),1816			value: value.into(),1817		})?;1818		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1819		Ok(())1820	}18211822	fn add_refungible_item(1823		collection: &CollectionHandle<T>,1824		item: ReFungibleItemType<T::CrossAccountId>,1825	) -> DispatchResult {1826		let collection_id = collection.id;18271828		let current_index = <ItemListIndex>::get(collection_id)1829			.checked_add(1)1830			.ok_or(Error::<T>::NumOverflow)?;1831		let itemcopy = item.clone();18321833		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1834		let item_owner = item.owner.first().expect("only one owner is defined");18351836		let value = item_owner.fraction;1837		let owner = item_owner.owner.clone();18381839		Self::add_token_index(collection, current_index, &owner)?;18401841		<ItemListIndex>::insert(collection_id, current_index);1842		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18431844		// Update balance1845		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1846			.checked_add(value)1847			.ok_or(Error::<T>::NumOverflow)?;1848		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18491850		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1851		Ok(())1852	}18531854	fn add_nft_item(1855		collection: &CollectionHandle<T>,1856		item: NftItemType<T::CrossAccountId>,1857	) -> DispatchResult {1858		let collection_id = collection.id;18591860		let current_index = <ItemListIndex>::get(collection_id)1861			.checked_add(1)1862			.ok_or(Error::<T>::NumOverflow)?;18631864		let item_owner = item.owner.clone();1865		Self::add_token_index(collection, current_index, &item.owner)?;18661867		<ItemListIndex>::insert(collection_id, current_index);1868		<NftItemList<T>>::insert(collection_id, current_index, item);18691870		// Update balance1871		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1872			.checked_add(1)1873			.ok_or(Error::<T>::NumOverflow)?;1874		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18751876		collection.log(ERC721Events::Transfer {1877			from: H160::default(),1878			to: *item_owner.as_eth(),1879			token_id: current_index.into(),1880		})?;1881		Self::deposit_event(RawEvent::ItemCreated(1882			collection_id,1883			current_index,1884			item_owner,1885		));1886		Ok(())1887	}18881889	fn burn_refungible_item(1890		collection: &CollectionHandle<T>,1891		item_id: TokenId,1892		owner: &T::CrossAccountId,1893		value: u128,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 mut rft_balance = token1900			.owner1901			.iter()1902			.find(|&i| i.owner == *owner)1903			.ok_or(Error::<T>::TokenNotFound)?1904			.clone();1905		Self::remove_token_index(collection, item_id, owner)?;19061907		// update balance1908		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1909			.checked_sub(value)1910			.ok_or(Error::<T>::NumOverflow)?;1911		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19121913		rft_balance.fraction = (rft_balance.fraction)1914			.checked_sub(value)1915			.ok_or(Error::<T>::NumOverflow)?;19161917		let index = token1918			.owner1919			.iter()1920			.position(|i| i.owner == *owner)1921			.expect("owned item is exists");1922		if rft_balance.fraction == 0 {1923			// Re-create owners list with sender removed1924			token.owner.remove(index);1925		} else {1926			token.owner[index] = rft_balance;1927		}19281929		let owner_count = token.owner.len();19301931		// Burn the token completely if this was the last (only) owner1932		if owner_count == 0 {1933			<ReFungibleItemList<T>>::remove(collection_id, item_id);1934			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1935		} else {1936			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1937		}19381939		Ok(())1940	}19411942	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1943		let collection_id = collection.id;19441945		let item =1946			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1947		Self::remove_token_index(collection, item_id, &item.owner)?;19481949		// update balance1950		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1951			.checked_sub(1)1952			.ok_or(Error::<T>::NumOverflow)?;1953		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1954		<NftItemList<T>>::remove(collection_id, item_id);1955		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);19561957		collection.log(ERC721Events::Transfer {1958			from: *item.owner.as_eth(),1959			to: H160::default(),1960			token_id: item_id.into(),1961		})?;1962		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1963		Ok(())1964	}19651966	fn burn_fungible_item(1967		collection: &CollectionHandle<T>,1968		owner: &T::CrossAccountId,1969		value: u128,1970	) -> DispatchResult {1971		let collection_id = collection.id;19721973		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1974		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19751976		// update balance1977		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1978			.checked_sub(value)1979			.ok_or(Error::<T>::NumOverflow)?;1980		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19811982		if balance.value - value > 0 {1983			balance.value -= value;1984			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1985		} else {1986			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1987		}19881989		collection.log(ERC20Events::Transfer {1990			from: *owner.as_eth(),1991			to: H160::default(),1992			value: value.into(),1993		})?;1994		Ok(())1995	}19961997	pub fn get_collection(1998		collection_id: CollectionId,1999	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2000		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)2001	}20022003	fn check_owner_permissions(2004		target_collection: &CollectionHandle<T>,2005		subject: &T::AccountId,2006	) -> DispatchResult {2007		ensure!(2008			*subject == target_collection.owner,2009			Error::<T>::NoPermission2010		);20112012		Ok(())2013	}20142015	fn is_owner_or_admin_permissions(2016		collection: &CollectionHandle<T>,2017		subject: &T::CrossAccountId,2018	) -> Result<bool, DispatchError> {2019		collection.consume_sload()?;2020		Ok(*subject.as_sub() == collection.owner2021			|| <AdminList<T>>::get(collection.id).contains(subject))2022	}20232024	fn check_owner_or_admin_permissions(2025		collection: &CollectionHandle<T>,2026		subject: &T::CrossAccountId,2027	) -> DispatchResult {2028		ensure!(2029			Self::is_owner_or_admin_permissions(collection, subject)?,2030			Error::<T>::NoPermission2031		);20322033		Ok(())2034	}20352036	fn owned_amount(2037		subject: &T::CrossAccountId,2038		collection: &CollectionHandle<T>,2039		item_id: TokenId,2040	) -> Result<Option<u128>, DispatchError> {2041		collection.consume_sload()?;2042		Ok(Self::owned_amount_unchecked(subject, collection, item_id))2043	}20442045	fn owned_amount_unchecked(2046		subject: &T::CrossAccountId,2047		target_collection: &CollectionHandle<T>,2048		item_id: TokenId,2049	) -> Option<u128> {2050		let collection_id = target_collection.id;20512052		match target_collection.mode {2053			CollectionMode::NFT => {2054				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2055			}2056			CollectionMode::Fungible(_) => {2057				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2058			}2059			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2060				.owner2061				.iter()2062				.find(|i| i.owner == *subject)2063				.map(|i| i.fraction),2064		}2065	}20662067	fn is_item_owner(2068		subject: &T::CrossAccountId,2069		target_collection: &CollectionHandle<T>,2070		item_id: TokenId,2071	) -> Result<bool, DispatchError> {2072		Ok(match target_collection.mode {2073			CollectionMode::Fungible(_) => true,2074			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2075		})2076	}20772078	fn check_white_list(2079		collection: &CollectionHandle<T>,2080		address: &T::CrossAccountId,2081	) -> DispatchResult {2082		collection.consume_sload()?;2083		ensure!(2084			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),2085			Error::<T>::AddresNotInWhiteList,2086		);2087		Ok(())2088	}20892090	/// Check if token exists. In case of Fungible, check if there is an entry for2091	/// the owner in fungible balances double map2092	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2093		let collection_id = target_collection.id;2094		let exists = match target_collection.mode {2095			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2096			CollectionMode::Fungible(_) => true,2097			CollectionMode::ReFungible => {2098				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2099			}2100		};21012102		ensure!(exists, Error::<T>::TokenNotFound);2103		Ok(())2104	}21052106	fn transfer_fungible(2107		collection: &CollectionHandle<T>,2108		value: u128,2109		owner: &T::CrossAccountId,2110		recipient: &T::CrossAccountId,2111	) -> DispatchResult {2112		let collection_id = collection.id;21132114		collection.consume_sload()?;2115		collection.consume_sload()?;2116		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2117		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21182119		recipient_balance.value = recipient_balance2120			.value2121			.checked_add(value)2122			.ok_or(Error::<T>::NumOverflow)?;2123		balance.value = balance2124			.value2125			.checked_sub(value)2126			.ok_or(Error::<T>::TokenValueTooLow)?;21272128		// update balanceOf2129		collection.consume_sstore()?;2130		collection.consume_sstore()?;2131		if balance.value != 0 {2132			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2133		} else {2134			<Balance<T>>::remove(collection_id, owner.as_sub());2135		}2136		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21372138		// Reduce or remove sender2139		collection.consume_sstore()?;2140		collection.consume_sstore()?;2141		if balance.value != 0 {2142			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2143		} else {2144			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2145		}2146		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21472148		collection.log(ERC20Events::Transfer {2149			from: *owner.as_eth(),2150			to: *recipient.as_eth(),2151			value: value.into(),2152		})?;2153		Self::deposit_event(RawEvent::Transfer(2154			collection.id,2155			1,2156			owner.clone(),2157			recipient.clone(),2158			value,2159		));21602161		Ok(())2162	}21632164	fn transfer_refungible(2165		collection: &CollectionHandle<T>,2166		item_id: TokenId,2167		value: u128,2168		owner: T::CrossAccountId,2169		new_owner: T::CrossAccountId,2170	) -> DispatchResult {2171		let collection_id = collection.id;2172		collection.consume_sload()?;2173		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2174			.ok_or(Error::<T>::TokenNotFound)?;21752176		let item = full_item2177			.owner2178			.iter()2179			.find(|i| i.owner == owner)2180			.ok_or(Error::<T>::TokenNotFound)?;2181		let amount = item.fraction;21822183		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21842185		collection.consume_sload()?;2186		// update balance2187		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2188			.checked_sub(value)2189			.ok_or(Error::<T>::NumOverflow)?;2190		collection.consume_sstore()?;2191		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21922193		collection.consume_sload()?;2194		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2195			.checked_add(value)2196			.ok_or(Error::<T>::NumOverflow)?;2197		collection.consume_sstore()?;2198		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21992200		let old_owner = item.owner.clone();2201		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22022203		let mut new_full_item = full_item.clone();2204		// transfer2205		if amount == value && !new_owner_has_account {2206			// change owner2207			// new owner do not have account2208			new_full_item2209				.owner2210				.iter_mut()2211				.find(|i| i.owner == owner)2212				.expect("old owner does present in refungible")2213				.owner = new_owner.clone();2214			collection.consume_sstore()?;2215			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22162217			// update index collection2218			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2219		} else {2220			new_full_item2221				.owner2222				.iter_mut()2223				.find(|i| i.owner == owner)2224				.expect("old owner does present in refungible")2225				.fraction -= value;22262227			// separate amount2228			if new_owner_has_account {2229				// new owner has account2230				new_full_item2231					.owner2232					.iter_mut()2233					.find(|i| i.owner == new_owner)2234					.expect("new owner has account")2235					.fraction += value;2236			} else {2237				// new owner do not have account2238				new_full_item.owner.push(Ownership {2239					owner: new_owner.clone(),2240					fraction: value,2241				});2242				Self::add_token_index(collection, item_id, &new_owner)?;2243			}22442245			collection.consume_sstore()?;2246			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2247		}22482249		Self::deposit_event(RawEvent::Transfer(2250			collection.id,2251			item_id,2252			owner,2253			new_owner,2254			amount,2255		));22562257		Ok(())2258	}22592260	fn transfer_nft(2261		collection: &CollectionHandle<T>,2262		item_id: TokenId,2263		sender: T::CrossAccountId,2264		new_owner: T::CrossAccountId,2265	) -> DispatchResult {2266		let collection_id = collection.id;2267		collection.consume_sload()?;2268		let mut item =2269			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22702271		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22722273		collection.consume_sload()?;2274		// update balance2275		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2276			.checked_sub(1)2277			.ok_or(Error::<T>::NumOverflow)?;2278		collection.consume_sstore()?;2279		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22802281		collection.consume_sload()?;2282		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2283			.checked_add(1)2284			.ok_or(Error::<T>::NumOverflow)?;2285		collection.consume_sstore()?;2286		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22872288		// change owner2289		let old_owner = item.owner.clone();2290		item.owner = new_owner.clone();2291		collection.consume_sstore()?;2292		<NftItemList<T>>::insert(collection_id, item_id, item);22932294		// update index collection2295		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22962297		collection.log(ERC721Events::Transfer {2298			from: *sender.as_eth(),2299			to: *new_owner.as_eth(),2300			token_id: item_id.into(),2301		})?;2302		Self::deposit_event(RawEvent::Transfer(2303			collection.id,2304			item_id,2305			sender,2306			new_owner,2307			1,2308		));23092310		Ok(())2311	}23122313	fn set_re_fungible_variable_data(2314		collection: &CollectionHandle<T>,2315		item_id: TokenId,2316		data: Vec<u8>,2317	) -> DispatchResult {2318		let collection_id = collection.id;2319		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2320			.ok_or(Error::<T>::TokenNotFound)?;23212322		item.variable_data = data;23232324		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);23252326		Ok(())2327	}23282329	fn set_nft_variable_data(2330		collection: &CollectionHandle<T>,2331		item_id: TokenId,2332		data: Vec<u8>,2333	) -> DispatchResult {2334		let collection_id = collection.id;2335		let mut item =2336			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23372338		item.variable_data = data;23392340		<NftItemList<T>>::insert(collection_id, item_id, item);23412342		Ok(())2343	}23442345	#[allow(dead_code)]2346	fn init_collection(item: &Collection<T>) {2347		// check params2348		assert!(2349			item.decimal_points <= MAX_DECIMAL_POINTS,2350			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2351		);2352		assert!(2353			item.name.len() <= 64,2354			"Collection name can not be longer than 63 char"2355		);2356		assert!(2357			item.name.len() <= 256,2358			"Collection description can not be longer than 255 char"2359		);2360		assert!(2361			item.token_prefix.len() <= 16,2362			"Token prefix can not be longer than 15 char"2363		);23642365		// Generate next collection ID2366		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23672368		CreatedCollectionCount::put(next_id);2369	}23702371	#[allow(dead_code)]2372	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2373		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23742375		Self::add_token_index(2376			&CollectionHandle::get(collection_id).unwrap(),2377			current_index,2378			&item.owner,2379		)2380		.unwrap();23812382		<ItemListIndex>::insert(collection_id, current_index);23832384		// Update balance2385		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2386			.checked_add(1)2387			.unwrap();2388		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2389	}23902391	#[allow(dead_code)]2392	fn init_fungible_token(2393		collection_id: CollectionId,2394		owner: &T::CrossAccountId,2395		item: &FungibleItemType,2396	) {2397		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23982399		Self::add_token_index(2400			&CollectionHandle::get(collection_id).unwrap(),2401			current_index,2402			owner,2403		)2404		.unwrap();24052406		<ItemListIndex>::insert(collection_id, current_index);24072408		// Update balance2409		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2410			.checked_add(item.value)2411			.unwrap();2412		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2413	}24142415	#[allow(dead_code)]2416	fn init_refungible_token(2417		collection_id: CollectionId,2418		item: &ReFungibleItemType<T::CrossAccountId>,2419	) {2420		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24212422		let value = item.owner.first().unwrap().fraction;2423		let owner = item.owner.first().unwrap().owner.clone();24242425		Self::add_token_index(2426			&CollectionHandle::get(collection_id).unwrap(),2427			current_index,2428			&owner,2429		)2430		.unwrap();24312432		<ItemListIndex>::insert(collection_id, current_index);24332434		// Update balance2435		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2436			.checked_add(value)2437			.unwrap();2438		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2439	}24402441	fn add_token_index(2442		collection: &CollectionHandle<T>,2443		item_index: TokenId,2444		owner: &T::CrossAccountId,2445	) -> DispatchResult {2446		collection.consume_sload()?;2447		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2448		if list_exists {2449			collection.consume_sload()?;2450			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24512452			// bound Owned tokens by a single address in collection2453			let account_items: u32 = list.len() as u32;2454			ensure!(2455				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2456				Error::<T>::AddressOwnershipLimitExceeded2457			);24582459			let item_contains = list.contains(&item_index.clone());24602461			if !item_contains {2462				list.push(item_index);2463			}24642465			collection.consume_sstore()?;2466			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2467		} else {2468			let itm = vec![item_index];2469			collection.consume_sstore()?;2470			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2471		}24722473		Ok(())2474	}24752476	fn remove_token_index(2477		collection: &CollectionHandle<T>,2478		item_index: TokenId,2479		owner: &T::CrossAccountId,2480	) -> DispatchResult {2481		collection.consume_sload()?;2482		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2483		if list_exists {2484			collection.consume_sload()?;2485			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2486			let item_contains = list.contains(&item_index.clone());24872488			if item_contains {2489				list.retain(|&item| item != item_index);2490				collection.consume_sstore()?;2491				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2492			}2493		}24942495		Ok(())2496	}24972498	fn move_token_index(2499		collection: &CollectionHandle<T>,2500		item_index: TokenId,2501		old_owner: &T::CrossAccountId,2502		new_owner: &T::CrossAccountId,2503	) -> DispatchResult {2504		Self::remove_token_index(collection, item_index, old_owner)?;2505		Self::add_token_index(collection, item_index, new_owner)?;25062507		Ok(())2508	}2509}25102511sp_api::decl_runtime_apis! {2512	pub trait NftApi {2513		/// Used for ethereum integration2514		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2515	}2516}