git.delta.rocks / unique-network / refs/commits / 51e66acd38a2

1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9	clippy::too_many_arguments,10	clippy::unnecessary_mut_passed,11	clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19	construct_runtime, decl_event, decl_module, decl_storage, decl_error,20	dispatch::DispatchResult,21	ensure, fail, parameter_types,22	traits::{23		Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24		Randomness, IsSubType, WithdrawReasons,25	},26	weights::{27		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29		WeightToFeePolynomial, DispatchClass,30	},31	StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41	CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46	FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70	/// Error for non-fungible-token module.71	pub enum Error for Module<T: Config> {72		/// Total collections bound exceeded.73		TotalCollectionsLimitExceeded,74		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75		CollectionDecimalPointLimitExceeded,76		/// Collection name can not be longer than 63 char.77		CollectionNameLimitExceeded,78		/// Collection description can not be longer than 255 char.79		CollectionDescriptionLimitExceeded,80		/// Token prefix can not be longer than 15 char.81		CollectionTokenPrefixLimitExceeded,82		/// This collection does not exist.83		CollectionNotFound,84		/// Item not exists.85		TokenNotFound,86		/// Admin not found87		AdminNotFound,88		/// Arithmetic calculation overflow.89		NumOverflow,90		/// Account already has admin role.91		AlreadyAdmin,92		/// You do not own this collection.93		NoPermission,94		/// This address is not set as sponsor, use setCollectionSponsor first.95		ConfirmUnsetSponsorFail,96		/// Collection is not in mint mode.97		PublicMintingNotAllowed,98		/// Sender parameter and item owner must be equal.99		MustBeTokenOwner,100		/// Item balance not enough.101		TokenValueTooLow,102		/// Size of item is too large.103		NftSizeLimitExceeded,104		/// No approve found105		ApproveNotFound,106		/// Requested value more than approved.107		TokenValueNotEnough,108		/// Only approved addresses can call this method.109		ApproveRequired,110		/// Address is not in white list.111		AddresNotInWhiteList,112		/// Number of collection admins bound exceeded.113		CollectionAdminsLimitExceeded,114		/// Owned tokens by a single address bound exceeded.115		AddressOwnershipLimitExceeded,116		/// Length of items properties must be greater than 0.117		EmptyArgument,118		/// const_data exceeded data limit.119		TokenConstDataLimitExceeded,120		/// variable_data exceeded data limit.121		TokenVariableDataLimitExceeded,122		/// Not NFT item data used to mint in NFT collection.123		NotNftDataUsedToMintNftCollectionToken,124		/// Not Fungible item data used to mint in Fungible collection.125		NotFungibleDataUsedToMintFungibleCollectionToken,126		/// Not Re Fungible item data used to mint in Re Fungible collection.127		NotReFungibleDataUsedToMintReFungibleCollectionToken,128		/// Unexpected collection type.129		UnexpectedCollectionType,130		/// Can't store metadata in fungible tokens.131		CantStoreMetadataInFungibleTokens,132		/// Collection token limit exceeded133		CollectionTokenLimitExceeded,134		/// Account token limit exceeded per collection135		AccountTokenLimitExceeded,136		/// Collection limit bounds per collection exceeded137		CollectionLimitBoundsExceeded,138		/// Tried to enable permissions which are only permitted to be disabled139		OwnerPermissionsCantBeReverted,140		/// Schema data size limit bound exceeded141		SchemaDataLimitExceeded,142		/// Maximum refungibility exceeded143		WrongRefungiblePieces,144		/// createRefungible should be called with one owner145		BadCreateRefungibleCall,146		/// Gas limit exceeded147		OutOfGas,148		/// Collection settings not allowing items transferring149		TransferNotAllowed,150		/// Can't transfer tokens to ethereum zero address151		AddressIsZero,152	}153}154155#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]156pub struct CollectionHandle<T: Config> {157	pub id: CollectionId,158	collection: Collection<T>,159	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,160}161impl<T: Config> CollectionHandle<T> {162	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {163		<CollectionById<T>>::get(id).map(|collection| Self {164			id,165			collection,166			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(167				eth::collection_id_to_address(id),168				gas_limit,169			),170		})171	}172	pub fn get(id: CollectionId) -> Option<Self> {173		Self::get_with_gas_limit(id, u64::MAX)174	}175	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {176		self.recorder.log_sub(log)177	}178	#[allow(dead_code)]179	fn consume_gas(&self, gas: u64) -> DispatchResult {180		self.recorder.consume_gas_sub(gas)181	}182	fn consume_sload(&self) -> DispatchResult {183		self.recorder.consume_sload_sub()184	}185	fn consume_sstore(&self) -> DispatchResult {186		self.recorder.consume_sstore_sub()187	}188	pub fn submit_logs(self) -> DispatchResult {189		self.recorder.submit_logs()190	}191	pub fn save(self) -> DispatchResult {192		self.recorder.submit_logs()?;193		<CollectionById<T>>::insert(self.id, self.collection);194		Ok(())195	}196}197impl<T: Config> Deref for CollectionHandle<T> {198	type Target = Collection<T>;199200	fn deref(&self) -> &Self::Target {201		&self.collection202	}203}204205impl<T: Config> DerefMut for CollectionHandle<T> {206	fn deref_mut(&mut self) -> &mut Self::Target {207		&mut self.collection208	}209}210211pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {212	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;213214	/// Weight information for extrinsics in this pallet.215	type WeightInfo: WeightInfo;216217	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;218	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;219220	type CrossAccountId: CrossAccountId<Self::AccountId>;221	type Currency: Currency<Self::AccountId>;222	type CollectionCreationPrice: Get<223		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,224	>;225	type TreasuryAccountId: Get<Self::AccountId>;226}227228type SelfWeightOf<T> = <T as Config>::WeightInfo;229230trait WeightInfoHelpers: WeightInfo {231	fn transfer() -> Weight {232		Self::transfer_nft()233			.max(Self::transfer_fungible())234			.max(Self::transfer_refungible())235	}236	fn transfer_from() -> Weight {237		Self::transfer_from_nft()238			.max(Self::transfer_from_fungible())239			.max(Self::transfer_from_refungible())240	}241	fn approve() -> Weight {242		// TODO: refungible, fungible243		Self::approve_nft()244	}245	fn set_variable_meta_data(data: u32) -> Weight {246		// TODO: refungible247		Self::set_variable_meta_data_nft(data)248	}249	fn create_item(data: u32) -> Weight {250		Self::create_item_nft(data)251			.max(Self::create_item_fungible())252			.max(Self::create_item_refungible(data))253	}254	fn create_multiple_items(amount: u32) -> Weight {255		Self::create_multiple_items_nft(amount)256			.max(Self::create_multiple_items_fungible(amount))257			.max(Self::create_multiple_items_refungible(amount))258	}259	fn burn_item() -> Weight {260		// TODO: refungible, fungible261		Self::burn_item_nft()262	}263}264impl<T: WeightInfo> WeightInfoHelpers for T {}265266// # Used definitions267//268// ## User control levels269//270// chain-controlled - key is uncontrolled by user271//                    i.e autoincrementing index272//                    can use non-cryptographic hash273// real - key is controlled by user274//        but it is hard to generate enough colliding values, i.e owner of signed txs275//        can use non-cryptographic hash276// controlled - key is completly controlled by users277//              i.e maps with mutable keys278//              should use cryptographic hash279//280// ## User control level downgrade reasons281//282// ?1 - chain-controlled -> controlled283//      collections/tokens can be destroyed, resulting in massive holes284// ?2 - chain-controlled -> controlled285//      same as ?1, but can be only added, resulting in easier exploitation286// ?3 - real -> controlled287//      no confirmation required, so addresses can be easily generated288decl_storage! {289	trait Store for Module<T: Config> as Nft {290291		//#region Private members292		/// Id of next collection293		CreatedCollectionCount: u32;294		/// Used for migrations295		ChainVersion: u64;296		/// Id of last collection token297		/// Collection id (controlled?1)298		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;299		//#endregion300301		//#region Bound counters302		/// Amount of collections destroyed, used for total amount tracking with303		/// CreatedCollectionCount304		DestroyedCollectionCount: u32;305		/// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)306		/// Account id (real)307		pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;308		//#endregion309310		//#region Basic collections311		/// Collection info312		/// Collection id (controlled?1)313		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;314		/// List of collection admins315		/// Collection id (controlled?2)316		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;317		/// Whitelisted collection users318		/// Collection id (controlled?2), user id (controlled?3)319		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;320		//#endregion321322		/// How many of collection items user have323		/// Collection id (controlled?2), account id (real)324		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;325326		/// Amount of items which spender can transfer out of owners account (via transferFrom)327		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))328		/// TODO: Off chain worker should remove from this map when token gets removed329		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;330331		//#region Item collections332		/// Collection id (controlled?2), token id (controlled?1)333		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;334		/// Collection id (controlled?2), owner (controlled?2)335		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;336		/// Collection id (controlled?2), token id (controlled?1)337		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;338		//#endregion339340		//#region Index list341		/// Collection id (controlled?2), tokens owner (controlled?2)342		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;343		//#endregion344345		//#region Tokens transfer rate limit baskets346		/// (Collection id (controlled?2), who created (real))347		/// TODO: Off chain worker should remove from this map when collection gets removed348		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;349		/// Collection id (controlled?2), token id (controlled?2)350		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;351		/// Collection id (controlled?2), owning user (real)352		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;353		/// Collection id (controlled?2), token id (controlled?2)354		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;355		//#endregion356357		/// Variable metadata sponsoring358		/// Collection id (controlled?2), token id (controlled?2)359		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;360	}361	add_extra_genesis {362		build(|config: &GenesisConfig<T>| {363			// Modification of storage364			for (_num, _c) in &config.collection_id {365				<Module<T>>::init_collection(_c);366			}367368			for (_num, _c, _i) in &config.nft_item_id {369				<Module<T>>::init_nft_token(*_c, _i);370			}371372			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {373				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);374			}375376			for (_num, _c, _i) in &config.refungible_item_id {377				<Module<T>>::init_refungible_token(*_c, _i);378			}379		})380	}381}382383decl_event!(384	pub enum Event<T>385	where386		AccountId = <T as frame_system::Config>::AccountId,387		CrossAccountId = <T as Config>::CrossAccountId,388	{389		/// New collection was created390		///391		/// # Arguments392		///393		/// * collection_id: Globally unique identifier of newly created collection.394		///395		/// * mode: [CollectionMode] converted into u8.396		///397		/// * account_id: Collection owner.398		CollectionCreated(CollectionId, u8, AccountId),399400		/// New item was created.401		///402		/// # Arguments403		///404		/// * collection_id: Id of the collection where item was created.405		///406		/// * item_id: Id of an item. Unique within the collection.407		///408		/// * recipient: Owner of newly created item409		ItemCreated(CollectionId, TokenId, CrossAccountId),410411		/// Collection item was burned.412		///413		/// # Arguments414		///415		/// collection_id.416		///417		/// item_id: Identifier of burned NFT.418		ItemDestroyed(CollectionId, TokenId),419420		/// Item was transferred421		///422		/// * collection_id: Id of collection to which item is belong423		///424		/// * item_id: Id of an item425		///426		/// * sender: Original owner of item427		///428		/// * recipient: New owner of item429		///430		/// * amount: Always 1 for NFT431		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),432433		/// * collection_id434		///435		/// * item_id436		///437		/// * sender438		///439		/// * spender440		///441		/// * amount442		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),443	}444);445446decl_module! {447	pub struct Module<T: Config> for enum Call448	where449		origin: T::Origin450	{451		fn deposit_event() = default;452		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;453		type Error = Error<T>;454455		fn on_initialize(_now: T::BlockNumber) -> Weight {456			0457		}458459		/// 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.460		///461		/// # Permissions462		///463		/// * Anyone.464		///465		/// # Arguments466		///467		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.468		///469		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.470		///471		/// * token_prefix: UTF-8 string with token prefix.472		///473		/// * mode: [CollectionMode] collection type and type dependent data.474		// returns collection ID475		#[weight = <SelfWeightOf<T>>::create_collection()]476		#[transactional]477		pub fn create_collection(origin,478								 collection_name: Vec<u16>,479								 collection_description: Vec<u16>,480								 token_prefix: Vec<u8>,481								 mode: CollectionMode) -> DispatchResult {482483			// Anyone can create a collection484			let who = ensure_signed(origin)?;485486			// Take a (non-refundable) deposit of collection creation487			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();488			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(489				&T::TreasuryAccountId::get(),490				T::CollectionCreationPrice::get(),491			));492			<T as Config>::Currency::settle(493				&who,494				imbalance,495				WithdrawReasons::TRANSFER,496				ExistenceRequirement::KeepAlive,497			).map_err(|_| Error::<T>::NoPermission)?;498499			let decimal_points = match mode {500				CollectionMode::Fungible(points) => points,501				_ => 0502			};503504			let created_count = CreatedCollectionCount::get();505			let destroyed_count = DestroyedCollectionCount::get();506507			// bound Total number of collections508			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);509510			// check params511			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);512			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);513			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);514			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);515516			// Generate next collection ID517			let next_id = created_count518				.checked_add(1)519				.ok_or(Error::<T>::NumOverflow)?;520521			CreatedCollectionCount::put(next_id);522523			let limits = CollectionLimits {524				sponsored_data_size: CUSTOM_DATA_LIMIT,525				..Default::default()526			};527528			// Create new collection529			let new_collection = Collection {530				owner: who.clone(),531				name: collection_name,532				mode: mode.clone(),533				mint_mode: false,534				access: AccessMode::Normal,535				description: collection_description,536				decimal_points,537				token_prefix,538				offchain_schema: Vec::new(),539				schema_version: SchemaVersion::ImageURL,540				sponsorship: SponsorshipState::Disabled,541				variable_on_chain_schema: Vec::new(),542				const_on_chain_schema: Vec::new(),543				limits,544				transfers_enabled: true,545			};546547			// Add new collection to map548			<CollectionById<T>>::insert(next_id, new_collection);549550			// call event551			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));552553			Ok(())554		}555556		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.557		///558		/// # Permissions559		///560		/// * Collection Owner.561		///562		/// # Arguments563		///564		/// * collection_id: collection to destroy.565		#[weight = <SelfWeightOf<T>>::destroy_collection()]566		#[transactional]567		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {568569			let sender = ensure_signed(origin)?;570			let collection = Self::get_collection(collection_id)?;571			Self::check_owner_permissions(&collection, &sender)?;572			if !collection.limits.owner_can_destroy {573				fail!(Error::<T>::NoPermission);574			}575576			<AddressTokens<T>>::remove_prefix(collection_id, None);577			<Allowances<T>>::remove_prefix(collection_id, None);578			<Balance<T>>::remove_prefix(collection_id, None);579			<ItemListIndex>::remove(collection_id);580			<AdminList<T>>::remove(collection_id);581			<CollectionById<T>>::remove(collection_id);582			<WhiteList<T>>::remove_prefix(collection_id, None);583584			<NftItemList<T>>::remove_prefix(collection_id, None);585			<FungibleItemList<T>>::remove_prefix(collection_id, None);586			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);587588			<NftTransferBasket<T>>::remove_prefix(collection_id, None);589			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);590			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);591592			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);593594			DestroyedCollectionCount::put(DestroyedCollectionCount::get()595				.checked_add(1)596				.ok_or(Error::<T>::NumOverflow)?);597598			Ok(())599		}600601		/// Add an address to white list.602		///603		/// # Permissions604		///605		/// * Collection Owner606		/// * Collection Admin607		///608		/// # Arguments609		///610		/// * collection_id.611		///612		/// * address.613		#[weight = <SelfWeightOf<T>>::add_to_white_list()]614		#[transactional]615		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{616617			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);618			let collection = Self::get_collection(collection_id)?;619620			Self::toggle_white_list_internal(621				&sender,622				&collection,623				&address,624				true,625			)?;626627			Ok(())628		}629630		/// Remove an address from white list.631		///632		/// # Permissions633		///634		/// * Collection Owner635		/// * Collection Admin636		///637		/// # Arguments638		///639		/// * collection_id.640		///641		/// * address.642		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]643		#[transactional]644		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{645646			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);647			let collection = Self::get_collection(collection_id)?;648649			Self::toggle_white_list_internal(650				&sender,651				&collection,652				&address,653				false,654			)?;655656			Ok(())657		}658659		/// Toggle between normal and white list access for the methods with access for `Anyone`.660		///661		/// # Permissions662		///663		/// * Collection Owner.664		///665		/// # Arguments666		///667		/// * collection_id.668		///669		/// * mode: [AccessMode]670		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]671		#[transactional]672		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult673		{674			let sender = ensure_signed(origin)?;675676			let mut target_collection = Self::get_collection(collection_id)?;677			Self::check_owner_permissions(&target_collection, &sender)?;678			target_collection.access = mode;679			target_collection.save()680		}681682		/// Allows Anyone to create tokens if:683		/// * White List is enabled, and684		/// * Address is added to white list, and685		/// * This method was called with True parameter686		///687		/// # Permissions688		/// * Collection Owner689		///690		/// # Arguments691		///692		/// * collection_id.693		///694		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.695		#[weight = <SelfWeightOf<T>>::set_mint_permission()]696		#[transactional]697		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult698		{699			let sender = ensure_signed(origin)?;700701			let mut target_collection = Self::get_collection(collection_id)?;702			Self::check_owner_permissions(&target_collection, &sender)?;703			target_collection.mint_mode = mint_permission;704			target_collection.save()705		}706707		/// Change the owner of the collection.708		///709		/// # Permissions710		///711		/// * Collection Owner.712		///713		/// # Arguments714		///715		/// * collection_id.716		///717		/// * new_owner.718		#[weight = <SelfWeightOf<T>>::change_collection_owner()]719		#[transactional]720		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {721722			let sender = ensure_signed(origin)?;723			let mut target_collection = Self::get_collection(collection_id)?;724			Self::check_owner_permissions(&target_collection, &sender)?;725			target_collection.owner = new_owner;726			target_collection.save()727		}728729		/// Adds an admin of the Collection.730		/// 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.731		///732		/// # Permissions733		///734		/// * Collection Owner.735		/// * Collection Admin.736		///737		/// # Arguments738		///739		/// * collection_id: ID of the Collection to add admin for.740		///741		/// * new_admin_id: Address of new admin to add.742		#[weight = <SelfWeightOf<T>>::add_collection_admin()]743		#[transactional]744		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {745			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);746			let collection = Self::get_collection(collection_id)?;747			Self::check_owner_or_admin_permissions(&collection, &sender)?;748			let mut admin_arr = <AdminList<T>>::get(collection_id);749750			match admin_arr.binary_search(&new_admin_id) {751				Ok(_) => {},752				Err(idx) => {753					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);754					admin_arr.insert(idx, new_admin_id);755					<AdminList<T>>::insert(collection_id, admin_arr);756				}757			}758			Ok(())759		}760761		/// 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.762		///763		/// # Permissions764		///765		/// * Collection Owner.766		/// * Collection Admin.767		///768		/// # Arguments769		///770		/// * collection_id: ID of the Collection to remove admin for.771		///772		/// * account_id: Address of admin to remove.773		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]774		#[transactional]775		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {776			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);777			let collection = Self::get_collection(collection_id)?;778			Self::check_owner_or_admin_permissions(&collection, &sender)?;779			let mut admin_arr = <AdminList<T>>::get(collection_id);780781			if let Ok(idx) = admin_arr.binary_search(&account_id) {782				admin_arr.remove(idx);783				<AdminList<T>>::insert(collection_id, admin_arr);784			}785			Ok(())786		}787788		/// # Permissions789		///790		/// * Collection Owner791		///792		/// # Arguments793		///794		/// * collection_id.795		///796		/// * new_sponsor.797		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]798		#[transactional]799		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {800			let sender = ensure_signed(origin)?;801			let mut target_collection = Self::get_collection(collection_id)?;802			Self::check_owner_permissions(&target_collection, &sender)?;803804			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);805			target_collection.save()806		}807808		/// # Permissions809		///810		/// * Sponsor.811		///812		/// # Arguments813		///814		/// * collection_id.815		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]816		#[transactional]817		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {818			let sender = ensure_signed(origin)?;819820			let mut target_collection = Self::get_collection(collection_id)?;821			ensure!(822				target_collection.sponsorship.pending_sponsor() == Some(&sender),823				Error::<T>::ConfirmUnsetSponsorFail824			);825826			target_collection.sponsorship = SponsorshipState::Confirmed(sender);827			target_collection.save()828		}829830		/// Switch back to pay-per-own-transaction model.831		///832		/// # Permissions833		///834		/// * Collection owner.835		///836		/// # Arguments837		///838		/// * collection_id.839		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]840		#[transactional]841		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {842			let sender = ensure_signed(origin)?;843844			let mut target_collection = Self::get_collection(collection_id)?;845			Self::check_owner_permissions(&target_collection, &sender)?;846847			target_collection.sponsorship = SponsorshipState::Disabled;848			target_collection.save()849		}850851		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.852		///853		/// # Permissions854		///855		/// * Collection Owner.856		/// * Collection Admin.857		/// * Anyone if858		///     * White List is enabled, and859		///     * Address is added to white list, and860		///     * MintPermission is enabled (see SetMintPermission method)861		///862		/// # Arguments863		///864		/// * collection_id: ID of the collection.865		///866		/// * owner: Address, initial owner of the NFT.867		///868		/// * data: Token data to store on chain.869		// #[weight =870		// (130_000_000 as Weight)871		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))872		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))873		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]874875		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]876		#[transactional]877		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {878			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);879			let collection = Self::get_collection(collection_id)?;880881			Self::create_item_internal(&sender, &collection, &owner, data)?;882883			collection.submit_logs()884		}885886		/// This method creates multiple items in a collection created with CreateCollection method.887		///888		/// # Permissions889		///890		/// * Collection Owner.891		/// * Collection Admin.892		/// * Anyone if893		///     * White List is enabled, and894		///     * Address is added to white list, and895		///     * MintPermission is enabled (see SetMintPermission method)896		///897		/// # Arguments898		///899		/// * collection_id: ID of the collection.900		///901		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].902		///903		/// * owner: Address, initial owner of the NFT.904		#[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]905		#[transactional]906		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {907908			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);909			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);910			let collection = Self::get_collection(collection_id)?;911912			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;913914			collection.submit_logs()915		}916917		// TODO! transaction weight918919		/// Set transfers_enabled value for particular collection920		///921		/// # Permissions922		///923		/// * Collection Owner.924		///925		/// # Arguments926		///927		/// * collection_id: ID of the collection.928		///929		/// * value: New flag value.930		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]931		#[transactional]932		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {933934			let sender = ensure_signed(origin)?;935			let mut target_collection = Self::get_collection(collection_id)?;936937			Self::check_owner_permissions(&target_collection, &sender)?;938939			target_collection.transfers_enabled = value;940			target_collection.save()941		}942943		/// Destroys a concrete instance of NFT.944		///945		/// # Permissions946		///947		/// * Collection Owner.948		/// * Collection Admin.949		/// * Current NFT Owner.950		///951		/// # Arguments952		///953		/// * collection_id: ID of the collection.954		///955		/// * item_id: ID of NFT to burn.956		#[weight = <SelfWeightOf<T>>::burn_item()]957		#[transactional]958		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {959960			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);961			let target_collection = Self::get_collection(collection_id)?;962963			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;964965			target_collection.submit_logs()966		}967968		/// Change ownership of the token.969		///970		/// # Permissions971		///972		/// * Collection Owner973		/// * Collection Admin974		/// * Current NFT owner975		///976		/// # Arguments977		///978		/// * recipient: Address of token recipient.979		///980		/// * collection_id.981		///982		/// * item_id: ID of the item983		///     * Non-Fungible Mode: Required.984		///     * Fungible Mode: Ignored.985		///     * Re-Fungible Mode: Required.986		///987		/// * value: Amount to transfer.988		///     * Non-Fungible Mode: Ignored989		///     * Fungible Mode: Must specify transferred amount990		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)991		#[weight = <SelfWeightOf<T>>::transfer()]992		#[transactional]993		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {994			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);995			let collection = Self::get_collection(collection_id)?;996997			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;998999			collection.submit_logs()1000		}10011002		/// Set, change, or remove approved address to transfer the ownership of the NFT.1003		///1004		/// # Permissions1005		///1006		/// * Collection Owner1007		/// * Collection Admin1008		/// * Current NFT owner1009		///1010		/// # Arguments1011		///1012		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1013		///1014		/// * collection_id.1015		///1016		/// * item_id: ID of the item.1017		#[weight = <SelfWeightOf<T>>::approve()]1018		#[transactional]1019		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1020			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1021			let collection = Self::get_collection(collection_id)?;10221023			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10241025			collection.submit_logs()1026		}10271028		/// 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.1029		///1030		/// # Permissions1031		/// * Collection Owner1032		/// * Collection Admin1033		/// * Current NFT owner1034		/// * Address approved by current NFT owner1035		///1036		/// # Arguments1037		///1038		/// * from: Address that owns token.1039		///1040		/// * recipient: Address of token recipient.1041		///1042		/// * collection_id.1043		///1044		/// * item_id: ID of the item.1045		///1046		/// * value: Amount to transfer.1047		#[weight = <SelfWeightOf<T>>::transfer_from()]1048		#[transactional]1049		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1050			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1051			let collection = Self::get_collection(collection_id)?;10521053			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10541055			collection.submit_logs()1056		}1057		// #[weight = 0]1058		//     // let no_perm_mes = "You do not have permissions to modify this collection";1059		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1060		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1061		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10621063		//     // // on_nft_received  call10641065		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10661067		//     Ok(())1068		// }10691070		/// Set off-chain data schema.1071		///1072		/// # Permissions1073		///1074		/// * Collection Owner1075		/// * Collection Admin1076		///1077		/// # Arguments1078		///1079		/// * collection_id.1080		///1081		/// * schema: String representing the offchain data schema.1082		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1083		#[transactional]1084		pub fn set_variable_meta_data (1085			origin,1086			collection_id: CollectionId,1087			item_id: TokenId,1088			data: Vec<u8>1089		) -> DispatchResult {1090			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10911092			let collection = Self::get_collection(collection_id)?;10931094			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10951096			Ok(())1097		}10981099		/// Set schema standard1100		/// ImageURL1101		/// Unique1102		///1103		/// # Permissions1104		///1105		/// * Collection Owner1106		/// * Collection Admin1107		///1108		/// # Arguments1109		///1110		/// * collection_id.1111		///1112		/// * schema: SchemaVersion: enum1113		#[weight = <SelfWeightOf<T>>::set_schema_version()]1114		#[transactional]1115		pub fn set_schema_version(1116			origin,1117			collection_id: CollectionId,1118			version: SchemaVersion1119		) -> DispatchResult {1120			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1121			let mut target_collection = Self::get_collection(collection_id)?;1122			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1123			target_collection.schema_version = version;1124			target_collection.save()1125		}11261127		/// Set off-chain data schema.1128		///1129		/// # Permissions1130		///1131		/// * Collection Owner1132		/// * Collection Admin1133		///1134		/// # Arguments1135		///1136		/// * collection_id.1137		///1138		/// * schema: String representing the offchain data schema.1139		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1140		#[transactional]1141		pub fn set_offchain_schema(1142			origin,1143			collection_id: CollectionId,1144			schema: Vec<u8>1145		) -> DispatchResult {1146			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1147			let mut target_collection = Self::get_collection(collection_id)?;1148			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11491150			// check schema limit1151			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11521153			target_collection.offchain_schema = schema;1154			target_collection.save()1155		}11561157		/// Set const on-chain data schema.1158		///1159		/// # Permissions1160		///1161		/// * Collection Owner1162		/// * Collection Admin1163		///1164		/// # Arguments1165		///1166		/// * collection_id.1167		///1168		/// * schema: String representing the const on-chain data schema.1169		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1170		#[transactional]1171		pub fn set_const_on_chain_schema (1172			origin,1173			collection_id: CollectionId,1174			schema: Vec<u8>1175		) -> DispatchResult {1176			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1177			let mut target_collection = Self::get_collection(collection_id)?;1178			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11791180			// check schema limit1181			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");11821183			target_collection.const_on_chain_schema = schema;1184			target_collection.save()1185		}11861187		/// Set variable on-chain data schema.1188		///1189		/// # Permissions1190		///1191		/// * Collection Owner1192		/// * Collection Admin1193		///1194		/// # Arguments1195		///1196		/// * collection_id.1197		///1198		/// * schema: String representing the variable on-chain data schema.1199		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1200		#[transactional]1201		pub fn set_variable_on_chain_schema (1202			origin,1203			collection_id: CollectionId,1204			schema: Vec<u8>1205		) -> DispatchResult {1206			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1207			let mut target_collection = Self::get_collection(collection_id)?;1208			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12091210			// check schema limit1211			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12121213			target_collection.variable_on_chain_schema = schema;1214			target_collection.save()1215		}12161217		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1218		#[transactional]1219		pub fn set_collection_limits(1220			origin,1221			collection_id: u32,1222			new_limits: CollectionLimits<T::BlockNumber>,1223		) -> DispatchResult {1224			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1225			let mut target_collection = Self::get_collection(collection_id)?;1226			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1227			let old_limits = &target_collection.limits;12281229			// collection bounds1230			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1231				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1232				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1233				Error::<T>::CollectionLimitBoundsExceeded);12341235			// token_limit   check  prev1236			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1237			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12381239			ensure!(1240				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1241				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1242				Error::<T>::OwnerPermissionsCantBeReverted,1243			);12441245			target_collection.limits = new_limits;12461247			target_collection.save()1248		}1249	}1250}12511252impl<T: Config> Module<T> {1253	pub fn create_item_internal(1254		sender: &T::CrossAccountId,1255		collection: &CollectionHandle<T>,1256		owner: &T::CrossAccountId,1257		data: CreateItemData,1258	) -> DispatchResult {1259		ensure!(1260			owner != &T::CrossAccountId::from_eth(H160([0; 20])),1261			Error::<T>::AddressIsZero1262		);12631264		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1265		Self::validate_create_item_args(collection, &data)?;1266		Self::create_item_no_validation(collection, owner, data)?;12671268		Ok(())1269	}12701271	pub fn transfer_internal(1272		sender: &T::CrossAccountId,1273		recipient: &T::CrossAccountId,1274		target_collection: &CollectionHandle<T>,1275		item_id: TokenId,1276		value: u128,1277	) -> DispatchResult {1278		ensure!(1279			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1280			Error::<T>::AddressIsZero1281		);12821283		// Limits check1284		Self::is_correct_transfer(target_collection, recipient)?;12851286		// Transfer permissions check1287		ensure!(1288			Self::is_item_owner(sender, target_collection, item_id)?1289				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,1290			Error::<T>::NoPermission1291		);12921293		if target_collection.access == AccessMode::WhiteList {1294			Self::check_white_list(target_collection, sender)?;1295			Self::check_white_list(target_collection, recipient)?;1296		}12971298		match target_collection.mode {1299			CollectionMode::NFT => Self::transfer_nft(1300				target_collection,1301				item_id,1302				sender.clone(),1303				recipient.clone(),1304			)?,1305			CollectionMode::Fungible(_) => {1306				Self::transfer_fungible(target_collection, value, sender, recipient)?1307			}1308			CollectionMode::ReFungible => Self::transfer_refungible(1309				target_collection,1310				item_id,1311				value,1312				sender.clone(),1313				recipient.clone(),1314			)?,1315			_ => (),1316		};13171318		Self::deposit_event(RawEvent::Transfer(1319			target_collection.id,1320			item_id,1321			sender.clone(),1322			recipient.clone(),1323			value,1324		));13251326		Ok(())1327	}13281329	pub fn approve_internal(1330		sender: &T::CrossAccountId,1331		spender: &T::CrossAccountId,1332		collection: &CollectionHandle<T>,1333		item_id: TokenId,1334		amount: u128,1335	) -> DispatchResult {1336		Self::token_exists(collection, item_id)?;13371338		// Transfer permissions check1339		let bypasses_limits = collection.limits.owner_can_transfer1340			&& Self::is_owner_or_admin_permissions(collection, sender)?;13411342		let allowance_limit = if bypasses_limits {1343			None1344		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1345			Some(amount)1346		} else {1347			fail!(Error::<T>::NoPermission);1348		};13491350		if collection.access == AccessMode::WhiteList {1351			Self::check_white_list(collection, sender)?;1352			Self::check_white_list(collection, spender)?;1353		}13541355		collection.consume_sload()?;1356		let allowance: u128 = amount1357			.checked_add(<Allowances<T>>::get(1358				collection.id,1359				(item_id, sender.as_sub(), spender.as_sub()),1360			))1361			.ok_or(Error::<T>::NumOverflow)?;1362		if let Some(limit) = allowance_limit {1363			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1364		}1365		collection.consume_sstore()?;1366		<Allowances<T>>::insert(1367			collection.id,1368			(item_id, sender.as_sub(), spender.as_sub()),1369			allowance,1370		);13711372		if matches!(collection.mode, CollectionMode::NFT) {1373			// TODO: NFT: only one owner may exist for token in ERC7211374			collection.log(ERC721Events::Approval {1375				owner: *sender.as_eth(),1376				approved: *spender.as_eth(),1377				token_id: item_id.into(),1378			})?;1379		}13801381		if matches!(collection.mode, CollectionMode::Fungible(_)) {1382			// TODO: NFT: only one owner may exist for token in ERC201383			collection.log(ERC20Events::Approval {1384				owner: *sender.as_eth(),1385				spender: *spender.as_eth(),1386				value: allowance.into(),1387			})?;1388		}13891390		Self::deposit_event(RawEvent::Approved(1391			collection.id,1392			item_id,1393			sender.clone(),1394			spender.clone(),1395			allowance,1396		));1397		Ok(())1398	}13991400	pub fn transfer_from_internal(1401		sender: &T::CrossAccountId,1402		from: &T::CrossAccountId,1403		recipient: &T::CrossAccountId,1404		collection: &CollectionHandle<T>,1405		item_id: TokenId,1406		amount: u128,1407	) -> DispatchResult {1408		if sender == from {1409			// Transfer by `from`, because it is either equal to sender, or derived from him1410			return Self::transfer_internal(from, recipient, collection, item_id, amount);1411		}14121413		// Check approval1414		collection.consume_sload()?;1415		let approval: u128 =1416			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14171418		// Limits check1419		Self::is_correct_transfer(collection, recipient)?;14201421		// Transfer permissions check1422		ensure!(1423			approval >= amount1424				|| (collection.limits.owner_can_transfer1425					&& Self::is_owner_or_admin_permissions(collection, sender)?),1426			Error::<T>::NoPermission1427		);14281429		if collection.access == AccessMode::WhiteList {1430			Self::check_white_list(collection, sender)?;1431			Self::check_white_list(collection, recipient)?;1432		}14331434		// Reduce approval by transferred amount or remove if remaining approval drops to 01435		let allowance = approval.saturating_sub(amount);1436		collection.consume_sstore()?;1437		if allowance > 0 {1438			<Allowances<T>>::insert(1439				collection.id,1440				(item_id, from.as_sub(), sender.as_sub()),1441				allowance,1442			);1443		} else {1444			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1445		}14461447		match collection.mode {1448			CollectionMode::NFT => {1449				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1450			}1451			CollectionMode::Fungible(_) => {1452				Self::transfer_fungible(collection, amount, from, recipient)?1453			}1454			CollectionMode::ReFungible => Self::transfer_refungible(1455				collection,1456				item_id,1457				amount,1458				from.clone(),1459				recipient.clone(),1460			)?,1461			_ => (),1462		};14631464		if matches!(collection.mode, CollectionMode::Fungible(_)) {1465			collection.log(ERC20Events::Approval {1466				owner: *from.as_eth(),1467				spender: *sender.as_eth(),1468				value: allowance.into(),1469			})?;1470		}14711472		Ok(())1473	}14741475	pub fn set_variable_meta_data_internal(1476		sender: &T::CrossAccountId,1477		collection: &CollectionHandle<T>,1478		item_id: TokenId,1479		data: Vec<u8>,1480	) -> DispatchResult {1481		Self::token_exists(collection, item_id)?;14821483		ensure!(1484			CUSTOM_DATA_LIMIT >= data.len() as u32,1485			Error::<T>::TokenVariableDataLimitExceeded1486		);14871488		// Modify permissions check1489		ensure!(1490			Self::is_item_owner(sender, collection, item_id)?1491				|| Self::is_owner_or_admin_permissions(collection, sender)?,1492			Error::<T>::NoPermission1493		);14941495		match collection.mode {1496			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1497			CollectionMode::ReFungible => {1498				Self::set_re_fungible_variable_data(collection, item_id, data)?1499			}1500			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1501			_ => fail!(Error::<T>::UnexpectedCollectionType),1502		};15031504		Ok(())1505	}15061507	pub fn get_variable_metadata(1508		collection: &CollectionHandle<T>,1509		item_id: TokenId,1510	) -> Result<Vec<u8>, DispatchError> {1511		Ok(match collection.mode {1512			CollectionMode::NFT => {1513				<NftItemList<T>>::get(collection.id, item_id)1514					.ok_or(Error::<T>::TokenNotFound)?1515					.variable_data1516			}1517			CollectionMode::ReFungible => {1518				<ReFungibleItemList<T>>::get(collection.id, item_id)1519					.ok_or(Error::<T>::TokenNotFound)?1520					.variable_data1521			}1522			_ => fail!(Error::<T>::UnexpectedCollectionType),1523		})1524	}15251526	pub fn create_multiple_items_internal(1527		sender: &T::CrossAccountId,1528		collection: &CollectionHandle<T>,1529		owner: &T::CrossAccountId,1530		items_data: Vec<CreateItemData>,1531	) -> DispatchResult {1532		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15331534		for data in &items_data {1535			Self::validate_create_item_args(collection, data)?;1536		}1537		for data in &items_data {1538			Self::create_item_no_validation(collection, owner, data.clone())?;1539		}15401541		Ok(())1542	}15431544	pub fn burn_item_internal(1545		sender: &T::CrossAccountId,1546		collection: &CollectionHandle<T>,1547		item_id: TokenId,1548		value: u128,1549	) -> DispatchResult {1550		ensure!(1551			Self::is_item_owner(sender, collection, item_id)?1552				|| (collection.limits.owner_can_transfer1553					&& Self::is_owner_or_admin_permissions(collection, sender)?),1554			Error::<T>::NoPermission1555		);15561557		if collection.access == AccessMode::WhiteList {1558			Self::check_white_list(collection, sender)?;1559		}15601561		match collection.mode {1562			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1563			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1564			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1565			_ => (),1566		};15671568		Ok(())1569	}15701571	pub fn toggle_white_list_internal(1572		sender: &T::CrossAccountId,1573		collection: &CollectionHandle<T>,1574		address: &T::CrossAccountId,1575		whitelisted: bool,1576	) -> DispatchResult {1577		Self::check_owner_or_admin_permissions(collection, sender)?;15781579		if whitelisted {1580			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1581		} else {1582			<WhiteList<T>>::remove(collection.id, address.as_sub());1583		}15841585		Ok(())1586	}15871588	fn is_correct_transfer(1589		collection: &CollectionHandle<T>,1590		recipient: &T::CrossAccountId,1591	) -> DispatchResult {1592		let collection_id = collection.id;15931594		// check token limit and account token limit1595		collection.consume_sload()?;1596		let account_items: u32 =1597			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1598		ensure!(1599			collection.limits.account_token_ownership_limit > account_items,1600			Error::<T>::AccountTokenLimitExceeded1601		);16021603		// preliminary transfer check1604		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16051606		Ok(())1607	}16081609	fn can_create_items_in_collection(1610		collection: &CollectionHandle<T>,1611		sender: &T::CrossAccountId,1612		owner: &T::CrossAccountId,1613		amount: u32,1614	) -> DispatchResult {1615		let collection_id = collection.id;16161617		// check token limit and account token limit1618		let total_items: u32 = ItemListIndex::get(collection_id)1619			.checked_add(amount)1620			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1621		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1622			as u32)1623			.checked_add(amount)1624			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1625		ensure!(1626			collection.limits.token_limit >= total_items,1627			Error::<T>::CollectionTokenLimitExceeded1628		);1629		ensure!(1630			collection.limits.account_token_ownership_limit >= account_items,1631			Error::<T>::AccountTokenLimitExceeded1632		);16331634		if !Self::is_owner_or_admin_permissions(collection, sender)? {1635			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1636			Self::check_white_list(collection, owner)?;1637			Self::check_white_list(collection, sender)?;1638		}16391640		Ok(())1641	}16421643	fn validate_create_item_args(1644		target_collection: &CollectionHandle<T>,1645		data: &CreateItemData,1646	) -> DispatchResult {1647		match target_collection.mode {1648			CollectionMode::NFT => {1649				if !matches!(data, CreateItemData::NFT(_)) {1650					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1651				}1652			}1653			CollectionMode::Fungible(_) => {1654				if !matches!(data, CreateItemData::Fungible(_)) {1655					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1656				}1657			}1658			CollectionMode::ReFungible => {1659				if let CreateItemData::ReFungible(data) = data {1660					// Check refungibility limits1661					ensure!(1662						data.pieces <= MAX_REFUNGIBLE_PIECES,1663						Error::<T>::WrongRefungiblePieces1664					);1665					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1666				} else {1667					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1668				}1669			}1670			_ => {1671				fail!(Error::<T>::UnexpectedCollectionType);1672			}1673		};16741675		Ok(())1676	}16771678	fn create_item_no_validation(1679		collection: &CollectionHandle<T>,1680		owner: &T::CrossAccountId,1681		data: CreateItemData,1682	) -> DispatchResult {1683		match data {1684			CreateItemData::NFT(data) => {1685				let item = NftItemType {1686					owner: owner.clone(),1687					const_data: data.const_data.into_inner(),1688					variable_data: data.variable_data.into_inner(),1689				};16901691				Self::add_nft_item(collection, item)?;1692			}1693			CreateItemData::Fungible(data) => {1694				Self::add_fungible_item(collection, owner, data.value)?;1695			}1696			CreateItemData::ReFungible(data) => {1697				let owner_list = vec![Ownership {1698					owner: owner.clone(),1699					fraction: data.pieces,1700				}];17011702				let item = ReFungibleItemType {1703					owner: owner_list,1704					const_data: data.const_data.into_inner(),1705					variable_data: data.variable_data.into_inner(),1706				};17071708				Self::add_refungible_item(collection, item)?;1709			}1710		};17111712		Ok(())1713	}17141715	fn add_fungible_item(1716		collection: &CollectionHandle<T>,1717		owner: &T::CrossAccountId,1718		value: u128,1719	) -> DispatchResult {1720		let collection_id = collection.id;17211722		// Does new owner already have an account?1723		collection.consume_sload()?;1724		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17251726		// Mint1727		let item = FungibleItemType {1728			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1729		};1730		collection.consume_sstore()?;1731		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17321733		// Update balance1734		collection.consume_sload()?;1735		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1736			.checked_add(value)1737			.ok_or(Error::<T>::NumOverflow)?;1738		collection.consume_sstore()?;1739		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17401741		collection.log(ERC20Events::Transfer {1742			from: H160::default(),1743			to: *owner.as_eth(),1744			value: value.into(),1745		})?;1746		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1747		Ok(())1748	}17491750	fn add_refungible_item(1751		collection: &CollectionHandle<T>,1752		item: ReFungibleItemType<T::CrossAccountId>,1753	) -> DispatchResult {1754		let collection_id = collection.id;17551756		let current_index = <ItemListIndex>::get(collection_id)1757			.checked_add(1)1758			.ok_or(Error::<T>::NumOverflow)?;1759		let itemcopy = item.clone();17601761		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1762		let item_owner = item.owner.first().expect("only one owner is defined");17631764		let value = item_owner.fraction;1765		let owner = item_owner.owner.clone();17661767		Self::add_token_index(collection, current_index, &owner)?;17681769		<ItemListIndex>::insert(collection_id, current_index);1770		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17711772		// Update balance1773		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1774			.checked_add(value)1775			.ok_or(Error::<T>::NumOverflow)?;1776		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17771778		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1779		Ok(())1780	}17811782	fn add_nft_item(1783		collection: &CollectionHandle<T>,1784		item: NftItemType<T::CrossAccountId>,1785	) -> DispatchResult {1786		let collection_id = collection.id;17871788		let current_index = <ItemListIndex>::get(collection_id)1789			.checked_add(1)1790			.ok_or(Error::<T>::NumOverflow)?;17911792		let item_owner = item.owner.clone();1793		Self::add_token_index(collection, current_index, &item.owner)?;17941795		<ItemListIndex>::insert(collection_id, current_index);1796		<NftItemList<T>>::insert(collection_id, current_index, item);17971798		// Update balance1799		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1800			.checked_add(1)1801			.ok_or(Error::<T>::NumOverflow)?;1802		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18031804		collection.log(ERC721Events::Transfer {1805			from: H160::default(),1806			to: *item_owner.as_eth(),1807			token_id: current_index.into(),1808		})?;1809		Self::deposit_event(RawEvent::ItemCreated(1810			collection_id,1811			current_index,1812			item_owner,1813		));1814		Ok(())1815	}18161817	fn burn_refungible_item(1818		collection: &CollectionHandle<T>,1819		item_id: TokenId,1820		owner: &T::CrossAccountId,1821	) -> DispatchResult {1822		let collection_id = collection.id;18231824		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1825			.ok_or(Error::<T>::TokenNotFound)?;1826		let rft_balance = token1827			.owner1828			.iter()1829			.find(|&i| i.owner == *owner)1830			.ok_or(Error::<T>::TokenNotFound)?;1831		Self::remove_token_index(collection, item_id, owner)?;18321833		// update balance1834		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1835			.checked_sub(rft_balance.fraction)1836			.ok_or(Error::<T>::NumOverflow)?;1837		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18381839		// Re-create owners list with sender removed1840		let index = token1841			.owner1842			.iter()1843			.position(|i| i.owner == *owner)1844			.expect("owned item is exists");1845		token.owner.remove(index);1846		let owner_count = token.owner.len();18471848		// Burn the token completely if this was the last (only) owner1849		if owner_count == 0 {1850			<ReFungibleItemList<T>>::remove(collection_id, item_id);1851			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1852		} else {1853			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1854		}18551856		Ok(())1857	}18581859	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1860		let collection_id = collection.id;18611862		let item =1863			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1864		Self::remove_token_index(collection, item_id, &item.owner)?;18651866		// update balance1867		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1868			.checked_sub(1)1869			.ok_or(Error::<T>::NumOverflow)?;1870		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1871		<NftItemList<T>>::remove(collection_id, item_id);1872		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);18731874		collection.log(ERC721Events::Transfer {1875			from: *item.owner.as_eth(),1876			to: H160::default(),1877			token_id: item_id.into(),1878		})?;1879		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1880		Ok(())1881	}18821883	fn burn_fungible_item(1884		owner: &T::CrossAccountId,1885		collection: &CollectionHandle<T>,1886		value: u128,1887	) -> DispatchResult {1888		let collection_id = collection.id;18891890		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1891		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18921893		// update balance1894		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1895			.checked_sub(value)1896			.ok_or(Error::<T>::NumOverflow)?;1897		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18981899		if balance.value - value > 0 {1900			balance.value -= value;1901			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1902		} else {1903			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1904		}19051906		collection.log(ERC20Events::Transfer {1907			from: *owner.as_eth(),1908			to: H160::default(),1909			value: value.into(),1910		})?;1911		Ok(())1912	}19131914	pub fn get_collection(1915		collection_id: CollectionId,1916	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1917		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1918	}19191920	fn check_owner_permissions(1921		target_collection: &CollectionHandle<T>,1922		subject: &T::AccountId,1923	) -> DispatchResult {1924		ensure!(1925			*subject == target_collection.owner,1926			Error::<T>::NoPermission1927		);19281929		Ok(())1930	}19311932	fn is_owner_or_admin_permissions(1933		collection: &CollectionHandle<T>,1934		subject: &T::CrossAccountId,1935	) -> Result<bool, DispatchError> {1936		collection.consume_sload()?;1937		Ok(*subject.as_sub() == collection.owner1938			|| <AdminList<T>>::get(collection.id).contains(subject))1939	}19401941	fn check_owner_or_admin_permissions(1942		collection: &CollectionHandle<T>,1943		subject: &T::CrossAccountId,1944	) -> DispatchResult {1945		ensure!(1946			Self::is_owner_or_admin_permissions(collection, subject)?,1947			Error::<T>::NoPermission1948		);19491950		Ok(())1951	}19521953	fn owned_amount(1954		subject: &T::CrossAccountId,1955		collection: &CollectionHandle<T>,1956		item_id: TokenId,1957	) -> Result<Option<u128>, DispatchError> {1958		collection.consume_sload()?;1959		Ok(Self::owned_amount_unchecked(subject, collection, item_id))1960	}19611962	fn owned_amount_unchecked(1963		subject: &T::CrossAccountId,1964		target_collection: &CollectionHandle<T>,1965		item_id: TokenId,1966	) -> Option<u128> {1967		let collection_id = target_collection.id;19681969		match target_collection.mode {1970			CollectionMode::NFT => {1971				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1972			}1973			CollectionMode::Fungible(_) => {1974				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1975			}1976			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1977				.owner1978				.iter()1979				.find(|i| i.owner == *subject)1980				.map(|i| i.fraction),1981			CollectionMode::Invalid => None,1982		}1983	}19841985	fn is_item_owner(1986		subject: &T::CrossAccountId,1987		target_collection: &CollectionHandle<T>,1988		item_id: TokenId,1989	) -> Result<bool, DispatchError> {1990		Ok(match target_collection.mode {1991			CollectionMode::Fungible(_) => true,1992			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),1993		})1994	}19951996	fn check_white_list(1997		collection: &CollectionHandle<T>,1998		address: &T::CrossAccountId,1999	) -> DispatchResult {2000		collection.consume_sload()?;2001		ensure!(2002			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),2003			Error::<T>::AddresNotInWhiteList,2004		);2005		Ok(())2006	}20072008	/// Check if token exists. In case of Fungible, check if there is an entry for2009	/// the owner in fungible balances double map2010	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2011		let collection_id = target_collection.id;2012		let exists = match target_collection.mode {2013			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2014			CollectionMode::Fungible(_) => true,2015			CollectionMode::ReFungible => {2016				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2017			}2018			_ => false,2019		};20202021		ensure!(exists, Error::<T>::TokenNotFound);2022		Ok(())2023	}20242025	fn transfer_fungible(2026		collection: &CollectionHandle<T>,2027		value: u128,2028		owner: &T::CrossAccountId,2029		recipient: &T::CrossAccountId,2030	) -> DispatchResult {2031		let collection_id = collection.id;20322033		collection.consume_sload()?;2034		collection.consume_sload()?;2035		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2036		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20372038		recipient_balance.value = recipient_balance2039			.value2040			.checked_add(value)2041			.ok_or(Error::<T>::NumOverflow)?;2042		balance.value = balance2043			.value2044			.checked_sub(value)2045			.ok_or(Error::<T>::TokenValueTooLow)?;20462047		// update balanceOf2048		collection.consume_sstore()?;2049		collection.consume_sstore()?;2050		if balance.value != 0 {2051			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2052		} else {2053			<Balance<T>>::remove(collection_id, owner.as_sub());2054		}2055		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20562057		// Reduce or remove sender2058		collection.consume_sstore()?;2059		collection.consume_sstore()?;2060		if balance.value != 0 {2061			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2062		} else {2063			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2064		}2065		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);20662067		collection.log(ERC20Events::Transfer {2068			from: *owner.as_eth(),2069			to: *recipient.as_eth(),2070			value: value.into(),2071		})?;2072		Self::deposit_event(RawEvent::Transfer(2073			collection.id,2074			1,2075			owner.clone(),2076			recipient.clone(),2077			value,2078		));20792080		Ok(())2081	}20822083	fn transfer_refungible(2084		collection: &CollectionHandle<T>,2085		item_id: TokenId,2086		value: u128,2087		owner: T::CrossAccountId,2088		new_owner: T::CrossAccountId,2089	) -> DispatchResult {2090		let collection_id = collection.id;2091		collection.consume_sload()?;2092		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2093			.ok_or(Error::<T>::TokenNotFound)?;20942095		let item = full_item2096			.owner2097			.iter()2098			.find(|i| i.owner == owner)2099			.ok_or(Error::<T>::TokenNotFound)?;2100		let amount = item.fraction;21012102		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21032104		collection.consume_sload()?;2105		// update balance2106		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2107			.checked_sub(value)2108			.ok_or(Error::<T>::NumOverflow)?;2109		collection.consume_sstore()?;2110		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21112112		collection.consume_sload()?;2113		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2114			.checked_add(value)2115			.ok_or(Error::<T>::NumOverflow)?;2116		collection.consume_sstore()?;2117		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21182119		let old_owner = item.owner.clone();2120		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21212122		let mut new_full_item = full_item.clone();2123		// transfer2124		if amount == value && !new_owner_has_account {2125			// change owner2126			// new owner do not have account2127			new_full_item2128				.owner2129				.iter_mut()2130				.find(|i| i.owner == owner)2131				.expect("old owner does present in refungible")2132				.owner = new_owner.clone();2133			collection.consume_sstore()?;2134			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21352136			// update index collection2137			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2138		} else {2139			new_full_item2140				.owner2141				.iter_mut()2142				.find(|i| i.owner == owner)2143				.expect("old owner does present in refungible")2144				.fraction -= value;21452146			// separate amount2147			if new_owner_has_account {2148				// new owner has account2149				new_full_item2150					.owner2151					.iter_mut()2152					.find(|i| i.owner == new_owner)2153					.expect("new owner has account")2154					.fraction += value;2155			} else {2156				// new owner do not have account2157				new_full_item.owner.push(Ownership {2158					owner: new_owner.clone(),2159					fraction: value,2160				});2161				Self::add_token_index(collection, item_id, &new_owner)?;2162			}21632164			collection.consume_sstore()?;2165			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2166		}21672168		Self::deposit_event(RawEvent::Transfer(2169			collection.id,2170			item_id,2171			owner,2172			new_owner,2173			amount,2174		));21752176		Ok(())2177	}21782179	fn transfer_nft(2180		collection: &CollectionHandle<T>,2181		item_id: TokenId,2182		sender: T::CrossAccountId,2183		new_owner: T::CrossAccountId,2184	) -> DispatchResult {2185		let collection_id = collection.id;2186		collection.consume_sload()?;2187		let mut item =2188			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21892190		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21912192		collection.consume_sload()?;2193		// update balance2194		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2195			.checked_sub(1)2196			.ok_or(Error::<T>::NumOverflow)?;2197		collection.consume_sstore()?;2198		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21992200		collection.consume_sload()?;2201		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2202			.checked_add(1)2203			.ok_or(Error::<T>::NumOverflow)?;2204		collection.consume_sstore()?;2205		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22062207		// change owner2208		let old_owner = item.owner.clone();2209		item.owner = new_owner.clone();2210		collection.consume_sstore()?;2211		<NftItemList<T>>::insert(collection_id, item_id, item);22122213		// update index collection2214		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22152216		collection.log(ERC721Events::Transfer {2217			from: *sender.as_eth(),2218			to: *new_owner.as_eth(),2219			token_id: item_id.into(),2220		})?;2221		Self::deposit_event(RawEvent::Transfer(2222			collection.id,2223			item_id,2224			sender,2225			new_owner,2226			1,2227		));22282229		Ok(())2230	}22312232	fn set_re_fungible_variable_data(2233		collection: &CollectionHandle<T>,2234		item_id: TokenId,2235		data: Vec<u8>,2236	) -> DispatchResult {2237		let collection_id = collection.id;2238		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2239			.ok_or(Error::<T>::TokenNotFound)?;22402241		item.variable_data = data;22422243		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22442245		Ok(())2246	}22472248	fn set_nft_variable_data(2249		collection: &CollectionHandle<T>,2250		item_id: TokenId,2251		data: Vec<u8>,2252	) -> DispatchResult {2253		let collection_id = collection.id;2254		let mut item =2255			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22562257		item.variable_data = data;22582259		<NftItemList<T>>::insert(collection_id, item_id, item);22602261		Ok(())2262	}22632264	#[allow(dead_code)]2265	fn init_collection(item: &Collection<T>) {2266		// check params2267		assert!(2268			item.decimal_points <= MAX_DECIMAL_POINTS,2269			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2270		);2271		assert!(2272			item.name.len() <= 64,2273			"Collection name can not be longer than 63 char"2274		);2275		assert!(2276			item.name.len() <= 256,2277			"Collection description can not be longer than 255 char"2278		);2279		assert!(2280			item.token_prefix.len() <= 16,2281			"Token prefix can not be longer than 15 char"2282		);22832284		// Generate next collection ID2285		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22862287		CreatedCollectionCount::put(next_id);2288	}22892290	#[allow(dead_code)]2291	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2292		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22932294		Self::add_token_index(2295			&CollectionHandle::get(collection_id).unwrap(),2296			current_index,2297			&item.owner,2298		)2299		.unwrap();23002301		<ItemListIndex>::insert(collection_id, current_index);23022303		// Update balance2304		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2305			.checked_add(1)2306			.unwrap();2307		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2308	}23092310	#[allow(dead_code)]2311	fn init_fungible_token(2312		collection_id: CollectionId,2313		owner: &T::CrossAccountId,2314		item: &FungibleItemType,2315	) {2316		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23172318		Self::add_token_index(2319			&CollectionHandle::get(collection_id).unwrap(),2320			current_index,2321			owner,2322		)2323		.unwrap();23242325		<ItemListIndex>::insert(collection_id, current_index);23262327		// Update balance2328		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2329			.checked_add(item.value)2330			.unwrap();2331		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2332	}23332334	#[allow(dead_code)]2335	fn init_refungible_token(2336		collection_id: CollectionId,2337		item: &ReFungibleItemType<T::CrossAccountId>,2338	) {2339		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23402341		let value = item.owner.first().unwrap().fraction;2342		let owner = item.owner.first().unwrap().owner.clone();23432344		Self::add_token_index(2345			&CollectionHandle::get(collection_id).unwrap(),2346			current_index,2347			&owner,2348		)2349		.unwrap();23502351		<ItemListIndex>::insert(collection_id, current_index);23522353		// Update balance2354		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2355			.checked_add(value)2356			.unwrap();2357		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2358	}23592360	fn add_token_index(2361		collection: &CollectionHandle<T>,2362		item_index: TokenId,2363		owner: &T::CrossAccountId,2364	) -> DispatchResult {2365		// add to account limit2366		collection.consume_sload()?;2367		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2368			// bound Owned tokens by a single address2369			collection.consume_sload()?;2370			let count = <AccountItemCount<T>>::get(owner.as_sub());2371			ensure!(2372				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2373				Error::<T>::AddressOwnershipLimitExceeded2374			);23752376			collection.consume_sstore()?;2377			<AccountItemCount<T>>::insert(2378				owner.as_sub(),2379				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2380			);2381		} else {2382			collection.consume_sstore()?;2383			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2384		}23852386		collection.consume_sload()?;2387		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2388		if list_exists {2389			collection.consume_sload()?;2390			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2391			let item_contains = list.contains(&item_index.clone());23922393			if !item_contains {2394				list.push(item_index);2395			}23962397			collection.consume_sstore()?;2398			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2399		} else {2400			let itm = vec![item_index];2401			collection.consume_sstore()?;2402			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2403		}24042405		Ok(())2406	}24072408	fn remove_token_index(2409		collection: &CollectionHandle<T>,2410		item_index: TokenId,2411		owner: &T::CrossAccountId,2412	) -> DispatchResult {2413		// update counter2414		collection.consume_sload()?;2415		collection.consume_sstore()?;2416		<AccountItemCount<T>>::insert(2417			owner.as_sub(),2418			<AccountItemCount<T>>::get(owner.as_sub())2419				.checked_sub(1)2420				.ok_or(Error::<T>::NumOverflow)?,2421		);24222423		collection.consume_sload()?;2424		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2425		if list_exists {2426			collection.consume_sload()?;2427			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2428			let item_contains = list.contains(&item_index.clone());24292430			if item_contains {2431				list.retain(|&item| item != item_index);2432				collection.consume_sstore()?;2433				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2434			}2435		}24362437		Ok(())2438	}24392440	fn move_token_index(2441		collection: &CollectionHandle<T>,2442		item_index: TokenId,2443		old_owner: &T::CrossAccountId,2444		new_owner: &T::CrossAccountId,2445	) -> DispatchResult {2446		Self::remove_token_index(collection, item_index, old_owner)?;2447		Self::add_token_index(collection, item_index, new_owner)?;24482449		Ok(())2450	}2451}24522453sp_api::decl_runtime_apis! {2454	pub trait NftApi {2455		/// Used for ethereum integration2456		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2457	}2458}