git.delta.rocks / unique-network / refs/commits / 4e33887cc333

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 get_variable_metadata(collection: &CollectionHandle<T>, item_id: TokenId) -> Result<Vec<u8>, DispatchError> {1505		Ok(match collection.mode {1506			CollectionMode::NFT => <NftItemList<T>>::get(collection.id, item_id).ok_or(Error::<T>::TokenNotFound)?.variable_data,1507			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection.id, item_id).ok_or(Error::<T>::TokenNotFound)?.variable_data,1508			_ => fail!(Error::<T>::UnexpectedCollectionType),1509		})1510	}15111512	pub fn create_multiple_items_internal(1513		sender: &T::CrossAccountId,1514		collection: &CollectionHandle<T>,1515		owner: &T::CrossAccountId,1516		items_data: Vec<CreateItemData>,1517	) -> DispatchResult {1518		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15191520		for data in &items_data {1521			Self::validate_create_item_args(collection, data)?;1522		}1523		for data in &items_data {1524			Self::create_item_no_validation(collection, owner, data.clone())?;1525		}15261527		Ok(())1528	}15291530	pub fn burn_item_internal(1531		sender: &T::CrossAccountId,1532		collection: &CollectionHandle<T>,1533		item_id: TokenId,1534		value: u128,1535	) -> DispatchResult {1536		ensure!(1537			Self::is_item_owner(sender, collection, item_id)?1538				|| (collection.limits.owner_can_transfer1539					&& Self::is_owner_or_admin_permissions(collection, sender)?),1540			Error::<T>::NoPermission1541		);15421543		if collection.access == AccessMode::WhiteList {1544			Self::check_white_list(collection, sender)?;1545		}15461547		match collection.mode {1548			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1549			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1550			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1551			_ => (),1552		};15531554		Ok(())1555	}15561557	pub fn toggle_white_list_internal(1558		sender: &T::CrossAccountId,1559		collection: &CollectionHandle<T>,1560		address: &T::CrossAccountId,1561		whitelisted: bool,1562	) -> DispatchResult {1563		Self::check_owner_or_admin_permissions(collection, sender)?;15641565		if whitelisted {1566			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1567		} else {1568			<WhiteList<T>>::remove(collection.id, address.as_sub());1569		}15701571		Ok(())1572	}15731574	fn is_correct_transfer(1575		collection: &CollectionHandle<T>,1576		recipient: &T::CrossAccountId,1577	) -> DispatchResult {1578		let collection_id = collection.id;15791580		// check token limit and account token limit1581		collection.consume_sload()?;1582		let account_items: u32 =1583			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1584		ensure!(1585			collection.limits.account_token_ownership_limit > account_items,1586			Error::<T>::AccountTokenLimitExceeded1587		);15881589		// preliminary transfer check1590		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);15911592		Ok(())1593	}15941595	fn can_create_items_in_collection(1596		collection: &CollectionHandle<T>,1597		sender: &T::CrossAccountId,1598		owner: &T::CrossAccountId,1599		amount: u32,1600	) -> DispatchResult {1601		let collection_id = collection.id;16021603		// check token limit and account token limit1604		let total_items: u32 = ItemListIndex::get(collection_id)1605			.checked_add(amount)1606			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1607		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1608			as u32)1609			.checked_add(amount)1610			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1611		ensure!(1612			collection.limits.token_limit >= total_items,1613			Error::<T>::CollectionTokenLimitExceeded1614		);1615		ensure!(1616			collection.limits.account_token_ownership_limit >= account_items,1617			Error::<T>::AccountTokenLimitExceeded1618		);16191620		if !Self::is_owner_or_admin_permissions(collection, sender)? {1621			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1622			Self::check_white_list(collection, owner)?;1623			Self::check_white_list(collection, sender)?;1624		}16251626		Ok(())1627	}16281629	fn validate_create_item_args(1630		target_collection: &CollectionHandle<T>,1631		data: &CreateItemData,1632	) -> DispatchResult {1633		match target_collection.mode {1634			CollectionMode::NFT => {1635				if !matches!(data, CreateItemData::NFT(_)) {1636					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1637				}1638			}1639			CollectionMode::Fungible(_) => {1640				if !matches!(data, CreateItemData::Fungible(_)) {1641					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1642				}1643			}1644			CollectionMode::ReFungible => {1645				if let CreateItemData::ReFungible(data) = data {1646					// Check refungibility limits1647					ensure!(1648						data.pieces <= MAX_REFUNGIBLE_PIECES,1649						Error::<T>::WrongRefungiblePieces1650					);1651					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1652				} else {1653					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1654				}1655			}1656			_ => {1657				fail!(Error::<T>::UnexpectedCollectionType);1658			}1659		};16601661		Ok(())1662	}16631664	fn create_item_no_validation(1665		collection: &CollectionHandle<T>,1666		owner: &T::CrossAccountId,1667		data: CreateItemData,1668	) -> DispatchResult {1669		match data {1670			CreateItemData::NFT(data) => {1671				let item = NftItemType {1672					owner: owner.clone(),1673					const_data: data.const_data.into_inner(),1674					variable_data: data.variable_data.into_inner(),1675				};16761677				Self::add_nft_item(collection, item)?;1678			}1679			CreateItemData::Fungible(data) => {1680				Self::add_fungible_item(collection, owner, data.value)?;1681			}1682			CreateItemData::ReFungible(data) => {1683				let owner_list = vec![Ownership {1684					owner: owner.clone(),1685					fraction: data.pieces,1686				}];16871688				let item = ReFungibleItemType {1689					owner: owner_list,1690					const_data: data.const_data.into_inner(),1691					variable_data: data.variable_data.into_inner(),1692				};16931694				Self::add_refungible_item(collection, item)?;1695			}1696		};16971698		Ok(())1699	}17001701	fn add_fungible_item(1702		collection: &CollectionHandle<T>,1703		owner: &T::CrossAccountId,1704		value: u128,1705	) -> DispatchResult {1706		let collection_id = collection.id;17071708		// Does new owner already have an account?1709		collection.consume_sload()?;1710		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17111712		// Mint1713		let item = FungibleItemType {1714			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1715		};1716		collection.consume_sstore()?;1717		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17181719		// Update balance1720		collection.consume_sload()?;1721		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1722			.checked_add(value)1723			.ok_or(Error::<T>::NumOverflow)?;1724		collection.consume_sstore()?;1725		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17261727		collection.log(ERC20Events::Transfer {1728			from: H160::default(),1729			to: *owner.as_eth(),1730			value: value.into(),1731		})?;1732		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1733		Ok(())1734	}17351736	fn add_refungible_item(1737		collection: &CollectionHandle<T>,1738		item: ReFungibleItemType<T::CrossAccountId>,1739	) -> DispatchResult {1740		let collection_id = collection.id;17411742		let current_index = <ItemListIndex>::get(collection_id)1743			.checked_add(1)1744			.ok_or(Error::<T>::NumOverflow)?;1745		let itemcopy = item.clone();17461747		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1748		let item_owner = item.owner.first().expect("only one owner is defined");17491750		let value = item_owner.fraction;1751		let owner = item_owner.owner.clone();17521753		Self::add_token_index(collection, current_index, &owner)?;17541755		<ItemListIndex>::insert(collection_id, current_index);1756		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17571758		// Update balance1759		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1760			.checked_add(value)1761			.ok_or(Error::<T>::NumOverflow)?;1762		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17631764		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1765		Ok(())1766	}17671768	fn add_nft_item(1769		collection: &CollectionHandle<T>,1770		item: NftItemType<T::CrossAccountId>,1771	) -> DispatchResult {1772		let collection_id = collection.id;17731774		let current_index = <ItemListIndex>::get(collection_id)1775			.checked_add(1)1776			.ok_or(Error::<T>::NumOverflow)?;17771778		let item_owner = item.owner.clone();1779		Self::add_token_index(collection, current_index, &item.owner)?;17801781		<ItemListIndex>::insert(collection_id, current_index);1782		<NftItemList<T>>::insert(collection_id, current_index, item);17831784		// Update balance1785		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1786			.checked_add(1)1787			.ok_or(Error::<T>::NumOverflow)?;1788		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17891790		collection.log(ERC721Events::Transfer {1791			from: H160::default(),1792			to: *item_owner.as_eth(),1793			token_id: current_index.into(),1794		})?;1795		Self::deposit_event(RawEvent::ItemCreated(1796			collection_id,1797			current_index,1798			item_owner,1799		));1800		Ok(())1801	}18021803	fn burn_refungible_item(1804		collection: &CollectionHandle<T>,1805		item_id: TokenId,1806		owner: &T::CrossAccountId,1807	) -> DispatchResult {1808		let collection_id = collection.id;18091810		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1811			.ok_or(Error::<T>::TokenNotFound)?;1812		let rft_balance = token1813			.owner1814			.iter()1815			.find(|&i| i.owner == *owner)1816			.ok_or(Error::<T>::TokenNotFound)?;1817		Self::remove_token_index(collection, item_id, owner)?;18181819		// update balance1820		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1821			.checked_sub(rft_balance.fraction)1822			.ok_or(Error::<T>::NumOverflow)?;1823		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18241825		// Re-create owners list with sender removed1826		let index = token1827			.owner1828			.iter()1829			.position(|i| i.owner == *owner)1830			.expect("owned item is exists");1831		token.owner.remove(index);1832		let owner_count = token.owner.len();18331834		// Burn the token completely if this was the last (only) owner1835		if owner_count == 0 {1836			<ReFungibleItemList<T>>::remove(collection_id, item_id);1837			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1838		} else {1839			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1840		}18411842		Ok(())1843	}18441845	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1846		let collection_id = collection.id;18471848		let item =1849			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1850		Self::remove_token_index(collection, item_id, &item.owner)?;18511852		// update balance1853		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1854			.checked_sub(1)1855			.ok_or(Error::<T>::NumOverflow)?;1856		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1857		<NftItemList<T>>::remove(collection_id, item_id);1858		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);18591860		collection.log(ERC721Events::Transfer {1861			from: *item.owner.as_eth(),1862			to: H160::default(),1863			token_id: item_id.into(),1864		})?;1865		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1866		Ok(())1867	}18681869	fn burn_fungible_item(1870		owner: &T::CrossAccountId,1871		collection: &CollectionHandle<T>,1872		value: u128,1873	) -> DispatchResult {1874		let collection_id = collection.id;18751876		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1877		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18781879		// update balance1880		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1881			.checked_sub(value)1882			.ok_or(Error::<T>::NumOverflow)?;1883		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18841885		if balance.value - value > 0 {1886			balance.value -= value;1887			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1888		} else {1889			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1890		}18911892		collection.log(ERC20Events::Transfer {1893			from: *owner.as_eth(),1894			to: H160::default(),1895			value: value.into(),1896		})?;1897		Ok(())1898	}18991900	pub fn get_collection(1901		collection_id: CollectionId,1902	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1903		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1904	}19051906	fn check_owner_permissions(1907		target_collection: &CollectionHandle<T>,1908		subject: &T::AccountId,1909	) -> DispatchResult {1910		ensure!(1911			*subject == target_collection.owner,1912			Error::<T>::NoPermission1913		);19141915		Ok(())1916	}19171918	fn is_owner_or_admin_permissions(1919		collection: &CollectionHandle<T>,1920		subject: &T::CrossAccountId,1921	) -> Result<bool, DispatchError> {1922		collection.consume_sload()?;1923		Ok(*subject.as_sub() == collection.owner1924			|| <AdminList<T>>::get(collection.id).contains(subject))1925	}19261927	fn check_owner_or_admin_permissions(1928		collection: &CollectionHandle<T>,1929		subject: &T::CrossAccountId,1930	) -> DispatchResult {1931		ensure!(1932			Self::is_owner_or_admin_permissions(collection, subject)?,1933			Error::<T>::NoPermission1934		);19351936		Ok(())1937	}19381939	fn owned_amount(1940		subject: &T::CrossAccountId,1941		collection: &CollectionHandle<T>,1942		item_id: TokenId,1943	) -> Result<Option<u128>, DispatchError> {1944		collection.consume_sload()?;1945		Ok(Self::owned_amount_unchecked(subject, collection, item_id))1946	}19471948	fn owned_amount_unchecked(1949		subject: &T::CrossAccountId,1950		target_collection: &CollectionHandle<T>,1951		item_id: TokenId,1952	) -> Option<u128> {1953		let collection_id = target_collection.id;19541955		match target_collection.mode {1956			CollectionMode::NFT => {1957				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1958			}1959			CollectionMode::Fungible(_) => {1960				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1961			}1962			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1963				.owner1964				.iter()1965				.find(|i| i.owner == *subject)1966				.map(|i| i.fraction),1967			CollectionMode::Invalid => None,1968		}1969	}19701971	fn is_item_owner(1972		subject: &T::CrossAccountId,1973		target_collection: &CollectionHandle<T>,1974		item_id: TokenId,1975	) -> Result<bool, DispatchError> {1976		Ok(match target_collection.mode {1977			CollectionMode::Fungible(_) => true,1978			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),1979		})1980	}19811982	fn check_white_list(1983		collection: &CollectionHandle<T>,1984		address: &T::CrossAccountId,1985	) -> DispatchResult {1986		collection.consume_sload()?;1987		ensure!(1988			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),1989			Error::<T>::AddresNotInWhiteList,1990		);1991		Ok(())1992	}19931994	/// Check if token exists. In case of Fungible, check if there is an entry for1995	/// the owner in fungible balances double map1996	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1997		let collection_id = target_collection.id;1998		let exists = match target_collection.mode {1999			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2000			CollectionMode::Fungible(_) => true,2001			CollectionMode::ReFungible => {2002				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2003			}2004			_ => false,2005		};20062007		ensure!(exists, Error::<T>::TokenNotFound);2008		Ok(())2009	}20102011	fn transfer_fungible(2012		collection: &CollectionHandle<T>,2013		value: u128,2014		owner: &T::CrossAccountId,2015		recipient: &T::CrossAccountId,2016	) -> DispatchResult {2017		let collection_id = collection.id;20182019		collection.consume_sload()?;2020		collection.consume_sload()?;2021		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2022		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20232024		recipient_balance.value = recipient_balance2025			.value2026			.checked_add(value)2027			.ok_or(Error::<T>::NumOverflow)?;2028		balance.value = balance2029			.value2030			.checked_sub(value)2031			.ok_or(Error::<T>::TokenValueTooLow)?;20322033		// update balanceOf2034		collection.consume_sstore()?;2035		collection.consume_sstore()?;2036		if balance.value != 0 {2037			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2038		} else {2039			<Balance<T>>::remove(collection_id, owner.as_sub());2040		}2041		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20422043		// Reduce or remove sender2044		collection.consume_sstore()?;2045		collection.consume_sstore()?;2046		if balance.value != 0 {2047			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2048		} else {2049			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2050		}2051		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20522053		collection.log(ERC20Events::Transfer {2054			from: *owner.as_eth(),2055			to: *recipient.as_eth(),2056			value: value.into(),2057		})?;2058		Self::deposit_event(RawEvent::Transfer(2059			collection.id,2060			1,2061			owner.clone(),2062			recipient.clone(),2063			value,2064		));20652066		Ok(())2067	}20682069	fn transfer_refungible(2070		collection: &CollectionHandle<T>,2071		item_id: TokenId,2072		value: u128,2073		owner: T::CrossAccountId,2074		new_owner: T::CrossAccountId,2075	) -> DispatchResult {2076		let collection_id = collection.id;2077		collection.consume_sload()?;2078		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2079			.ok_or(Error::<T>::TokenNotFound)?;20802081		let item = full_item2082			.owner2083			.iter()2084			.find(|i| i.owner == owner)2085			.ok_or(Error::<T>::TokenNotFound)?;2086		let amount = item.fraction;20872088		ensure!(amount >= value, Error::<T>::TokenValueTooLow);20892090		collection.consume_sload()?;2091		// update balance2092		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2093			.checked_sub(value)2094			.ok_or(Error::<T>::NumOverflow)?;2095		collection.consume_sstore()?;2096		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20972098		collection.consume_sload()?;2099		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2100			.checked_add(value)2101			.ok_or(Error::<T>::NumOverflow)?;2102		collection.consume_sstore()?;2103		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21042105		let old_owner = item.owner.clone();2106		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21072108		let mut new_full_item = full_item.clone();2109		// transfer2110		if amount == value && !new_owner_has_account {2111			// change owner2112			// new owner do not have account2113			new_full_item2114				.owner2115				.iter_mut()2116				.find(|i| i.owner == owner)2117				.expect("old owner does present in refungible")2118				.owner = new_owner.clone();2119			collection.consume_sstore()?;2120			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21212122			// update index collection2123			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2124		} else {2125			new_full_item2126				.owner2127				.iter_mut()2128				.find(|i| i.owner == owner)2129				.expect("old owner does present in refungible")2130				.fraction -= value;21312132			// separate amount2133			if new_owner_has_account {2134				// new owner has account2135				new_full_item2136					.owner2137					.iter_mut()2138					.find(|i| i.owner == new_owner)2139					.expect("new owner has account")2140					.fraction += value;2141			} else {2142				// new owner do not have account2143				new_full_item.owner.push(Ownership {2144					owner: new_owner.clone(),2145					fraction: value,2146				});2147				Self::add_token_index(collection, item_id, &new_owner)?;2148			}21492150			collection.consume_sstore()?;2151			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2152		}21532154		Self::deposit_event(RawEvent::Transfer(2155			collection.id,2156			item_id,2157			owner,2158			new_owner,2159			amount,2160		));21612162		Ok(())2163	}21642165	fn transfer_nft(2166		collection: &CollectionHandle<T>,2167		item_id: TokenId,2168		sender: T::CrossAccountId,2169		new_owner: T::CrossAccountId,2170	) -> DispatchResult {2171		let collection_id = collection.id;2172		collection.consume_sload()?;2173		let mut item =2174			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21752176		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21772178		collection.consume_sload()?;2179		// update balance2180		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2181			.checked_sub(1)2182			.ok_or(Error::<T>::NumOverflow)?;2183		collection.consume_sstore()?;2184		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21852186		collection.consume_sload()?;2187		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2188			.checked_add(1)2189			.ok_or(Error::<T>::NumOverflow)?;2190		collection.consume_sstore()?;2191		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21922193		// change owner2194		let old_owner = item.owner.clone();2195		item.owner = new_owner.clone();2196		collection.consume_sstore()?;2197		<NftItemList<T>>::insert(collection_id, item_id, item);21982199		// update index collection2200		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22012202		collection.log(ERC721Events::Transfer {2203			from: *sender.as_eth(),2204			to: *new_owner.as_eth(),2205			token_id: item_id.into(),2206		})?;2207		Self::deposit_event(RawEvent::Transfer(2208			collection.id,2209			item_id,2210			sender,2211			new_owner,2212			1,2213		));22142215		Ok(())2216	}22172218	fn set_re_fungible_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 = <ReFungibleItemList<T>>::get(collection_id, item_id)2225			.ok_or(Error::<T>::TokenNotFound)?;22262227		item.variable_data = data;22282229		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22302231		Ok(())2232	}22332234	fn set_nft_variable_data(2235		collection: &CollectionHandle<T>,2236		item_id: TokenId,2237		data: Vec<u8>,2238	) -> DispatchResult {2239		let collection_id = collection.id;2240		let mut item =2241			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22422243		item.variable_data = data;22442245		<NftItemList<T>>::insert(collection_id, item_id, item);22462247		Ok(())2248	}22492250	#[allow(dead_code)]2251	fn init_collection(item: &Collection<T>) {2252		// check params2253		assert!(2254			item.decimal_points <= MAX_DECIMAL_POINTS,2255			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2256		);2257		assert!(2258			item.name.len() <= 64,2259			"Collection name can not be longer than 63 char"2260		);2261		assert!(2262			item.name.len() <= 256,2263			"Collection description can not be longer than 255 char"2264		);2265		assert!(2266			item.token_prefix.len() <= 16,2267			"Token prefix can not be longer than 15 char"2268		);22692270		// Generate next collection ID2271		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22722273		CreatedCollectionCount::put(next_id);2274	}22752276	#[allow(dead_code)]2277	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2278		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22792280		Self::add_token_index(2281			&CollectionHandle::get(collection_id).unwrap(),2282			current_index,2283			&item.owner,2284		)2285		.unwrap();22862287		<ItemListIndex>::insert(collection_id, current_index);22882289		// Update balance2290		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2291			.checked_add(1)2292			.unwrap();2293		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2294	}22952296	#[allow(dead_code)]2297	fn init_fungible_token(2298		collection_id: CollectionId,2299		owner: &T::CrossAccountId,2300		item: &FungibleItemType,2301	) {2302		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23032304		Self::add_token_index(2305			&CollectionHandle::get(collection_id).unwrap(),2306			current_index,2307			owner,2308		)2309		.unwrap();23102311		<ItemListIndex>::insert(collection_id, current_index);23122313		// Update balance2314		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2315			.checked_add(item.value)2316			.unwrap();2317		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2318	}23192320	#[allow(dead_code)]2321	fn init_refungible_token(2322		collection_id: CollectionId,2323		item: &ReFungibleItemType<T::CrossAccountId>,2324	) {2325		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23262327		let value = item.owner.first().unwrap().fraction;2328		let owner = item.owner.first().unwrap().owner.clone();23292330		Self::add_token_index(2331			&CollectionHandle::get(collection_id).unwrap(),2332			current_index,2333			&owner,2334		)2335		.unwrap();23362337		<ItemListIndex>::insert(collection_id, current_index);23382339		// Update balance2340		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2341			.checked_add(value)2342			.unwrap();2343		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2344	}23452346	fn add_token_index(2347		collection: &CollectionHandle<T>,2348		item_index: TokenId,2349		owner: &T::CrossAccountId,2350	) -> DispatchResult {2351		// add to account limit2352		collection.consume_sload()?;2353		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2354			// bound Owned tokens by a single address2355			collection.consume_sload()?;2356			let count = <AccountItemCount<T>>::get(owner.as_sub());2357			ensure!(2358				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2359				Error::<T>::AddressOwnershipLimitExceeded2360			);23612362			collection.consume_sstore()?;2363			<AccountItemCount<T>>::insert(2364				owner.as_sub(),2365				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2366			);2367		} else {2368			collection.consume_sstore()?;2369			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2370		}23712372		collection.consume_sload()?;2373		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2374		if list_exists {2375			collection.consume_sload()?;2376			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2377			let item_contains = list.contains(&item_index.clone());23782379			if !item_contains {2380				list.push(item_index);2381			}23822383			collection.consume_sstore()?;2384			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2385		} else {2386			let itm = vec![item_index];2387			collection.consume_sstore()?;2388			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2389		}23902391		Ok(())2392	}23932394	fn remove_token_index(2395		collection: &CollectionHandle<T>,2396		item_index: TokenId,2397		owner: &T::CrossAccountId,2398	) -> DispatchResult {2399		// update counter2400		collection.consume_sload()?;2401		collection.consume_sstore()?;2402		<AccountItemCount<T>>::insert(2403			owner.as_sub(),2404			<AccountItemCount<T>>::get(owner.as_sub())2405				.checked_sub(1)2406				.ok_or(Error::<T>::NumOverflow)?,2407		);24082409		collection.consume_sload()?;2410		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2411		if list_exists {2412			collection.consume_sload()?;2413			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2414			let item_contains = list.contains(&item_index.clone());24152416			if item_contains {2417				list.retain(|&item| item != item_index);2418				collection.consume_sstore()?;2419				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2420			}2421		}24222423		Ok(())2424	}24252426	fn move_token_index(2427		collection: &CollectionHandle<T>,2428		item_index: TokenId,2429		old_owner: &T::CrossAccountId,2430		new_owner: &T::CrossAccountId,2431	) -> DispatchResult {2432		Self::remove_token_index(collection, item_index, old_owner)?;2433		Self::add_token_index(collection, item_index, new_owner)?;24342435		Ok(())2436	}2437}24382439sp_api::decl_runtime_apis! {2440	pub trait NftApi {2441		/// Used for ethereum integration2442		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2443	}2444}