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

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9	clippy::too_many_arguments,10	clippy::unnecessary_mut_passed,11	clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19	construct_runtime, decl_event, decl_module, decl_storage, decl_error,20	dispatch::DispatchResult,21	ensure, fail, parameter_types,22	traits::{23		Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24		Randomness, IsSubType, WithdrawReasons,25	},26	weights::{27		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29		WeightToFeePolynomial, DispatchClass,30	},31	StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41	CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46	MetaUpdatePermission, FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70	/// Error for non-fungible-token module.71	pub enum Error for Module<T: Config> {72		/// Total collections bound exceeded.73		TotalCollectionsLimitExceeded,74		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75		CollectionDecimalPointLimitExceeded,76		/// Collection name can not be longer than 63 char.77		CollectionNameLimitExceeded,78		/// Collection description can not be longer than 255 char.79		CollectionDescriptionLimitExceeded,80		/// Token prefix can not be longer than 15 char.81		CollectionTokenPrefixLimitExceeded,82		/// This collection does not exist.83		CollectionNotFound,84		/// Item not exists.85		TokenNotFound,86		/// Admin not found87		AdminNotFound,88		/// Arithmetic calculation overflow.89		NumOverflow,90		/// Account already has admin role.91		AlreadyAdmin,92		/// You do not own this collection.93		NoPermission,94		/// This address is not set as sponsor, use setCollectionSponsor first.95		ConfirmUnsetSponsorFail,96		/// Collection is not in mint mode.97		PublicMintingNotAllowed,98		/// Sender parameter and item owner must be equal.99		MustBeTokenOwner,100		/// Item balance not enough.101		TokenValueTooLow,102		/// Size of item is too large.103		NftSizeLimitExceeded,104		/// No approve found105		ApproveNotFound,106		/// Requested value more than approved.107		TokenValueNotEnough,108		/// Only approved addresses can call this method.109		ApproveRequired,110		/// Address is not in white list.111		AddresNotInWhiteList,112		/// Number of collection admins bound exceeded.113		CollectionAdminsLimitExceeded,114		/// Owned tokens by a single address bound exceeded.115		AddressOwnershipLimitExceeded,116		/// Length of items properties must be greater than 0.117		EmptyArgument,118		/// const_data exceeded data limit.119		TokenConstDataLimitExceeded,120		/// variable_data exceeded data limit.121		TokenVariableDataLimitExceeded,122		/// Not NFT item data used to mint in NFT collection.123		NotNftDataUsedToMintNftCollectionToken,124		/// Not Fungible item data used to mint in Fungible collection.125		NotFungibleDataUsedToMintFungibleCollectionToken,126		/// Not Re Fungible item data used to mint in Re Fungible collection.127		NotReFungibleDataUsedToMintReFungibleCollectionToken,128		/// Unexpected collection type.129		UnexpectedCollectionType,130		/// Can't store metadata in fungible tokens.131		CantStoreMetadataInFungibleTokens,132		/// Collection token limit exceeded133		CollectionTokenLimitExceeded,134		/// Account token limit exceeded per collection135		AccountTokenLimitExceeded,136		/// Collection limit bounds per collection exceeded137		CollectionLimitBoundsExceeded,138		/// Tried to enable permissions which are only permitted to be disabled139		OwnerPermissionsCantBeReverted,140		/// Schema data size limit bound exceeded141		SchemaDataLimitExceeded,142		/// Maximum refungibility exceeded143		WrongRefungiblePieces,144		/// createRefungible should be called with one owner145		BadCreateRefungibleCall,146		/// Gas limit exceeded147		OutOfGas,148		/// Metadata update denied by collection settings149		MetadataUpdateDenied,150		/// Metadata update flag become unmutable with None option151		MetadataFlagFrozen,152		/// Collection settings not allowing items transferring153		TransferNotAllowed,154		/// Can't transfer tokens to ethereum zero address155		AddressIsZero,156	}157}158159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]160pub struct CollectionHandle<T: Config> {161	pub id: CollectionId,162	collection: Collection<T>,163	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,164}165impl<T: Config> CollectionHandle<T> {166	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {167		<CollectionById<T>>::get(id).map(|collection| Self {168			id,169			collection,170			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(171				eth::collection_id_to_address(id),172				gas_limit,173			),174		})175	}176	pub fn get(id: CollectionId) -> Option<Self> {177		Self::get_with_gas_limit(id, u64::MAX)178	}179	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {180		self.recorder.log_sub(log)181	}182	#[allow(dead_code)]183	fn consume_gas(&self, gas: u64) -> DispatchResult {184		self.recorder.consume_gas_sub(gas)185	}186	fn consume_sload(&self) -> DispatchResult {187		self.recorder.consume_sload_sub()188	}189	fn consume_sstore(&self) -> DispatchResult {190		self.recorder.consume_sstore_sub()191	}192	pub fn submit_logs(self) -> DispatchResult {193		self.recorder.submit_logs()194	}195	pub fn save(self) -> DispatchResult {196		self.recorder.submit_logs()?;197		<CollectionById<T>>::insert(self.id, self.collection);198		Ok(())199	}200}201impl<T: Config> Deref for CollectionHandle<T> {202	type Target = Collection<T>;203204	fn deref(&self) -> &Self::Target {205		&self.collection206	}207}208209impl<T: Config> DerefMut for CollectionHandle<T> {210	fn deref_mut(&mut self) -> &mut Self::Target {211		&mut self.collection212	}213}214215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {216	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;217218	/// Weight information for extrinsics in this pallet.219	type WeightInfo: WeightInfo;220221	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;222	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;223224	type CrossAccountId: CrossAccountId<Self::AccountId>;225	type Currency: Currency<Self::AccountId>;226	type CollectionCreationPrice: Get<227		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,228	>;229	type TreasuryAccountId: Get<Self::AccountId>;230}231232type SelfWeightOf<T> = <T as Config>::WeightInfo;233234trait WeightInfoHelpers: WeightInfo {235	fn transfer() -> Weight {236		Self::transfer_nft()237			.max(Self::transfer_fungible())238			.max(Self::transfer_refungible())239	}240	fn transfer_from() -> Weight {241		Self::transfer_from_nft()242			.max(Self::transfer_from_fungible())243			.max(Self::transfer_from_refungible())244	}245	fn approve() -> Weight {246		// TODO: refungible, fungible247		Self::approve_nft()248	}249	fn set_variable_meta_data(data: u32) -> Weight {250		// TODO: refungible251		Self::set_variable_meta_data_nft(data)252	}253	fn create_item(data: u32) -> Weight {254		Self::create_item_nft(data)255			.max(Self::create_item_fungible())256			.max(Self::create_item_refungible(data))257	}258	fn create_multiple_items(amount: u32) -> Weight {259		Self::create_multiple_items_nft(amount)260			.max(Self::create_multiple_items_fungible(amount))261			.max(Self::create_multiple_items_refungible(amount))262	}263	fn burn_item() -> Weight {264		// TODO: refungible, fungible265		Self::burn_item_nft()266	}267}268impl<T: WeightInfo> WeightInfoHelpers for T {}269270// # Used definitions271//272// ## User control levels273//274// chain-controlled - key is uncontrolled by user275//                    i.e autoincrementing index276//                    can use non-cryptographic hash277// real - key is controlled by user278//        but it is hard to generate enough colliding values, i.e owner of signed txs279//        can use non-cryptographic hash280// controlled - key is completly controlled by users281//              i.e maps with mutable keys282//              should use cryptographic hash283//284// ## User control level downgrade reasons285//286// ?1 - chain-controlled -> controlled287//      collections/tokens can be destroyed, resulting in massive holes288// ?2 - chain-controlled -> controlled289//      same as ?1, but can be only added, resulting in easier exploitation290// ?3 - real -> controlled291//      no confirmation required, so addresses can be easily generated292decl_storage! {293	trait Store for Module<T: Config> as Nft {294295		//#region Private members296		/// Id of next collection297		CreatedCollectionCount: u32;298		/// Used for migrations299		ChainVersion: u64;300		/// Id of last collection token301		/// Collection id (controlled?1)302		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;303		//#endregion304305		//#region Bound counters306		/// Amount of collections destroyed, used for total amount tracking with307		/// CreatedCollectionCount308		DestroyedCollectionCount: u32;309		//#endregion310311		//#region Basic collections312		/// Collection info313		/// Collection id (controlled?1)314		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;315		/// List of collection admins316		/// Collection id (controlled?2)317		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;318		/// Whitelisted collection users319		/// Collection id (controlled?2), user id (controlled?3)320		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;321		//#endregion322323		/// How many of collection items user have324		/// Collection id (controlled?2), account id (real)325		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;326327		/// Amount of items which spender can transfer out of owners account (via transferFrom)328		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))329		/// TODO: Off chain worker should remove from this map when token gets removed330		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;331332		//#region Item collections333		/// Collection id (controlled?2), token id (controlled?1)334		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;335		/// Collection id (controlled?2), owner (controlled?2)336		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;337		/// Collection id (controlled?2), token id (controlled?1)338		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;339		//#endregion340341		//#region Index list342		/// Collection id (controlled?2), tokens owner (controlled?2)343		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;344		//#endregion345346		//#region Tokens transfer rate limit baskets347		/// (Collection id (controlled?2), who created (real))348		/// TODO: Off chain worker should remove from this map when collection gets removed349		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;350		/// Collection id (controlled?2), token id (controlled?2)351		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352		/// Collection id (controlled?2), owning user (real)353		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;354		/// Collection id (controlled?2), token id (controlled?2)355		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;356		//#endregion357358		/// Variable metadata sponsoring359		/// Collection id (controlled?2), token id (controlled?2)360		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;361	}362	add_extra_genesis {363		build(|config: &GenesisConfig<T>| {364			// Modification of storage365			for (_num, _c) in &config.collection_id {366				<Module<T>>::init_collection(_c);367			}368369			for (_num, _c, _i) in &config.nft_item_id {370				<Module<T>>::init_nft_token(*_c, _i);371			}372373			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {374				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);375			}376377			for (_num, _c, _i) in &config.refungible_item_id {378				<Module<T>>::init_refungible_token(*_c, _i);379			}380		})381	}382}383384decl_event!(385	pub enum Event<T>386	where387		AccountId = <T as frame_system::Config>::AccountId,388		CrossAccountId = <T as Config>::CrossAccountId,389	{390		/// New collection was created391		///392		/// # Arguments393		///394		/// * collection_id: Globally unique identifier of newly created collection.395		///396		/// * mode: [CollectionMode] converted into u8.397		///398		/// * account_id: Collection owner.399		CollectionCreated(CollectionId, u8, AccountId),400401		/// New item was created.402		///403		/// # Arguments404		///405		/// * collection_id: Id of the collection where item was created.406		///407		/// * item_id: Id of an item. Unique within the collection.408		///409		/// * recipient: Owner of newly created item410		ItemCreated(CollectionId, TokenId, CrossAccountId),411412		/// Collection item was burned.413		///414		/// # Arguments415		///416		/// collection_id.417		///418		/// item_id: Identifier of burned NFT.419		ItemDestroyed(CollectionId, TokenId),420421		/// Item was transferred422		///423		/// * collection_id: Id of collection to which item is belong424		///425		/// * item_id: Id of an item426		///427		/// * sender: Original owner of item428		///429		/// * recipient: New owner of item430		///431		/// * amount: Always 1 for NFT432		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),433434		/// * collection_id435		///436		/// * item_id437		///438		/// * sender439		///440		/// * spender441		///442		/// * amount443		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),444	}445);446447decl_module! {448	pub struct Module<T: Config> for enum Call449	where450		origin: T::Origin451	{452		fn deposit_event() = default;453		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;454		type Error = Error<T>;455456		fn on_initialize(_now: T::BlockNumber) -> Weight {457			0458		}459460		/// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.461		///462		/// # Permissions463		///464		/// * Anyone.465		///466		/// # Arguments467		///468		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.469		///470		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.471		///472		/// * token_prefix: UTF-8 string with token prefix.473		///474		/// * mode: [CollectionMode] collection type and type dependent data.475		// returns collection ID476		#[weight = <SelfWeightOf<T>>::create_collection()]477		#[transactional]478		pub fn create_collection(origin,479								 collection_name: Vec<u16>,480								 collection_description: Vec<u16>,481								 token_prefix: Vec<u8>,482								 mode: CollectionMode) -> DispatchResult {483484			// Anyone can create a collection485			let who = ensure_signed(origin)?;486487			// Take a (non-refundable) deposit of collection creation488			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();489			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(490				&T::TreasuryAccountId::get(),491				T::CollectionCreationPrice::get(),492			));493			<T as Config>::Currency::settle(494				&who,495				imbalance,496				WithdrawReasons::TRANSFER,497				ExistenceRequirement::KeepAlive,498			).map_err(|_| Error::<T>::NoPermission)?;499500			let decimal_points = match mode {501				CollectionMode::Fungible(points) => points,502				_ => 0503			};504505			let created_count = CreatedCollectionCount::get();506			let destroyed_count = DestroyedCollectionCount::get();507508			// bound Total number of collections509			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);510511			// check params512			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);513			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);514			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);515			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);516517			// Generate next collection ID518			let next_id = created_count519				.checked_add(1)520				.ok_or(Error::<T>::NumOverflow)?;521522			CreatedCollectionCount::put(next_id);523524			let limits = CollectionLimits {525				sponsored_data_size: CUSTOM_DATA_LIMIT,526				..Default::default()527			};528529			// Create new collection530			let new_collection = Collection {531				owner: who.clone(),532				name: collection_name,533				mode: mode.clone(),534				mint_mode: false,535				access: AccessMode::Normal,536				description: collection_description,537				decimal_points,538				token_prefix,539				offchain_schema: Vec::new(),540				schema_version: SchemaVersion::ImageURL,541				sponsorship: SponsorshipState::Disabled,542				variable_on_chain_schema: Vec::new(),543				const_on_chain_schema: Vec::new(),544				limits,545				meta_update_permission: MetaUpdatePermission::default(),546				transfers_enabled: true,547			};548549			// Add new collection to map550			<CollectionById<T>>::insert(next_id, new_collection);551552			// call event553			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));554555			Ok(())556		}557558		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.559		///560		/// # Permissions561		///562		/// * Collection Owner.563		///564		/// # Arguments565		///566		/// * collection_id: collection to destroy.567		#[weight = <SelfWeightOf<T>>::destroy_collection()]568		#[transactional]569		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {570571			let sender = ensure_signed(origin)?;572			let collection = Self::get_collection(collection_id)?;573			Self::check_owner_permissions(&collection, &sender)?;574			if !collection.limits.owner_can_destroy {575				fail!(Error::<T>::NoPermission);576			}577578			<AddressTokens<T>>::remove_prefix(collection_id, None);579			<Allowances<T>>::remove_prefix(collection_id, None);580			<Balance<T>>::remove_prefix(collection_id, None);581			<ItemListIndex>::remove(collection_id);582			<AdminList<T>>::remove(collection_id);583			<CollectionById<T>>::remove(collection_id);584			<WhiteList<T>>::remove_prefix(collection_id, None);585586			<NftItemList<T>>::remove_prefix(collection_id, None);587			<FungibleItemList<T>>::remove_prefix(collection_id, None);588			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);589590			<NftTransferBasket<T>>::remove_prefix(collection_id, None);591			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);592			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);593594			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);595596			DestroyedCollectionCount::put(DestroyedCollectionCount::get()597				.checked_add(1)598				.ok_or(Error::<T>::NumOverflow)?);599600			Ok(())601		}602603		/// Add an address to white list.604		///605		/// # Permissions606		///607		/// * Collection Owner608		/// * Collection Admin609		///610		/// # Arguments611		///612		/// * collection_id.613		///614		/// * address.615		#[weight = <SelfWeightOf<T>>::add_to_white_list()]616		#[transactional]617		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{618619			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);620			let collection = Self::get_collection(collection_id)?;621622			Self::toggle_white_list_internal(623				&sender,624				&collection,625				&address,626				true,627			)?;628629			Ok(())630		}631632		/// Remove an address from white list.633		///634		/// # Permissions635		///636		/// * Collection Owner637		/// * Collection Admin638		///639		/// # Arguments640		///641		/// * collection_id.642		///643		/// * address.644		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]645		#[transactional]646		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{647648			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);649			let collection = Self::get_collection(collection_id)?;650651			Self::toggle_white_list_internal(652				&sender,653				&collection,654				&address,655				false,656			)?;657658			Ok(())659		}660661		/// Toggle between normal and white list access for the methods with access for `Anyone`.662		///663		/// # Permissions664		///665		/// * Collection Owner.666		///667		/// # Arguments668		///669		/// * collection_id.670		///671		/// * mode: [AccessMode]672		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]673		#[transactional]674		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult675		{676			let sender = ensure_signed(origin)?;677678			let mut target_collection = Self::get_collection(collection_id)?;679			Self::check_owner_permissions(&target_collection, &sender)?;680			target_collection.access = mode;681			target_collection.save()682		}683684		/// Allows Anyone to create tokens if:685		/// * White List is enabled, and686		/// * Address is added to white list, and687		/// * This method was called with True parameter688		///689		/// # Permissions690		/// * Collection Owner691		///692		/// # Arguments693		///694		/// * collection_id.695		///696		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.697		#[weight = <SelfWeightOf<T>>::set_mint_permission()]698		#[transactional]699		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult700		{701			let sender = ensure_signed(origin)?;702703			let mut target_collection = Self::get_collection(collection_id)?;704			Self::check_owner_permissions(&target_collection, &sender)?;705			target_collection.mint_mode = mint_permission;706			target_collection.save()707		}708709		/// Change the owner of the collection.710		///711		/// # Permissions712		///713		/// * Collection Owner.714		///715		/// # Arguments716		///717		/// * collection_id.718		///719		/// * new_owner.720		#[weight = <SelfWeightOf<T>>::change_collection_owner()]721		#[transactional]722		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {723724			let sender = ensure_signed(origin)?;725			let mut target_collection = Self::get_collection(collection_id)?;726			Self::check_owner_permissions(&target_collection, &sender)?;727			target_collection.owner = new_owner;728			target_collection.save()729		}730731		/// Adds an admin of the Collection.732		/// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.733		///734		/// # Permissions735		///736		/// * Collection Owner.737		/// * Collection Admin.738		///739		/// # Arguments740		///741		/// * collection_id: ID of the Collection to add admin for.742		///743		/// * new_admin_id: Address of new admin to add.744		#[weight = <SelfWeightOf<T>>::add_collection_admin()]745		#[transactional]746		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {747			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);748			let collection = Self::get_collection(collection_id)?;749			Self::check_owner_or_admin_permissions(&collection, &sender)?;750			let mut admin_arr = <AdminList<T>>::get(collection_id);751752			match admin_arr.binary_search(&new_admin_id) {753				Ok(_) => {},754				Err(idx) => {755					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);756					admin_arr.insert(idx, new_admin_id);757					<AdminList<T>>::insert(collection_id, admin_arr);758				}759			}760			Ok(())761		}762763		/// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.764		///765		/// # Permissions766		///767		/// * Collection Owner.768		/// * Collection Admin.769		///770		/// # Arguments771		///772		/// * collection_id: ID of the Collection to remove admin for.773		///774		/// * account_id: Address of admin to remove.775		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]776		#[transactional]777		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {778			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);779			let collection = Self::get_collection(collection_id)?;780			Self::check_owner_or_admin_permissions(&collection, &sender)?;781			let mut admin_arr = <AdminList<T>>::get(collection_id);782783			if let Ok(idx) = admin_arr.binary_search(&account_id) {784				admin_arr.remove(idx);785				<AdminList<T>>::insert(collection_id, admin_arr);786			}787			Ok(())788		}789790		/// # Permissions791		///792		/// * Collection Owner793		///794		/// # Arguments795		///796		/// * collection_id.797		///798		/// * new_sponsor.799		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]800		#[transactional]801		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {802			let sender = ensure_signed(origin)?;803			let mut target_collection = Self::get_collection(collection_id)?;804			Self::check_owner_permissions(&target_collection, &sender)?;805806			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);807			target_collection.save()808		}809810		/// # Permissions811		///812		/// * Sponsor.813		///814		/// # Arguments815		///816		/// * collection_id.817		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]818		#[transactional]819		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {820			let sender = ensure_signed(origin)?;821822			let mut target_collection = Self::get_collection(collection_id)?;823			ensure!(824				target_collection.sponsorship.pending_sponsor() == Some(&sender),825				Error::<T>::ConfirmUnsetSponsorFail826			);827828			target_collection.sponsorship = SponsorshipState::Confirmed(sender);829			target_collection.save()830		}831832		/// Switch back to pay-per-own-transaction model.833		///834		/// # Permissions835		///836		/// * Collection owner.837		///838		/// # Arguments839		///840		/// * collection_id.841		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]842		#[transactional]843		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844			let sender = ensure_signed(origin)?;845846			let mut target_collection = Self::get_collection(collection_id)?;847			Self::check_owner_permissions(&target_collection, &sender)?;848849			target_collection.sponsorship = SponsorshipState::Disabled;850			target_collection.save()851		}852853		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.854		///855		/// # Permissions856		///857		/// * Collection Owner.858		/// * Collection Admin.859		/// * Anyone if860		///     * White List is enabled, and861		///     * Address is added to white list, and862		///     * MintPermission is enabled (see SetMintPermission method)863		///864		/// # Arguments865		///866		/// * collection_id: ID of the collection.867		///868		/// * owner: Address, initial owner of the NFT.869		///870		/// * data: Token data to store on chain.871		// #[weight =872		// (130_000_000 as Weight)873		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))874		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))875		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]876877		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]878		#[transactional]879		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {880			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881			let collection = Self::get_collection(collection_id)?;882883			Self::create_item_internal(&sender, &collection, &owner, data)?;884885			collection.submit_logs()886		}887888		/// This method creates multiple items in a collection created with CreateCollection method.889		///890		/// # Permissions891		///892		/// * Collection Owner.893		/// * Collection Admin.894		/// * Anyone if895		///     * White List is enabled, and896		///     * Address is added to white list, and897		///     * MintPermission is enabled (see SetMintPermission method)898		///899		/// # Arguments900		///901		/// * collection_id: ID of the collection.902		///903		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].904		///905		/// * owner: Address, initial owner of the NFT.906		#[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]907		#[transactional]908		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {909910			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);911			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);912			let collection = Self::get_collection(collection_id)?;913914			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;915916			collection.submit_logs()917		}918919		// TODO! transaction weight920921		/// Set transfers_enabled value for particular collection922		///923		/// # Permissions924		///925		/// * Collection Owner.926		///927		/// # Arguments928		///929		/// * collection_id: ID of the collection.930		///931		/// * value: New flag value.932		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]933		#[transactional]934		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {935936			let sender = ensure_signed(origin)?;937			let mut target_collection = Self::get_collection(collection_id)?;938939			Self::check_owner_permissions(&target_collection, &sender)?;940941			target_collection.transfers_enabled = value;942			target_collection.save()943		}944945		// TODO! transaction weight946		/// Set meta_update_permission value for particular collection947		///948		/// # Permissions949		///950		/// * Collection Owner.951		///952		/// # Arguments953		///954		/// * collection_id: ID of the collection.955		///956		/// * value: New flag value.957		#[weight = <T as Config>::WeightInfo::burn_item()]958		#[transactional]959		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {960961			let sender = ensure_signed(origin)?;962			let mut target_collection = Self::get_collection(collection_id)?;963964			ensure!(965				target_collection.meta_update_permission != MetaUpdatePermission::None,966				Error::<T>::MetadataFlagFrozen967			);968			Self::check_owner_permissions(&target_collection, &sender)?;969970			target_collection.meta_update_permission = value;971972			target_collection.save()973		}974975		/// Destroys a concrete instance of NFT.976		///977		/// # Permissions978		///979		/// * Collection Owner.980		/// * Collection Admin.981		/// * Current NFT Owner.982		///983		/// # Arguments984		///985		/// * collection_id: ID of the collection.986		///987		/// * item_id: ID of NFT to burn.988		#[weight = <SelfWeightOf<T>>::burn_item()]989		#[transactional]990		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991992			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993			let target_collection = Self::get_collection(collection_id)?;994995			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;996997			target_collection.submit_logs()998		}9991000		/// Change ownership of the token.1001		///1002		/// # Permissions1003		///1004		/// * Collection Owner1005		/// * Collection Admin1006		/// * Current NFT owner1007		///1008		/// # Arguments1009		///1010		/// * recipient: Address of token recipient.1011		///1012		/// * collection_id.1013		///1014		/// * item_id: ID of the item1015		///     * Non-Fungible Mode: Required.1016		///     * Fungible Mode: Ignored.1017		///     * Re-Fungible Mode: Required.1018		///1019		/// * value: Amount to transfer.1020		///     * Non-Fungible Mode: Ignored1021		///     * Fungible Mode: Must specify transferred amount1022		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1023		#[weight = <SelfWeightOf<T>>::transfer()]1024		#[transactional]1025		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1026			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1027			let collection = Self::get_collection(collection_id)?;10281029			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10301031			collection.submit_logs()1032		}10331034		/// Set, change, or remove approved address to transfer the ownership of the NFT.1035		///1036		/// # Permissions1037		///1038		/// * Collection Owner1039		/// * Collection Admin1040		/// * Current NFT owner1041		///1042		/// # Arguments1043		///1044		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1045		///1046		/// * collection_id.1047		///1048		/// * item_id: ID of the item.1049		#[weight = <SelfWeightOf<T>>::approve()]1050		#[transactional]1051		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1052			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1053			let collection = Self::get_collection(collection_id)?;10541055			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10561057			collection.submit_logs()1058		}10591060		/// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1061		///1062		/// # Permissions1063		/// * Collection Owner1064		/// * Collection Admin1065		/// * Current NFT owner1066		/// * Address approved by current NFT owner1067		///1068		/// # Arguments1069		///1070		/// * from: Address that owns token.1071		///1072		/// * recipient: Address of token recipient.1073		///1074		/// * collection_id.1075		///1076		/// * item_id: ID of the item.1077		///1078		/// * value: Amount to transfer.1079		#[weight = <SelfWeightOf<T>>::transfer_from()]1080		#[transactional]1081		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1082			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1083			let collection = Self::get_collection(collection_id)?;10841085			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10861087			collection.submit_logs()1088		}1089		// #[weight = 0]1090		//     // let no_perm_mes = "You do not have permissions to modify this collection";1091		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1092		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1093		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10941095		//     // // on_nft_received  call10961097		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10981099		//     Ok(())1100		// }11011102		/// Set off-chain data schema.1103		///1104		/// # Permissions1105		///1106		/// * Collection Owner1107		/// * Collection Admin1108		///1109		/// # Arguments1110		///1111		/// * collection_id.1112		///1113		/// * schema: String representing the offchain data schema.1114		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1115		#[transactional]1116		pub fn set_variable_meta_data (1117			origin,1118			collection_id: CollectionId,1119			item_id: TokenId,1120			data: Vec<u8>1121		) -> DispatchResult {1122			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124			let collection = Self::get_collection(collection_id)?;11251126			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11271128			Ok(())1129		}11301131		/// Set schema standard1132		/// ImageURL1133		/// Unique1134		///1135		/// # Permissions1136		///1137		/// * Collection Owner1138		/// * Collection Admin1139		///1140		/// # Arguments1141		///1142		/// * collection_id.1143		///1144		/// * schema: SchemaVersion: enum1145		#[weight = <SelfWeightOf<T>>::set_schema_version()]1146		#[transactional]1147		pub fn set_schema_version(1148			origin,1149			collection_id: CollectionId,1150			version: SchemaVersion1151		) -> DispatchResult {1152			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1153			let mut target_collection = Self::get_collection(collection_id)?;1154			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1155			target_collection.schema_version = version;1156			target_collection.save()1157		}11581159		/// Set off-chain data schema.1160		///1161		/// # Permissions1162		///1163		/// * Collection Owner1164		/// * Collection Admin1165		///1166		/// # Arguments1167		///1168		/// * collection_id.1169		///1170		/// * schema: String representing the offchain data schema.1171		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1172		#[transactional]1173		pub fn set_offchain_schema(1174			origin,1175			collection_id: CollectionId,1176			schema: Vec<u8>1177		) -> DispatchResult {1178			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1179			let mut target_collection = Self::get_collection(collection_id)?;1180			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11811182			// check schema limit1183			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11841185			target_collection.offchain_schema = schema;1186			target_collection.save()1187		}11881189		/// Set const on-chain data schema.1190		///1191		/// # Permissions1192		///1193		/// * Collection Owner1194		/// * Collection Admin1195		///1196		/// # Arguments1197		///1198		/// * collection_id.1199		///1200		/// * schema: String representing the const on-chain data schema.1201		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1202		#[transactional]1203		pub fn set_const_on_chain_schema (1204			origin,1205			collection_id: CollectionId,1206			schema: Vec<u8>1207		) -> DispatchResult {1208			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1209			let mut target_collection = Self::get_collection(collection_id)?;1210			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12111212			// check schema limit1213			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12141215			target_collection.const_on_chain_schema = schema;1216			target_collection.save()1217		}12181219		/// Set variable on-chain data schema.1220		///1221		/// # Permissions1222		///1223		/// * Collection Owner1224		/// * Collection Admin1225		///1226		/// # Arguments1227		///1228		/// * collection_id.1229		///1230		/// * schema: String representing the variable on-chain data schema.1231		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1232		#[transactional]1233		pub fn set_variable_on_chain_schema (1234			origin,1235			collection_id: CollectionId,1236			schema: Vec<u8>1237		) -> DispatchResult {1238			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1239			let mut target_collection = Self::get_collection(collection_id)?;1240			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12411242			// check schema limit1243			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12441245			target_collection.variable_on_chain_schema = schema;1246			target_collection.save()1247		}12481249		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1250		#[transactional]1251		pub fn set_collection_limits(1252			origin,1253			collection_id: u32,1254			new_limits: CollectionLimits<T::BlockNumber>,1255		) -> DispatchResult {1256			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1257			let mut target_collection = Self::get_collection(collection_id)?;1258			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1259			let old_limits = &target_collection.limits;12601261			// collection bounds1262			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1263				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1264				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1265				Error::<T>::CollectionLimitBoundsExceeded);12661267			// token_limit   check  prev1268			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1269			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12701271			ensure!(1272				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1273				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1274				Error::<T>::OwnerPermissionsCantBeReverted,1275			);12761277			target_collection.limits = new_limits;12781279			target_collection.save()1280		}1281	}1282}12831284impl<T: Config> Module<T> {1285	pub fn create_item_internal(1286		sender: &T::CrossAccountId,1287		collection: &CollectionHandle<T>,1288		owner: &T::CrossAccountId,1289		data: CreateItemData,1290	) -> DispatchResult {1291		ensure!(1292			owner != &T::CrossAccountId::from_eth(H160([0; 20])),1293			Error::<T>::AddressIsZero1294		);12951296		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1297		Self::validate_create_item_args(collection, &data)?;1298		Self::create_item_no_validation(collection, owner, data)?;12991300		Ok(())1301	}13021303	pub fn transfer_internal(1304		sender: &T::CrossAccountId,1305		recipient: &T::CrossAccountId,1306		target_collection: &CollectionHandle<T>,1307		item_id: TokenId,1308		value: u128,1309	) -> DispatchResult {1310		ensure!(1311			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1312			Error::<T>::AddressIsZero1313		);13141315		// Limits check1316		Self::is_correct_transfer(target_collection, recipient)?;13171318		// Transfer permissions check1319		ensure!(1320			Self::is_item_owner(sender, target_collection, item_id)?1321				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,1322			Error::<T>::NoPermission1323		);13241325		if target_collection.access == AccessMode::WhiteList {1326			Self::check_white_list(target_collection, sender)?;1327			Self::check_white_list(target_collection, recipient)?;1328		}13291330		match target_collection.mode {1331			CollectionMode::NFT => Self::transfer_nft(1332				target_collection,1333				item_id,1334				sender.clone(),1335				recipient.clone(),1336			)?,1337			CollectionMode::Fungible(_) => {1338				Self::transfer_fungible(target_collection, value, sender, recipient)?1339			}1340			CollectionMode::ReFungible => Self::transfer_refungible(1341				target_collection,1342				item_id,1343				value,1344				sender.clone(),1345				recipient.clone(),1346			)?,1347			_ => (),1348		};13491350		Self::deposit_event(RawEvent::Transfer(1351			target_collection.id,1352			item_id,1353			sender.clone(),1354			recipient.clone(),1355			value,1356		));13571358		Ok(())1359	}13601361	pub fn approve_internal(1362		sender: &T::CrossAccountId,1363		spender: &T::CrossAccountId,1364		collection: &CollectionHandle<T>,1365		item_id: TokenId,1366		amount: u128,1367	) -> DispatchResult {1368		Self::token_exists(collection, item_id)?;13691370		// Transfer permissions check1371		let bypasses_limits = collection.limits.owner_can_transfer1372			&& Self::is_owner_or_admin_permissions(collection, sender)?;13731374		let allowance_limit = if bypasses_limits {1375			None1376		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1377			Some(amount)1378		} else {1379			fail!(Error::<T>::NoPermission);1380		};13811382		if collection.access == AccessMode::WhiteList {1383			Self::check_white_list(collection, sender)?;1384			Self::check_white_list(collection, spender)?;1385		}13861387		collection.consume_sload()?;1388		let allowance: u128 = amount1389			.checked_add(<Allowances<T>>::get(1390				collection.id,1391				(item_id, sender.as_sub(), spender.as_sub()),1392			))1393			.ok_or(Error::<T>::NumOverflow)?;1394		if let Some(limit) = allowance_limit {1395			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1396		}1397		collection.consume_sstore()?;1398		<Allowances<T>>::insert(1399			collection.id,1400			(item_id, sender.as_sub(), spender.as_sub()),1401			allowance,1402		);14031404		if matches!(collection.mode, CollectionMode::NFT) {1405			// TODO: NFT: only one owner may exist for token in ERC7211406			collection.log(ERC721Events::Approval {1407				owner: *sender.as_eth(),1408				approved: *spender.as_eth(),1409				token_id: item_id.into(),1410			})?;1411		}14121413		if matches!(collection.mode, CollectionMode::Fungible(_)) {1414			// TODO: NFT: only one owner may exist for token in ERC201415			collection.log(ERC20Events::Approval {1416				owner: *sender.as_eth(),1417				spender: *spender.as_eth(),1418				value: allowance.into(),1419			})?;1420		}14211422		Self::deposit_event(RawEvent::Approved(1423			collection.id,1424			item_id,1425			sender.clone(),1426			spender.clone(),1427			allowance,1428		));1429		Ok(())1430	}14311432	pub fn transfer_from_internal(1433		sender: &T::CrossAccountId,1434		from: &T::CrossAccountId,1435		recipient: &T::CrossAccountId,1436		collection: &CollectionHandle<T>,1437		item_id: TokenId,1438		amount: u128,1439	) -> DispatchResult {1440		if sender == from {1441			// Transfer by `from`, because it is either equal to sender, or derived from him1442			return Self::transfer_internal(from, recipient, collection, item_id, amount);1443		}14441445		// Check approval1446		collection.consume_sload()?;1447		let approval: u128 =1448			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14491450		// Limits check1451		Self::is_correct_transfer(collection, recipient)?;14521453		// Transfer permissions check1454		ensure!(1455			approval >= amount1456				|| (collection.limits.owner_can_transfer1457					&& Self::is_owner_or_admin_permissions(collection, sender)?),1458			Error::<T>::NoPermission1459		);14601461		if collection.access == AccessMode::WhiteList {1462			Self::check_white_list(collection, sender)?;1463			Self::check_white_list(collection, recipient)?;1464		}14651466		// Reduce approval by transferred amount or remove if remaining approval drops to 01467		let allowance = approval.saturating_sub(amount);1468		collection.consume_sstore()?;1469		if allowance > 0 {1470			<Allowances<T>>::insert(1471				collection.id,1472				(item_id, from.as_sub(), sender.as_sub()),1473				allowance,1474			);1475		} else {1476			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1477		}14781479		match collection.mode {1480			CollectionMode::NFT => {1481				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1482			}1483			CollectionMode::Fungible(_) => {1484				Self::transfer_fungible(collection, amount, from, recipient)?1485			}1486			CollectionMode::ReFungible => Self::transfer_refungible(1487				collection,1488				item_id,1489				amount,1490				from.clone(),1491				recipient.clone(),1492			)?,1493			_ => (),1494		};14951496		if matches!(collection.mode, CollectionMode::Fungible(_)) {1497			collection.log(ERC20Events::Approval {1498				owner: *from.as_eth(),1499				spender: *sender.as_eth(),1500				value: allowance.into(),1501			})?;1502		}15031504		Ok(())1505	}15061507	pub fn set_variable_meta_data_internal(1508		sender: &T::CrossAccountId,1509		collection: &CollectionHandle<T>,1510		item_id: TokenId,1511		data: Vec<u8>,1512	) -> DispatchResult {1513		Self::token_exists(collection, item_id)?;15141515		ensure!(1516			CUSTOM_DATA_LIMIT >= data.len() as u32,1517			Error::<T>::TokenVariableDataLimitExceeded1518		);15191520		ensure!(1521			(Self::is_item_owner(sender, collection, item_id)?1522				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1523				|| (Self::is_owner_or_admin_permissions(collection, sender)?1524					&& collection.meta_update_permission == MetaUpdatePermission::Admin),1525			Error::<T>::NoPermission1526		);15271528		match collection.mode {1529			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1530			CollectionMode::ReFungible => {1531				Self::set_re_fungible_variable_data(collection, item_id, data)?1532			}1533			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1534			_ => fail!(Error::<T>::UnexpectedCollectionType),1535		};15361537		Ok(())1538	}15391540	pub fn meta_update_check(1541		sender: &T::CrossAccountId,1542		collection: &CollectionHandle<T>,1543		item_id: TokenId,1544	) -> DispatchResult {1545		match collection.meta_update_permission {1546			MetaUpdatePermission::ItemOwner => ensure!(1547				Self::is_item_owner(sender, collection, item_id)?,1548				Error::<T>::NoPermission1549			),1550			MetaUpdatePermission::Admin => ensure!(1551				Self::is_owner_or_admin_permissions(collection, sender)?,1552				Error::<T>::NoPermission1553			),1554			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1555		}15561557		Ok(())1558	}15591560	pub fn get_variable_metadata(1561		collection: &CollectionHandle<T>,1562		item_id: TokenId,1563	) -> Result<Vec<u8>, DispatchError> {1564		Ok(match collection.mode {1565			CollectionMode::NFT => {1566				<NftItemList<T>>::get(collection.id, item_id)1567					.ok_or(Error::<T>::TokenNotFound)?1568					.variable_data1569			}1570			CollectionMode::ReFungible => {1571				<ReFungibleItemList<T>>::get(collection.id, item_id)1572					.ok_or(Error::<T>::TokenNotFound)?1573					.variable_data1574			}1575			_ => fail!(Error::<T>::UnexpectedCollectionType),1576		})1577	}15781579	pub fn create_multiple_items_internal(1580		sender: &T::CrossAccountId,1581		collection: &CollectionHandle<T>,1582		owner: &T::CrossAccountId,1583		items_data: Vec<CreateItemData>,1584	) -> DispatchResult {1585		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15861587		for data in &items_data {1588			Self::validate_create_item_args(collection, data)?;1589		}1590		for data in &items_data {1591			Self::create_item_no_validation(collection, owner, data.clone())?;1592		}15931594		Ok(())1595	}15961597	pub fn burn_item_internal(1598		sender: &T::CrossAccountId,1599		collection: &CollectionHandle<T>,1600		item_id: TokenId,1601		value: u128,1602	) -> DispatchResult {1603		ensure!(1604			Self::is_item_owner(sender, collection, item_id)?1605				|| (collection.limits.owner_can_transfer1606					&& Self::is_owner_or_admin_permissions(collection, sender)?),1607			Error::<T>::NoPermission1608		);16091610		if collection.access == AccessMode::WhiteList {1611			Self::check_white_list(collection, sender)?;1612		}16131614		match collection.mode {1615			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1616			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1617			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1618			_ => (),1619		};16201621		Ok(())1622	}16231624	pub fn toggle_white_list_internal(1625		sender: &T::CrossAccountId,1626		collection: &CollectionHandle<T>,1627		address: &T::CrossAccountId,1628		whitelisted: bool,1629	) -> DispatchResult {1630		Self::check_owner_or_admin_permissions(collection, sender)?;16311632		if whitelisted {1633			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1634		} else {1635			<WhiteList<T>>::remove(collection.id, address.as_sub());1636		}16371638		Ok(())1639	}16401641	fn is_correct_transfer(1642		collection: &CollectionHandle<T>,1643		recipient: &T::CrossAccountId,1644	) -> DispatchResult {1645		let collection_id = collection.id;16461647		// check token limit and account token limit1648		collection.consume_sload()?;1649		let account_items: u32 =1650			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16511652		// zero limit means collection limit is disabled1653		// otherwise get lower value1654		let limit = if collection.limits.account_token_ownership_limit == 01655			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1656		{1657			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1658		} else {1659			collection.limits.account_token_ownership_limit1660		};16611662		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16631664		// preliminary transfer check1665		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16661667		Ok(())1668	}16691670	fn can_create_items_in_collection(1671		collection: &CollectionHandle<T>,1672		sender: &T::CrossAccountId,1673		owner: &T::CrossAccountId,1674		amount: u32,1675	) -> DispatchResult {1676		let collection_id = collection.id;16771678		// check token limit and account token limit1679		let total_items: u32 = ItemListIndex::get(collection_id)1680			.checked_add(amount)1681			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1682		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1683			as u32)1684			.checked_add(amount)1685			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;16861687		// zero limit means collection limit is disabled1688		// otherwise get lower value1689		let account_token_limit = if collection.limits.account_token_ownership_limit == 01690			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1691		{1692			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1693		} else {1694			collection.limits.account_token_ownership_limit1695		};16961697		ensure!(1698			collection.limits.token_limit >= total_items,1699			Error::<T>::CollectionTokenLimitExceeded1700		);1701		ensure!(1702			account_token_limit >= account_items,1703			Error::<T>::AccountTokenLimitExceeded1704		);17051706		if !Self::is_owner_or_admin_permissions(collection, sender)? {1707			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1708			Self::check_white_list(collection, owner)?;1709			Self::check_white_list(collection, sender)?;1710		}17111712		Ok(())1713	}17141715	fn validate_create_item_args(1716		target_collection: &CollectionHandle<T>,1717		data: &CreateItemData,1718	) -> DispatchResult {1719		match target_collection.mode {1720			CollectionMode::NFT => {1721				if !matches!(data, CreateItemData::NFT(_)) {1722					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1723				}1724			}1725			CollectionMode::Fungible(_) => {1726				if !matches!(data, CreateItemData::Fungible(_)) {1727					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1728				}1729			}1730			CollectionMode::ReFungible => {1731				if let CreateItemData::ReFungible(data) = data {1732					// Check refungibility limits1733					ensure!(1734						data.pieces <= MAX_REFUNGIBLE_PIECES,1735						Error::<T>::WrongRefungiblePieces1736					);1737					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1738				} else {1739					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1740				}1741			}1742			_ => {1743				fail!(Error::<T>::UnexpectedCollectionType);1744			}1745		};17461747		Ok(())1748	}17491750	fn create_item_no_validation(1751		collection: &CollectionHandle<T>,1752		owner: &T::CrossAccountId,1753		data: CreateItemData,1754	) -> DispatchResult {1755		match data {1756			CreateItemData::NFT(data) => {1757				let item = NftItemType {1758					owner: owner.clone(),1759					const_data: data.const_data.into_inner(),1760					variable_data: data.variable_data.into_inner(),1761				};17621763				Self::add_nft_item(collection, item)?;1764			}1765			CreateItemData::Fungible(data) => {1766				Self::add_fungible_item(collection, owner, data.value)?;1767			}1768			CreateItemData::ReFungible(data) => {1769				let owner_list = vec![Ownership {1770					owner: owner.clone(),1771					fraction: data.pieces,1772				}];17731774				let item = ReFungibleItemType {1775					owner: owner_list,1776					const_data: data.const_data.into_inner(),1777					variable_data: data.variable_data.into_inner(),1778				};17791780				Self::add_refungible_item(collection, item)?;1781			}1782		};17831784		Ok(())1785	}17861787	fn add_fungible_item(1788		collection: &CollectionHandle<T>,1789		owner: &T::CrossAccountId,1790		value: u128,1791	) -> DispatchResult {1792		let collection_id = collection.id;17931794		// Does new owner already have an account?1795		collection.consume_sload()?;1796		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17971798		// Mint1799		let item = FungibleItemType {1800			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1801		};1802		collection.consume_sstore()?;1803		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18041805		// Update balance1806		collection.consume_sload()?;1807		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1808			.checked_add(value)1809			.ok_or(Error::<T>::NumOverflow)?;1810		collection.consume_sstore()?;1811		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18121813		collection.log(ERC20Events::Transfer {1814			from: H160::default(),1815			to: *owner.as_eth(),1816			value: value.into(),1817		})?;1818		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1819		Ok(())1820	}18211822	fn add_refungible_item(1823		collection: &CollectionHandle<T>,1824		item: ReFungibleItemType<T::CrossAccountId>,1825	) -> DispatchResult {1826		let collection_id = collection.id;18271828		let current_index = <ItemListIndex>::get(collection_id)1829			.checked_add(1)1830			.ok_or(Error::<T>::NumOverflow)?;1831		let itemcopy = item.clone();18321833		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1834		let item_owner = item.owner.first().expect("only one owner is defined");18351836		let value = item_owner.fraction;1837		let owner = item_owner.owner.clone();18381839		Self::add_token_index(collection, current_index, &owner)?;18401841		<ItemListIndex>::insert(collection_id, current_index);1842		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18431844		// Update balance1845		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1846			.checked_add(value)1847			.ok_or(Error::<T>::NumOverflow)?;1848		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18491850		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1851		Ok(())1852	}18531854	fn add_nft_item(1855		collection: &CollectionHandle<T>,1856		item: NftItemType<T::CrossAccountId>,1857	) -> DispatchResult {1858		let collection_id = collection.id;18591860		let current_index = <ItemListIndex>::get(collection_id)1861			.checked_add(1)1862			.ok_or(Error::<T>::NumOverflow)?;18631864		let item_owner = item.owner.clone();1865		Self::add_token_index(collection, current_index, &item.owner)?;18661867		<ItemListIndex>::insert(collection_id, current_index);1868		<NftItemList<T>>::insert(collection_id, current_index, item);18691870		// Update balance1871		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1872			.checked_add(1)1873			.ok_or(Error::<T>::NumOverflow)?;1874		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18751876		collection.log(ERC721Events::Transfer {1877			from: H160::default(),1878			to: *item_owner.as_eth(),1879			token_id: current_index.into(),1880		})?;1881		Self::deposit_event(RawEvent::ItemCreated(1882			collection_id,1883			current_index,1884			item_owner,1885		));1886		Ok(())1887	}18881889	fn burn_refungible_item(1890		collection: &CollectionHandle<T>,1891		item_id: TokenId,1892		owner: &T::CrossAccountId,1893	) -> DispatchResult {1894		let collection_id = collection.id;18951896		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1897			.ok_or(Error::<T>::TokenNotFound)?;1898		let rft_balance = token1899			.owner1900			.iter()1901			.find(|&i| i.owner == *owner)1902			.ok_or(Error::<T>::TokenNotFound)?;1903		Self::remove_token_index(collection, item_id, owner)?;19041905		// update balance1906		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1907			.checked_sub(rft_balance.fraction)1908			.ok_or(Error::<T>::NumOverflow)?;1909		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19101911		// Re-create owners list with sender removed1912		let index = token1913			.owner1914			.iter()1915			.position(|i| i.owner == *owner)1916			.expect("owned item is exists");1917		token.owner.remove(index);1918		let owner_count = token.owner.len();19191920		// Burn the token completely if this was the last (only) owner1921		if owner_count == 0 {1922			<ReFungibleItemList<T>>::remove(collection_id, item_id);1923			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1924		} else {1925			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1926		}19271928		Ok(())1929	}19301931	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1932		let collection_id = collection.id;19331934		let item =1935			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1936		Self::remove_token_index(collection, item_id, &item.owner)?;19371938		// update balance1939		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1940			.checked_sub(1)1941			.ok_or(Error::<T>::NumOverflow)?;1942		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1943		<NftItemList<T>>::remove(collection_id, item_id);1944		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);19451946		collection.log(ERC721Events::Transfer {1947			from: *item.owner.as_eth(),1948			to: H160::default(),1949			token_id: item_id.into(),1950		})?;1951		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1952		Ok(())1953	}19541955	fn burn_fungible_item(1956		owner: &T::CrossAccountId,1957		collection: &CollectionHandle<T>,1958		value: u128,1959	) -> DispatchResult {1960		let collection_id = collection.id;19611962		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1963		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19641965		// update balance1966		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1967			.checked_sub(value)1968			.ok_or(Error::<T>::NumOverflow)?;1969		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19701971		if balance.value - value > 0 {1972			balance.value -= value;1973			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1974		} else {1975			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1976		}19771978		collection.log(ERC20Events::Transfer {1979			from: *owner.as_eth(),1980			to: H160::default(),1981			value: value.into(),1982		})?;1983		Ok(())1984	}19851986	pub fn get_collection(1987		collection_id: CollectionId,1988	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1989		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1990	}19911992	fn check_owner_permissions(1993		target_collection: &CollectionHandle<T>,1994		subject: &T::AccountId,1995	) -> DispatchResult {1996		ensure!(1997			*subject == target_collection.owner,1998			Error::<T>::NoPermission1999		);20002001		Ok(())2002	}20032004	fn is_owner_or_admin_permissions(2005		collection: &CollectionHandle<T>,2006		subject: &T::CrossAccountId,2007	) -> Result<bool, DispatchError> {2008		collection.consume_sload()?;2009		Ok(*subject.as_sub() == collection.owner2010			|| <AdminList<T>>::get(collection.id).contains(subject))2011	}20122013	fn check_owner_or_admin_permissions(2014		collection: &CollectionHandle<T>,2015		subject: &T::CrossAccountId,2016	) -> DispatchResult {2017		ensure!(2018			Self::is_owner_or_admin_permissions(collection, subject)?,2019			Error::<T>::NoPermission2020		);20212022		Ok(())2023	}20242025	fn owned_amount(2026		subject: &T::CrossAccountId,2027		collection: &CollectionHandle<T>,2028		item_id: TokenId,2029	) -> Result<Option<u128>, DispatchError> {2030		collection.consume_sload()?;2031		Ok(Self::owned_amount_unchecked(subject, collection, item_id))2032	}20332034	fn owned_amount_unchecked(2035		subject: &T::CrossAccountId,2036		target_collection: &CollectionHandle<T>,2037		item_id: TokenId,2038	) -> Option<u128> {2039		let collection_id = target_collection.id;20402041		match target_collection.mode {2042			CollectionMode::NFT => {2043				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2044			}2045			CollectionMode::Fungible(_) => {2046				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2047			}2048			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2049				.owner2050				.iter()2051				.find(|i| i.owner == *subject)2052				.map(|i| i.fraction),2053			CollectionMode::Invalid => None,2054		}2055	}20562057	fn is_item_owner(2058		subject: &T::CrossAccountId,2059		target_collection: &CollectionHandle<T>,2060		item_id: TokenId,2061	) -> Result<bool, DispatchError> {2062		Ok(match target_collection.mode {2063			CollectionMode::Fungible(_) => true,2064			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2065		})2066	}20672068	fn check_white_list(2069		collection: &CollectionHandle<T>,2070		address: &T::CrossAccountId,2071	) -> DispatchResult {2072		collection.consume_sload()?;2073		ensure!(2074			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),2075			Error::<T>::AddresNotInWhiteList,2076		);2077		Ok(())2078	}20792080	/// Check if token exists. In case of Fungible, check if there is an entry for2081	/// the owner in fungible balances double map2082	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2083		let collection_id = target_collection.id;2084		let exists = match target_collection.mode {2085			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2086			CollectionMode::Fungible(_) => true,2087			CollectionMode::ReFungible => {2088				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2089			}2090			_ => false,2091		};20922093		ensure!(exists, Error::<T>::TokenNotFound);2094		Ok(())2095	}20962097	fn transfer_fungible(2098		collection: &CollectionHandle<T>,2099		value: u128,2100		owner: &T::CrossAccountId,2101		recipient: &T::CrossAccountId,2102	) -> DispatchResult {2103		let collection_id = collection.id;21042105		collection.consume_sload()?;2106		collection.consume_sload()?;2107		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2108		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21092110		recipient_balance.value = recipient_balance2111			.value2112			.checked_add(value)2113			.ok_or(Error::<T>::NumOverflow)?;2114		balance.value = balance2115			.value2116			.checked_sub(value)2117			.ok_or(Error::<T>::TokenValueTooLow)?;21182119		// update balanceOf2120		collection.consume_sstore()?;2121		collection.consume_sstore()?;2122		if balance.value != 0 {2123			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2124		} else {2125			<Balance<T>>::remove(collection_id, owner.as_sub());2126		}2127		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21282129		// Reduce or remove sender2130		collection.consume_sstore()?;2131		collection.consume_sstore()?;2132		if balance.value != 0 {2133			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2134		} else {2135			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2136		}2137		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21382139		collection.log(ERC20Events::Transfer {2140			from: *owner.as_eth(),2141			to: *recipient.as_eth(),2142			value: value.into(),2143		})?;2144		Self::deposit_event(RawEvent::Transfer(2145			collection.id,2146			1,2147			owner.clone(),2148			recipient.clone(),2149			value,2150		));21512152		Ok(())2153	}21542155	fn transfer_refungible(2156		collection: &CollectionHandle<T>,2157		item_id: TokenId,2158		value: u128,2159		owner: T::CrossAccountId,2160		new_owner: T::CrossAccountId,2161	) -> DispatchResult {2162		let collection_id = collection.id;2163		collection.consume_sload()?;2164		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2165			.ok_or(Error::<T>::TokenNotFound)?;21662167		let item = full_item2168			.owner2169			.iter()2170			.find(|i| i.owner == owner)2171			.ok_or(Error::<T>::TokenNotFound)?;2172		let amount = item.fraction;21732174		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21752176		collection.consume_sload()?;2177		// update balance2178		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2179			.checked_sub(value)2180			.ok_or(Error::<T>::NumOverflow)?;2181		collection.consume_sstore()?;2182		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21832184		collection.consume_sload()?;2185		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2186			.checked_add(value)2187			.ok_or(Error::<T>::NumOverflow)?;2188		collection.consume_sstore()?;2189		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21902191		let old_owner = item.owner.clone();2192		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21932194		let mut new_full_item = full_item.clone();2195		// transfer2196		if amount == value && !new_owner_has_account {2197			// change owner2198			// new owner do not have account2199			new_full_item2200				.owner2201				.iter_mut()2202				.find(|i| i.owner == owner)2203				.expect("old owner does present in refungible")2204				.owner = new_owner.clone();2205			collection.consume_sstore()?;2206			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22072208			// update index collection2209			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2210		} else {2211			new_full_item2212				.owner2213				.iter_mut()2214				.find(|i| i.owner == owner)2215				.expect("old owner does present in refungible")2216				.fraction -= value;22172218			// separate amount2219			if new_owner_has_account {2220				// new owner has account2221				new_full_item2222					.owner2223					.iter_mut()2224					.find(|i| i.owner == new_owner)2225					.expect("new owner has account")2226					.fraction += value;2227			} else {2228				// new owner do not have account2229				new_full_item.owner.push(Ownership {2230					owner: new_owner.clone(),2231					fraction: value,2232				});2233				Self::add_token_index(collection, item_id, &new_owner)?;2234			}22352236			collection.consume_sstore()?;2237			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2238		}22392240		Self::deposit_event(RawEvent::Transfer(2241			collection.id,2242			item_id,2243			owner,2244			new_owner,2245			amount,2246		));22472248		Ok(())2249	}22502251	fn transfer_nft(2252		collection: &CollectionHandle<T>,2253		item_id: TokenId,2254		sender: T::CrossAccountId,2255		new_owner: T::CrossAccountId,2256	) -> DispatchResult {2257		let collection_id = collection.id;2258		collection.consume_sload()?;2259		let mut item =2260			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22612262		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22632264		collection.consume_sload()?;2265		// update balance2266		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2267			.checked_sub(1)2268			.ok_or(Error::<T>::NumOverflow)?;2269		collection.consume_sstore()?;2270		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22712272		collection.consume_sload()?;2273		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2274			.checked_add(1)2275			.ok_or(Error::<T>::NumOverflow)?;2276		collection.consume_sstore()?;2277		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22782279		// change owner2280		let old_owner = item.owner.clone();2281		item.owner = new_owner.clone();2282		collection.consume_sstore()?;2283		<NftItemList<T>>::insert(collection_id, item_id, item);22842285		// update index collection2286		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22872288		collection.log(ERC721Events::Transfer {2289			from: *sender.as_eth(),2290			to: *new_owner.as_eth(),2291			token_id: item_id.into(),2292		})?;2293		Self::deposit_event(RawEvent::Transfer(2294			collection.id,2295			item_id,2296			sender,2297			new_owner,2298			1,2299		));23002301		Ok(())2302	}23032304	fn set_re_fungible_variable_data(2305		collection: &CollectionHandle<T>,2306		item_id: TokenId,2307		data: Vec<u8>,2308	) -> DispatchResult {2309		let collection_id = collection.id;2310		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2311			.ok_or(Error::<T>::TokenNotFound)?;23122313		item.variable_data = data;23142315		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);23162317		Ok(())2318	}23192320	fn set_nft_variable_data(2321		collection: &CollectionHandle<T>,2322		item_id: TokenId,2323		data: Vec<u8>,2324	) -> DispatchResult {2325		let collection_id = collection.id;2326		let mut item =2327			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23282329		item.variable_data = data;23302331		<NftItemList<T>>::insert(collection_id, item_id, item);23322333		Ok(())2334	}23352336	#[allow(dead_code)]2337	fn init_collection(item: &Collection<T>) {2338		// check params2339		assert!(2340			item.decimal_points <= MAX_DECIMAL_POINTS,2341			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2342		);2343		assert!(2344			item.name.len() <= 64,2345			"Collection name can not be longer than 63 char"2346		);2347		assert!(2348			item.name.len() <= 256,2349			"Collection description can not be longer than 255 char"2350		);2351		assert!(2352			item.token_prefix.len() <= 16,2353			"Token prefix can not be longer than 15 char"2354		);23552356		// Generate next collection ID2357		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23582359		CreatedCollectionCount::put(next_id);2360	}23612362	#[allow(dead_code)]2363	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2364		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23652366		Self::add_token_index(2367			&CollectionHandle::get(collection_id).unwrap(),2368			current_index,2369			&item.owner,2370		)2371		.unwrap();23722373		<ItemListIndex>::insert(collection_id, current_index);23742375		// Update balance2376		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2377			.checked_add(1)2378			.unwrap();2379		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2380	}23812382	#[allow(dead_code)]2383	fn init_fungible_token(2384		collection_id: CollectionId,2385		owner: &T::CrossAccountId,2386		item: &FungibleItemType,2387	) {2388		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23892390		Self::add_token_index(2391			&CollectionHandle::get(collection_id).unwrap(),2392			current_index,2393			owner,2394		)2395		.unwrap();23962397		<ItemListIndex>::insert(collection_id, current_index);23982399		// Update balance2400		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2401			.checked_add(item.value)2402			.unwrap();2403		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2404	}24052406	#[allow(dead_code)]2407	fn init_refungible_token(2408		collection_id: CollectionId,2409		item: &ReFungibleItemType<T::CrossAccountId>,2410	) {2411		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24122413		let value = item.owner.first().unwrap().fraction;2414		let owner = item.owner.first().unwrap().owner.clone();24152416		Self::add_token_index(2417			&CollectionHandle::get(collection_id).unwrap(),2418			current_index,2419			&owner,2420		)2421		.unwrap();24222423		<ItemListIndex>::insert(collection_id, current_index);24242425		// Update balance2426		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2427			.checked_add(value)2428			.unwrap();2429		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2430	}24312432	fn add_token_index(2433		collection: &CollectionHandle<T>,2434		item_index: TokenId,2435		owner: &T::CrossAccountId,2436	) -> DispatchResult {2437		collection.consume_sload()?;2438		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2439		if list_exists {2440			collection.consume_sload()?;2441			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24422443			// bound Owned tokens by a single address in collection2444			let account_items: u32 = list.len() as u32;2445			ensure!(2446				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2447				Error::<T>::AddressOwnershipLimitExceeded2448			);24492450			let item_contains = list.contains(&item_index.clone());24512452			if !item_contains {2453				list.push(item_index);2454			}24552456			collection.consume_sstore()?;2457			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2458		} else {2459			let itm = vec![item_index];2460			collection.consume_sstore()?;2461			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2462		}24632464		Ok(())2465	}24662467	fn remove_token_index(2468		collection: &CollectionHandle<T>,2469		item_index: TokenId,2470		owner: &T::CrossAccountId,2471	) -> DispatchResult {2472		collection.consume_sload()?;2473		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2474		if list_exists {2475			collection.consume_sload()?;2476			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2477			let item_contains = list.contains(&item_index.clone());24782479			if item_contains {2480				list.retain(|&item| item != item_index);2481				collection.consume_sstore()?;2482				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2483			}2484		}24852486		Ok(())2487	}24882489	fn move_token_index(2490		collection: &CollectionHandle<T>,2491		item_index: TokenId,2492		old_owner: &T::CrossAccountId,2493		new_owner: &T::CrossAccountId,2494	) -> DispatchResult {2495		Self::remove_token_index(collection, item_index, old_owner)?;2496		Self::add_token_index(collection, item_index, new_owner)?;24972498		Ok(())2499	}2500}25012502sp_api::decl_runtime_apis! {2503	pub trait NftApi {2504		/// Used for ethereum integration2505		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2506	}2507}