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

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	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		/// Collection settings not allowing items transferring149		TransferNotAllowed,150		/// Can't transfer tokens to ethereum zero address151		AddressIsZero,152	}153}154155#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]156pub struct CollectionHandle<T: Config> {157	pub id: CollectionId,158	collection: Collection<T>,159	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,160}161impl<T: Config> CollectionHandle<T> {162	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {163		<CollectionById<T>>::get(id).map(|collection| Self {164			id,165			collection,166			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(167				eth::collection_id_to_address(id),168				gas_limit,169			),170		})171	}172	pub fn get(id: CollectionId) -> Option<Self> {173		Self::get_with_gas_limit(id, u64::MAX)174	}175	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {176		self.recorder.log_sub(log)177	}178	#[allow(dead_code)]179	fn consume_gas(&self, gas: u64) -> DispatchResult {180		self.recorder.consume_gas_sub(gas)181	}182	fn consume_sload(&self) -> DispatchResult {183		self.recorder.consume_sload_sub()184	}185	fn consume_sstore(&self) -> DispatchResult {186		self.recorder.consume_sstore_sub()187	}188	pub fn submit_logs(self) -> DispatchResult {189		self.recorder.submit_logs()190	}191	pub fn save(self) -> DispatchResult {192		self.recorder.submit_logs()?;193		<CollectionById<T>>::insert(self.id, self.collection);194		Ok(())195	}196}197impl<T: Config> Deref for CollectionHandle<T> {198	type Target = Collection<T>;199200	fn deref(&self) -> &Self::Target {201		&self.collection202	}203}204205impl<T: Config> DerefMut for CollectionHandle<T> {206	fn deref_mut(&mut self) -> &mut Self::Target {207		&mut self.collection208	}209}210211pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {212	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;213214	/// Weight information for extrinsics in this pallet.215	type WeightInfo: WeightInfo;216217	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;218	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;219220	type CrossAccountId: CrossAccountId<Self::AccountId>;221	type Currency: Currency<Self::AccountId>;222	type CollectionCreationPrice: Get<223		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,224	>;225	type TreasuryAccountId: Get<Self::AccountId>;226}227228type SelfWeightOf<T> = <T as Config>::WeightInfo;229230trait WeightInfoHelpers: WeightInfo {231	fn transfer() -> Weight {232		Self::transfer_nft()233			.max(Self::transfer_fungible())234			.max(Self::transfer_refungible())235	}236	fn transfer_from() -> Weight {237		Self::transfer_from_nft()238			.max(Self::transfer_from_fungible())239			.max(Self::transfer_from_refungible())240	}241	fn approve() -> Weight {242		// TODO: refungible, fungible243		Self::approve_nft()244	}245	fn set_variable_meta_data(data: u32) -> Weight {246		// TODO: refungible247		Self::set_variable_meta_data_nft(data)248	}249	fn create_item(data: u32) -> Weight {250		Self::create_item_nft(data)251			.max(Self::create_item_fungible())252			.max(Self::create_item_refungible(data))253	}254	fn burn_item() -> Weight {255		// TODO: refungible, fungible256		Self::burn_item_nft()257	}258}259impl<T: WeightInfo> WeightInfoHelpers for T {}260261// # Used definitions262//263// ## User control levels264//265// chain-controlled - key is uncontrolled by user266//                    i.e autoincrementing index267//                    can use non-cryptographic hash268// real - key is controlled by user269//        but it is hard to generate enough colliding values, i.e owner of signed txs270//        can use non-cryptographic hash271// controlled - key is completly controlled by users272//              i.e maps with mutable keys273//              should use cryptographic hash274//275// ## User control level downgrade reasons276//277// ?1 - chain-controlled -> controlled278//      collections/tokens can be destroyed, resulting in massive holes279// ?2 - chain-controlled -> controlled280//      same as ?1, but can be only added, resulting in easier exploitation281// ?3 - real -> controlled282//      no confirmation required, so addresses can be easily generated283decl_storage! {284	trait Store for Module<T: Config> as Nft {285286		//#region Private members287		/// Id of next collection288		CreatedCollectionCount: u32;289		/// Used for migrations290		ChainVersion: u64;291		/// Id of last collection token292		/// Collection id (controlled?1)293		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;294		//#endregion295296		//#region Bound counters297		/// Amount of collections destroyed, used for total amount tracking with298		/// CreatedCollectionCount299		DestroyedCollectionCount: u32;300		/// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)301		/// Account id (real)302		pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;303		//#endregion304305		//#region Basic collections306		/// Collection info307		/// Collection id (controlled?1)308		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;309		/// List of collection admins310		/// Collection id (controlled?2)311		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;312		/// Whitelisted collection users313		/// Collection id (controlled?2), user id (controlled?3)314		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;315		//#endregion316317		/// How many of collection items user have318		/// Collection id (controlled?2), account id (real)319		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;320321		/// Amount of items which spender can transfer out of owners account (via transferFrom)322		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))323		/// TODO: Off chain worker should remove from this map when token gets removed324		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;325326		//#region Item collections327		/// Collection id (controlled?2), token id (controlled?1)328		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;329		/// Collection id (controlled?2), owner (controlled?2)330		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;331		/// Collection id (controlled?2), token id (controlled?1)332		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;333		//#endregion334335		//#region Index list336		/// Collection id (controlled?2), tokens owner (controlled?2)337		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;338		//#endregion339340		//#region Tokens transfer rate limit baskets341		/// (Collection id (controlled?2), who created (real))342		/// TODO: Off chain worker should remove from this map when collection gets removed343		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;344		/// Collection id (controlled?2), token id (controlled?2)345		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;346		/// Collection id (controlled?2), owning user (real)347		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;348		/// Collection id (controlled?2), token id (controlled?2)349		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;350		//#endregion351352		/// Variable metadata sponsoring353		/// Collection id (controlled?2), token id (controlled?2)354		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;355	}356	add_extra_genesis {357		build(|config: &GenesisConfig<T>| {358			// Modification of storage359			for (_num, _c) in &config.collection_id {360				<Module<T>>::init_collection(_c);361			}362363			for (_num, _c, _i) in &config.nft_item_id {364				<Module<T>>::init_nft_token(*_c, _i);365			}366367			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {368				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);369			}370371			for (_num, _c, _i) in &config.refungible_item_id {372				<Module<T>>::init_refungible_token(*_c, _i);373			}374		})375	}376}377378decl_event!(379	pub enum Event<T>380	where381		AccountId = <T as frame_system::Config>::AccountId,382		CrossAccountId = <T as Config>::CrossAccountId,383	{384		/// New collection was created385		///386		/// # Arguments387		///388		/// * collection_id: Globally unique identifier of newly created collection.389		///390		/// * mode: [CollectionMode] converted into u8.391		///392		/// * account_id: Collection owner.393		CollectionCreated(CollectionId, u8, AccountId),394395		/// New item was created.396		///397		/// # Arguments398		///399		/// * collection_id: Id of the collection where item was created.400		///401		/// * item_id: Id of an item. Unique within the collection.402		///403		/// * recipient: Owner of newly created item404		ItemCreated(CollectionId, TokenId, CrossAccountId),405406		/// Collection item was burned.407		///408		/// # Arguments409		///410		/// collection_id.411		///412		/// item_id: Identifier of burned NFT.413		ItemDestroyed(CollectionId, TokenId),414415		/// Item was transferred416		///417		/// * collection_id: Id of collection to which item is belong418		///419		/// * item_id: Id of an item420		///421		/// * sender: Original owner of item422		///423		/// * recipient: New owner of item424		///425		/// * amount: Always 1 for NFT426		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),427428		/// * collection_id429		///430		/// * item_id431		///432		/// * sender433		///434		/// * spender435		///436		/// * amount437		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),438	}439);440441decl_module! {442	pub struct Module<T: Config> for enum Call443	where444		origin: T::Origin445	{446		fn deposit_event() = default;447		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;448		type Error = Error<T>;449450		fn on_initialize(_now: T::BlockNumber) -> Weight {451			0452		}453454		/// 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.455		///456		/// # Permissions457		///458		/// * Anyone.459		///460		/// # Arguments461		///462		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.463		///464		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.465		///466		/// * token_prefix: UTF-8 string with token prefix.467		///468		/// * mode: [CollectionMode] collection type and type dependent data.469		// returns collection ID470		#[weight = <SelfWeightOf<T>>::create_collection()]471		#[transactional]472		pub fn create_collection(origin,473								 collection_name: Vec<u16>,474								 collection_description: Vec<u16>,475								 token_prefix: Vec<u8>,476								 mode: CollectionMode) -> DispatchResult {477478			// Anyone can create a collection479			let who = ensure_signed(origin)?;480481			// Take a (non-refundable) deposit of collection creation482			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();483			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(484				&T::TreasuryAccountId::get(),485				T::CollectionCreationPrice::get(),486			));487			<T as Config>::Currency::settle(488				&who,489				imbalance,490				WithdrawReasons::TRANSFER,491				ExistenceRequirement::KeepAlive,492			).map_err(|_| Error::<T>::NoPermission)?;493494			let decimal_points = match mode {495				CollectionMode::Fungible(points) => points,496				_ => 0497			};498499			let created_count = CreatedCollectionCount::get();500			let destroyed_count = DestroyedCollectionCount::get();501502			// bound Total number of collections503			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);504505			// check params506			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);507			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);508			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);509			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);510511			// Generate next collection ID512			let next_id = created_count513				.checked_add(1)514				.ok_or(Error::<T>::NumOverflow)?;515516			CreatedCollectionCount::put(next_id);517518			let limits = CollectionLimits {519				sponsored_data_size: CUSTOM_DATA_LIMIT,520				..Default::default()521			};522523			// Create new collection524			let new_collection = Collection {525				owner: who.clone(),526				name: collection_name,527				mode: mode.clone(),528				mint_mode: false,529				access: AccessMode::Normal,530				description: collection_description,531				decimal_points,532				token_prefix,533				offchain_schema: Vec::new(),534				schema_version: SchemaVersion::ImageURL,535				sponsorship: SponsorshipState::Disabled,536				variable_on_chain_schema: Vec::new(),537				const_on_chain_schema: Vec::new(),538				limits,539				transfers_enabled: true,540			};541542			// Add new collection to map543			<CollectionById<T>>::insert(next_id, new_collection);544545			// call event546			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));547548			Ok(())549		}550551		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.552		///553		/// # Permissions554		///555		/// * Collection Owner.556		///557		/// # Arguments558		///559		/// * collection_id: collection to destroy.560		#[weight = <SelfWeightOf<T>>::destroy_collection()]561		#[transactional]562		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {563564			let sender = ensure_signed(origin)?;565			let collection = Self::get_collection(collection_id)?;566			Self::check_owner_permissions(&collection, &sender)?;567			if !collection.limits.owner_can_destroy {568				fail!(Error::<T>::NoPermission);569			}570571			<AddressTokens<T>>::remove_prefix(collection_id, None);572			<Allowances<T>>::remove_prefix(collection_id, None);573			<Balance<T>>::remove_prefix(collection_id, None);574			<ItemListIndex>::remove(collection_id);575			<AdminList<T>>::remove(collection_id);576			<CollectionById<T>>::remove(collection_id);577			<WhiteList<T>>::remove_prefix(collection_id, None);578579			<NftItemList<T>>::remove_prefix(collection_id, None);580			<FungibleItemList<T>>::remove_prefix(collection_id, None);581			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);582583			<NftTransferBasket<T>>::remove_prefix(collection_id, None);584			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);585			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);586587			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);588589			DestroyedCollectionCount::put(DestroyedCollectionCount::get()590				.checked_add(1)591				.ok_or(Error::<T>::NumOverflow)?);592593			Ok(())594		}595596		/// Add an address to white list.597		///598		/// # Permissions599		///600		/// * Collection Owner601		/// * Collection Admin602		///603		/// # Arguments604		///605		/// * collection_id.606		///607		/// * address.608		#[weight = <SelfWeightOf<T>>::add_to_white_list()]609		#[transactional]610		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{611612			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);613			let collection = Self::get_collection(collection_id)?;614615			Self::toggle_white_list_internal(616				&sender,617				&collection,618				&address,619				true,620			)?;621622			Ok(())623		}624625		/// Remove an address from white list.626		///627		/// # Permissions628		///629		/// * Collection Owner630		/// * Collection Admin631		///632		/// # Arguments633		///634		/// * collection_id.635		///636		/// * address.637		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]638		#[transactional]639		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{640641			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);642			let collection = Self::get_collection(collection_id)?;643644			Self::toggle_white_list_internal(645				&sender,646				&collection,647				&address,648				false,649			)?;650651			Ok(())652		}653654		/// Toggle between normal and white list access for the methods with access for `Anyone`.655		///656		/// # Permissions657		///658		/// * Collection Owner.659		///660		/// # Arguments661		///662		/// * collection_id.663		///664		/// * mode: [AccessMode]665		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]666		#[transactional]667		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult668		{669			let sender = ensure_signed(origin)?;670671			let mut target_collection = Self::get_collection(collection_id)?;672			Self::check_owner_permissions(&target_collection, &sender)?;673			target_collection.access = mode;674			target_collection.save()675		}676677		/// Allows Anyone to create tokens if:678		/// * White List is enabled, and679		/// * Address is added to white list, and680		/// * This method was called with True parameter681		///682		/// # Permissions683		/// * Collection Owner684		///685		/// # Arguments686		///687		/// * collection_id.688		///689		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.690		#[weight = <SelfWeightOf<T>>::set_mint_permission()]691		#[transactional]692		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult693		{694			let sender = ensure_signed(origin)?;695696			let mut target_collection = Self::get_collection(collection_id)?;697			Self::check_owner_permissions(&target_collection, &sender)?;698			target_collection.mint_mode = mint_permission;699			target_collection.save()700		}701702		/// Change the owner of the collection.703		///704		/// # Permissions705		///706		/// * Collection Owner.707		///708		/// # Arguments709		///710		/// * collection_id.711		///712		/// * new_owner.713		#[weight = <SelfWeightOf<T>>::change_collection_owner()]714		#[transactional]715		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {716717			let sender = ensure_signed(origin)?;718			let mut target_collection = Self::get_collection(collection_id)?;719			Self::check_owner_permissions(&target_collection, &sender)?;720			target_collection.owner = new_owner;721			target_collection.save()722		}723724		/// Adds an admin of the Collection.725		/// 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.726		///727		/// # Permissions728		///729		/// * Collection Owner.730		/// * Collection Admin.731		///732		/// # Arguments733		///734		/// * collection_id: ID of the Collection to add admin for.735		///736		/// * new_admin_id: Address of new admin to add.737		#[weight = <SelfWeightOf<T>>::add_collection_admin()]738		#[transactional]739		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {740			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);741			let collection = Self::get_collection(collection_id)?;742			Self::check_owner_or_admin_permissions(&collection, &sender)?;743			let mut admin_arr = <AdminList<T>>::get(collection_id);744745			match admin_arr.binary_search(&new_admin_id) {746				Ok(_) => {},747				Err(idx) => {748					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);749					admin_arr.insert(idx, new_admin_id);750					<AdminList<T>>::insert(collection_id, admin_arr);751				}752			}753			Ok(())754		}755756		/// 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.757		///758		/// # Permissions759		///760		/// * Collection Owner.761		/// * Collection Admin.762		///763		/// # Arguments764		///765		/// * collection_id: ID of the Collection to remove admin for.766		///767		/// * account_id: Address of admin to remove.768		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]769		#[transactional]770		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {771			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);772			let collection = Self::get_collection(collection_id)?;773			Self::check_owner_or_admin_permissions(&collection, &sender)?;774			let mut admin_arr = <AdminList<T>>::get(collection_id);775776			if let Ok(idx) = admin_arr.binary_search(&account_id) {777				admin_arr.remove(idx);778				<AdminList<T>>::insert(collection_id, admin_arr);779			}780			Ok(())781		}782783		/// # Permissions784		///785		/// * Collection Owner786		///787		/// # Arguments788		///789		/// * collection_id.790		///791		/// * new_sponsor.792		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]793		#[transactional]794		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {795			let sender = ensure_signed(origin)?;796			let mut target_collection = Self::get_collection(collection_id)?;797			Self::check_owner_permissions(&target_collection, &sender)?;798799			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);800			target_collection.save()801		}802803		/// # Permissions804		///805		/// * Sponsor.806		///807		/// # Arguments808		///809		/// * collection_id.810		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]811		#[transactional]812		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {813			let sender = ensure_signed(origin)?;814815			let mut target_collection = Self::get_collection(collection_id)?;816			ensure!(817				target_collection.sponsorship.pending_sponsor() == Some(&sender),818				Error::<T>::ConfirmUnsetSponsorFail819			);820821			target_collection.sponsorship = SponsorshipState::Confirmed(sender);822			target_collection.save()823		}824825		/// Switch back to pay-per-own-transaction model.826		///827		/// # Permissions828		///829		/// * Collection owner.830		///831		/// # Arguments832		///833		/// * collection_id.834		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]835		#[transactional]836		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {837			let sender = ensure_signed(origin)?;838839			let mut target_collection = Self::get_collection(collection_id)?;840			Self::check_owner_permissions(&target_collection, &sender)?;841842			target_collection.sponsorship = SponsorshipState::Disabled;843			target_collection.save()844		}845846		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.847		///848		/// # Permissions849		///850		/// * Collection Owner.851		/// * Collection Admin.852		/// * Anyone if853		///     * White List is enabled, and854		///     * Address is added to white list, and855		///     * MintPermission is enabled (see SetMintPermission method)856		///857		/// # Arguments858		///859		/// * collection_id: ID of the collection.860		///861		/// * owner: Address, initial owner of the NFT.862		///863		/// * data: Token data to store on chain.864		// #[weight =865		// (130_000_000 as Weight)866		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))867		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))868		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]869870		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]871		#[transactional]872		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {873			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);874			let collection = Self::get_collection(collection_id)?;875876			Self::create_item_internal(&sender, &collection, &owner, data)?;877878			collection.submit_logs()879		}880881		/// This method creates multiple items in a collection created with CreateCollection method.882		///883		/// # Permissions884		///885		/// * Collection Owner.886		/// * Collection Admin.887		/// * Anyone if888		///     * White List is enabled, and889		///     * Address is added to white list, and890		///     * MintPermission is enabled (see SetMintPermission method)891		///892		/// # Arguments893		///894		/// * collection_id: ID of the collection.895		///896		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].897		///898		/// * owner: Address, initial owner of the NFT.899		#[weight = <SelfWeightOf<T>>::create_item(items_data.iter()900							   .map(|data| { data.data_size() as u32 })901							   .sum())]902		#[transactional]903		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {904905			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);906			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);907			let collection = Self::get_collection(collection_id)?;908909			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;910911			collection.submit_logs()912		}913914		// TODO! transaction weight915916		/// Set transfers_enabled value for particular collection917		///918		/// # Permissions919		///920		/// * Collection Owner.921		///922		/// # Arguments923		///924		/// * collection_id: ID of the collection.925		///926		/// * value: New flag value.927		#[weight = <SelfWeightOf<T>>::burn_item()]928		#[transactional]929		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {930931			let sender = ensure_signed(origin)?;932			let mut target_collection = Self::get_collection(collection_id)?;933934			Self::check_owner_permissions(&target_collection, &sender)?;935936			target_collection.transfers_enabled = value;937			target_collection.save()938		}939940		/// Destroys a concrete instance of NFT.941		///942		/// # Permissions943		///944		/// * Collection Owner.945		/// * Collection Admin.946		/// * Current NFT Owner.947		///948		/// # Arguments949		///950		/// * collection_id: ID of the collection.951		///952		/// * item_id: ID of NFT to burn.953		#[weight = <SelfWeightOf<T>>::burn_item()]954		#[transactional]955		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {956957			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);958			let target_collection = Self::get_collection(collection_id)?;959960			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;961962			target_collection.submit_logs()963		}964965		/// Change ownership of the token.966		///967		/// # Permissions968		///969		/// * Collection Owner970		/// * Collection Admin971		/// * Current NFT owner972		///973		/// # Arguments974		///975		/// * recipient: Address of token recipient.976		///977		/// * collection_id.978		///979		/// * item_id: ID of the item980		///     * Non-Fungible Mode: Required.981		///     * Fungible Mode: Ignored.982		///     * Re-Fungible Mode: Required.983		///984		/// * value: Amount to transfer.985		///     * Non-Fungible Mode: Ignored986		///     * Fungible Mode: Must specify transferred amount987		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)988		#[weight = <SelfWeightOf<T>>::transfer()]989		#[transactional]990		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);992			let collection = Self::get_collection(collection_id)?;993994			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;995996			collection.submit_logs()997		}998999		/// Set, change, or remove approved address to transfer the ownership of the NFT.1000		///1001		/// # Permissions1002		///1003		/// * Collection Owner1004		/// * Collection Admin1005		/// * Current NFT owner1006		///1007		/// # Arguments1008		///1009		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1010		///1011		/// * collection_id.1012		///1013		/// * item_id: ID of the item.1014		#[weight = <SelfWeightOf<T>>::approve()]1015		#[transactional]1016		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1017			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1018			let collection = Self::get_collection(collection_id)?;10191020			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10211022			collection.submit_logs()1023		}10241025		/// 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.1026		///1027		/// # Permissions1028		/// * Collection Owner1029		/// * Collection Admin1030		/// * Current NFT owner1031		/// * Address approved by current NFT owner1032		///1033		/// # Arguments1034		///1035		/// * from: Address that owns token.1036		///1037		/// * recipient: Address of token recipient.1038		///1039		/// * collection_id.1040		///1041		/// * item_id: ID of the item.1042		///1043		/// * value: Amount to transfer.1044		#[weight = <SelfWeightOf<T>>::transfer_from()]1045		#[transactional]1046		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1047			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1048			let collection = Self::get_collection(collection_id)?;10491050			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10511052			collection.submit_logs()1053		}1054		// #[weight = 0]1055		//     // let no_perm_mes = "You do not have permissions to modify this collection";1056		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1057		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1058		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10591060		//     // // on_nft_received  call10611062		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10631064		//     Ok(())1065		// }10661067		/// Set off-chain data schema.1068		///1069		/// # Permissions1070		///1071		/// * Collection Owner1072		/// * Collection Admin1073		///1074		/// # Arguments1075		///1076		/// * collection_id.1077		///1078		/// * schema: String representing the offchain data schema.1079		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1080		#[transactional]1081		pub fn set_variable_meta_data (1082			origin,1083			collection_id: CollectionId,1084			item_id: TokenId,1085			data: Vec<u8>1086		) -> DispatchResult {1087			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10881089			let collection = Self::get_collection(collection_id)?;10901091			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10921093			Ok(())1094		}10951096		/// Set schema standard1097		/// ImageURL1098		/// Unique1099		///1100		/// # Permissions1101		///1102		/// * Collection Owner1103		/// * Collection Admin1104		///1105		/// # Arguments1106		///1107		/// * collection_id.1108		///1109		/// * schema: SchemaVersion: enum1110		#[weight = <SelfWeightOf<T>>::set_schema_version()]1111		#[transactional]1112		pub fn set_schema_version(1113			origin,1114			collection_id: CollectionId,1115			version: SchemaVersion1116		) -> DispatchResult {1117			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1118			let mut target_collection = Self::get_collection(collection_id)?;1119			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1120			target_collection.schema_version = version;1121			target_collection.save()1122		}11231124		/// Set off-chain data schema.1125		///1126		/// # Permissions1127		///1128		/// * Collection Owner1129		/// * Collection Admin1130		///1131		/// # Arguments1132		///1133		/// * collection_id.1134		///1135		/// * schema: String representing the offchain data schema.1136		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1137		#[transactional]1138		pub fn set_offchain_schema(1139			origin,1140			collection_id: CollectionId,1141			schema: Vec<u8>1142		) -> DispatchResult {1143			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1144			let mut target_collection = Self::get_collection(collection_id)?;1145			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11461147			// check schema limit1148			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11491150			target_collection.offchain_schema = schema;1151			target_collection.save()1152		}11531154		/// Set const on-chain data schema.1155		///1156		/// # Permissions1157		///1158		/// * Collection Owner1159		/// * Collection Admin1160		///1161		/// # Arguments1162		///1163		/// * collection_id.1164		///1165		/// * schema: String representing the const on-chain data schema.1166		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1167		#[transactional]1168		pub fn set_const_on_chain_schema (1169			origin,1170			collection_id: CollectionId,1171			schema: Vec<u8>1172		) -> DispatchResult {1173			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1174			let mut target_collection = Self::get_collection(collection_id)?;1175			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11761177			// check schema limit1178			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");11791180			target_collection.const_on_chain_schema = schema;1181			target_collection.save()1182		}11831184		/// Set variable on-chain data schema.1185		///1186		/// # Permissions1187		///1188		/// * Collection Owner1189		/// * Collection Admin1190		///1191		/// # Arguments1192		///1193		/// * collection_id.1194		///1195		/// * schema: String representing the variable on-chain data schema.1196		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1197		#[transactional]1198		pub fn set_variable_on_chain_schema (1199			origin,1200			collection_id: CollectionId,1201			schema: Vec<u8>1202		) -> DispatchResult {1203			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1204			let mut target_collection = Self::get_collection(collection_id)?;1205			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12061207			// check schema limit1208			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12091210			target_collection.variable_on_chain_schema = schema;1211			target_collection.save()1212		}12131214		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1215		#[transactional]1216		pub fn set_collection_limits(1217			origin,1218			collection_id: u32,1219			new_limits: CollectionLimits<T::BlockNumber>,1220		) -> DispatchResult {1221			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1222			let mut target_collection = Self::get_collection(collection_id)?;1223			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1224			let old_limits = &target_collection.limits;12251226			// collection bounds1227			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1228				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1229				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1230				Error::<T>::CollectionLimitBoundsExceeded);12311232			// token_limit   check  prev1233			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1234			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12351236			ensure!(1237				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1238				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1239				Error::<T>::OwnerPermissionsCantBeReverted,1240			);12411242			target_collection.limits = new_limits;12431244			target_collection.save()1245		}1246	}1247}12481249impl<T: Config> Module<T> {1250	pub fn create_item_internal(1251		sender: &T::CrossAccountId,1252		collection: &CollectionHandle<T>,1253		owner: &T::CrossAccountId,1254		data: CreateItemData,1255	) -> DispatchResult {1256		ensure!(1257			owner != &T::CrossAccountId::from_eth(H160([0; 20])),1258			Error::<T>::AddressIsZero1259		);12601261		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1262		Self::validate_create_item_args(collection, &data)?;1263		Self::create_item_no_validation(collection, owner, data)?;12641265		Ok(())1266	}12671268	pub fn transfer_internal(1269		sender: &T::CrossAccountId,1270		recipient: &T::CrossAccountId,1271		target_collection: &CollectionHandle<T>,1272		item_id: TokenId,1273		value: u128,1274	) -> DispatchResult {1275		ensure!(1276			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1277			Error::<T>::AddressIsZero1278		);12791280		// Limits check1281		Self::is_correct_transfer(target_collection, recipient)?;12821283		// Transfer permissions check1284		ensure!(1285			Self::is_item_owner(sender, target_collection, item_id)?1286				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,1287			Error::<T>::NoPermission1288		);12891290		if target_collection.access == AccessMode::WhiteList {1291			Self::check_white_list(target_collection, sender)?;1292			Self::check_white_list(target_collection, recipient)?;1293		}12941295		match target_collection.mode {1296			CollectionMode::NFT => Self::transfer_nft(1297				target_collection,1298				item_id,1299				sender.clone(),1300				recipient.clone(),1301			)?,1302			CollectionMode::Fungible(_) => {1303				Self::transfer_fungible(target_collection, value, sender, recipient)?1304			}1305			CollectionMode::ReFungible => Self::transfer_refungible(1306				target_collection,1307				item_id,1308				value,1309				sender.clone(),1310				recipient.clone(),1311			)?,1312			_ => (),1313		};13141315		Self::deposit_event(RawEvent::Transfer(1316			target_collection.id,1317			item_id,1318			sender.clone(),1319			recipient.clone(),1320			value,1321		));13221323		Ok(())1324	}13251326	pub fn approve_internal(1327		sender: &T::CrossAccountId,1328		spender: &T::CrossAccountId,1329		collection: &CollectionHandle<T>,1330		item_id: TokenId,1331		amount: u128,1332	) -> DispatchResult {1333		Self::token_exists(collection, item_id)?;13341335		// Transfer permissions check1336		let bypasses_limits = collection.limits.owner_can_transfer1337			&& Self::is_owner_or_admin_permissions(collection, sender)?;13381339		let allowance_limit = if bypasses_limits {1340			None1341		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1342			Some(amount)1343		} else {1344			fail!(Error::<T>::NoPermission);1345		};13461347		if collection.access == AccessMode::WhiteList {1348			Self::check_white_list(collection, sender)?;1349			Self::check_white_list(collection, spender)?;1350		}13511352		collection.consume_sload()?;1353		let allowance: u128 = amount1354			.checked_add(<Allowances<T>>::get(1355				collection.id,1356				(item_id, sender.as_sub(), spender.as_sub()),1357			))1358			.ok_or(Error::<T>::NumOverflow)?;1359		if let Some(limit) = allowance_limit {1360			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1361		}1362		collection.consume_sstore()?;1363		<Allowances<T>>::insert(1364			collection.id,1365			(item_id, sender.as_sub(), spender.as_sub()),1366			allowance,1367		);13681369		if matches!(collection.mode, CollectionMode::NFT) {1370			// TODO: NFT: only one owner may exist for token in ERC7211371			collection.log(ERC721Events::Approval {1372				owner: *sender.as_eth(),1373				approved: *spender.as_eth(),1374				token_id: item_id.into(),1375			})?;1376		}13771378		if matches!(collection.mode, CollectionMode::Fungible(_)) {1379			// TODO: NFT: only one owner may exist for token in ERC201380			collection.log(ERC20Events::Approval {1381				owner: *sender.as_eth(),1382				spender: *spender.as_eth(),1383				value: allowance.into(),1384			})?;1385		}13861387		Self::deposit_event(RawEvent::Approved(1388			collection.id,1389			item_id,1390			sender.clone(),1391			spender.clone(),1392			allowance,1393		));1394		Ok(())1395	}13961397	pub fn transfer_from_internal(1398		sender: &T::CrossAccountId,1399		from: &T::CrossAccountId,1400		recipient: &T::CrossAccountId,1401		collection: &CollectionHandle<T>,1402		item_id: TokenId,1403		amount: u128,1404	) -> DispatchResult {1405		if sender == from {1406			// Transfer by `from`, because it is either equal to sender, or derived from him1407			return Self::transfer_internal(from, recipient, collection, item_id, amount);1408		}14091410		// Check approval1411		collection.consume_sload()?;1412		let approval: u128 =1413			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14141415		// Limits check1416		Self::is_correct_transfer(collection, recipient)?;14171418		// Transfer permissions check1419		ensure!(1420			approval >= amount1421				|| (collection.limits.owner_can_transfer1422					&& Self::is_owner_or_admin_permissions(collection, sender)?),1423			Error::<T>::NoPermission1424		);14251426		if collection.access == AccessMode::WhiteList {1427			Self::check_white_list(collection, sender)?;1428			Self::check_white_list(collection, recipient)?;1429		}14301431		// Reduce approval by transferred amount or remove if remaining approval drops to 01432		let allowance = approval.saturating_sub(amount);1433		collection.consume_sstore()?;1434		if allowance > 0 {1435			<Allowances<T>>::insert(1436				collection.id,1437				(item_id, from.as_sub(), sender.as_sub()),1438				allowance,1439			);1440		} else {1441			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1442		}14431444		match collection.mode {1445			CollectionMode::NFT => {1446				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1447			}1448			CollectionMode::Fungible(_) => {1449				Self::transfer_fungible(collection, amount, from, recipient)?1450			}1451			CollectionMode::ReFungible => Self::transfer_refungible(1452				collection,1453				item_id,1454				amount,1455				from.clone(),1456				recipient.clone(),1457			)?,1458			_ => (),1459		};14601461		if matches!(collection.mode, CollectionMode::Fungible(_)) {1462			collection.log(ERC20Events::Approval {1463				owner: *from.as_eth(),1464				spender: *sender.as_eth(),1465				value: allowance.into(),1466			})?;1467		}14681469		Ok(())1470	}14711472	pub fn set_variable_meta_data_internal(1473		sender: &T::CrossAccountId,1474		collection: &CollectionHandle<T>,1475		item_id: TokenId,1476		data: Vec<u8>,1477	) -> DispatchResult {1478		Self::token_exists(collection, item_id)?;14791480		ensure!(1481			CUSTOM_DATA_LIMIT >= data.len() as u32,1482			Error::<T>::TokenVariableDataLimitExceeded1483		);14841485		// Modify permissions check1486		ensure!(1487			Self::is_item_owner(sender, collection, item_id)?1488				|| Self::is_owner_or_admin_permissions(collection, sender)?,1489			Error::<T>::NoPermission1490		);14911492		match collection.mode {1493			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1494			CollectionMode::ReFungible => {1495				Self::set_re_fungible_variable_data(collection, item_id, data)?1496			}1497			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1498			_ => fail!(Error::<T>::UnexpectedCollectionType),1499		};15001501		Ok(())1502	}15031504	pub fn create_multiple_items_internal(1505		sender: &T::CrossAccountId,1506		collection: &CollectionHandle<T>,1507		owner: &T::CrossAccountId,1508		items_data: Vec<CreateItemData>,1509	) -> DispatchResult {1510		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15111512		for data in &items_data {1513			Self::validate_create_item_args(collection, data)?;1514		}1515		for data in &items_data {1516			Self::create_item_no_validation(collection, owner, data.clone())?;1517		}15181519		Ok(())1520	}15211522	pub fn burn_item_internal(1523		sender: &T::CrossAccountId,1524		collection: &CollectionHandle<T>,1525		item_id: TokenId,1526		value: u128,1527	) -> DispatchResult {1528		ensure!(1529			Self::is_item_owner(sender, collection, item_id)?1530				|| (collection.limits.owner_can_transfer1531					&& Self::is_owner_or_admin_permissions(collection, sender)?),1532			Error::<T>::NoPermission1533		);15341535		if collection.access == AccessMode::WhiteList {1536			Self::check_white_list(collection, sender)?;1537		}15381539		match collection.mode {1540			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1541			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1542			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1543			_ => (),1544		};15451546		Ok(())1547	}15481549	pub fn toggle_white_list_internal(1550		sender: &T::CrossAccountId,1551		collection: &CollectionHandle<T>,1552		address: &T::CrossAccountId,1553		whitelisted: bool,1554	) -> DispatchResult {1555		Self::check_owner_or_admin_permissions(collection, sender)?;15561557		if whitelisted {1558			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1559		} else {1560			<WhiteList<T>>::remove(collection.id, address.as_sub());1561		}15621563		Ok(())1564	}15651566	fn is_correct_transfer(1567		collection: &CollectionHandle<T>,1568		recipient: &T::CrossAccountId,1569	) -> DispatchResult {1570		let collection_id = collection.id;15711572		// check token limit and account token limit1573		collection.consume_sload()?;1574		let account_items: u32 =1575			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1576		ensure!(1577			collection.limits.account_token_ownership_limit > account_items,1578			Error::<T>::AccountTokenLimitExceeded1579		);15801581		// preliminary transfer check1582		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);15831584		Ok(())1585	}15861587	fn can_create_items_in_collection(1588		collection: &CollectionHandle<T>,1589		sender: &T::CrossAccountId,1590		owner: &T::CrossAccountId,1591		amount: u32,1592	) -> DispatchResult {1593		let collection_id = collection.id;15941595		// check token limit and account token limit1596		let total_items: u32 = ItemListIndex::get(collection_id)1597			.checked_add(amount)1598			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1599		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1600			as u32)1601			.checked_add(amount)1602			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1603		ensure!(1604			collection.limits.token_limit >= total_items,1605			Error::<T>::CollectionTokenLimitExceeded1606		);1607		ensure!(1608			collection.limits.account_token_ownership_limit >= account_items,1609			Error::<T>::AccountTokenLimitExceeded1610		);16111612		if !Self::is_owner_or_admin_permissions(collection, sender)? {1613			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1614			Self::check_white_list(collection, owner)?;1615			Self::check_white_list(collection, sender)?;1616		}16171618		Ok(())1619	}16201621	fn validate_create_item_args(1622		target_collection: &CollectionHandle<T>,1623		data: &CreateItemData,1624	) -> DispatchResult {1625		match target_collection.mode {1626			CollectionMode::NFT => {1627				if !matches!(data, CreateItemData::NFT(_)) {1628					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1629				}1630			}1631			CollectionMode::Fungible(_) => {1632				if !matches!(data, CreateItemData::Fungible(_)) {1633					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1634				}1635			}1636			CollectionMode::ReFungible => {1637				if let CreateItemData::ReFungible(data) = data {1638					// Check refungibility limits1639					ensure!(1640						data.pieces <= MAX_REFUNGIBLE_PIECES,1641						Error::<T>::WrongRefungiblePieces1642					);1643					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1644				} else {1645					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1646				}1647			}1648			_ => {1649				fail!(Error::<T>::UnexpectedCollectionType);1650			}1651		};16521653		Ok(())1654	}16551656	fn create_item_no_validation(1657		collection: &CollectionHandle<T>,1658		owner: &T::CrossAccountId,1659		data: CreateItemData,1660	) -> DispatchResult {1661		match data {1662			CreateItemData::NFT(data) => {1663				let item = NftItemType {1664					owner: owner.clone(),1665					const_data: data.const_data.into_inner(),1666					variable_data: data.variable_data.into_inner(),1667				};16681669				Self::add_nft_item(collection, item)?;1670			}1671			CreateItemData::Fungible(data) => {1672				Self::add_fungible_item(collection, owner, data.value)?;1673			}1674			CreateItemData::ReFungible(data) => {1675				let owner_list = vec![Ownership {1676					owner: owner.clone(),1677					fraction: data.pieces,1678				}];16791680				let item = ReFungibleItemType {1681					owner: owner_list,1682					const_data: data.const_data.into_inner(),1683					variable_data: data.variable_data.into_inner(),1684				};16851686				Self::add_refungible_item(collection, item)?;1687			}1688		};16891690		Ok(())1691	}16921693	fn add_fungible_item(1694		collection: &CollectionHandle<T>,1695		owner: &T::CrossAccountId,1696		value: u128,1697	) -> DispatchResult {1698		let collection_id = collection.id;16991700		// Does new owner already have an account?1701		collection.consume_sload()?;1702		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17031704		// Mint1705		let item = FungibleItemType {1706			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1707		};1708		collection.consume_sstore()?;1709		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17101711		// Update balance1712		collection.consume_sload()?;1713		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1714			.checked_add(value)1715			.ok_or(Error::<T>::NumOverflow)?;1716		collection.consume_sstore()?;1717		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17181719		collection.log(ERC20Events::Transfer {1720			from: H160::default(),1721			to: *owner.as_eth(),1722			value: value.into(),1723		})?;1724		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1725		Ok(())1726	}17271728	fn add_refungible_item(1729		collection: &CollectionHandle<T>,1730		item: ReFungibleItemType<T::CrossAccountId>,1731	) -> DispatchResult {1732		let collection_id = collection.id;17331734		let current_index = <ItemListIndex>::get(collection_id)1735			.checked_add(1)1736			.ok_or(Error::<T>::NumOverflow)?;1737		let itemcopy = item.clone();17381739		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1740		let item_owner = item.owner.first().expect("only one owner is defined");17411742		let value = item_owner.fraction;1743		let owner = item_owner.owner.clone();17441745		Self::add_token_index(collection, current_index, &owner)?;17461747		<ItemListIndex>::insert(collection_id, current_index);1748		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17491750		// Update balance1751		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1752			.checked_add(value)1753			.ok_or(Error::<T>::NumOverflow)?;1754		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17551756		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1757		Ok(())1758	}17591760	fn add_nft_item(1761		collection: &CollectionHandle<T>,1762		item: NftItemType<T::CrossAccountId>,1763	) -> DispatchResult {1764		let collection_id = collection.id;17651766		let current_index = <ItemListIndex>::get(collection_id)1767			.checked_add(1)1768			.ok_or(Error::<T>::NumOverflow)?;17691770		let item_owner = item.owner.clone();1771		Self::add_token_index(collection, current_index, &item.owner)?;17721773		<ItemListIndex>::insert(collection_id, current_index);1774		<NftItemList<T>>::insert(collection_id, current_index, item);17751776		// Update balance1777		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1778			.checked_add(1)1779			.ok_or(Error::<T>::NumOverflow)?;1780		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17811782		collection.log(ERC721Events::Transfer {1783			from: H160::default(),1784			to: *item_owner.as_eth(),1785			token_id: current_index.into(),1786		})?;1787		Self::deposit_event(RawEvent::ItemCreated(1788			collection_id,1789			current_index,1790			item_owner,1791		));1792		Ok(())1793	}17941795	fn burn_refungible_item(1796		collection: &CollectionHandle<T>,1797		item_id: TokenId,1798		owner: &T::CrossAccountId,1799	) -> DispatchResult {1800		let collection_id = collection.id;18011802		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1803			.ok_or(Error::<T>::TokenNotFound)?;1804		let rft_balance = token1805			.owner1806			.iter()1807			.find(|&i| i.owner == *owner)1808			.ok_or(Error::<T>::TokenNotFound)?;1809		Self::remove_token_index(collection, item_id, owner)?;18101811		// update balance1812		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1813			.checked_sub(rft_balance.fraction)1814			.ok_or(Error::<T>::NumOverflow)?;1815		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18161817		// Re-create owners list with sender removed1818		let index = token1819			.owner1820			.iter()1821			.position(|i| i.owner == *owner)1822			.expect("owned item is exists");1823		token.owner.remove(index);1824		let owner_count = token.owner.len();18251826		// Burn the token completely if this was the last (only) owner1827		if owner_count == 0 {1828			<ReFungibleItemList<T>>::remove(collection_id, item_id);1829			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1830		} else {1831			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1832		}18331834		Ok(())1835	}18361837	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1838		let collection_id = collection.id;18391840		let item =1841			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1842		Self::remove_token_index(collection, item_id, &item.owner)?;18431844		// update balance1845		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1846			.checked_sub(1)1847			.ok_or(Error::<T>::NumOverflow)?;1848		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1849		<NftItemList<T>>::remove(collection_id, item_id);1850		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);18511852		collection.log(ERC721Events::Transfer {1853			from: *item.owner.as_eth(),1854			to: H160::default(),1855			token_id: item_id.into(),1856		})?;1857		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1858		Ok(())1859	}18601861	fn burn_fungible_item(1862		owner: &T::CrossAccountId,1863		collection: &CollectionHandle<T>,1864		value: u128,1865	) -> DispatchResult {1866		let collection_id = collection.id;18671868		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1869		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18701871		// update balance1872		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1873			.checked_sub(value)1874			.ok_or(Error::<T>::NumOverflow)?;1875		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18761877		if balance.value - value > 0 {1878			balance.value -= value;1879			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1880		} else {1881			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1882		}18831884		collection.log(ERC20Events::Transfer {1885			from: *owner.as_eth(),1886			to: H160::default(),1887			value: value.into(),1888		})?;1889		Ok(())1890	}18911892	pub fn get_collection(1893		collection_id: CollectionId,1894	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1895		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1896	}18971898	fn check_owner_permissions(1899		target_collection: &CollectionHandle<T>,1900		subject: &T::AccountId,1901	) -> DispatchResult {1902		ensure!(1903			*subject == target_collection.owner,1904			Error::<T>::NoPermission1905		);19061907		Ok(())1908	}19091910	fn is_owner_or_admin_permissions(1911		collection: &CollectionHandle<T>,1912		subject: &T::CrossAccountId,1913	) -> Result<bool, DispatchError> {1914		collection.consume_sload()?;1915		Ok(*subject.as_sub() == collection.owner1916			|| <AdminList<T>>::get(collection.id).contains(subject))1917	}19181919	fn check_owner_or_admin_permissions(1920		collection: &CollectionHandle<T>,1921		subject: &T::CrossAccountId,1922	) -> DispatchResult {1923		ensure!(1924			Self::is_owner_or_admin_permissions(collection, subject)?,1925			Error::<T>::NoPermission1926		);19271928		Ok(())1929	}19301931	fn owned_amount(1932		subject: &T::CrossAccountId,1933		collection: &CollectionHandle<T>,1934		item_id: TokenId,1935	) -> Result<Option<u128>, DispatchError> {1936		collection.consume_sload()?;1937		Ok(Self::owned_amount_unchecked(subject, collection, item_id))1938	}19391940	fn owned_amount_unchecked(1941		subject: &T::CrossAccountId,1942		target_collection: &CollectionHandle<T>,1943		item_id: TokenId,1944	) -> Option<u128> {1945		let collection_id = target_collection.id;19461947		match target_collection.mode {1948			CollectionMode::NFT => {1949				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1950			}1951			CollectionMode::Fungible(_) => {1952				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1953			}1954			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1955				.owner1956				.iter()1957				.find(|i| i.owner == *subject)1958				.map(|i| i.fraction),1959			CollectionMode::Invalid => None,1960		}1961	}19621963	fn is_item_owner(1964		subject: &T::CrossAccountId,1965		target_collection: &CollectionHandle<T>,1966		item_id: TokenId,1967	) -> Result<bool, DispatchError> {1968		Ok(match target_collection.mode {1969			CollectionMode::Fungible(_) => true,1970			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),1971		})1972	}19731974	fn check_white_list(1975		collection: &CollectionHandle<T>,1976		address: &T::CrossAccountId,1977	) -> DispatchResult {1978		collection.consume_sload()?;1979		ensure!(1980			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),1981			Error::<T>::AddresNotInWhiteList,1982		);1983		Ok(())1984	}19851986	/// Check if token exists. In case of Fungible, check if there is an entry for1987	/// the owner in fungible balances double map1988	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1989		let collection_id = target_collection.id;1990		let exists = match target_collection.mode {1991			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1992			CollectionMode::Fungible(_) => true,1993			CollectionMode::ReFungible => {1994				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)1995			}1996			_ => false,1997		};19981999		ensure!(exists, Error::<T>::TokenNotFound);2000		Ok(())2001	}20022003	fn transfer_fungible(2004		collection: &CollectionHandle<T>,2005		value: u128,2006		owner: &T::CrossAccountId,2007		recipient: &T::CrossAccountId,2008	) -> DispatchResult {2009		let collection_id = collection.id;20102011		collection.consume_sload()?;2012		collection.consume_sload()?;2013		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2014		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20152016		recipient_balance.value = recipient_balance2017			.value2018			.checked_add(value)2019			.ok_or(Error::<T>::NumOverflow)?;2020		balance.value = balance2021			.value2022			.checked_sub(value)2023			.ok_or(Error::<T>::TokenValueTooLow)?;20242025		// update balanceOf2026		collection.consume_sstore()?;2027		collection.consume_sstore()?;2028		if balance.value != 0 {2029			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2030		} else {2031			<Balance<T>>::remove(collection_id, owner.as_sub());2032		}2033		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20342035		// Reduce or remove sender2036		collection.consume_sstore()?;2037		collection.consume_sstore()?;2038		if balance.value != 0 {2039			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2040		} else {2041			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2042		}2043		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20442045		collection.log(ERC20Events::Transfer {2046			from: *owner.as_eth(),2047			to: *recipient.as_eth(),2048			value: value.into(),2049		})?;2050		Self::deposit_event(RawEvent::Transfer(2051			collection.id,2052			1,2053			owner.clone(),2054			recipient.clone(),2055			value,2056		));20572058		Ok(())2059	}20602061	fn transfer_refungible(2062		collection: &CollectionHandle<T>,2063		item_id: TokenId,2064		value: u128,2065		owner: T::CrossAccountId,2066		new_owner: T::CrossAccountId,2067	) -> DispatchResult {2068		let collection_id = collection.id;2069		collection.consume_sload()?;2070		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2071			.ok_or(Error::<T>::TokenNotFound)?;20722073		let item = full_item2074			.owner2075			.iter()2076			.find(|i| i.owner == owner)2077			.ok_or(Error::<T>::TokenNotFound)?;2078		let amount = item.fraction;20792080		ensure!(amount >= value, Error::<T>::TokenValueTooLow);20812082		collection.consume_sload()?;2083		// update balance2084		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2085			.checked_sub(value)2086			.ok_or(Error::<T>::NumOverflow)?;2087		collection.consume_sstore()?;2088		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20892090		collection.consume_sload()?;2091		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2092			.checked_add(value)2093			.ok_or(Error::<T>::NumOverflow)?;2094		collection.consume_sstore()?;2095		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20962097		let old_owner = item.owner.clone();2098		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20992100		let mut new_full_item = full_item.clone();2101		// transfer2102		if amount == value && !new_owner_has_account {2103			// change owner2104			// new owner do not have account2105			new_full_item2106				.owner2107				.iter_mut()2108				.find(|i| i.owner == owner)2109				.expect("old owner does present in refungible")2110				.owner = new_owner.clone();2111			collection.consume_sstore()?;2112			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21132114			// update index collection2115			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2116		} else {2117			new_full_item2118				.owner2119				.iter_mut()2120				.find(|i| i.owner == owner)2121				.expect("old owner does present in refungible")2122				.fraction -= value;21232124			// separate amount2125			if new_owner_has_account {2126				// new owner has account2127				new_full_item2128					.owner2129					.iter_mut()2130					.find(|i| i.owner == new_owner)2131					.expect("new owner has account")2132					.fraction += value;2133			} else {2134				// new owner do not have account2135				new_full_item.owner.push(Ownership {2136					owner: new_owner.clone(),2137					fraction: value,2138				});2139				Self::add_token_index(collection, item_id, &new_owner)?;2140			}21412142			collection.consume_sstore()?;2143			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2144		}21452146		Self::deposit_event(RawEvent::Transfer(2147			collection.id,2148			item_id,2149			owner,2150			new_owner,2151			amount,2152		));21532154		Ok(())2155	}21562157	fn transfer_nft(2158		collection: &CollectionHandle<T>,2159		item_id: TokenId,2160		sender: T::CrossAccountId,2161		new_owner: T::CrossAccountId,2162	) -> DispatchResult {2163		let collection_id = collection.id;2164		collection.consume_sload()?;2165		let mut item =2166			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21672168		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21692170		collection.consume_sload()?;2171		// update balance2172		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2173			.checked_sub(1)2174			.ok_or(Error::<T>::NumOverflow)?;2175		collection.consume_sstore()?;2176		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21772178		collection.consume_sload()?;2179		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2180			.checked_add(1)2181			.ok_or(Error::<T>::NumOverflow)?;2182		collection.consume_sstore()?;2183		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21842185		// change owner2186		let old_owner = item.owner.clone();2187		item.owner = new_owner.clone();2188		collection.consume_sstore()?;2189		<NftItemList<T>>::insert(collection_id, item_id, item);21902191		// update index collection2192		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;21932194		collection.log(ERC721Events::Transfer {2195			from: *sender.as_eth(),2196			to: *new_owner.as_eth(),2197			token_id: item_id.into(),2198		})?;2199		Self::deposit_event(RawEvent::Transfer(2200			collection.id,2201			item_id,2202			sender,2203			new_owner,2204			1,2205		));22062207		Ok(())2208	}22092210	fn set_re_fungible_variable_data(2211		collection: &CollectionHandle<T>,2212		item_id: TokenId,2213		data: Vec<u8>,2214	) -> DispatchResult {2215		let collection_id = collection.id;2216		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2217			.ok_or(Error::<T>::TokenNotFound)?;22182219		item.variable_data = data;22202221		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22222223		Ok(())2224	}22252226	fn set_nft_variable_data(2227		collection: &CollectionHandle<T>,2228		item_id: TokenId,2229		data: Vec<u8>,2230	) -> DispatchResult {2231		let collection_id = collection.id;2232		let mut item =2233			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22342235		item.variable_data = data;22362237		<NftItemList<T>>::insert(collection_id, item_id, item);22382239		Ok(())2240	}22412242	#[allow(dead_code)]2243	fn init_collection(item: &Collection<T>) {2244		// check params2245		assert!(2246			item.decimal_points <= MAX_DECIMAL_POINTS,2247			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2248		);2249		assert!(2250			item.name.len() <= 64,2251			"Collection name can not be longer than 63 char"2252		);2253		assert!(2254			item.name.len() <= 256,2255			"Collection description can not be longer than 255 char"2256		);2257		assert!(2258			item.token_prefix.len() <= 16,2259			"Token prefix can not be longer than 15 char"2260		);22612262		// Generate next collection ID2263		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22642265		CreatedCollectionCount::put(next_id);2266	}22672268	#[allow(dead_code)]2269	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2270		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22712272		Self::add_token_index(2273			&CollectionHandle::get(collection_id).unwrap(),2274			current_index,2275			&item.owner,2276		)2277		.unwrap();22782279		<ItemListIndex>::insert(collection_id, current_index);22802281		// Update balance2282		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2283			.checked_add(1)2284			.unwrap();2285		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2286	}22872288	#[allow(dead_code)]2289	fn init_fungible_token(2290		collection_id: CollectionId,2291		owner: &T::CrossAccountId,2292		item: &FungibleItemType,2293	) {2294		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22952296		Self::add_token_index(2297			&CollectionHandle::get(collection_id).unwrap(),2298			current_index,2299			owner,2300		)2301		.unwrap();23022303		<ItemListIndex>::insert(collection_id, current_index);23042305		// Update balance2306		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2307			.checked_add(item.value)2308			.unwrap();2309		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2310	}23112312	#[allow(dead_code)]2313	fn init_refungible_token(2314		collection_id: CollectionId,2315		item: &ReFungibleItemType<T::CrossAccountId>,2316	) {2317		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23182319		let value = item.owner.first().unwrap().fraction;2320		let owner = item.owner.first().unwrap().owner.clone();23212322		Self::add_token_index(2323			&CollectionHandle::get(collection_id).unwrap(),2324			current_index,2325			&owner,2326		)2327		.unwrap();23282329		<ItemListIndex>::insert(collection_id, current_index);23302331		// Update balance2332		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2333			.checked_add(value)2334			.unwrap();2335		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2336	}23372338	fn add_token_index(2339		collection: &CollectionHandle<T>,2340		item_index: TokenId,2341		owner: &T::CrossAccountId,2342	) -> DispatchResult {2343		// add to account limit2344		collection.consume_sload()?;2345		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2346			// bound Owned tokens by a single address2347			collection.consume_sload()?;2348			let count = <AccountItemCount<T>>::get(owner.as_sub());2349			ensure!(2350				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2351				Error::<T>::AddressOwnershipLimitExceeded2352			);23532354			collection.consume_sstore()?;2355			<AccountItemCount<T>>::insert(2356				owner.as_sub(),2357				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2358			);2359		} else {2360			collection.consume_sstore()?;2361			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2362		}23632364		collection.consume_sload()?;2365		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2366		if list_exists {2367			collection.consume_sload()?;2368			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2369			let item_contains = list.contains(&item_index.clone());23702371			if !item_contains {2372				list.push(item_index);2373			}23742375			collection.consume_sstore()?;2376			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2377		} else {2378			let itm = vec![item_index];2379			collection.consume_sstore()?;2380			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2381		}23822383		Ok(())2384	}23852386	fn remove_token_index(2387		collection: &CollectionHandle<T>,2388		item_index: TokenId,2389		owner: &T::CrossAccountId,2390	) -> DispatchResult {2391		// update counter2392		collection.consume_sload()?;2393		collection.consume_sstore()?;2394		<AccountItemCount<T>>::insert(2395			owner.as_sub(),2396			<AccountItemCount<T>>::get(owner.as_sub())2397				.checked_sub(1)2398				.ok_or(Error::<T>::NumOverflow)?,2399		);24002401		collection.consume_sload()?;2402		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2403		if list_exists {2404			collection.consume_sload()?;2405			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2406			let item_contains = list.contains(&item_index.clone());24072408			if item_contains {2409				list.retain(|&item| item != item_index);2410				collection.consume_sstore()?;2411				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2412			}2413		}24142415		Ok(())2416	}24172418	fn move_token_index(2419		collection: &CollectionHandle<T>,2420		item_index: TokenId,2421		old_owner: &T::CrossAccountId,2422		new_owner: &T::CrossAccountId,2423	) -> DispatchResult {2424		Self::remove_token_index(collection, item_index, old_owner)?;2425		Self::add_token_index(collection, item_index, new_owner)?;24262427		Ok(())2428	}2429}24302431sp_api::decl_runtime_apis! {2432	pub trait NftApi {2433		/// Used for ethereum integration2434		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2435	}2436}