git.delta.rocks / unique-network / refs/commits / 8e4698bc6eb3

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, AccessMode, Collection, CreateItemData, CollectionLimits, CollectionId,44	CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,45	FungibleItemType, ReFungibleItemType,46};4748#[cfg(test)]49mod mock;5051#[cfg(test)]52mod tests;5354mod default_weights;55mod 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;6667pub trait WeightInfo {68	fn create_collection() -> Weight;69	fn destroy_collection() -> Weight;70	fn add_to_white_list() -> Weight;71	fn remove_from_white_list() -> Weight;72	fn set_public_access_mode() -> Weight;73	fn set_mint_permission() -> Weight;74	fn change_collection_owner() -> Weight;75	fn add_collection_admin() -> Weight;76	fn remove_collection_admin() -> Weight;77	fn set_collection_sponsor() -> Weight;78	fn confirm_sponsorship() -> Weight;79	fn remove_collection_sponsor() -> Weight;80	fn create_item(s: usize) -> Weight;81	fn burn_item() -> Weight;82	fn transfer() -> Weight;83	fn approve() -> Weight;84	fn transfer_from() -> Weight;85	fn set_offchain_schema() -> Weight;86	fn set_const_on_chain_schema() -> Weight;87	fn set_variable_on_chain_schema() -> Weight;88	fn set_variable_meta_data() -> Weight;89	fn enable_contract_sponsoring() -> Weight;90	fn set_schema_version() -> Weight;91	fn set_contract_sponsoring_rate_limit() -> Weight;92	fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;93	fn toggle_contract_white_list() -> Weight;94	fn add_to_contract_white_list() -> Weight;95	fn remove_from_contract_white_list() -> Weight;96	fn set_collection_limits() -> Weight;97}9899decl_error! {100	/// Error for non-fungible-token module.101	pub enum Error for Module<T: Config> {102		/// Total collections bound exceeded.103		TotalCollectionsLimitExceeded,104		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.105		CollectionDecimalPointLimitExceeded,106		/// Collection name can not be longer than 63 char.107		CollectionNameLimitExceeded,108		/// Collection description can not be longer than 255 char.109		CollectionDescriptionLimitExceeded,110		/// Token prefix can not be longer than 15 char.111		CollectionTokenPrefixLimitExceeded,112		/// This collection does not exist.113		CollectionNotFound,114		/// Item not exists.115		TokenNotFound,116		/// Admin not found117		AdminNotFound,118		/// Arithmetic calculation overflow.119		NumOverflow,120		/// Account already has admin role.121		AlreadyAdmin,122		/// You do not own this collection.123		NoPermission,124		/// This address is not set as sponsor, use setCollectionSponsor first.125		ConfirmUnsetSponsorFail,126		/// Collection is not in mint mode.127		PublicMintingNotAllowed,128		/// Sender parameter and item owner must be equal.129		MustBeTokenOwner,130		/// Item balance not enough.131		TokenValueTooLow,132		/// Size of item is too large.133		NftSizeLimitExceeded,134		/// No approve found135		ApproveNotFound,136		/// Requested value more than approved.137		TokenValueNotEnough,138		/// Only approved addresses can call this method.139		ApproveRequired,140		/// Address is not in white list.141		AddresNotInWhiteList,142		/// Number of collection admins bound exceeded.143		CollectionAdminsLimitExceeded,144		/// Owned tokens by a single address bound exceeded.145		AddressOwnershipLimitExceeded,146		/// Length of items properties must be greater than 0.147		EmptyArgument,148		/// const_data exceeded data limit.149		TokenConstDataLimitExceeded,150		/// variable_data exceeded data limit.151		TokenVariableDataLimitExceeded,152		/// Not NFT item data used to mint in NFT collection.153		NotNftDataUsedToMintNftCollectionToken,154		/// Not Fungible item data used to mint in Fungible collection.155		NotFungibleDataUsedToMintFungibleCollectionToken,156		/// Not Re Fungible item data used to mint in Re Fungible collection.157		NotReFungibleDataUsedToMintReFungibleCollectionToken,158		/// Unexpected collection type.159		UnexpectedCollectionType,160		/// Can't store metadata in fungible tokens.161		CantStoreMetadataInFungibleTokens,162		/// Collection token limit exceeded163		CollectionTokenLimitExceeded,164		/// Account token limit exceeded per collection165		AccountTokenLimitExceeded,166		/// Collection limit bounds per collection exceeded167		CollectionLimitBoundsExceeded,168		/// Tried to enable permissions which are only permitted to be disabled169		OwnerPermissionsCantBeReverted,170		/// Schema data size limit bound exceeded171		SchemaDataLimitExceeded,172		/// Maximum refungibility exceeded173		WrongRefungiblePieces,174		/// createRefungible should be called with one owner175		BadCreateRefungibleCall,176		/// Gas limit exceeded177		OutOfGas,178		/// Collection settings not allowing items transferring179		TransferNotAllowed,180		/// Can't transfer tokens to ethereum zero address181		AddressIsZero,182	}183}184185#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]186pub struct CollectionHandle<T: Config> {187	pub id: CollectionId,188	collection: Collection<T>,189	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,190}191impl<T: Config> CollectionHandle<T> {192	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {193		<CollectionById<T>>::get(id).map(|collection| Self {194			id,195			collection,196			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(197				eth::collection_id_to_address(id),198				gas_limit,199			),200		})201	}202	pub fn get(id: CollectionId) -> Option<Self> {203		Self::get_with_gas_limit(id, u64::MAX)204	}205	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {206		self.recorder.log_sub(log)207	}208	#[allow(dead_code)]209	fn consume_gas(&self, gas: u64) -> DispatchResult {210		self.recorder.consume_gas_sub(gas)211	}212	fn consume_sload(&self) -> DispatchResult {213		self.recorder.consume_sload_sub()214	}215	fn consume_sstore(&self) -> DispatchResult {216		self.recorder.consume_sstore_sub()217	}218	pub fn submit_logs(self) -> DispatchResult {219		self.recorder.submit_logs()220	}221	pub fn save(self) -> DispatchResult {222		self.recorder.submit_logs()?;223		<CollectionById<T>>::insert(self.id, self.collection);224		Ok(())225	}226}227impl<T: Config> Deref for CollectionHandle<T> {228	type Target = Collection<T>;229230	fn deref(&self) -> &Self::Target {231		&self.collection232	}233}234235impl<T: Config> DerefMut for CollectionHandle<T> {236	fn deref_mut(&mut self) -> &mut Self::Target {237		&mut self.collection238	}239}240241pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {242	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;243244	/// Weight information for extrinsics in this pallet.245	type WeightInfo: WeightInfo;246247	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;248	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;249250	type CrossAccountId: CrossAccountId<Self::AccountId>;251	type Currency: Currency<Self::AccountId>;252	type CollectionCreationPrice: Get<253		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,254	>;255	type TreasuryAccountId: Get<Self::AccountId>;256}257258// # Used definitions259//260// ## User control levels261//262// chain-controlled - key is uncontrolled by user263//                    i.e autoincrementing index264//                    can use non-cryptographic hash265// real - key is controlled by user266//        but it is hard to generate enough colliding values, i.e owner of signed txs267//        can use non-cryptographic hash268// controlled - key is completly controlled by users269//              i.e maps with mutable keys270//              should use cryptographic hash271//272// ## User control level downgrade reasons273//274// ?1 - chain-controlled -> controlled275//      collections/tokens can be destroyed, resulting in massive holes276// ?2 - chain-controlled -> controlled277//      same as ?1, but can be only added, resulting in easier exploitation278// ?3 - real -> controlled279//      no confirmation required, so addresses can be easily generated280decl_storage! {281	trait Store for Module<T: Config> as Nft {282283		//#region Private members284		/// Id of next collection285		CreatedCollectionCount: u32;286		/// Used for migrations287		ChainVersion: u64;288		/// Id of last collection token289		/// Collection id (controlled?1)290		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;291		//#endregion292293		//#region Bound counters294		/// Amount of collections destroyed, used for total amount tracking with295		/// CreatedCollectionCount296		DestroyedCollectionCount: u32;297		/// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)298		/// Account id (real)299		pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;300		//#endregion301302		//#region Basic collections303		/// Collection info304		/// Collection id (controlled?1)305		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;306		/// List of collection admins307		/// Collection id (controlled?2)308		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;309		/// Whitelisted collection users310		/// Collection id (controlled?2), user id (controlled?3)311		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;312		//#endregion313314		/// How many of collection items user have315		/// Collection id (controlled?2), account id (real)316		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;317318		/// Amount of items which spender can transfer out of owners account (via transferFrom)319		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))320		/// TODO: Off chain worker should remove from this map when token gets removed321		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;322323		//#region Item collections324		/// Collection id (controlled?2), token id (controlled?1)325		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;326		/// Collection id (controlled?2), owner (controlled?2)327		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;328		/// Collection id (controlled?2), token id (controlled?1)329		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;330		//#endregion331332		//#region Index list333		/// Collection id (controlled?2), tokens owner (controlled?2)334		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;335		//#endregion336337		//#region Tokens transfer rate limit baskets338		/// (Collection id (controlled?2), who created (real))339		/// TODO: Off chain worker should remove from this map when collection gets removed340		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;341		/// Collection id (controlled?2), token id (controlled?2)342		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;343		/// Collection id (controlled?2), owning user (real)344		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;345		/// Collection id (controlled?2), token id (controlled?2)346		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;347		//#endregion348349		/// Variable metadata sponsoring350		/// Collection id (controlled?2), token id (controlled?2)351		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;352	}353	add_extra_genesis {354		build(|config: &GenesisConfig<T>| {355			// Modification of storage356			for (_num, _c) in &config.collection_id {357				<Module<T>>::init_collection(_c);358			}359360			for (_num, _c, _i) in &config.nft_item_id {361				<Module<T>>::init_nft_token(*_c, _i);362			}363364			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {365				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);366			}367368			for (_num, _c, _i) in &config.refungible_item_id {369				<Module<T>>::init_refungible_token(*_c, _i);370			}371		})372	}373}374375decl_event!(376	pub enum Event<T>377	where378		AccountId = <T as frame_system::Config>::AccountId,379		CrossAccountId = <T as Config>::CrossAccountId,380	{381		/// New collection was created382		///383		/// # Arguments384		///385		/// * collection_id: Globally unique identifier of newly created collection.386		///387		/// * mode: [CollectionMode] converted into u8.388		///389		/// * account_id: Collection owner.390		CollectionCreated(CollectionId, u8, AccountId),391392		/// New item was created.393		///394		/// # Arguments395		///396		/// * collection_id: Id of the collection where item was created.397		///398		/// * item_id: Id of an item. Unique within the collection.399		///400		/// * recipient: Owner of newly created item401		ItemCreated(CollectionId, TokenId, CrossAccountId),402403		/// Collection item was burned.404		///405		/// # Arguments406		///407		/// collection_id.408		///409		/// item_id: Identifier of burned NFT.410		ItemDestroyed(CollectionId, TokenId),411412		/// Item was transferred413		///414		/// * collection_id: Id of collection to which item is belong415		///416		/// * item_id: Id of an item417		///418		/// * sender: Original owner of item419		///420		/// * recipient: New owner of item421		///422		/// * amount: Always 1 for NFT423		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),424425		/// * collection_id426		///427		/// * item_id428		///429		/// * sender430		///431		/// * spender432		///433		/// * amount434		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),435	}436);437438decl_module! {439	pub struct Module<T: Config> for enum Call440	where441		origin: T::Origin442	{443		fn deposit_event() = default;444		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;445		type Error = Error<T>;446447		fn on_initialize(_now: T::BlockNumber) -> Weight {448			0449		}450451		/// 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.452		///453		/// # Permissions454		///455		/// * Anyone.456		///457		/// # Arguments458		///459		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.460		///461		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.462		///463		/// * token_prefix: UTF-8 string with token prefix.464		///465		/// * mode: [CollectionMode] collection type and type dependent data.466		// returns collection ID467		#[weight = <T as Config>::WeightInfo::create_collection()]468		#[transactional]469		pub fn create_collection(origin,470								 collection_name: Vec<u16>,471								 collection_description: Vec<u16>,472								 token_prefix: Vec<u8>,473								 mode: CollectionMode) -> DispatchResult {474475			// Anyone can create a collection476			let who = ensure_signed(origin)?;477478			// Take a (non-refundable) deposit of collection creation479			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();480			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(481				&T::TreasuryAccountId::get(),482				T::CollectionCreationPrice::get(),483			));484			<T as Config>::Currency::settle(485				&who,486				imbalance,487				WithdrawReasons::TRANSFER,488				ExistenceRequirement::KeepAlive,489			).map_err(|_| Error::<T>::NoPermission)?;490491			let decimal_points = match mode {492				CollectionMode::Fungible(points) => points,493				_ => 0494			};495496			let created_count = CreatedCollectionCount::get();497			let destroyed_count = DestroyedCollectionCount::get();498499			// bound Total number of collections500			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);501502			// check params503			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);504			ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);505			ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);506			ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);507508			// Generate next collection ID509			let next_id = created_count510				.checked_add(1)511				.ok_or(Error::<T>::NumOverflow)?;512513			CreatedCollectionCount::put(next_id);514515			let limits = CollectionLimits {516				sponsored_data_size: CUSTOM_DATA_LIMIT,517				..Default::default()518			};519520			// Create new collection521			let new_collection = Collection {522				owner: who.clone(),523				name: collection_name,524				mode: mode.clone(),525				mint_mode: false,526				access: AccessMode::Normal,527				description: collection_description,528				decimal_points,529				token_prefix,530				offchain_schema: Vec::new(),531				schema_version: SchemaVersion::ImageURL,532				sponsorship: SponsorshipState::Disabled,533				variable_on_chain_schema: Vec::new(),534				const_on_chain_schema: Vec::new(),535				limits,536				transfers_enabled: true,537			};538539			// Add new collection to map540			<CollectionById<T>>::insert(next_id, new_collection);541542			// call event543			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));544545			Ok(())546		}547548		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.549		///550		/// # Permissions551		///552		/// * Collection Owner.553		///554		/// # Arguments555		///556		/// * collection_id: collection to destroy.557		#[weight = <T as Config>::WeightInfo::destroy_collection()]558		#[transactional]559		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {560561			let sender = ensure_signed(origin)?;562			let collection = Self::get_collection(collection_id)?;563			Self::check_owner_permissions(&collection, &sender)?;564			if !collection.limits.owner_can_destroy {565				fail!(Error::<T>::NoPermission);566			}567568			<AddressTokens<T>>::remove_prefix(collection_id, None);569			<Allowances<T>>::remove_prefix(collection_id, None);570			<Balance<T>>::remove_prefix(collection_id, None);571			<ItemListIndex>::remove(collection_id);572			<AdminList<T>>::remove(collection_id);573			<CollectionById<T>>::remove(collection_id);574			<WhiteList<T>>::remove_prefix(collection_id, None);575576			<NftItemList<T>>::remove_prefix(collection_id, None);577			<FungibleItemList<T>>::remove_prefix(collection_id, None);578			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);579580			<NftTransferBasket<T>>::remove_prefix(collection_id, None);581			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);582			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);583584			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);585586			DestroyedCollectionCount::put(DestroyedCollectionCount::get()587				.checked_add(1)588				.ok_or(Error::<T>::NumOverflow)?);589590			Ok(())591		}592593		/// Add an address to white list.594		///595		/// # Permissions596		///597		/// * Collection Owner598		/// * Collection Admin599		///600		/// # Arguments601		///602		/// * collection_id.603		///604		/// * address.605		#[weight = <T as Config>::WeightInfo::add_to_white_list()]606		#[transactional]607		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{608609			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);610			let collection = Self::get_collection(collection_id)?;611612			Self::toggle_white_list_internal(613				&sender,614				&collection,615				&address,616				true,617			)?;618619			Ok(())620		}621622		/// Remove an address from white list.623		///624		/// # Permissions625		///626		/// * Collection Owner627		/// * Collection Admin628		///629		/// # Arguments630		///631		/// * collection_id.632		///633		/// * address.634		#[weight = <T as Config>::WeightInfo::remove_from_white_list()]635		#[transactional]636		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{637638			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);639			let collection = Self::get_collection(collection_id)?;640641			Self::toggle_white_list_internal(642				&sender,643				&collection,644				&address,645				false,646			)?;647648			Ok(())649		}650651		/// Toggle between normal and white list access for the methods with access for `Anyone`.652		///653		/// # Permissions654		///655		/// * Collection Owner.656		///657		/// # Arguments658		///659		/// * collection_id.660		///661		/// * mode: [AccessMode]662		#[weight = <T as Config>::WeightInfo::set_public_access_mode()]663		#[transactional]664		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult665		{666			let sender = ensure_signed(origin)?;667668			let mut target_collection = Self::get_collection(collection_id)?;669			Self::check_owner_permissions(&target_collection, &sender)?;670			target_collection.access = mode;671			target_collection.save()672		}673674		/// Allows Anyone to create tokens if:675		/// * White List is enabled, and676		/// * Address is added to white list, and677		/// * This method was called with True parameter678		///679		/// # Permissions680		/// * Collection Owner681		///682		/// # Arguments683		///684		/// * collection_id.685		///686		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.687		#[weight = <T as Config>::WeightInfo::set_mint_permission()]688		#[transactional]689		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult690		{691			let sender = ensure_signed(origin)?;692693			let mut target_collection = Self::get_collection(collection_id)?;694			Self::check_owner_permissions(&target_collection, &sender)?;695			target_collection.mint_mode = mint_permission;696			target_collection.save()697		}698699		/// Change the owner of the collection.700		///701		/// # Permissions702		///703		/// * Collection Owner.704		///705		/// # Arguments706		///707		/// * collection_id.708		///709		/// * new_owner.710		#[weight = <T as Config>::WeightInfo::change_collection_owner()]711		#[transactional]712		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {713714			let sender = ensure_signed(origin)?;715			let mut target_collection = Self::get_collection(collection_id)?;716			Self::check_owner_permissions(&target_collection, &sender)?;717			target_collection.owner = new_owner;718			target_collection.save()719		}720721		/// Adds an admin of the Collection.722		/// 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.723		///724		/// # Permissions725		///726		/// * Collection Owner.727		/// * Collection Admin.728		///729		/// # Arguments730		///731		/// * collection_id: ID of the Collection to add admin for.732		///733		/// * new_admin_id: Address of new admin to add.734		#[weight = <T as Config>::WeightInfo::add_collection_admin()]735		#[transactional]736		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {737			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);738			let collection = Self::get_collection(collection_id)?;739			Self::check_owner_or_admin_permissions(&collection, &sender)?;740			let mut admin_arr = <AdminList<T>>::get(collection_id);741742			match admin_arr.binary_search(&new_admin_id) {743				Ok(_) => {},744				Err(idx) => {745					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);746					admin_arr.insert(idx, new_admin_id);747					<AdminList<T>>::insert(collection_id, admin_arr);748				}749			}750			Ok(())751		}752753		/// 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.754		///755		/// # Permissions756		///757		/// * Collection Owner.758		/// * Collection Admin.759		///760		/// # Arguments761		///762		/// * collection_id: ID of the Collection to remove admin for.763		///764		/// * account_id: Address of admin to remove.765		#[weight = <T as Config>::WeightInfo::remove_collection_admin()]766		#[transactional]767		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {768			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);769			let collection = Self::get_collection(collection_id)?;770			Self::check_owner_or_admin_permissions(&collection, &sender)?;771			let mut admin_arr = <AdminList<T>>::get(collection_id);772773			if let Ok(idx) = admin_arr.binary_search(&account_id) {774				admin_arr.remove(idx);775				<AdminList<T>>::insert(collection_id, admin_arr);776			}777			Ok(())778		}779780		/// # Permissions781		///782		/// * Collection Owner783		///784		/// # Arguments785		///786		/// * collection_id.787		///788		/// * new_sponsor.789		#[weight = <T as Config>::WeightInfo::set_collection_sponsor()]790		#[transactional]791		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {792			let sender = ensure_signed(origin)?;793			let mut target_collection = Self::get_collection(collection_id)?;794			Self::check_owner_permissions(&target_collection, &sender)?;795796			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);797			target_collection.save()798		}799800		/// # Permissions801		///802		/// * Sponsor.803		///804		/// # Arguments805		///806		/// * collection_id.807		#[weight = <T as Config>::WeightInfo::confirm_sponsorship()]808		#[transactional]809		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {810			let sender = ensure_signed(origin)?;811812			let mut target_collection = Self::get_collection(collection_id)?;813			ensure!(814				target_collection.sponsorship.pending_sponsor() == Some(&sender),815				Error::<T>::ConfirmUnsetSponsorFail816			);817818			target_collection.sponsorship = SponsorshipState::Confirmed(sender);819			target_collection.save()820		}821822		/// Switch back to pay-per-own-transaction model.823		///824		/// # Permissions825		///826		/// * Collection owner.827		///828		/// # Arguments829		///830		/// * collection_id.831		#[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]832		#[transactional]833		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {834			let sender = ensure_signed(origin)?;835836			let mut target_collection = Self::get_collection(collection_id)?;837			Self::check_owner_permissions(&target_collection, &sender)?;838839			target_collection.sponsorship = SponsorshipState::Disabled;840			target_collection.save()841		}842843		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.844		///845		/// # Permissions846		///847		/// * Collection Owner.848		/// * Collection Admin.849		/// * Anyone if850		///     * White List is enabled, and851		///     * Address is added to white list, and852		///     * MintPermission is enabled (see SetMintPermission method)853		///854		/// # Arguments855		///856		/// * collection_id: ID of the collection.857		///858		/// * owner: Address, initial owner of the NFT.859		///860		/// * data: Token data to store on chain.861		// #[weight =862		// (130_000_000 as Weight)863		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))864		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))865		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]866867		#[weight = <T as Config>::WeightInfo::create_item(data.data_size())]868		#[transactional]869		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {870			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);871			let collection = Self::get_collection(collection_id)?;872873			Self::create_item_internal(&sender, &collection, &owner, data)?;874875			collection.submit_logs()876		}877878		/// This method creates multiple items in a collection created with CreateCollection method.879		///880		/// # Permissions881		///882		/// * Collection Owner.883		/// * Collection Admin.884		/// * Anyone if885		///     * White List is enabled, and886		///     * Address is added to white list, and887		///     * MintPermission is enabled (see SetMintPermission method)888		///889		/// # Arguments890		///891		/// * collection_id: ID of the collection.892		///893		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].894		///895		/// * owner: Address, initial owner of the NFT.896		#[weight = <T as Config>::WeightInfo::create_item(items_data.iter()897							   .map(|data| { data.data_size() })898							   .sum())]899		#[transactional]900		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {901902			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);903			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);904			let collection = Self::get_collection(collection_id)?;905906			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;907908			collection.submit_logs()909		}910911		// TODO! transaction weight912913		/// Set transfers_enabled value for particular collection914		///915		/// # Permissions916		///917		/// * Collection Owner.918		///919		/// # Arguments920		///921		/// * collection_id: ID of the collection.922		///923		/// * value: New flag value.924		#[weight = <T as Config>::WeightInfo::burn_item()]925		#[transactional]926		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {927928			let sender = ensure_signed(origin)?;929			let mut target_collection = Self::get_collection(collection_id)?;930931			Self::check_owner_permissions(&target_collection, &sender)?;932933			target_collection.transfers_enabled = value;934			target_collection.save()935		}936937		/// Destroys a concrete instance of NFT.938		///939		/// # Permissions940		///941		/// * Collection Owner.942		/// * Collection Admin.943		/// * Current NFT Owner.944		///945		/// # Arguments946		///947		/// * collection_id: ID of the collection.948		///949		/// * item_id: ID of NFT to burn.950		#[weight = <T as Config>::WeightInfo::burn_item()]951		#[transactional]952		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {953954			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);955			let target_collection = Self::get_collection(collection_id)?;956957			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;958959			target_collection.submit_logs()960		}961962		/// Change ownership of the token.963		///964		/// # Permissions965		///966		/// * Collection Owner967		/// * Collection Admin968		/// * Current NFT owner969		///970		/// # Arguments971		///972		/// * recipient: Address of token recipient.973		///974		/// * collection_id.975		///976		/// * item_id: ID of the item977		///     * Non-Fungible Mode: Required.978		///     * Fungible Mode: Ignored.979		///     * Re-Fungible Mode: Required.980		///981		/// * value: Amount to transfer.982		///     * Non-Fungible Mode: Ignored983		///     * Fungible Mode: Must specify transferred amount984		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)985		#[weight = <T as Config>::WeightInfo::transfer()]986		#[transactional]987		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {988			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);989			let collection = Self::get_collection(collection_id)?;990991			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;992993			collection.submit_logs()994		}995996		/// Set, change, or remove approved address to transfer the ownership of the NFT.997		///998		/// # Permissions999		///1000		/// * Collection Owner1001		/// * Collection Admin1002		/// * Current NFT owner1003		///1004		/// # Arguments1005		///1006		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1007		///1008		/// * collection_id.1009		///1010		/// * item_id: ID of the item.1011		#[weight = <T as Config>::WeightInfo::approve()]1012		#[transactional]1013		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1014			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1015			let collection = Self::get_collection(collection_id)?;10161017			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10181019			collection.submit_logs()1020		}10211022		/// 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.1023		///1024		/// # Permissions1025		/// * Collection Owner1026		/// * Collection Admin1027		/// * Current NFT owner1028		/// * Address approved by current NFT owner1029		///1030		/// # Arguments1031		///1032		/// * from: Address that owns token.1033		///1034		/// * recipient: Address of token recipient.1035		///1036		/// * collection_id.1037		///1038		/// * item_id: ID of the item.1039		///1040		/// * value: Amount to transfer.1041		#[weight = <T as Config>::WeightInfo::transfer_from()]1042		#[transactional]1043		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1044			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1045			let collection = Self::get_collection(collection_id)?;10461047			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10481049			collection.submit_logs()1050		}1051		// #[weight = 0]1052		//     // let no_perm_mes = "You do not have permissions to modify this collection";1053		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1054		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1055		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10561057		//     // // on_nft_received  call10581059		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10601061		//     Ok(())1062		// }10631064		/// Set off-chain data schema.1065		///1066		/// # Permissions1067		///1068		/// * Collection Owner1069		/// * Collection Admin1070		///1071		/// # Arguments1072		///1073		/// * collection_id.1074		///1075		/// * schema: String representing the offchain data schema.1076		#[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1077		#[transactional]1078		pub fn set_variable_meta_data (1079			origin,1080			collection_id: CollectionId,1081			item_id: TokenId,1082			data: Vec<u8>1083		) -> DispatchResult {1084			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10851086			let collection = Self::get_collection(collection_id)?;10871088			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10891090			Ok(())1091		}10921093		/// Set schema standard1094		/// ImageURL1095		/// Unique1096		///1097		/// # Permissions1098		///1099		/// * Collection Owner1100		/// * Collection Admin1101		///1102		/// # Arguments1103		///1104		/// * collection_id.1105		///1106		/// * schema: SchemaVersion: enum1107		#[weight = <T as Config>::WeightInfo::set_schema_version()]1108		#[transactional]1109		pub fn set_schema_version(1110			origin,1111			collection_id: CollectionId,1112			version: SchemaVersion1113		) -> DispatchResult {1114			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1115			let mut target_collection = Self::get_collection(collection_id)?;1116			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1117			target_collection.schema_version = version;1118			target_collection.save()1119		}11201121		/// Set off-chain data schema.1122		///1123		/// # Permissions1124		///1125		/// * Collection Owner1126		/// * Collection Admin1127		///1128		/// # Arguments1129		///1130		/// * collection_id.1131		///1132		/// * schema: String representing the offchain data schema.1133		#[weight = <T as Config>::WeightInfo::set_offchain_schema()]1134		#[transactional]1135		pub fn set_offchain_schema(1136			origin,1137			collection_id: CollectionId,1138			schema: Vec<u8>1139		) -> DispatchResult {1140			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1141			let mut target_collection = Self::get_collection(collection_id)?;1142			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11431144			// check schema limit1145			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11461147			target_collection.offchain_schema = schema;1148			target_collection.save()1149		}11501151		/// Set const on-chain data schema.1152		///1153		/// # Permissions1154		///1155		/// * Collection Owner1156		/// * Collection Admin1157		///1158		/// # Arguments1159		///1160		/// * collection_id.1161		///1162		/// * schema: String representing the const on-chain data schema.1163		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1164		#[transactional]1165		pub fn set_const_on_chain_schema (1166			origin,1167			collection_id: CollectionId,1168			schema: Vec<u8>1169		) -> DispatchResult {1170			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1171			let mut target_collection = Self::get_collection(collection_id)?;1172			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11731174			// check schema limit1175			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");11761177			target_collection.const_on_chain_schema = schema;1178			target_collection.save()1179		}11801181		/// Set variable on-chain data schema.1182		///1183		/// # Permissions1184		///1185		/// * Collection Owner1186		/// * Collection Admin1187		///1188		/// # Arguments1189		///1190		/// * collection_id.1191		///1192		/// * schema: String representing the variable on-chain data schema.1193		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1194		#[transactional]1195		pub fn set_variable_on_chain_schema (1196			origin,1197			collection_id: CollectionId,1198			schema: Vec<u8>1199		) -> DispatchResult {1200			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1201			let mut target_collection = Self::get_collection(collection_id)?;1202			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12031204			// check schema limit1205			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12061207			target_collection.variable_on_chain_schema = schema;1208			target_collection.save()1209		}12101211		#[weight = <T as Config>::WeightInfo::set_collection_limits()]1212		#[transactional]1213		pub fn set_collection_limits(1214			origin,1215			collection_id: u32,1216			new_limits: CollectionLimits<T::BlockNumber>,1217		) -> DispatchResult {1218			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1219			let mut target_collection = Self::get_collection(collection_id)?;1220			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1221			let old_limits = &target_collection.limits;12221223			// collection bounds1224			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1225				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1226				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1227				Error::<T>::CollectionLimitBoundsExceeded);12281229			// token_limit   check  prev1230			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1231			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12321233			ensure!(1234				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1235				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1236				Error::<T>::OwnerPermissionsCantBeReverted,1237			);12381239			target_collection.limits = new_limits;12401241			target_collection.save()1242		}1243	}1244}12451246impl<T: Config> Module<T> {1247	pub fn create_item_internal(1248		sender: &T::CrossAccountId,1249		collection: &CollectionHandle<T>,1250		owner: &T::CrossAccountId,1251		data: CreateItemData,1252	) -> DispatchResult {1253		ensure!(1254			owner != &T::CrossAccountId::from_eth(H160([0; 20])),1255			Error::<T>::AddressIsZero1256		);12571258		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1259		Self::validate_create_item_args(collection, &data)?;1260		Self::create_item_no_validation(collection, owner, data)?;12611262		Ok(())1263	}12641265	pub fn transfer_internal(1266		sender: &T::CrossAccountId,1267		recipient: &T::CrossAccountId,1268		target_collection: &CollectionHandle<T>,1269		item_id: TokenId,1270		value: u128,1271	) -> DispatchResult {1272		ensure!(1273			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1274			Error::<T>::AddressIsZero1275		);12761277		// Limits check1278		Self::is_correct_transfer(target_collection, recipient)?;12791280		// Transfer permissions check1281		ensure!(1282			Self::is_item_owner(sender, target_collection, item_id)?1283				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,1284			Error::<T>::NoPermission1285		);12861287		if target_collection.access == AccessMode::WhiteList {1288			Self::check_white_list(target_collection, sender)?;1289			Self::check_white_list(target_collection, recipient)?;1290		}12911292		match target_collection.mode {1293			CollectionMode::NFT => Self::transfer_nft(1294				target_collection,1295				item_id,1296				sender.clone(),1297				recipient.clone(),1298			)?,1299			CollectionMode::Fungible(_) => {1300				Self::transfer_fungible(target_collection, value, sender, recipient)?1301			}1302			CollectionMode::ReFungible => Self::transfer_refungible(1303				target_collection,1304				item_id,1305				value,1306				sender.clone(),1307				recipient.clone(),1308			)?,1309			_ => (),1310		};13111312		Self::deposit_event(RawEvent::Transfer(1313			target_collection.id,1314			item_id,1315			sender.clone(),1316			recipient.clone(),1317			value,1318		));13191320		Ok(())1321	}13221323	pub fn approve_internal(1324		sender: &T::CrossAccountId,1325		spender: &T::CrossAccountId,1326		collection: &CollectionHandle<T>,1327		item_id: TokenId,1328		amount: u128,1329	) -> DispatchResult {1330		Self::token_exists(collection, item_id)?;13311332		// Transfer permissions check1333		let bypasses_limits = collection.limits.owner_can_transfer1334			&& Self::is_owner_or_admin_permissions(collection, sender)?;13351336		let allowance_limit = if bypasses_limits {1337			None1338		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1339			Some(amount)1340		} else {1341			fail!(Error::<T>::NoPermission);1342		};13431344		if collection.access == AccessMode::WhiteList {1345			Self::check_white_list(collection, sender)?;1346			Self::check_white_list(collection, spender)?;1347		}13481349		collection.consume_sload()?;1350		let allowance: u128 = amount1351			.checked_add(<Allowances<T>>::get(1352				collection.id,1353				(item_id, sender.as_sub(), spender.as_sub()),1354			))1355			.ok_or(Error::<T>::NumOverflow)?;1356		if let Some(limit) = allowance_limit {1357			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1358		}1359		collection.consume_sstore()?;1360		<Allowances<T>>::insert(1361			collection.id,1362			(item_id, sender.as_sub(), spender.as_sub()),1363			allowance,1364		);13651366		if matches!(collection.mode, CollectionMode::NFT) {1367			// TODO: NFT: only one owner may exist for token in ERC7211368			collection.log(ERC721Events::Approval {1369				owner: *sender.as_eth(),1370				approved: *spender.as_eth(),1371				token_id: item_id.into(),1372			})?;1373		}13741375		if matches!(collection.mode, CollectionMode::Fungible(_)) {1376			// TODO: NFT: only one owner may exist for token in ERC201377			collection.log(ERC20Events::Approval {1378				owner: *sender.as_eth(),1379				spender: *spender.as_eth(),1380				value: allowance.into(),1381			})?;1382		}13831384		Self::deposit_event(RawEvent::Approved(1385			collection.id,1386			item_id,1387			sender.clone(),1388			spender.clone(),1389			allowance,1390		));1391		Ok(())1392	}13931394	pub fn transfer_from_internal(1395		sender: &T::CrossAccountId,1396		from: &T::CrossAccountId,1397		recipient: &T::CrossAccountId,1398		collection: &CollectionHandle<T>,1399		item_id: TokenId,1400		amount: u128,1401	) -> DispatchResult {1402		// Check approval1403		collection.consume_sload()?;1404		let approval: u128 =1405			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14061407		// Limits check1408		Self::is_correct_transfer(collection, recipient)?;14091410		// Transfer permissions check1411		ensure!(1412			approval >= amount1413				|| (collection.limits.owner_can_transfer1414					&& Self::is_owner_or_admin_permissions(collection, sender)?),1415			Error::<T>::NoPermission1416		);14171418		if collection.access == AccessMode::WhiteList {1419			Self::check_white_list(collection, sender)?;1420			Self::check_white_list(collection, recipient)?;1421		}14221423		// Reduce approval by transferred amount or remove if remaining approval drops to 01424		let allowance = approval.saturating_sub(amount);1425		collection.consume_sstore()?;1426		if allowance > 0 {1427			<Allowances<T>>::insert(1428				collection.id,1429				(item_id, from.as_sub(), sender.as_sub()),1430				allowance,1431			);1432		} else {1433			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1434		}14351436		match collection.mode {1437			CollectionMode::NFT => {1438				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1439			}1440			CollectionMode::Fungible(_) => {1441				Self::transfer_fungible(collection, amount, from, recipient)?1442			}1443			CollectionMode::ReFungible => Self::transfer_refungible(1444				collection,1445				item_id,1446				amount,1447				from.clone(),1448				recipient.clone(),1449			)?,1450			_ => (),1451		};14521453		if matches!(collection.mode, CollectionMode::Fungible(_)) {1454			collection.log(ERC20Events::Approval {1455				owner: *from.as_eth(),1456				spender: *sender.as_eth(),1457				value: allowance.into(),1458			})?;1459		}14601461		Ok(())1462	}14631464	pub fn set_variable_meta_data_internal(1465		sender: &T::CrossAccountId,1466		collection: &CollectionHandle<T>,1467		item_id: TokenId,1468		data: Vec<u8>,1469	) -> DispatchResult {1470		Self::token_exists(collection, item_id)?;14711472		ensure!(1473			CUSTOM_DATA_LIMIT >= data.len() as u32,1474			Error::<T>::TokenVariableDataLimitExceeded1475		);14761477		// Modify permissions check1478		ensure!(1479			Self::is_item_owner(sender, collection, item_id)?1480				|| Self::is_owner_or_admin_permissions(collection, sender)?,1481			Error::<T>::NoPermission1482		);14831484		match collection.mode {1485			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1486			CollectionMode::ReFungible => {1487				Self::set_re_fungible_variable_data(collection, item_id, data)?1488			}1489			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1490			_ => fail!(Error::<T>::UnexpectedCollectionType),1491		};14921493		Ok(())1494	}14951496	pub fn create_multiple_items_internal(1497		sender: &T::CrossAccountId,1498		collection: &CollectionHandle<T>,1499		owner: &T::CrossAccountId,1500		items_data: Vec<CreateItemData>,1501	) -> DispatchResult {1502		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15031504		for data in &items_data {1505			Self::validate_create_item_args(collection, data)?;1506		}1507		for data in &items_data {1508			Self::create_item_no_validation(collection, owner, data.clone())?;1509		}15101511		Ok(())1512	}15131514	pub fn burn_item_internal(1515		sender: &T::CrossAccountId,1516		collection: &CollectionHandle<T>,1517		item_id: TokenId,1518		value: u128,1519	) -> DispatchResult {1520		ensure!(1521			Self::is_item_owner(sender, collection, item_id)?1522				|| (collection.limits.owner_can_transfer1523					&& Self::is_owner_or_admin_permissions(collection, sender)?),1524			Error::<T>::NoPermission1525		);15261527		if collection.access == AccessMode::WhiteList {1528			Self::check_white_list(collection, sender)?;1529		}15301531		match collection.mode {1532			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1533			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1534			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1535			_ => (),1536		};15371538		Ok(())1539	}15401541	pub fn toggle_white_list_internal(1542		sender: &T::CrossAccountId,1543		collection: &CollectionHandle<T>,1544		address: &T::CrossAccountId,1545		whitelisted: bool,1546	) -> DispatchResult {1547		Self::check_owner_or_admin_permissions(collection, sender)?;15481549		if whitelisted {1550			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1551		} else {1552			<WhiteList<T>>::remove(collection.id, address.as_sub());1553		}15541555		Ok(())1556	}15571558	fn is_correct_transfer(1559		collection: &CollectionHandle<T>,1560		recipient: &T::CrossAccountId,1561	) -> DispatchResult {1562		let collection_id = collection.id;15631564		// check token limit and account token limit1565		collection.consume_sload()?;1566		let account_items: u32 =1567			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1568		ensure!(1569			collection.limits.account_token_ownership_limit > account_items,1570			Error::<T>::AccountTokenLimitExceeded1571		);15721573		// preliminary transfer check1574		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);15751576		Ok(())1577	}15781579	fn can_create_items_in_collection(1580		collection: &CollectionHandle<T>,1581		sender: &T::CrossAccountId,1582		owner: &T::CrossAccountId,1583		amount: u32,1584	) -> DispatchResult {1585		let collection_id = collection.id;15861587		// check token limit and account token limit1588		let total_items: u32 = ItemListIndex::get(collection_id)1589			.checked_add(amount)1590			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1591		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1592			as u32)1593			.checked_add(amount)1594			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1595		ensure!(1596			collection.limits.token_limit >= total_items,1597			Error::<T>::CollectionTokenLimitExceeded1598		);1599		ensure!(1600			collection.limits.account_token_ownership_limit >= account_items,1601			Error::<T>::AccountTokenLimitExceeded1602		);16031604		if !Self::is_owner_or_admin_permissions(collection, sender)? {1605			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1606			Self::check_white_list(collection, owner)?;1607			Self::check_white_list(collection, sender)?;1608		}16091610		Ok(())1611	}16121613	fn validate_create_item_args(1614		target_collection: &CollectionHandle<T>,1615		data: &CreateItemData,1616	) -> DispatchResult {1617		match target_collection.mode {1618			CollectionMode::NFT => {1619				if !matches!(data, CreateItemData::NFT(_)) {1620					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1621				}1622			}1623			CollectionMode::Fungible(_) => {1624				if !matches!(data, CreateItemData::Fungible(_)) {1625					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1626				}1627			}1628			CollectionMode::ReFungible => {1629				if let CreateItemData::ReFungible(data) = data {1630					// Check refungibility limits1631					ensure!(1632						data.pieces <= MAX_REFUNGIBLE_PIECES,1633						Error::<T>::WrongRefungiblePieces1634					);1635					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1636				} else {1637					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1638				}1639			}1640			_ => {1641				fail!(Error::<T>::UnexpectedCollectionType);1642			}1643		};16441645		Ok(())1646	}16471648	fn create_item_no_validation(1649		collection: &CollectionHandle<T>,1650		owner: &T::CrossAccountId,1651		data: CreateItemData,1652	) -> DispatchResult {1653		match data {1654			CreateItemData::NFT(data) => {1655				let item = NftItemType {1656					owner: owner.clone(),1657					const_data: data.const_data.into_inner(),1658					variable_data: data.variable_data.into_inner(),1659				};16601661				Self::add_nft_item(collection, item)?;1662			}1663			CreateItemData::Fungible(data) => {1664				Self::add_fungible_item(collection, owner, data.value)?;1665			}1666			CreateItemData::ReFungible(data) => {1667				let owner_list = vec![Ownership {1668					owner: owner.clone(),1669					fraction: data.pieces,1670				}];16711672				let item = ReFungibleItemType {1673					owner: owner_list,1674					const_data: data.const_data.into_inner(),1675					variable_data: data.variable_data.into_inner(),1676				};16771678				Self::add_refungible_item(collection, item)?;1679			}1680		};16811682		Ok(())1683	}16841685	fn add_fungible_item(1686		collection: &CollectionHandle<T>,1687		owner: &T::CrossAccountId,1688		value: u128,1689	) -> DispatchResult {1690		let collection_id = collection.id;16911692		// Does new owner already have an account?1693		collection.consume_sload()?;1694		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;16951696		// Mint1697		let item = FungibleItemType {1698			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1699		};1700		collection.consume_sstore()?;1701		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17021703		// Update balance1704		collection.consume_sload()?;1705		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1706			.checked_add(value)1707			.ok_or(Error::<T>::NumOverflow)?;1708		collection.consume_sstore()?;1709		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17101711		collection.log(ERC20Events::Transfer {1712			from: H160::default(),1713			to: *owner.as_eth(),1714			value: value.into(),1715		})?;1716		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1717		Ok(())1718	}17191720	fn add_refungible_item(1721		collection: &CollectionHandle<T>,1722		item: ReFungibleItemType<T::CrossAccountId>,1723	) -> DispatchResult {1724		let collection_id = collection.id;17251726		let current_index = <ItemListIndex>::get(collection_id)1727			.checked_add(1)1728			.ok_or(Error::<T>::NumOverflow)?;1729		let itemcopy = item.clone();17301731		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1732		let item_owner = item.owner.first().expect("only one owner is defined");17331734		let value = item_owner.fraction;1735		let owner = item_owner.owner.clone();17361737		Self::add_token_index(collection, current_index, &owner)?;17381739		<ItemListIndex>::insert(collection_id, current_index);1740		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17411742		// Update balance1743		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1744			.checked_add(value)1745			.ok_or(Error::<T>::NumOverflow)?;1746		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17471748		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1749		Ok(())1750	}17511752	fn add_nft_item(1753		collection: &CollectionHandle<T>,1754		item: NftItemType<T::CrossAccountId>,1755	) -> DispatchResult {1756		let collection_id = collection.id;17571758		let current_index = <ItemListIndex>::get(collection_id)1759			.checked_add(1)1760			.ok_or(Error::<T>::NumOverflow)?;17611762		let item_owner = item.owner.clone();1763		Self::add_token_index(collection, current_index, &item.owner)?;17641765		<ItemListIndex>::insert(collection_id, current_index);1766		<NftItemList<T>>::insert(collection_id, current_index, item);17671768		// Update balance1769		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1770			.checked_add(1)1771			.ok_or(Error::<T>::NumOverflow)?;1772		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17731774		collection.log(ERC721Events::Transfer {1775			from: H160::default(),1776			to: *item_owner.as_eth(),1777			token_id: current_index.into(),1778		})?;1779		Self::deposit_event(RawEvent::ItemCreated(1780			collection_id,1781			current_index,1782			item_owner,1783		));1784		Ok(())1785	}17861787	fn burn_refungible_item(1788		collection: &CollectionHandle<T>,1789		item_id: TokenId,1790		owner: &T::CrossAccountId,1791	) -> DispatchResult {1792		let collection_id = collection.id;17931794		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1795			.ok_or(Error::<T>::TokenNotFound)?;1796		let rft_balance = token1797			.owner1798			.iter()1799			.find(|&i| i.owner == *owner)1800			.ok_or(Error::<T>::TokenNotFound)?;1801		Self::remove_token_index(collection, item_id, owner)?;18021803		// update balance1804		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1805			.checked_sub(rft_balance.fraction)1806			.ok_or(Error::<T>::NumOverflow)?;1807		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18081809		// Re-create owners list with sender removed1810		let index = token1811			.owner1812			.iter()1813			.position(|i| i.owner == *owner)1814			.expect("owned item is exists");1815		token.owner.remove(index);1816		let owner_count = token.owner.len();18171818		// Burn the token completely if this was the last (only) owner1819		if owner_count == 0 {1820			<ReFungibleItemList<T>>::remove(collection_id, item_id);1821			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1822		} else {1823			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1824		}18251826		Ok(())1827	}18281829	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1830		let collection_id = collection.id;18311832		let item =1833			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1834		Self::remove_token_index(collection, item_id, &item.owner)?;18351836		// update balance1837		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1838			.checked_sub(1)1839			.ok_or(Error::<T>::NumOverflow)?;1840		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1841		<NftItemList<T>>::remove(collection_id, item_id);1842		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);18431844		collection.log(ERC721Events::Transfer {1845			from: *item.owner.as_eth(),1846			to: H160::default(),1847			token_id: item_id.into(),1848		})?;1849		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1850		Ok(())1851	}18521853	fn burn_fungible_item(1854		owner: &T::CrossAccountId,1855		collection: &CollectionHandle<T>,1856		value: u128,1857	) -> DispatchResult {1858		let collection_id = collection.id;18591860		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1861		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18621863		// update balance1864		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1865			.checked_sub(value)1866			.ok_or(Error::<T>::NumOverflow)?;1867		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18681869		if balance.value - value > 0 {1870			balance.value -= value;1871			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1872		} else {1873			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1874		}18751876		collection.log(ERC20Events::Transfer {1877			from: *owner.as_eth(),1878			to: H160::default(),1879			value: value.into(),1880		})?;1881		Ok(())1882	}18831884	pub fn get_collection(1885		collection_id: CollectionId,1886	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1887		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1888	}18891890	fn check_owner_permissions(1891		target_collection: &CollectionHandle<T>,1892		subject: &T::AccountId,1893	) -> DispatchResult {1894		ensure!(1895			*subject == target_collection.owner,1896			Error::<T>::NoPermission1897		);18981899		Ok(())1900	}19011902	fn is_owner_or_admin_permissions(1903		collection: &CollectionHandle<T>,1904		subject: &T::CrossAccountId,1905	) -> Result<bool, DispatchError> {1906		collection.consume_sload()?;1907		Ok(*subject.as_sub() == collection.owner1908			|| <AdminList<T>>::get(collection.id).contains(subject))1909	}19101911	fn check_owner_or_admin_permissions(1912		collection: &CollectionHandle<T>,1913		subject: &T::CrossAccountId,1914	) -> DispatchResult {1915		ensure!(1916			Self::is_owner_or_admin_permissions(collection, subject)?,1917			Error::<T>::NoPermission1918		);19191920		Ok(())1921	}19221923	fn owned_amount(1924		subject: &T::CrossAccountId,1925		collection: &CollectionHandle<T>,1926		item_id: TokenId,1927	) -> Result<Option<u128>, DispatchError> {1928		collection.consume_sload()?;1929		Ok(Self::owned_amount_unchecked(subject, collection, item_id))1930	}19311932	fn owned_amount_unchecked(1933		subject: &T::CrossAccountId,1934		target_collection: &CollectionHandle<T>,1935		item_id: TokenId,1936	) -> Option<u128> {1937		let collection_id = target_collection.id;19381939		match target_collection.mode {1940			CollectionMode::NFT => {1941				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1942			}1943			CollectionMode::Fungible(_) => {1944				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1945			}1946			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1947				.owner1948				.iter()1949				.find(|i| i.owner == *subject)1950				.map(|i| i.fraction),1951			CollectionMode::Invalid => None,1952		}1953	}19541955	fn is_item_owner(1956		subject: &T::CrossAccountId,1957		target_collection: &CollectionHandle<T>,1958		item_id: TokenId,1959	) -> Result<bool, DispatchError> {1960		Ok(match target_collection.mode {1961			CollectionMode::Fungible(_) => true,1962			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),1963		})1964	}19651966	fn check_white_list(1967		collection: &CollectionHandle<T>,1968		address: &T::CrossAccountId,1969	) -> DispatchResult {1970		collection.consume_sload()?;1971		ensure!(1972			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),1973			Error::<T>::AddresNotInWhiteList,1974		);1975		Ok(())1976	}19771978	/// Check if token exists. In case of Fungible, check if there is an entry for1979	/// the owner in fungible balances double map1980	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1981		let collection_id = target_collection.id;1982		let exists = match target_collection.mode {1983			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1984			CollectionMode::Fungible(_) => true,1985			CollectionMode::ReFungible => {1986				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)1987			}1988			_ => false,1989		};19901991		ensure!(exists, Error::<T>::TokenNotFound);1992		Ok(())1993	}19941995	fn transfer_fungible(1996		collection: &CollectionHandle<T>,1997		value: u128,1998		owner: &T::CrossAccountId,1999		recipient: &T::CrossAccountId,2000	) -> DispatchResult {2001		let collection_id = collection.id;20022003		collection.consume_sload()?;2004		collection.consume_sload()?;2005		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2006		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20072008		recipient_balance.value = recipient_balance2009			.value2010			.checked_add(value)2011			.ok_or(Error::<T>::NumOverflow)?;2012		balance.value = balance2013			.value2014			.checked_sub(value)2015			.ok_or(Error::<T>::TokenValueTooLow)?;20162017		// update balanceOf2018		collection.consume_sstore()?;2019		collection.consume_sstore()?;2020		if balance.value != 0 {2021			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2022		} else {2023			<Balance<T>>::remove(collection_id, owner.as_sub());2024		}2025		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20262027		// Reduce or remove sender2028		collection.consume_sstore()?;2029		collection.consume_sstore()?;2030		if balance.value != 0 {2031			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2032		} else {2033			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2034		}2035		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20362037		collection.log(ERC20Events::Transfer {2038			from: *owner.as_eth(),2039			to: *recipient.as_eth(),2040			value: value.into(),2041		})?;2042		Self::deposit_event(RawEvent::Transfer(2043			collection.id,2044			1,2045			owner.clone(),2046			recipient.clone(),2047			value,2048		));20492050		Ok(())2051	}20522053	fn transfer_refungible(2054		collection: &CollectionHandle<T>,2055		item_id: TokenId,2056		value: u128,2057		owner: T::CrossAccountId,2058		new_owner: T::CrossAccountId,2059	) -> DispatchResult {2060		let collection_id = collection.id;2061		collection.consume_sload()?;2062		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2063			.ok_or(Error::<T>::TokenNotFound)?;20642065		let item = full_item2066			.owner2067			.iter()2068			.find(|i| i.owner == owner)2069			.ok_or(Error::<T>::TokenNotFound)?;2070		let amount = item.fraction;20712072		ensure!(amount >= value, Error::<T>::TokenValueTooLow);20732074		collection.consume_sload()?;2075		// update balance2076		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2077			.checked_sub(value)2078			.ok_or(Error::<T>::NumOverflow)?;2079		collection.consume_sstore()?;2080		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20812082		collection.consume_sload()?;2083		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2084			.checked_add(value)2085			.ok_or(Error::<T>::NumOverflow)?;2086		collection.consume_sstore()?;2087		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20882089		let old_owner = item.owner.clone();2090		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20912092		let mut new_full_item = full_item.clone();2093		// transfer2094		if amount == value && !new_owner_has_account {2095			// change owner2096			// new owner do not have account2097			new_full_item2098				.owner2099				.iter_mut()2100				.find(|i| i.owner == owner)2101				.expect("old owner does present in refungible")2102				.owner = new_owner.clone();2103			collection.consume_sstore()?;2104			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21052106			// update index collection2107			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2108		} else {2109			new_full_item2110				.owner2111				.iter_mut()2112				.find(|i| i.owner == owner)2113				.expect("old owner does present in refungible")2114				.fraction -= value;21152116			// separate amount2117			if new_owner_has_account {2118				// new owner has account2119				new_full_item2120					.owner2121					.iter_mut()2122					.find(|i| i.owner == new_owner)2123					.expect("new owner has account")2124					.fraction += value;2125			} else {2126				// new owner do not have account2127				new_full_item.owner.push(Ownership {2128					owner: new_owner.clone(),2129					fraction: value,2130				});2131				Self::add_token_index(collection, item_id, &new_owner)?;2132			}21332134			collection.consume_sstore()?;2135			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2136		}21372138		Self::deposit_event(RawEvent::Transfer(2139			collection.id,2140			item_id,2141			owner,2142			new_owner,2143			amount,2144		));21452146		Ok(())2147	}21482149	fn transfer_nft(2150		collection: &CollectionHandle<T>,2151		item_id: TokenId,2152		sender: T::CrossAccountId,2153		new_owner: T::CrossAccountId,2154	) -> DispatchResult {2155		let collection_id = collection.id;2156		collection.consume_sload()?;2157		let mut item =2158			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21592160		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21612162		collection.consume_sload()?;2163		// update balance2164		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2165			.checked_sub(1)2166			.ok_or(Error::<T>::NumOverflow)?;2167		collection.consume_sstore()?;2168		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21692170		collection.consume_sload()?;2171		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2172			.checked_add(1)2173			.ok_or(Error::<T>::NumOverflow)?;2174		collection.consume_sstore()?;2175		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21762177		// change owner2178		let old_owner = item.owner.clone();2179		item.owner = new_owner.clone();2180		collection.consume_sstore()?;2181		<NftItemList<T>>::insert(collection_id, item_id, item);21822183		// update index collection2184		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;21852186		collection.log(ERC721Events::Transfer {2187			from: *sender.as_eth(),2188			to: *new_owner.as_eth(),2189			token_id: item_id.into(),2190		})?;2191		Self::deposit_event(RawEvent::Transfer(2192			collection.id,2193			item_id,2194			sender,2195			new_owner,2196			1,2197		));21982199		Ok(())2200	}22012202	fn set_re_fungible_variable_data(2203		collection: &CollectionHandle<T>,2204		item_id: TokenId,2205		data: Vec<u8>,2206	) -> DispatchResult {2207		let collection_id = collection.id;2208		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2209			.ok_or(Error::<T>::TokenNotFound)?;22102211		item.variable_data = data;22122213		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22142215		Ok(())2216	}22172218	fn set_nft_variable_data(2219		collection: &CollectionHandle<T>,2220		item_id: TokenId,2221		data: Vec<u8>,2222	) -> DispatchResult {2223		let collection_id = collection.id;2224		let mut item =2225			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22262227		item.variable_data = data;22282229		<NftItemList<T>>::insert(collection_id, item_id, item);22302231		Ok(())2232	}22332234	#[allow(dead_code)]2235	fn init_collection(item: &Collection<T>) {2236		// check params2237		assert!(2238			item.decimal_points <= MAX_DECIMAL_POINTS,2239			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2240		);2241		assert!(2242			item.name.len() <= 64,2243			"Collection name can not be longer than 63 char"2244		);2245		assert!(2246			item.name.len() <= 256,2247			"Collection description can not be longer than 255 char"2248		);2249		assert!(2250			item.token_prefix.len() <= 16,2251			"Token prefix can not be longer than 15 char"2252		);22532254		// Generate next collection ID2255		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22562257		CreatedCollectionCount::put(next_id);2258	}22592260	#[allow(dead_code)]2261	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2262		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22632264		Self::add_token_index(2265			&CollectionHandle::get(collection_id).unwrap(),2266			current_index,2267			&item.owner,2268		)2269		.unwrap();22702271		<ItemListIndex>::insert(collection_id, current_index);22722273		// Update balance2274		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2275			.checked_add(1)2276			.unwrap();2277		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2278	}22792280	#[allow(dead_code)]2281	fn init_fungible_token(2282		collection_id: CollectionId,2283		owner: &T::CrossAccountId,2284		item: &FungibleItemType,2285	) {2286		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22872288		Self::add_token_index(2289			&CollectionHandle::get(collection_id).unwrap(),2290			current_index,2291			owner,2292		)2293		.unwrap();22942295		<ItemListIndex>::insert(collection_id, current_index);22962297		// Update balance2298		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2299			.checked_add(item.value)2300			.unwrap();2301		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2302	}23032304	#[allow(dead_code)]2305	fn init_refungible_token(2306		collection_id: CollectionId,2307		item: &ReFungibleItemType<T::CrossAccountId>,2308	) {2309		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23102311		let value = item.owner.first().unwrap().fraction;2312		let owner = item.owner.first().unwrap().owner.clone();23132314		Self::add_token_index(2315			&CollectionHandle::get(collection_id).unwrap(),2316			current_index,2317			&owner,2318		)2319		.unwrap();23202321		<ItemListIndex>::insert(collection_id, current_index);23222323		// Update balance2324		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2325			.checked_add(value)2326			.unwrap();2327		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2328	}23292330	fn add_token_index(2331		collection: &CollectionHandle<T>,2332		item_index: TokenId,2333		owner: &T::CrossAccountId,2334	) -> DispatchResult {2335		// add to account limit2336		collection.consume_sload()?;2337		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2338			// bound Owned tokens by a single address2339			collection.consume_sload()?;2340			let count = <AccountItemCount<T>>::get(owner.as_sub());2341			ensure!(2342				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2343				Error::<T>::AddressOwnershipLimitExceeded2344			);23452346			collection.consume_sstore()?;2347			<AccountItemCount<T>>::insert(2348				owner.as_sub(),2349				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2350			);2351		} else {2352			collection.consume_sstore()?;2353			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2354		}23552356		collection.consume_sload()?;2357		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2358		if list_exists {2359			collection.consume_sload()?;2360			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2361			let item_contains = list.contains(&item_index.clone());23622363			if !item_contains {2364				list.push(item_index);2365			}23662367			collection.consume_sstore()?;2368			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2369		} else {2370			let itm = vec![item_index];2371			collection.consume_sstore()?;2372			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2373		}23742375		Ok(())2376	}23772378	fn remove_token_index(2379		collection: &CollectionHandle<T>,2380		item_index: TokenId,2381		owner: &T::CrossAccountId,2382	) -> DispatchResult {2383		// update counter2384		collection.consume_sload()?;2385		collection.consume_sstore()?;2386		<AccountItemCount<T>>::insert(2387			owner.as_sub(),2388			<AccountItemCount<T>>::get(owner.as_sub())2389				.checked_sub(1)2390				.ok_or(Error::<T>::NumOverflow)?,2391		);23922393		collection.consume_sload()?;2394		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2395		if list_exists {2396			collection.consume_sload()?;2397			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2398			let item_contains = list.contains(&item_index.clone());23992400			if item_contains {2401				list.retain(|&item| item != item_index);2402				collection.consume_sstore()?;2403				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2404			}2405		}24062407		Ok(())2408	}24092410	fn move_token_index(2411		collection: &CollectionHandle<T>,2412		item_index: TokenId,2413		old_owner: &T::CrossAccountId,2414		new_owner: &T::CrossAccountId,2415	) -> DispatchResult {2416		Self::remove_token_index(collection, item_index, old_owner)?;2417		Self::add_token_index(collection, item_index, new_owner)?;24182419		Ok(())2420	}2421}24222423sp_api::decl_runtime_apis! {2424	pub trait NftApi {2425		/// Used for ethereum integration2426		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2427	}2428}