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

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9	clippy::too_many_arguments,10	clippy::unnecessary_mut_passed,11	clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19	construct_runtime, decl_event, decl_module, decl_storage, decl_error,20	dispatch::DispatchResult,21	ensure, fail, parameter_types,22	traits::{23		Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24		Randomness, IsSubType, WithdrawReasons,25	},26	weights::{27		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29		WeightToFeePolynomial, DispatchClass,30	},31	StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41	CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46	MetaUpdatePermission, FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70	/// Error for non-fungible-token module.71	pub enum Error for Module<T: Config> {72		/// Total collections bound exceeded.73		TotalCollectionsLimitExceeded,74		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75		CollectionDecimalPointLimitExceeded,76		/// Collection name can not be longer than 63 char.77		CollectionNameLimitExceeded,78		/// Collection description can not be longer than 255 char.79		CollectionDescriptionLimitExceeded,80		/// Token prefix can not be longer than 15 char.81		CollectionTokenPrefixLimitExceeded,82		/// This collection does not exist.83		CollectionNotFound,84		/// Item not exists.85		TokenNotFound,86		/// Admin not found87		AdminNotFound,88		/// Arithmetic calculation overflow.89		NumOverflow,90		/// Account already has admin role.91		AlreadyAdmin,92		/// You do not own this collection.93		NoPermission,94		/// This address is not set as sponsor, use setCollectionSponsor first.95		ConfirmUnsetSponsorFail,96		/// Collection is not in mint mode.97		PublicMintingNotAllowed,98		/// Sender parameter and item owner must be equal.99		MustBeTokenOwner,100		/// Item balance not enough.101		TokenValueTooLow,102		/// Size of item is too large.103		NftSizeLimitExceeded,104		/// No approve found105		ApproveNotFound,106		/// Requested value more than approved.107		TokenValueNotEnough,108		/// Only approved addresses can call this method.109		ApproveRequired,110		/// Address is not in white list.111		AddresNotInWhiteList,112		/// Number of collection admins bound exceeded.113		CollectionAdminsLimitExceeded,114		/// Owned tokens by a single address bound exceeded.115		AddressOwnershipLimitExceeded,116		/// Length of items properties must be greater than 0.117		EmptyArgument,118		/// const_data exceeded data limit.119		TokenConstDataLimitExceeded,120		/// variable_data exceeded data limit.121		TokenVariableDataLimitExceeded,122		/// Not NFT item data used to mint in NFT collection.123		NotNftDataUsedToMintNftCollectionToken,124		/// Not Fungible item data used to mint in Fungible collection.125		NotFungibleDataUsedToMintFungibleCollectionToken,126		/// Not Re Fungible item data used to mint in Re Fungible collection.127		NotReFungibleDataUsedToMintReFungibleCollectionToken,128		/// Unexpected collection type.129		UnexpectedCollectionType,130		/// Can't store metadata in fungible tokens.131		CantStoreMetadataInFungibleTokens,132		/// Collection token limit exceeded133		CollectionTokenLimitExceeded,134		/// Account token limit exceeded per collection135		AccountTokenLimitExceeded,136		/// Collection limit bounds per collection exceeded137		CollectionLimitBoundsExceeded,138		/// Tried to enable permissions which are only permitted to be disabled139		OwnerPermissionsCantBeReverted,140		/// Schema data size limit bound exceeded141		SchemaDataLimitExceeded,142		/// Maximum refungibility exceeded143		WrongRefungiblePieces,144		/// createRefungible should be called with one owner145		BadCreateRefungibleCall,146		/// Gas limit exceeded147		OutOfGas,148		/// Metadata update denied by collection settings149		MetadataUpdateDenied,150		/// Metadata update flag become unmutable with None option151		MetadataFlagFrozen,152		/// Collection settings not allowing items transferring153		TransferNotAllowed,154		/// Can't transfer tokens to ethereum zero address155		AddressIsZero,156	}157}158159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]160pub struct CollectionHandle<T: Config> {161	pub id: CollectionId,162	collection: Collection<T>,163	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,164}165impl<T: Config> CollectionHandle<T> {166	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {167		<CollectionById<T>>::get(id).map(|collection| Self {168			id,169			collection,170			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(171				eth::collection_id_to_address(id),172				gas_limit,173			),174		})175	}176	pub fn get(id: CollectionId) -> Option<Self> {177		Self::get_with_gas_limit(id, u64::MAX)178	}179	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {180		self.recorder.log_sub(log)181	}182	#[allow(dead_code)]183	fn consume_gas(&self, gas: u64) -> DispatchResult {184		self.recorder.consume_gas_sub(gas)185	}186	fn consume_sload(&self) -> DispatchResult {187		self.recorder.consume_sload_sub()188	}189	fn consume_sstore(&self) -> DispatchResult {190		self.recorder.consume_sstore_sub()191	}192	pub fn submit_logs(self) -> DispatchResult {193		self.recorder.submit_logs()194	}195	pub fn save(self) -> DispatchResult {196		self.recorder.submit_logs()?;197		<CollectionById<T>>::insert(self.id, self.collection);198		Ok(())199	}200}201impl<T: Config> Deref for CollectionHandle<T> {202	type Target = Collection<T>;203204	fn deref(&self) -> &Self::Target {205		&self.collection206	}207}208209impl<T: Config> DerefMut for CollectionHandle<T> {210	fn deref_mut(&mut self) -> &mut Self::Target {211		&mut self.collection212	}213}214215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {216	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;217218	/// Weight information for extrinsics in this pallet.219	type WeightInfo: WeightInfo;220221	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;222	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;223224	type CrossAccountId: CrossAccountId<Self::AccountId>;225	type Currency: Currency<Self::AccountId>;226	type CollectionCreationPrice: Get<227		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,228	>;229	type TreasuryAccountId: Get<Self::AccountId>;230}231232type SelfWeightOf<T> = <T as Config>::WeightInfo;233234trait WeightInfoHelpers: WeightInfo {235	fn transfer() -> Weight {236		Self::transfer_nft()237			.max(Self::transfer_fungible())238			.max(Self::transfer_refungible())239	}240	fn transfer_from() -> Weight {241		Self::transfer_from_nft()242			.max(Self::transfer_from_fungible())243			.max(Self::transfer_from_refungible())244	}245	fn approve() -> Weight {246		// TODO: refungible, fungible247		Self::approve_nft()248	}249	fn set_variable_meta_data(data: u32) -> Weight {250		// TODO: refungible251		Self::set_variable_meta_data_nft(data)252	}253	fn create_item(data: u32) -> Weight {254		Self::create_item_nft(data)255			.max(Self::create_item_fungible())256			.max(Self::create_item_refungible(data))257	}258	fn create_multiple_items(amount: u32) -> Weight {259		Self::create_multiple_items_nft(amount)260			.max(Self::create_multiple_items_fungible(amount))261			.max(Self::create_multiple_items_refungible(amount))262	}263	fn burn_item() -> Weight {264		// TODO: refungible, fungible265		Self::burn_item_nft()266	}267}268impl<T: WeightInfo> WeightInfoHelpers for T {}269270// # Used definitions271//272// ## User control levels273//274// chain-controlled - key is uncontrolled by user275//                    i.e autoincrementing index276//                    can use non-cryptographic hash277// real - key is controlled by user278//        but it is hard to generate enough colliding values, i.e owner of signed txs279//        can use non-cryptographic hash280// controlled - key is completly controlled by users281//              i.e maps with mutable keys282//              should use cryptographic hash283//284// ## User control level downgrade reasons285//286// ?1 - chain-controlled -> controlled287//      collections/tokens can be destroyed, resulting in massive holes288// ?2 - chain-controlled -> controlled289//      same as ?1, but can be only added, resulting in easier exploitation290// ?3 - real -> controlled291//      no confirmation required, so addresses can be easily generated292decl_storage! {293	trait Store for Module<T: Config> as Nft {294295		//#region Private members296		/// Id of next collection297		CreatedCollectionCount: u32;298		/// Used for migrations299		ChainVersion: u64;300		/// Id of last collection token301		/// Collection id (controlled?1)302		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;303		//#endregion304305		//#region Bound counters306		/// Amount of collections destroyed, used for total amount tracking with307		/// CreatedCollectionCount308		DestroyedCollectionCount: u32;309		//#endregion310311		//#region Basic collections312		/// Collection info313		/// Collection id (controlled?1)314		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;315		/// List of collection admins316		/// Collection id (controlled?2)317		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;318		/// Whitelisted collection users319		/// Collection id (controlled?2), user id (controlled?3)320		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;321		//#endregion322323		/// How many of collection items user have324		/// Collection id (controlled?2), account id (real)325		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;326327		/// Amount of items which spender can transfer out of owners account (via transferFrom)328		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))329		/// TODO: Off chain worker should remove from this map when token gets removed330		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;331332		//#region Item collections333		/// Collection id (controlled?2), token id (controlled?1)334		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;335		/// Collection id (controlled?2), owner (controlled?2)336		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;337		/// Collection id (controlled?2), token id (controlled?1)338		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;339		//#endregion340341		//#region Index list342		/// Collection id (controlled?2), tokens owner (controlled?2)343		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;344		//#endregion345346		//#region Tokens transfer rate limit baskets347		/// (Collection id (controlled?2), who created (real))348		/// TODO: Off chain worker should remove from this map when collection gets removed349		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;350		/// Collection id (controlled?2), token id (controlled?2)351		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352		/// Collection id (controlled?2), owning user (real)353		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;354		/// Collection id (controlled?2), token id (controlled?2)355		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;356		//#endregion357358		/// Variable metadata sponsoring359		/// Collection id (controlled?2), token id (controlled?2)360		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;361	}362	add_extra_genesis {363		build(|config: &GenesisConfig<T>| {364			// Modification of storage365			for (_num, _c) in &config.collection_id {366				<Module<T>>::init_collection(_c);367			}368369			for (_num, _c, _i) in &config.nft_item_id {370				<Module<T>>::init_nft_token(*_c, _i);371			}372373			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {374				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);375			}376377			for (_num, _c, _i) in &config.refungible_item_id {378				<Module<T>>::init_refungible_token(*_c, _i);379			}380		})381	}382}383384decl_event!(385	pub enum Event<T>386	where387		AccountId = <T as frame_system::Config>::AccountId,388		CrossAccountId = <T as Config>::CrossAccountId,389	{390		/// New collection was created391		///392		/// # Arguments393		///394		/// * collection_id: Globally unique identifier of newly created collection.395		///396		/// * mode: [CollectionMode] converted into u8.397		///398		/// * account_id: Collection owner.399		CollectionCreated(CollectionId, u8, AccountId),400401		/// New item was created.402		///403		/// # Arguments404		///405		/// * collection_id: Id of the collection where item was created.406		///407		/// * item_id: Id of an item. Unique within the collection.408		///409		/// * recipient: Owner of newly created item410		ItemCreated(CollectionId, TokenId, CrossAccountId),411412		/// Collection item was burned.413		///414		/// # Arguments415		///416		/// collection_id.417		///418		/// item_id: Identifier of burned NFT.419		ItemDestroyed(CollectionId, TokenId),420421		/// Item was transferred422		///423		/// * collection_id: Id of collection to which item is belong424		///425		/// * item_id: Id of an item426		///427		/// * sender: Original owner of item428		///429		/// * recipient: New owner of item430		///431		/// * amount: Always 1 for NFT432		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),433434		/// * collection_id435		///436		/// * item_id437		///438		/// * sender439		///440		/// * spender441		///442		/// * amount443		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),444	}445);446447decl_module! {448	pub struct Module<T: Config> for enum Call449	where450		origin: T::Origin451	{452		fn deposit_event() = default;453		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;454		type Error = Error<T>;455456		fn on_initialize(_now: T::BlockNumber) -> Weight {457			0458		}459460		/// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.461		///462		/// # Permissions463		///464		/// * Anyone.465		///466		/// # Arguments467		///468		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.469		///470		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.471		///472		/// * token_prefix: UTF-8 string with token prefix.473		///474		/// * mode: [CollectionMode] collection type and type dependent data.475		// returns collection ID476		#[weight = <SelfWeightOf<T>>::create_collection()]477		#[transactional]478		pub fn create_collection(origin,479								 collection_name: Vec<u16>,480								 collection_description: Vec<u16>,481								 token_prefix: Vec<u8>,482								 mode: CollectionMode) -> DispatchResult {483484			// Anyone can create a collection485			let who = ensure_signed(origin)?;486487			// Take a (non-refundable) deposit of collection creation488			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();489			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(490				&T::TreasuryAccountId::get(),491				T::CollectionCreationPrice::get(),492			));493			<T as Config>::Currency::settle(494				&who,495				imbalance,496				WithdrawReasons::TRANSFER,497				ExistenceRequirement::KeepAlive,498			).map_err(|_| Error::<T>::NoPermission)?;499500			let decimal_points = match mode {501				CollectionMode::Fungible(points) => points,502				_ => 0503			};504505			let created_count = CreatedCollectionCount::get();506			let destroyed_count = DestroyedCollectionCount::get();507508			// bound Total number of collections509			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);510511			// check params512			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);513			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);514			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);515			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);516517			// Generate next collection ID518			let next_id = created_count519				.checked_add(1)520				.ok_or(Error::<T>::NumOverflow)?;521522			CreatedCollectionCount::put(next_id);523524			let limits = CollectionLimits {525				sponsored_data_size: CUSTOM_DATA_LIMIT,526				..Default::default()527			};528529			// Create new collection530			let new_collection = Collection {531				owner: who.clone(),532				name: collection_name,533				mode: mode.clone(),534				mint_mode: false,535				access: AccessMode::Normal,536				description: collection_description,537				decimal_points,538				token_prefix,539				offchain_schema: Vec::new(),540				schema_version: SchemaVersion::ImageURL,541				sponsorship: SponsorshipState::Disabled,542				variable_on_chain_schema: Vec::new(),543				const_on_chain_schema: Vec::new(),544				limits,545				meta_update_permission: MetaUpdatePermission::default(),546				transfers_enabled: true,547			};548549			// Add new collection to map550			<CollectionById<T>>::insert(next_id, new_collection);551552			// call event553			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));554555			Ok(())556		}557558		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.559		///560		/// # Permissions561		///562		/// * Collection Owner.563		///564		/// # Arguments565		///566		/// * collection_id: collection to destroy.567		#[weight = <SelfWeightOf<T>>::destroy_collection()]568		#[transactional]569		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {570571			let sender = ensure_signed(origin)?;572			let collection = Self::get_collection(collection_id)?;573			Self::check_owner_permissions(&collection, &sender)?;574			if !collection.limits.owner_can_destroy {575				fail!(Error::<T>::NoPermission);576			}577578			<AddressTokens<T>>::remove_prefix(collection_id, None);579			<Allowances<T>>::remove_prefix(collection_id, None);580			<Balance<T>>::remove_prefix(collection_id, None);581			<ItemListIndex>::remove(collection_id);582			<AdminList<T>>::remove(collection_id);583			<CollectionById<T>>::remove(collection_id);584			<WhiteList<T>>::remove_prefix(collection_id, None);585586			<NftItemList<T>>::remove_prefix(collection_id, None);587			<FungibleItemList<T>>::remove_prefix(collection_id, None);588			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);589590			<NftTransferBasket<T>>::remove_prefix(collection_id, None);591			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);592			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);593594			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);595596			DestroyedCollectionCount::put(DestroyedCollectionCount::get()597				.checked_add(1)598				.ok_or(Error::<T>::NumOverflow)?);599600			Ok(())601		}602603		/// Add an address to white list.604		///605		/// # Permissions606		///607		/// * Collection Owner608		/// * Collection Admin609		///610		/// # Arguments611		///612		/// * collection_id.613		///614		/// * address.615		#[weight = <SelfWeightOf<T>>::add_to_white_list()]616		#[transactional]617		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{618619			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);620			let collection = Self::get_collection(collection_id)?;621622			Self::toggle_white_list_internal(623				&sender,624				&collection,625				&address,626				true,627			)?;628629			Ok(())630		}631632		/// Remove an address from white list.633		///634		/// # Permissions635		///636		/// * Collection Owner637		/// * Collection Admin638		///639		/// # Arguments640		///641		/// * collection_id.642		///643		/// * address.644		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]645		#[transactional]646		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{647648			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);649			let collection = Self::get_collection(collection_id)?;650651			Self::toggle_white_list_internal(652				&sender,653				&collection,654				&address,655				false,656			)?;657658			Ok(())659		}660661		/// Toggle between normal and white list access for the methods with access for `Anyone`.662		///663		/// # Permissions664		///665		/// * Collection Owner.666		///667		/// # Arguments668		///669		/// * collection_id.670		///671		/// * mode: [AccessMode]672		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]673		#[transactional]674		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult675		{676			let sender = ensure_signed(origin)?;677678			let mut target_collection = Self::get_collection(collection_id)?;679			Self::check_owner_permissions(&target_collection, &sender)?;680			target_collection.access = mode;681			target_collection.save()682		}683684		/// Allows Anyone to create tokens if:685		/// * White List is enabled, and686		/// * Address is added to white list, and687		/// * This method was called with True parameter688		///689		/// # Permissions690		/// * Collection Owner691		///692		/// # Arguments693		///694		/// * collection_id.695		///696		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.697		#[weight = <SelfWeightOf<T>>::set_mint_permission()]698		#[transactional]699		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult700		{701			let sender = ensure_signed(origin)?;702703			let mut target_collection = Self::get_collection(collection_id)?;704			Self::check_owner_permissions(&target_collection, &sender)?;705			target_collection.mint_mode = mint_permission;706			target_collection.save()707		}708709		/// Change the owner of the collection.710		///711		/// # Permissions712		///713		/// * Collection Owner.714		///715		/// # Arguments716		///717		/// * collection_id.718		///719		/// * new_owner.720		#[weight = <SelfWeightOf<T>>::change_collection_owner()]721		#[transactional]722		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {723724			let sender = ensure_signed(origin)?;725			let mut target_collection = Self::get_collection(collection_id)?;726			Self::check_owner_permissions(&target_collection, &sender)?;727			target_collection.owner = new_owner;728			target_collection.save()729		}730731		/// Adds an admin of the Collection.732		/// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.733		///734		/// # Permissions735		///736		/// * Collection Owner.737		/// * Collection Admin.738		///739		/// # Arguments740		///741		/// * collection_id: ID of the Collection to add admin for.742		///743		/// * new_admin_id: Address of new admin to add.744		#[weight = <SelfWeightOf<T>>::add_collection_admin()]745		#[transactional]746		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {747			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);748			let collection = Self::get_collection(collection_id)?;749			Self::check_owner_or_admin_permissions(&collection, &sender)?;750			let mut admin_arr = <AdminList<T>>::get(collection_id);751752			match admin_arr.binary_search(&new_admin_id) {753				Ok(_) => {},754				Err(idx) => {755					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);756					admin_arr.insert(idx, new_admin_id);757					<AdminList<T>>::insert(collection_id, admin_arr);758				}759			}760			Ok(())761		}762763		/// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.764		///765		/// # Permissions766		///767		/// * Collection Owner.768		/// * Collection Admin.769		///770		/// # Arguments771		///772		/// * collection_id: ID of the Collection to remove admin for.773		///774		/// * account_id: Address of admin to remove.775		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]776		#[transactional]777		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {778			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);779			let collection = Self::get_collection(collection_id)?;780			Self::check_owner_or_admin_permissions(&collection, &sender)?;781			let mut admin_arr = <AdminList<T>>::get(collection_id);782783			if let Ok(idx) = admin_arr.binary_search(&account_id) {784				admin_arr.remove(idx);785				<AdminList<T>>::insert(collection_id, admin_arr);786			}787			Ok(())788		}789790		/// # Permissions791		///792		/// * Collection Owner793		///794		/// # Arguments795		///796		/// * collection_id.797		///798		/// * new_sponsor.799		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]800		#[transactional]801		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {802			let sender = ensure_signed(origin)?;803			let mut target_collection = Self::get_collection(collection_id)?;804			Self::check_owner_permissions(&target_collection, &sender)?;805806			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);807			target_collection.save()808		}809810		/// # Permissions811		///812		/// * Sponsor.813		///814		/// # Arguments815		///816		/// * collection_id.817		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]818		#[transactional]819		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {820			let sender = ensure_signed(origin)?;821822			let mut target_collection = Self::get_collection(collection_id)?;823			ensure!(824				target_collection.sponsorship.pending_sponsor() == Some(&sender),825				Error::<T>::ConfirmUnsetSponsorFail826			);827828			target_collection.sponsorship = SponsorshipState::Confirmed(sender);829			target_collection.save()830		}831832		/// Switch back to pay-per-own-transaction model.833		///834		/// # Permissions835		///836		/// * Collection owner.837		///838		/// # Arguments839		///840		/// * collection_id.841		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]842		#[transactional]843		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844			let sender = ensure_signed(origin)?;845846			let mut target_collection = Self::get_collection(collection_id)?;847			Self::check_owner_permissions(&target_collection, &sender)?;848849			target_collection.sponsorship = SponsorshipState::Disabled;850			target_collection.save()851		}852853		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.854		///855		/// # Permissions856		///857		/// * Collection Owner.858		/// * Collection Admin.859		/// * Anyone if860		///     * White List is enabled, and861		///     * Address is added to white list, and862		///     * MintPermission is enabled (see SetMintPermission method)863		///864		/// # Arguments865		///866		/// * collection_id: ID of the collection.867		///868		/// * owner: Address, initial owner of the NFT.869		///870		/// * data: Token data to store on chain.871		// #[weight =872		// (130_000_000 as Weight)873		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))874		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))875		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]876877		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]878		#[transactional]879		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {880			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881			let collection = Self::get_collection(collection_id)?;882883			Self::create_item_internal(&sender, &collection, &owner, data)?;884885			collection.submit_logs()886		}887888		/// This method creates multiple items in a collection created with CreateCollection method.889		///890		/// # Permissions891		///892		/// * Collection Owner.893		/// * Collection Admin.894		/// * Anyone if895		///     * White List is enabled, and896		///     * Address is added to white list, and897		///     * MintPermission is enabled (see SetMintPermission method)898		///899		/// # Arguments900		///901		/// * collection_id: ID of the collection.902		///903		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].904		///905		/// * owner: Address, initial owner of the NFT.906		#[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]907		#[transactional]908		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {909910			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);911			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);912			let collection = Self::get_collection(collection_id)?;913914			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;915916			collection.submit_logs()917		}918919		// TODO! transaction weight920921		/// Set transfers_enabled value for particular collection922		///923		/// # Permissions924		///925		/// * Collection Owner.926		///927		/// # Arguments928		///929		/// * collection_id: ID of the collection.930		///931		/// * value: New flag value.932		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]933		#[transactional]934		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {935936			let sender = ensure_signed(origin)?;937			let mut target_collection = Self::get_collection(collection_id)?;938939			Self::check_owner_permissions(&target_collection, &sender)?;940941			target_collection.transfers_enabled = value;942			target_collection.save()943		}944945		// TODO! transaction weight946		/// Set meta_update_permission value for particular collection947		///948		/// # Permissions949		///950		/// * Collection Owner.951		///952		/// # Arguments953		///954		/// * collection_id: ID of the collection.955		///956		/// * value: New flag value.957		#[weight = <T as Config>::WeightInfo::burn_item()]958		#[transactional]959		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {960961			let sender = ensure_signed(origin)?;962			let mut target_collection = Self::get_collection(collection_id)?;963964			ensure!(965				target_collection.meta_update_permission != MetaUpdatePermission::None,966				Error::<T>::MetadataFlagFrozen967			);968			Self::check_owner_permissions(&target_collection, &sender)?;969970			target_collection.meta_update_permission = value;971972			target_collection.save()973		}974975		/// Destroys a concrete instance of NFT.976		///977		/// # Permissions978		///979		/// * Collection Owner.980		/// * Collection Admin.981		/// * Current NFT Owner.982		///983		/// # Arguments984		///985		/// * collection_id: ID of the collection.986		///987		/// * item_id: ID of NFT to burn.988		#[weight = <SelfWeightOf<T>>::burn_item()]989		#[transactional]990		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, item_owner: T::CrossAccountId, value: u128) -> DispatchResult {991992			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993			let target_collection = Self::get_collection(collection_id)?;994995			Self::burn_item_internal(&sender, &target_collection, item_id, &item_owner, value)?;996997			target_collection.submit_logs()998		}9991000		/// Change ownership of the token.1001		///1002		/// # Permissions1003		///1004		/// * Collection Owner1005		/// * Collection Admin1006		/// * Current NFT owner1007		///1008		/// # Arguments1009		///1010		/// * recipient: Address of token recipient.1011		///1012		/// * collection_id.1013		///1014		/// * item_id: ID of the item1015		///     * Non-Fungible Mode: Required.1016		///     * Fungible Mode: Ignored.1017		///     * Re-Fungible Mode: Required.1018		///1019		/// * value: Amount to transfer.1020		///     * Non-Fungible Mode: Ignored1021		///     * Fungible Mode: Must specify transferred amount1022		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1023		#[weight = <SelfWeightOf<T>>::transfer()]1024		#[transactional]1025		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1026			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1027			let collection = Self::get_collection(collection_id)?;10281029			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10301031			collection.submit_logs()1032		}10331034		/// Set, change, or remove approved address to transfer the ownership of the NFT.1035		///1036		/// # Permissions1037		///1038		/// * Collection Owner1039		/// * Collection Admin1040		/// * Current NFT owner1041		///1042		/// # Arguments1043		///1044		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1045		///1046		/// * collection_id.1047		///1048		/// * item_id: ID of the item.1049		#[weight = <SelfWeightOf<T>>::approve()]1050		#[transactional]1051		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1052			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1053			let collection = Self::get_collection(collection_id)?;10541055			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10561057			collection.submit_logs()1058		}10591060		/// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1061		///1062		/// # Permissions1063		/// * Collection Owner1064		/// * Collection Admin1065		/// * Current NFT owner1066		/// * Address approved by current NFT owner1067		///1068		/// # Arguments1069		///1070		/// * from: Address that owns token.1071		///1072		/// * recipient: Address of token recipient.1073		///1074		/// * collection_id.1075		///1076		/// * item_id: ID of the item.1077		///1078		/// * value: Amount to transfer.1079		#[weight = <SelfWeightOf<T>>::transfer_from()]1080		#[transactional]1081		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1082			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1083			let collection = Self::get_collection(collection_id)?;10841085			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10861087			collection.submit_logs()1088		}1089		// #[weight = 0]1090		//     // let no_perm_mes = "You do not have permissions to modify this collection";1091		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1092		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1093		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10941095		//     // // on_nft_received  call10961097		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10981099		//     Ok(())1100		// }11011102		/// Set off-chain data schema.1103		///1104		/// # Permissions1105		///1106		/// * Collection Owner1107		/// * Collection Admin1108		///1109		/// # Arguments1110		///1111		/// * collection_id.1112		///1113		/// * schema: String representing the offchain data schema.1114		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1115		#[transactional]1116		pub fn set_variable_meta_data (1117			origin,1118			collection_id: CollectionId,1119			item_id: TokenId,1120			data: Vec<u8>1121		) -> DispatchResult {1122			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124			let collection = Self::get_collection(collection_id)?;1125			Self::meta_update_check(&sender, &collection, item_id)?;11261127			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11281129			Ok(())1130		}11311132		/// Set schema standard1133		/// ImageURL1134		/// Unique1135		///1136		/// # Permissions1137		///1138		/// * Collection Owner1139		/// * Collection Admin1140		///1141		/// # Arguments1142		///1143		/// * collection_id.1144		///1145		/// * schema: SchemaVersion: enum1146		#[weight = <SelfWeightOf<T>>::set_schema_version()]1147		#[transactional]1148		pub fn set_schema_version(1149			origin,1150			collection_id: CollectionId,1151			version: SchemaVersion1152		) -> DispatchResult {1153			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1154			let mut target_collection = Self::get_collection(collection_id)?;1155			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1156			target_collection.schema_version = version;1157			target_collection.save()1158		}11591160		/// Set off-chain data schema.1161		///1162		/// # Permissions1163		///1164		/// * Collection Owner1165		/// * Collection Admin1166		///1167		/// # Arguments1168		///1169		/// * collection_id.1170		///1171		/// * schema: String representing the offchain data schema.1172		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1173		#[transactional]1174		pub fn set_offchain_schema(1175			origin,1176			collection_id: CollectionId,1177			schema: Vec<u8>1178		) -> DispatchResult {1179			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1180			let mut target_collection = Self::get_collection(collection_id)?;1181			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11821183			// check schema limit1184			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11851186			target_collection.offchain_schema = schema;1187			target_collection.save()1188		}11891190		/// Set const on-chain data schema.1191		///1192		/// # Permissions1193		///1194		/// * Collection Owner1195		/// * Collection Admin1196		///1197		/// # Arguments1198		///1199		/// * collection_id.1200		///1201		/// * schema: String representing the const on-chain data schema.1202		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1203		#[transactional]1204		pub fn set_const_on_chain_schema (1205			origin,1206			collection_id: CollectionId,1207			schema: Vec<u8>1208		) -> DispatchResult {1209			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1210			let mut target_collection = Self::get_collection(collection_id)?;1211			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12121213			// check schema limit1214			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12151216			target_collection.const_on_chain_schema = schema;1217			target_collection.save()1218		}12191220		/// Set variable on-chain data schema.1221		///1222		/// # Permissions1223		///1224		/// * Collection Owner1225		/// * Collection Admin1226		///1227		/// # Arguments1228		///1229		/// * collection_id.1230		///1231		/// * schema: String representing the variable on-chain data schema.1232		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1233		#[transactional]1234		pub fn set_variable_on_chain_schema (1235			origin,1236			collection_id: CollectionId,1237			schema: Vec<u8>1238		) -> DispatchResult {1239			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1240			let mut target_collection = Self::get_collection(collection_id)?;1241			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12421243			// check schema limit1244			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12451246			target_collection.variable_on_chain_schema = schema;1247			target_collection.save()1248		}12491250		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1251		#[transactional]1252		pub fn set_collection_limits(1253			origin,1254			collection_id: u32,1255			new_limits: CollectionLimits<T::BlockNumber>,1256		) -> DispatchResult {1257			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1258			let mut target_collection = Self::get_collection(collection_id)?;1259			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1260			let old_limits = &target_collection.limits;12611262			// collection bounds1263			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1264				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1265				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1266				Error::<T>::CollectionLimitBoundsExceeded);12671268			// token_limit   check  prev1269			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1270			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12711272			ensure!(1273				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1274				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1275				Error::<T>::OwnerPermissionsCantBeReverted,1276			);12771278			target_collection.limits = new_limits;12791280			target_collection.save()1281		}1282	}1283}12841285impl<T: Config> Module<T> {1286	pub fn create_item_internal(1287		sender: &T::CrossAccountId,1288		collection: &CollectionHandle<T>,1289		owner: &T::CrossAccountId,1290		data: CreateItemData,1291	) -> DispatchResult {1292		ensure!(1293			owner != &T::CrossAccountId::from_eth(H160([0; 20])),1294			Error::<T>::AddressIsZero1295		);12961297		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1298		Self::validate_create_item_args(collection, &data)?;1299		Self::create_item_no_validation(collection, owner, data)?;13001301		Ok(())1302	}13031304	pub fn transfer_internal(1305		sender: &T::CrossAccountId,1306		recipient: &T::CrossAccountId,1307		target_collection: &CollectionHandle<T>,1308		item_id: TokenId,1309		value: u128,1310	) -> DispatchResult {1311		ensure!(1312			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1313			Error::<T>::AddressIsZero1314		);13151316		// Limits check1317		Self::is_correct_transfer(target_collection, recipient)?;13181319		// Transfer permissions check1320		ensure!(1321			Self::is_item_owner(sender, target_collection, item_id)?1322				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,1323			Error::<T>::NoPermission1324		);13251326		if target_collection.access == AccessMode::WhiteList {1327			Self::check_white_list(target_collection, sender)?;1328			Self::check_white_list(target_collection, recipient)?;1329		}13301331		match target_collection.mode {1332			CollectionMode::NFT => Self::transfer_nft(1333				target_collection,1334				item_id,1335				sender.clone(),1336				recipient.clone(),1337			)?,1338			CollectionMode::Fungible(_) => {1339				Self::transfer_fungible(target_collection, value, sender, recipient)?1340			}1341			CollectionMode::ReFungible => Self::transfer_refungible(1342				target_collection,1343				item_id,1344				value,1345				sender.clone(),1346				recipient.clone(),1347			)?,1348		};13491350		Self::deposit_event(RawEvent::Transfer(1351			target_collection.id,1352			item_id,1353			sender.clone(),1354			recipient.clone(),1355			value,1356		));13571358		Ok(())1359	}13601361	pub fn approve_internal(1362		sender: &T::CrossAccountId,1363		spender: &T::CrossAccountId,1364		collection: &CollectionHandle<T>,1365		item_id: TokenId,1366		amount: u128,1367	) -> DispatchResult {1368		Self::token_exists(collection, item_id)?;13691370		// Transfer permissions check1371		let bypasses_limits = collection.limits.owner_can_transfer1372			&& Self::is_owner_or_admin_permissions(collection, sender)?;13731374		let allowance_limit = if bypasses_limits {1375			None1376		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1377			Some(amount)1378		} else {1379			fail!(Error::<T>::NoPermission);1380		};13811382		if collection.access == AccessMode::WhiteList {1383			Self::check_white_list(collection, sender)?;1384			Self::check_white_list(collection, spender)?;1385		}13861387		collection.consume_sload()?;1388		let allowance: u128 = amount1389			.checked_add(<Allowances<T>>::get(1390				collection.id,1391				(item_id, sender.as_sub(), spender.as_sub()),1392			))1393			.ok_or(Error::<T>::NumOverflow)?;1394		if let Some(limit) = allowance_limit {1395			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1396		}1397		collection.consume_sstore()?;1398		<Allowances<T>>::insert(1399			collection.id,1400			(item_id, sender.as_sub(), spender.as_sub()),1401			allowance,1402		);14031404		if matches!(collection.mode, CollectionMode::NFT) {1405			// TODO: NFT: only one owner may exist for token in ERC7211406			collection.log(ERC721Events::Approval {1407				owner: *sender.as_eth(),1408				approved: *spender.as_eth(),1409				token_id: item_id.into(),1410			})?;1411		}14121413		if matches!(collection.mode, CollectionMode::Fungible(_)) {1414			// TODO: NFT: only one owner may exist for token in ERC201415			collection.log(ERC20Events::Approval {1416				owner: *sender.as_eth(),1417				spender: *spender.as_eth(),1418				value: allowance.into(),1419			})?;1420		}14211422		Self::deposit_event(RawEvent::Approved(1423			collection.id,1424			item_id,1425			sender.clone(),1426			spender.clone(),1427			allowance,1428		));1429		Ok(())1430	}14311432	pub fn transfer_from_internal(1433		sender: &T::CrossAccountId,1434		from: &T::CrossAccountId,1435		recipient: &T::CrossAccountId,1436		collection: &CollectionHandle<T>,1437		item_id: TokenId,1438		amount: u128,1439	) -> DispatchResult {1440		if sender == from {1441			// Transfer by `from`, because it is either equal to sender, or derived from him1442			return Self::transfer_internal(from, recipient, collection, item_id, amount);1443		}14441445		// Check approval1446		collection.consume_sload()?;1447		let approval: u128 =1448			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14491450		// Limits check1451		Self::is_correct_transfer(collection, recipient)?;14521453		// Transfer permissions check1454		ensure!(1455			approval >= amount1456				|| (collection.limits.owner_can_transfer1457					&& Self::is_owner_or_admin_permissions(collection, sender)?),1458			Error::<T>::NoPermission1459		);14601461		if collection.access == AccessMode::WhiteList {1462			Self::check_white_list(collection, sender)?;1463			Self::check_white_list(collection, recipient)?;1464		}14651466		// Reduce approval by transferred amount or remove if remaining approval drops to 01467		let allowance = approval.saturating_sub(amount);1468		collection.consume_sstore()?;1469		if allowance > 0 {1470			<Allowances<T>>::insert(1471				collection.id,1472				(item_id, from.as_sub(), sender.as_sub()),1473				allowance,1474			);1475		} else {1476			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1477		}14781479		match collection.mode {1480			CollectionMode::NFT => {1481				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1482			}1483			CollectionMode::Fungible(_) => {1484				Self::transfer_fungible(collection, amount, from, recipient)?1485			}1486			CollectionMode::ReFungible => Self::transfer_refungible(1487				collection,1488				item_id,1489				amount,1490				from.clone(),1491				recipient.clone(),1492			)?,1493		};14941495		if matches!(collection.mode, CollectionMode::Fungible(_)) {1496			collection.log(ERC20Events::Approval {1497				owner: *from.as_eth(),1498				spender: *sender.as_eth(),1499				value: allowance.into(),1500			})?;1501		}15021503		Ok(())1504	}15051506	pub fn set_variable_meta_data_internal(1507		sender: &T::CrossAccountId,1508		collection: &CollectionHandle<T>,1509		item_id: TokenId,1510		data: Vec<u8>,1511	) -> DispatchResult {1512		Self::token_exists(collection, item_id)?;15131514		ensure!(1515			CUSTOM_DATA_LIMIT >= data.len() as u32,1516			Error::<T>::TokenVariableDataLimitExceeded1517		);15181519		ensure!(1520			(Self::is_item_owner(sender, collection, item_id)?1521				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1522				|| (Self::is_owner_or_admin_permissions(collection, sender)?1523					&& collection.meta_update_permission == MetaUpdatePermission::Admin),1524			Error::<T>::NoPermission1525		);15261527		match collection.mode {1528			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1529			CollectionMode::ReFungible => {1530				Self::set_re_fungible_variable_data(collection, item_id, data)?1531			}1532			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1533		};15341535		Ok(())1536	}15371538	pub fn meta_update_check(1539		sender: &T::CrossAccountId,1540		collection: &CollectionHandle<T>,1541		item_id: TokenId,1542	) -> DispatchResult {1543		match collection.meta_update_permission {1544			MetaUpdatePermission::ItemOwner => ensure!(1545				Self::is_item_owner(sender, collection, item_id)?,1546				Error::<T>::NoPermission1547			),1548			MetaUpdatePermission::Admin => ensure!(1549				Self::is_owner_or_admin_permissions(collection, sender)?,1550				Error::<T>::NoPermission1551			),1552			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1553		}15541555		Ok(())1556	}15571558	pub fn get_variable_metadata(1559		collection: &CollectionHandle<T>,1560		item_id: TokenId,1561	) -> Result<Vec<u8>, DispatchError> {1562		Ok(match collection.mode {1563			CollectionMode::NFT => {1564				<NftItemList<T>>::get(collection.id, item_id)1565					.ok_or(Error::<T>::TokenNotFound)?1566					.variable_data1567			}1568			CollectionMode::ReFungible => {1569				<ReFungibleItemList<T>>::get(collection.id, item_id)1570					.ok_or(Error::<T>::TokenNotFound)?1571					.variable_data1572			}1573			_ => fail!(Error::<T>::UnexpectedCollectionType),1574		})1575	}15761577	pub fn create_multiple_items_internal(1578		sender: &T::CrossAccountId,1579		collection: &CollectionHandle<T>,1580		owner: &T::CrossAccountId,1581		items_data: Vec<CreateItemData>,1582	) -> DispatchResult {1583		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15841585		for data in &items_data {1586			Self::validate_create_item_args(collection, data)?;1587		}1588		for data in &items_data {1589			Self::create_item_no_validation(collection, owner, data.clone())?;1590		}15911592		Ok(())1593	}15941595	pub fn burn_item_internal(1596		sender: &T::CrossAccountId,1597		collection: &CollectionHandle<T>,1598		item_id: TokenId,1599		item_owner: &T::CrossAccountId,1600		value: u128,1601	) -> DispatchResult {1602		ensure!(1603			Self::is_item_owner(sender, collection, item_id)?1604				|| (collection.limits.owner_can_transfer1605					&& Self::is_owner_or_admin_permissions(collection, sender)?),1606			Error::<T>::NoPermission1607		);16081609		if collection.access == AccessMode::WhiteList {1610			Self::check_white_list(collection, sender)?;1611		}16121613		match collection.mode {1614			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1615			CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, item_owner, value)?,1616			CollectionMode::ReFungible => {1617				Self::burn_refungible_item(collection, item_id, item_owner)?1618			}1619			_ => (),1620		};16211622		Ok(())1623	}16241625	pub fn toggle_white_list_internal(1626		sender: &T::CrossAccountId,1627		collection: &CollectionHandle<T>,1628		address: &T::CrossAccountId,1629		whitelisted: bool,1630	) -> DispatchResult {1631		Self::check_owner_or_admin_permissions(collection, sender)?;16321633		if whitelisted {1634			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1635		} else {1636			<WhiteList<T>>::remove(collection.id, address.as_sub());1637		}16381639		Ok(())1640	}16411642	fn is_correct_transfer(1643		collection: &CollectionHandle<T>,1644		recipient: &T::CrossAccountId,1645	) -> DispatchResult {1646		let collection_id = collection.id;16471648		// check token limit and account token limit1649		collection.consume_sload()?;1650		let account_items: u32 =1651			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16521653		// zero limit means collection limit is disabled1654		// otherwise get lower value1655		let limit = if collection.limits.account_token_ownership_limit == 01656			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1657		{1658			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1659		} else {1660			collection.limits.account_token_ownership_limit1661		};16621663		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16641665		// preliminary transfer check1666		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16671668		Ok(())1669	}16701671	fn can_create_items_in_collection(1672		collection: &CollectionHandle<T>,1673		sender: &T::CrossAccountId,1674		owner: &T::CrossAccountId,1675		amount: u32,1676	) -> DispatchResult {1677		let collection_id = collection.id;16781679		// check token limit and account token limit1680		let total_items: u32 = ItemListIndex::get(collection_id)1681			.checked_add(amount)1682			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1683		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1684			as u32)1685			.checked_add(amount)1686			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;16871688		// zero limit means collection limit is disabled1689		// otherwise get lower value1690		let account_token_limit = if collection.limits.account_token_ownership_limit == 01691			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1692		{1693			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1694		} else {1695			collection.limits.account_token_ownership_limit1696		};16971698		ensure!(1699			collection.limits.token_limit >= total_items,1700			Error::<T>::CollectionTokenLimitExceeded1701		);1702		ensure!(1703			account_token_limit >= account_items,1704			Error::<T>::AccountTokenLimitExceeded1705		);17061707		if !Self::is_owner_or_admin_permissions(collection, sender)? {1708			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1709			Self::check_white_list(collection, owner)?;1710			Self::check_white_list(collection, sender)?;1711		}17121713		Ok(())1714	}17151716	fn validate_create_item_args(1717		target_collection: &CollectionHandle<T>,1718		data: &CreateItemData,1719	) -> DispatchResult {1720		match target_collection.mode {1721			CollectionMode::NFT => {1722				if !matches!(data, CreateItemData::NFT(_)) {1723					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1724				}1725			}1726			CollectionMode::Fungible(_) => {1727				if !matches!(data, CreateItemData::Fungible(_)) {1728					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1729				}1730			}1731			CollectionMode::ReFungible => {1732				if let CreateItemData::ReFungible(data) = data {1733					// Check refungibility limits1734					ensure!(1735						data.pieces <= MAX_REFUNGIBLE_PIECES,1736						Error::<T>::WrongRefungiblePieces1737					);1738					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1739				} else {1740					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1741				}1742			}1743		};17441745		Ok(())1746	}17471748	fn create_item_no_validation(1749		collection: &CollectionHandle<T>,1750		owner: &T::CrossAccountId,1751		data: CreateItemData,1752	) -> DispatchResult {1753		match data {1754			CreateItemData::NFT(data) => {1755				let item = NftItemType {1756					owner: owner.clone(),1757					const_data: data.const_data.into_inner(),1758					variable_data: data.variable_data.into_inner(),1759				};17601761				Self::add_nft_item(collection, item)?;1762			}1763			CreateItemData::Fungible(data) => {1764				Self::add_fungible_item(collection, owner, data.value)?;1765			}1766			CreateItemData::ReFungible(data) => {1767				let owner_list = vec![Ownership {1768					owner: owner.clone(),1769					fraction: data.pieces,1770				}];17711772				let item = ReFungibleItemType {1773					owner: owner_list,1774					const_data: data.const_data.into_inner(),1775					variable_data: data.variable_data.into_inner(),1776				};17771778				Self::add_refungible_item(collection, item)?;1779			}1780		};17811782		Ok(())1783	}17841785	fn add_fungible_item(1786		collection: &CollectionHandle<T>,1787		owner: &T::CrossAccountId,1788		value: u128,1789	) -> DispatchResult {1790		let collection_id = collection.id;17911792		// Does new owner already have an account?1793		collection.consume_sload()?;1794		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17951796		// Mint1797		let item = FungibleItemType {1798			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1799		};1800		collection.consume_sstore()?;1801		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18021803		// Update balance1804		collection.consume_sload()?;1805		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1806			.checked_add(value)1807			.ok_or(Error::<T>::NumOverflow)?;1808		collection.consume_sstore()?;1809		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18101811		collection.log(ERC20Events::Transfer {1812			from: H160::default(),1813			to: *owner.as_eth(),1814			value: value.into(),1815		})?;1816		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1817		Ok(())1818	}18191820	fn add_refungible_item(1821		collection: &CollectionHandle<T>,1822		item: ReFungibleItemType<T::CrossAccountId>,1823	) -> DispatchResult {1824		let collection_id = collection.id;18251826		let current_index = <ItemListIndex>::get(collection_id)1827			.checked_add(1)1828			.ok_or(Error::<T>::NumOverflow)?;1829		let itemcopy = item.clone();18301831		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1832		let item_owner = item.owner.first().expect("only one owner is defined");18331834		let value = item_owner.fraction;1835		let owner = item_owner.owner.clone();18361837		Self::add_token_index(collection, current_index, &owner)?;18381839		<ItemListIndex>::insert(collection_id, current_index);1840		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18411842		// Update balance1843		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1844			.checked_add(value)1845			.ok_or(Error::<T>::NumOverflow)?;1846		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18471848		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1849		Ok(())1850	}18511852	fn add_nft_item(1853		collection: &CollectionHandle<T>,1854		item: NftItemType<T::CrossAccountId>,1855	) -> DispatchResult {1856		let collection_id = collection.id;18571858		let current_index = <ItemListIndex>::get(collection_id)1859			.checked_add(1)1860			.ok_or(Error::<T>::NumOverflow)?;18611862		let item_owner = item.owner.clone();1863		Self::add_token_index(collection, current_index, &item.owner)?;18641865		<ItemListIndex>::insert(collection_id, current_index);1866		<NftItemList<T>>::insert(collection_id, current_index, item);18671868		// Update balance1869		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1870			.checked_add(1)1871			.ok_or(Error::<T>::NumOverflow)?;1872		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18731874		collection.log(ERC721Events::Transfer {1875			from: H160::default(),1876			to: *item_owner.as_eth(),1877			token_id: current_index.into(),1878		})?;1879		Self::deposit_event(RawEvent::ItemCreated(1880			collection_id,1881			current_index,1882			item_owner,1883		));1884		Ok(())1885	}18861887	fn burn_refungible_item(1888		collection: &CollectionHandle<T>,1889		item_id: TokenId,1890		owner: &T::CrossAccountId,1891	) -> DispatchResult {1892		let collection_id = collection.id;18931894		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1895			.ok_or(Error::<T>::TokenNotFound)?;1896		let rft_balance = token1897			.owner1898			.iter()1899			.find(|&i| i.owner == *owner)1900			.ok_or(Error::<T>::TokenNotFound)?;1901		Self::remove_token_index(collection, item_id, owner)?;19021903		// update balance1904		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1905			.checked_sub(rft_balance.fraction)1906			.ok_or(Error::<T>::NumOverflow)?;1907		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19081909		// Re-create owners list with sender removed1910		let index = token1911			.owner1912			.iter()1913			.position(|i| i.owner == *owner)1914			.expect("owned item is exists");1915		token.owner.remove(index);1916		let owner_count = token.owner.len();19171918		// Burn the token completely if this was the last (only) owner1919		if owner_count == 0 {1920			<ReFungibleItemList<T>>::remove(collection_id, item_id);1921			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1922		} else {1923			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1924		}19251926		Ok(())1927	}19281929	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1930		let collection_id = collection.id;19311932		let item =1933			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1934		Self::remove_token_index(collection, item_id, &item.owner)?;19351936		// update balance1937		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1938			.checked_sub(1)1939			.ok_or(Error::<T>::NumOverflow)?;1940		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1941		<NftItemList<T>>::remove(collection_id, item_id);1942		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);19431944		collection.log(ERC721Events::Transfer {1945			from: *item.owner.as_eth(),1946			to: H160::default(),1947			token_id: item_id.into(),1948		})?;1949		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1950		Ok(())1951	}19521953	fn burn_fungible_item(1954		collection: &CollectionHandle<T>,1955		owner: &T::CrossAccountId,1956		value: u128,1957	) -> DispatchResult {1958		let collection_id = collection.id;19591960		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1961		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19621963		// update balance1964		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1965			.checked_sub(value)1966			.ok_or(Error::<T>::NumOverflow)?;1967		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19681969		if balance.value - value > 0 {1970			balance.value -= value;1971			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1972		} else {1973			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1974		}19751976		collection.log(ERC20Events::Transfer {1977			from: *owner.as_eth(),1978			to: H160::default(),1979			value: value.into(),1980		})?;1981		Ok(())1982	}19831984	pub fn get_collection(1985		collection_id: CollectionId,1986	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1987		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1988	}19891990	fn check_owner_permissions(1991		target_collection: &CollectionHandle<T>,1992		subject: &T::AccountId,1993	) -> DispatchResult {1994		ensure!(1995			*subject == target_collection.owner,1996			Error::<T>::NoPermission1997		);19981999		Ok(())2000	}20012002	fn is_owner_or_admin_permissions(2003		collection: &CollectionHandle<T>,2004		subject: &T::CrossAccountId,2005	) -> Result<bool, DispatchError> {2006		collection.consume_sload()?;2007		Ok(*subject.as_sub() == collection.owner2008			|| <AdminList<T>>::get(collection.id).contains(subject))2009	}20102011	fn check_owner_or_admin_permissions(2012		collection: &CollectionHandle<T>,2013		subject: &T::CrossAccountId,2014	) -> DispatchResult {2015		ensure!(2016			Self::is_owner_or_admin_permissions(collection, subject)?,2017			Error::<T>::NoPermission2018		);20192020		Ok(())2021	}20222023	fn owned_amount(2024		subject: &T::CrossAccountId,2025		collection: &CollectionHandle<T>,2026		item_id: TokenId,2027	) -> Result<Option<u128>, DispatchError> {2028		collection.consume_sload()?;2029		Ok(Self::owned_amount_unchecked(subject, collection, item_id))2030	}20312032	fn owned_amount_unchecked(2033		subject: &T::CrossAccountId,2034		target_collection: &CollectionHandle<T>,2035		item_id: TokenId,2036	) -> Option<u128> {2037		let collection_id = target_collection.id;20382039		match target_collection.mode {2040			CollectionMode::NFT => {2041				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2042			}2043			CollectionMode::Fungible(_) => {2044				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2045			}2046			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2047				.owner2048				.iter()2049				.find(|i| i.owner == *subject)2050				.map(|i| i.fraction),2051		}2052	}20532054	fn is_item_owner(2055		subject: &T::CrossAccountId,2056		target_collection: &CollectionHandle<T>,2057		item_id: TokenId,2058	) -> Result<bool, DispatchError> {2059		Ok(match target_collection.mode {2060			CollectionMode::Fungible(_) => true,2061			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2062		})2063	}20642065	fn check_white_list(2066		collection: &CollectionHandle<T>,2067		address: &T::CrossAccountId,2068	) -> DispatchResult {2069		collection.consume_sload()?;2070		ensure!(2071			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),2072			Error::<T>::AddresNotInWhiteList,2073		);2074		Ok(())2075	}20762077	/// Check if token exists. In case of Fungible, check if there is an entry for2078	/// the owner in fungible balances double map2079	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2080		let collection_id = target_collection.id;2081		let exists = match target_collection.mode {2082			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2083			CollectionMode::Fungible(_) => true,2084			CollectionMode::ReFungible => {2085				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2086			}2087		};20882089		ensure!(exists, Error::<T>::TokenNotFound);2090		Ok(())2091	}20922093	fn transfer_fungible(2094		collection: &CollectionHandle<T>,2095		value: u128,2096		owner: &T::CrossAccountId,2097		recipient: &T::CrossAccountId,2098	) -> DispatchResult {2099		let collection_id = collection.id;21002101		collection.consume_sload()?;2102		collection.consume_sload()?;2103		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2104		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21052106		recipient_balance.value = recipient_balance2107			.value2108			.checked_add(value)2109			.ok_or(Error::<T>::NumOverflow)?;2110		balance.value = balance2111			.value2112			.checked_sub(value)2113			.ok_or(Error::<T>::TokenValueTooLow)?;21142115		// update balanceOf2116		collection.consume_sstore()?;2117		collection.consume_sstore()?;2118		if balance.value != 0 {2119			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2120		} else {2121			<Balance<T>>::remove(collection_id, owner.as_sub());2122		}2123		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21242125		// Reduce or remove sender2126		collection.consume_sstore()?;2127		collection.consume_sstore()?;2128		if balance.value != 0 {2129			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2130		} else {2131			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2132		}2133		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21342135		collection.log(ERC20Events::Transfer {2136			from: *owner.as_eth(),2137			to: *recipient.as_eth(),2138			value: value.into(),2139		})?;2140		Self::deposit_event(RawEvent::Transfer(2141			collection.id,2142			1,2143			owner.clone(),2144			recipient.clone(),2145			value,2146		));21472148		Ok(())2149	}21502151	fn transfer_refungible(2152		collection: &CollectionHandle<T>,2153		item_id: TokenId,2154		value: u128,2155		owner: T::CrossAccountId,2156		new_owner: T::CrossAccountId,2157	) -> DispatchResult {2158		let collection_id = collection.id;2159		collection.consume_sload()?;2160		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2161			.ok_or(Error::<T>::TokenNotFound)?;21622163		let item = full_item2164			.owner2165			.iter()2166			.find(|i| i.owner == owner)2167			.ok_or(Error::<T>::TokenNotFound)?;2168		let amount = item.fraction;21692170		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21712172		collection.consume_sload()?;2173		// update balance2174		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2175			.checked_sub(value)2176			.ok_or(Error::<T>::NumOverflow)?;2177		collection.consume_sstore()?;2178		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21792180		collection.consume_sload()?;2181		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2182			.checked_add(value)2183			.ok_or(Error::<T>::NumOverflow)?;2184		collection.consume_sstore()?;2185		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21862187		let old_owner = item.owner.clone();2188		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21892190		let mut new_full_item = full_item.clone();2191		// transfer2192		if amount == value && !new_owner_has_account {2193			// change owner2194			// new owner do not have account2195			new_full_item2196				.owner2197				.iter_mut()2198				.find(|i| i.owner == owner)2199				.expect("old owner does present in refungible")2200				.owner = new_owner.clone();2201			collection.consume_sstore()?;2202			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22032204			// update index collection2205			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2206		} else {2207			new_full_item2208				.owner2209				.iter_mut()2210				.find(|i| i.owner == owner)2211				.expect("old owner does present in refungible")2212				.fraction -= value;22132214			// separate amount2215			if new_owner_has_account {2216				// new owner has account2217				new_full_item2218					.owner2219					.iter_mut()2220					.find(|i| i.owner == new_owner)2221					.expect("new owner has account")2222					.fraction += value;2223			} else {2224				// new owner do not have account2225				new_full_item.owner.push(Ownership {2226					owner: new_owner.clone(),2227					fraction: value,2228				});2229				Self::add_token_index(collection, item_id, &new_owner)?;2230			}22312232			collection.consume_sstore()?;2233			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2234		}22352236		Self::deposit_event(RawEvent::Transfer(2237			collection.id,2238			item_id,2239			owner,2240			new_owner,2241			amount,2242		));22432244		Ok(())2245	}22462247	fn transfer_nft(2248		collection: &CollectionHandle<T>,2249		item_id: TokenId,2250		sender: T::CrossAccountId,2251		new_owner: T::CrossAccountId,2252	) -> DispatchResult {2253		let collection_id = collection.id;2254		collection.consume_sload()?;2255		let mut item =2256			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22572258		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22592260		collection.consume_sload()?;2261		// update balance2262		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2263			.checked_sub(1)2264			.ok_or(Error::<T>::NumOverflow)?;2265		collection.consume_sstore()?;2266		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22672268		collection.consume_sload()?;2269		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2270			.checked_add(1)2271			.ok_or(Error::<T>::NumOverflow)?;2272		collection.consume_sstore()?;2273		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22742275		// change owner2276		let old_owner = item.owner.clone();2277		item.owner = new_owner.clone();2278		collection.consume_sstore()?;2279		<NftItemList<T>>::insert(collection_id, item_id, item);22802281		// update index collection2282		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22832284		collection.log(ERC721Events::Transfer {2285			from: *sender.as_eth(),2286			to: *new_owner.as_eth(),2287			token_id: item_id.into(),2288		})?;2289		Self::deposit_event(RawEvent::Transfer(2290			collection.id,2291			item_id,2292			sender,2293			new_owner,2294			1,2295		));22962297		Ok(())2298	}22992300	fn set_re_fungible_variable_data(2301		collection: &CollectionHandle<T>,2302		item_id: TokenId,2303		data: Vec<u8>,2304	) -> DispatchResult {2305		let collection_id = collection.id;2306		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2307			.ok_or(Error::<T>::TokenNotFound)?;23082309		item.variable_data = data;23102311		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);23122313		Ok(())2314	}23152316	fn set_nft_variable_data(2317		collection: &CollectionHandle<T>,2318		item_id: TokenId,2319		data: Vec<u8>,2320	) -> DispatchResult {2321		let collection_id = collection.id;2322		let mut item =2323			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23242325		item.variable_data = data;23262327		<NftItemList<T>>::insert(collection_id, item_id, item);23282329		Ok(())2330	}23312332	#[allow(dead_code)]2333	fn init_collection(item: &Collection<T>) {2334		// check params2335		assert!(2336			item.decimal_points <= MAX_DECIMAL_POINTS,2337			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2338		);2339		assert!(2340			item.name.len() <= 64,2341			"Collection name can not be longer than 63 char"2342		);2343		assert!(2344			item.name.len() <= 256,2345			"Collection description can not be longer than 255 char"2346		);2347		assert!(2348			item.token_prefix.len() <= 16,2349			"Token prefix can not be longer than 15 char"2350		);23512352		// Generate next collection ID2353		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23542355		CreatedCollectionCount::put(next_id);2356	}23572358	#[allow(dead_code)]2359	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2360		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23612362		Self::add_token_index(2363			&CollectionHandle::get(collection_id).unwrap(),2364			current_index,2365			&item.owner,2366		)2367		.unwrap();23682369		<ItemListIndex>::insert(collection_id, current_index);23702371		// Update balance2372		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2373			.checked_add(1)2374			.unwrap();2375		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2376	}23772378	#[allow(dead_code)]2379	fn init_fungible_token(2380		collection_id: CollectionId,2381		owner: &T::CrossAccountId,2382		item: &FungibleItemType,2383	) {2384		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23852386		Self::add_token_index(2387			&CollectionHandle::get(collection_id).unwrap(),2388			current_index,2389			owner,2390		)2391		.unwrap();23922393		<ItemListIndex>::insert(collection_id, current_index);23942395		// Update balance2396		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2397			.checked_add(item.value)2398			.unwrap();2399		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2400	}24012402	#[allow(dead_code)]2403	fn init_refungible_token(2404		collection_id: CollectionId,2405		item: &ReFungibleItemType<T::CrossAccountId>,2406	) {2407		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24082409		let value = item.owner.first().unwrap().fraction;2410		let owner = item.owner.first().unwrap().owner.clone();24112412		Self::add_token_index(2413			&CollectionHandle::get(collection_id).unwrap(),2414			current_index,2415			&owner,2416		)2417		.unwrap();24182419		<ItemListIndex>::insert(collection_id, current_index);24202421		// Update balance2422		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2423			.checked_add(value)2424			.unwrap();2425		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2426	}24272428	fn add_token_index(2429		collection: &CollectionHandle<T>,2430		item_index: TokenId,2431		owner: &T::CrossAccountId,2432	) -> DispatchResult {2433		collection.consume_sload()?;2434		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2435		if list_exists {2436			collection.consume_sload()?;2437			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24382439			// bound Owned tokens by a single address in collection2440			let account_items: u32 = list.len() as u32;2441			ensure!(2442				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2443				Error::<T>::AddressOwnershipLimitExceeded2444			);24452446			let item_contains = list.contains(&item_index.clone());24472448			if !item_contains {2449				list.push(item_index);2450			}24512452			collection.consume_sstore()?;2453			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2454		} else {2455			let itm = vec![item_index];2456			collection.consume_sstore()?;2457			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2458		}24592460		Ok(())2461	}24622463	fn remove_token_index(2464		collection: &CollectionHandle<T>,2465		item_index: TokenId,2466		owner: &T::CrossAccountId,2467	) -> DispatchResult {2468		collection.consume_sload()?;2469		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2470		if list_exists {2471			collection.consume_sload()?;2472			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2473			let item_contains = list.contains(&item_index.clone());24742475			if item_contains {2476				list.retain(|&item| item != item_index);2477				collection.consume_sstore()?;2478				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2479			}2480		}24812482		Ok(())2483	}24842485	fn move_token_index(2486		collection: &CollectionHandle<T>,2487		item_index: TokenId,2488		old_owner: &T::CrossAccountId,2489		new_owner: &T::CrossAccountId,2490	) -> DispatchResult {2491		Self::remove_token_index(collection, item_index, old_owner)?;2492		Self::add_token_index(collection, item_index, new_owner)?;24932494		Ok(())2495	}2496}24972498sp_api::decl_runtime_apis! {2499	pub trait NftApi {2500		/// Used for ethereum integration2501		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2502	}2503}