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

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, ensure_root};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::sp_std::prelude::Vec;38use core::ops::{Deref, DerefMut};39use core::cell::RefCell;40use nft_data_structs::{41	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,42	AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits, CollectionId,43	CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,44	FungibleItemType, ReFungibleItemType, MetaUpdatePermission,45};46use pallet_ethereum::EthereumTransactionSender;4748#[cfg(test)]49mod mock;5051#[cfg(test)]52mod tests;5354mod default_weights;55mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;5859pub use eth::NftErcSupport;60pub use eth::account::*;61use eth::erc::{ERC20Events, ERC721Events};6263#[cfg(feature = "runtime-benchmarks")]64mod benchmarking;6566pub trait WeightInfo {67	fn create_collection() -> Weight;68	fn destroy_collection() -> Weight;69	fn add_to_white_list() -> Weight;70	fn remove_from_white_list() -> Weight;71	fn set_public_access_mode() -> Weight;72	fn set_mint_permission() -> Weight;73	fn change_collection_owner() -> Weight;74	fn add_collection_admin() -> Weight;75	fn remove_collection_admin() -> Weight;76	fn set_collection_sponsor() -> Weight;77	fn confirm_sponsorship() -> Weight;78	fn remove_collection_sponsor() -> Weight;79	fn create_item(s: usize) -> Weight;80	fn burn_item() -> Weight;81	fn transfer() -> Weight;82	fn approve() -> Weight;83	fn transfer_from() -> Weight;84	fn set_offchain_schema() -> Weight;85	fn set_const_on_chain_schema() -> Weight;86	fn set_variable_on_chain_schema() -> Weight;87	fn set_variable_meta_data() -> Weight;88	fn enable_contract_sponsoring() -> Weight;89	fn set_schema_version() -> Weight;90	fn set_chain_limits() -> Weight;91	fn set_contract_sponsoring_rate_limit() -> Weight;92	fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;93	fn toggle_contract_white_list() -> Weight;94	fn add_to_contract_white_list() -> Weight;95	fn remove_from_contract_white_list() -> Weight;96	fn set_collection_limits() -> Weight;97}9899decl_error! {100	/// Error for non-fungible-token module.101	pub enum Error for Module<T: Config> {102		/// Total collections bound exceeded.103		TotalCollectionsLimitExceeded,104		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.105		CollectionDecimalPointLimitExceeded,106		/// Collection name can not be longer than 63 char.107		CollectionNameLimitExceeded,108		/// Collection description can not be longer than 255 char.109		CollectionDescriptionLimitExceeded,110		/// Token prefix can not be longer than 15 char.111		CollectionTokenPrefixLimitExceeded,112		/// This collection does not exist.113		CollectionNotFound,114		/// Item not exists.115		TokenNotFound,116		/// Admin not found117		AdminNotFound,118		/// Arithmetic calculation overflow.119		NumOverflow,120		/// Account already has admin role.121		AlreadyAdmin,122		/// You do not own this collection.123		NoPermission,124		/// This address is not set as sponsor, use setCollectionSponsor first.125		ConfirmUnsetSponsorFail,126		/// Collection is not in mint mode.127		PublicMintingNotAllowed,128		/// Sender parameter and item owner must be equal.129		MustBeTokenOwner,130		/// Item balance not enough.131		TokenValueTooLow,132		/// Size of item is too large.133		NftSizeLimitExceeded,134		/// No approve found135		ApproveNotFound,136		/// Requested value more than approved.137		TokenValueNotEnough,138		/// Only approved addresses can call this method.139		ApproveRequired,140		/// Address is not in white list.141		AddresNotInWhiteList,142		/// Number of collection admins bound exceeded.143		CollectionAdminsLimitExceeded,144		/// Owned tokens by a single address bound exceeded.145		AddressOwnershipLimitExceeded,146		/// Length of items properties must be greater than 0.147		EmptyArgument,148		/// const_data exceeded data limit.149		TokenConstDataLimitExceeded,150		/// variable_data exceeded data limit.151		TokenVariableDataLimitExceeded,152		/// Not NFT item data used to mint in NFT collection.153		NotNftDataUsedToMintNftCollectionToken,154		/// Not Fungible item data used to mint in Fungible collection.155		NotFungibleDataUsedToMintFungibleCollectionToken,156		/// Not Re Fungible item data used to mint in Re Fungible collection.157		NotReFungibleDataUsedToMintReFungibleCollectionToken,158		/// Unexpected collection type.159		UnexpectedCollectionType,160		/// Can't store metadata in fungible tokens.161		CantStoreMetadataInFungibleTokens,162		/// Collection token limit exceeded163		CollectionTokenLimitExceeded,164		/// Account token limit exceeded per collection165		AccountTokenLimitExceeded,166		/// Collection limit bounds per collection exceeded167		CollectionLimitBoundsExceeded,168		/// Tried to enable permissions which are only permitted to be disabled169		OwnerPermissionsCantBeReverted,170		/// Schema data size limit bound exceeded171		SchemaDataLimitExceeded,172		/// Maximum refungibility exceeded173		WrongRefungiblePieces,174		/// createRefungible should be called with one owner175		BadCreateRefungibleCall,176		/// Gas limit exceeded177		OutOfGas,178		/// Metadata update denied by collection settings179		MetadataUpdateDenied,180		/// Metadata update flag become unmutable with None option181		MetadataFlagFrozen,182	}183}184185pub struct CollectionHandle<T: Config> {186	pub id: CollectionId,187	collection: Collection<T>,188	logs: eth::log::LogRecorder,189	evm_address: H160,190	gas_limit: RefCell<u64>,191}192impl<T: Config> CollectionHandle<T> {193	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {194		<CollectionById<T>>::get(id).map(|collection| Self {195			id,196			collection,197			logs: eth::log::LogRecorder::default(),198			evm_address: eth::collection_id_to_address(id),199			gas_limit: RefCell::new(gas_limit),200		})201	}202	pub fn get(id: CollectionId) -> Option<Self> {203		Self::get_with_gas_limit(id, u64::MAX)204	}205	pub fn gas_left(&self) -> u64 {206		*self.gas_limit.borrow()207	}208	pub fn consume_gas(&self, gas: u64) -> DispatchResult {209		let mut gas_limit = self.gas_limit.borrow_mut();210		if *gas_limit < gas {211			fail!(Error::<T>::OutOfGas);212		}213		*gas_limit -= gas;214		Ok(())215	}216	pub fn log(&self, log: impl evm_coder::ToLog) {217		self.logs.log(log.to_log(self.evm_address))218	}219	pub fn into_inner(self) -> Collection<T> {220		self.collection221	}222}223impl<T: Config> Deref for CollectionHandle<T> {224	type Target = Collection<T>;225226	fn deref(&self) -> &Self::Target {227		&self.collection228	}229}230231impl<T: Config> DerefMut for CollectionHandle<T> {232	fn deref_mut(&mut self) -> &mut Self::Target {233		&mut self.collection234	}235}236237pub trait Config: system::Config + Sized {238	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;239240	/// Weight information for extrinsics in this pallet.241	type WeightInfo: WeightInfo;242243	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;244	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;245246	type CrossAccountId: CrossAccountId<Self::AccountId>;247	type Currency: Currency<Self::AccountId>;248	type CollectionCreationPrice: Get<249		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,250	>;251	type TreasuryAccountId: Get<Self::AccountId>;252253	type EthereumChainId: Get<u64>;254	type EthereumTransactionSender: pallet_ethereum::EthereumTransactionSender;255}256257// # Used definitions258//259// ## User control levels260//261// chain-controlled - key is uncontrolled by user262//                    i.e autoincrementing index263//                    can use non-cryptographic hash264// real - key is controlled by user265//        but it is hard to generate enough colliding values, i.e owner of signed txs266//        can use non-cryptographic hash267// controlled - key is completly controlled by users268//              i.e maps with mutable keys269//              should use cryptographic hash270//271// ## User control level downgrade reasons272//273// ?1 - chain-controlled -> controlled274//      collections/tokens can be destroyed, resulting in massive holes275// ?2 - chain-controlled -> controlled276//      same as ?1, but can be only added, resulting in easier exploitation277// ?3 - real -> controlled278//      no confirmation required, so addresses can be easily generated279decl_storage! {280	trait Store for Module<T: Config> as Nft {281282		//#region Private members283		/// Id of next collection284		CreatedCollectionCount: u32;285		/// Used for migrations286		ChainVersion: u64;287		/// Id of last collection token288		/// Collection id (controlled?1)289		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;290		//#endregion291292		//#region Chain limits struct293		pub ChainLimit get(fn chain_limit) config(): ChainLimits;294		//#endregion295296		//#region Bound counters297		/// Amount of collections destroyed, used for total amount tracking with298		/// CreatedCollectionCount299		DestroyedCollectionCount: u32;300		/// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)301		/// Account id (real)302		pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;303		//#endregion304305		//#region Basic collections306		/// Collection info307		/// Collection id (controlled?1)308		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;309		/// List of collection admins310		/// Collection id (controlled?2)311		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;312		/// Whitelisted collection users313		/// Collection id (controlled?2), user id (controlled?3)314		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;315		//#endregion316317		/// How many of collection items user have318		/// Collection id (controlled?2), account id (real)319		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;320321		/// Amount of items which spender can transfer out of owners account (via transferFrom)322		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))323		/// TODO: Off chain worker should remove from this map when token gets removed324		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;325326		//#region Item collections327		/// Collection id (controlled?2), token id (controlled?1)328		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;329		/// Collection id (controlled?2), owner (controlled?2)330		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;331		/// Collection id (controlled?2), token id (controlled?1)332		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;333		//#endregion334335		//#region Index list336		/// Collection id (controlled?2), tokens owner (controlled?2)337		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;338		//#endregion339340		//#region Tokens transfer rate limit baskets341		/// (Collection id (controlled?2), who created (real))342		/// TODO: Off chain worker should remove from this map when collection gets removed343		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;344		/// Collection id (controlled?2), token id (controlled?2)345		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;346		/// Collection id (controlled?2), owning user (real)347		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;348		/// Collection id (controlled?2), token id (controlled?2)349		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;350		//#endregion351352		/// Variable metadata sponsoring353		/// Collection id (controlled?2), token id (controlled?2)354		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;355	}356	add_extra_genesis {357		build(|config: &GenesisConfig<T>| {358			// Modification of storage359			for (_num, _c) in &config.collection_id {360				<Module<T>>::init_collection(_c);361			}362363			for (_num, _c, _i) in &config.nft_item_id {364				<Module<T>>::init_nft_token(*_c, _i);365			}366367			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {368				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);369			}370371			for (_num, _c, _i) in &config.refungible_item_id {372				<Module<T>>::init_refungible_token(*_c, _i);373			}374		})375	}376}377378decl_event!(379	pub enum Event<T>380	where381		AccountId = <T as frame_system::Config>::AccountId,382		CrossAccountId = <T as Config>::CrossAccountId,383	{384		/// New collection was created385		///386		/// # Arguments387		///388		/// * collection_id: Globally unique identifier of newly created collection.389		///390		/// * mode: [CollectionMode] converted into u8.391		///392		/// * account_id: Collection owner.393		CollectionCreated(CollectionId, u8, AccountId),394395		/// New item was created.396		///397		/// # Arguments398		///399		/// * collection_id: Id of the collection where item was created.400		///401		/// * item_id: Id of an item. Unique within the collection.402		///403		/// * recipient: Owner of newly created item404		ItemCreated(CollectionId, TokenId, CrossAccountId),405406		/// Collection item was burned.407		///408		/// # Arguments409		///410		/// collection_id.411		///412		/// item_id: Identifier of burned NFT.413		ItemDestroyed(CollectionId, TokenId),414415		/// Item was transferred416		///417		/// * collection_id: Id of collection to which item is belong418		///419		/// * item_id: Id of an item420		///421		/// * sender: Original owner of item422		///423		/// * recipient: New owner of item424		///425		/// * amount: Always 1 for NFT426		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),427428		/// * collection_id429		///430		/// * item_id431		///432		/// * sender433		///434		/// * spender435		///436		/// * amount437		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),438	}439);440441decl_module! {442	pub struct Module<T: Config> for enum Call443	where444		origin: T::Origin445	{446		fn deposit_event() = default;447		type Error = Error<T>;448449		fn on_initialize(_now: T::BlockNumber) -> Weight {450			0451		}452453		/// 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.454		///455		/// # Permissions456		///457		/// * Anyone.458		///459		/// # Arguments460		///461		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.462		///463		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.464		///465		/// * token_prefix: UTF-8 string with token prefix.466		///467		/// * mode: [CollectionMode] collection type and type dependent data.468		// returns collection ID469		#[weight = <T as Config>::WeightInfo::create_collection()]470		#[transactional]471		pub fn create_collection(origin,472								 collection_name: Vec<u16>,473								 collection_description: Vec<u16>,474								 token_prefix: Vec<u8>,475								 mode: CollectionMode) -> DispatchResult {476477			// Anyone can create a collection478			let who = ensure_signed(origin)?;479480			// Take a (non-refundable) deposit of collection creation481			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();482			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(483				&T::TreasuryAccountId::get(),484				T::CollectionCreationPrice::get(),485			));486			<T as Config>::Currency::settle(487				&who,488				imbalance,489				WithdrawReasons::TRANSFER,490				ExistenceRequirement::KeepAlive,491			).map_err(|_| Error::<T>::NoPermission)?;492493			let decimal_points = match mode {494				CollectionMode::Fungible(points) => points,495				_ => 0496			};497498			let chain_limit = ChainLimit::get();499500			let created_count = CreatedCollectionCount::get();501			let destroyed_count = DestroyedCollectionCount::get();502503			// bound Total number of collections504			ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);505506			// check params507			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);508			ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);509			ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);510			ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);511512			// Generate next collection ID513			let next_id = created_count514				.checked_add(1)515				.ok_or(Error::<T>::NumOverflow)?;516517			CreatedCollectionCount::put(next_id);518519			let limits = CollectionLimits {520				sponsored_data_size: chain_limit.custom_data_limit,521				..Default::default()522			};523524			// Create new collection525			let new_collection = Collection {526				owner: who.clone(),527				name: collection_name,528				mode: mode.clone(),529				mint_mode: false,530				access: AccessMode::Normal,531				description: collection_description,532				decimal_points,533				token_prefix,534				offchain_schema: Vec::new(),535				schema_version: SchemaVersion::ImageURL,536				sponsorship: SponsorshipState::Disabled,537				variable_on_chain_schema: Vec::new(),538				const_on_chain_schema: Vec::new(),539				limits,540				meta_update_permission: MetaUpdatePermission::default(),541			};542543			// Add new collection to map544			<CollectionById<T>>::insert(next_id, new_collection);545546			// call event547			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));548549			Ok(())550		}551552		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.553		///554		/// # Permissions555		///556		/// * Collection Owner.557		///558		/// # Arguments559		///560		/// * collection_id: collection to destroy.561		#[weight = <T as Config>::WeightInfo::destroy_collection()]562		#[transactional]563		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {564565			let sender = ensure_signed(origin)?;566			let collection = Self::get_collection(collection_id)?;567			Self::check_owner_permissions(&collection, &sender)?;568			if !collection.limits.owner_can_destroy {569				fail!(Error::<T>::NoPermission);570			}571572			<AddressTokens<T>>::remove_prefix(collection_id);573			<Allowances<T>>::remove_prefix(collection_id);574			<Balance<T>>::remove_prefix(collection_id);575			<ItemListIndex>::remove(collection_id);576			<AdminList<T>>::remove(collection_id);577			<CollectionById<T>>::remove(collection_id);578			<WhiteList<T>>::remove_prefix(collection_id);579580			<NftItemList<T>>::remove_prefix(collection_id);581			<FungibleItemList<T>>::remove_prefix(collection_id);582			<ReFungibleItemList<T>>::remove_prefix(collection_id);583584			<NftTransferBasket<T>>::remove_prefix(collection_id);585			<FungibleTransferBasket<T>>::remove_prefix(collection_id);586			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id);587588			<VariableMetaDataBasket<T>>::remove_prefix(collection_id);589590			DestroyedCollectionCount::put(DestroyedCollectionCount::get()591				.checked_add(1)592				.ok_or(Error::<T>::NumOverflow)?);593594			Ok(())595		}596597		/// Add an address to white list.598		///599		/// # Permissions600		///601		/// * Collection Owner602		/// * Collection Admin603		///604		/// # Arguments605		///606		/// * collection_id.607		///608		/// * address.609		#[weight = <T as Config>::WeightInfo::add_to_white_list()]610		#[transactional]611		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{612613			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);614			let collection = Self::get_collection(collection_id)?;615616			Self::toggle_white_list_internal(617				&sender,618				&collection,619				&address,620				true,621			)?;622623			Ok(())624		}625626		/// Remove an address from white list.627		///628		/// # Permissions629		///630		/// * Collection Owner631		/// * Collection Admin632		///633		/// # Arguments634		///635		/// * collection_id.636		///637		/// * address.638		#[weight = <T as Config>::WeightInfo::remove_from_white_list()]639		#[transactional]640		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{641642			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);643			let collection = Self::get_collection(collection_id)?;644645			Self::toggle_white_list_internal(646				&sender,647				&collection,648				&address,649				false,650			)?;651652			Ok(())653		}654655		/// Toggle between normal and white list access for the methods with access for `Anyone`.656		///657		/// # Permissions658		///659		/// * Collection Owner.660		///661		/// # Arguments662		///663		/// * collection_id.664		///665		/// * mode: [AccessMode]666		#[weight = <T as Config>::WeightInfo::set_public_access_mode()]667		#[transactional]668		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult669		{670			let sender = ensure_signed(origin)?;671672			let mut target_collection = Self::get_collection(collection_id)?;673			Self::check_owner_permissions(&target_collection, &sender)?;674			target_collection.access = mode;675			Self::save_collection(target_collection);676677			Ok(())678		}679680		/// Allows Anyone to create tokens if:681		/// * White List is enabled, and682		/// * Address is added to white list, and683		/// * This method was called with True parameter684		///685		/// # Permissions686		/// * Collection Owner687		///688		/// # Arguments689		///690		/// * collection_id.691		///692		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.693		#[weight = <T as Config>::WeightInfo::set_mint_permission()]694		#[transactional]695		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult696		{697			let sender = ensure_signed(origin)?;698699			let mut target_collection = Self::get_collection(collection_id)?;700			Self::check_owner_permissions(&target_collection, &sender)?;701			target_collection.mint_mode = mint_permission;702			Self::save_collection(target_collection);703704			Ok(())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 = <T as Config>::WeightInfo::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			Self::save_collection(target_collection);727728			Ok(())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 = <T as Config>::WeightInfo::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					let limits = ChainLimit::get();756					ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);757					admin_arr.insert(idx, new_admin_id);758					<AdminList<T>>::insert(collection_id, admin_arr);759				}760			}761			Ok(())762		}763764		/// 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.765		///766		/// # Permissions767		///768		/// * Collection Owner.769		/// * Collection Admin.770		///771		/// # Arguments772		///773		/// * collection_id: ID of the Collection to remove admin for.774		///775		/// * account_id: Address of admin to remove.776		#[weight = <T as Config>::WeightInfo::remove_collection_admin()]777		#[transactional]778		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {779			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);780			let collection = Self::get_collection(collection_id)?;781			Self::check_owner_or_admin_permissions(&collection, &sender)?;782			let mut admin_arr = <AdminList<T>>::get(collection_id);783784			if let Ok(idx) = admin_arr.binary_search(&account_id) {785				admin_arr.remove(idx);786				<AdminList<T>>::insert(collection_id, admin_arr);787			}788			Ok(())789		}790791		/// # Permissions792		///793		/// * Collection Owner794		///795		/// # Arguments796		///797		/// * collection_id.798		///799		/// * new_sponsor.800		#[weight = <T as Config>::WeightInfo::set_collection_sponsor()]801		#[transactional]802		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {803			let sender = ensure_signed(origin)?;804			let mut target_collection = Self::get_collection(collection_id)?;805			Self::check_owner_permissions(&target_collection, &sender)?;806807			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);808			Self::save_collection(target_collection);809810			Ok(())811		}812813		/// # Permissions814		///815		/// * Sponsor.816		///817		/// # Arguments818		///819		/// * collection_id.820		#[weight = <T as Config>::WeightInfo::confirm_sponsorship()]821		#[transactional]822		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {823			let sender = ensure_signed(origin)?;824825			let mut target_collection = Self::get_collection(collection_id)?;826			ensure!(827				target_collection.sponsorship.pending_sponsor() == Some(&sender),828				Error::<T>::ConfirmUnsetSponsorFail829			);830831			target_collection.sponsorship = SponsorshipState::Confirmed(sender);832			Self::save_collection(target_collection);833834			Ok(())835		}836837		/// Switch back to pay-per-own-transaction model.838		///839		/// # Permissions840		///841		/// * Collection owner.842		///843		/// # Arguments844		///845		/// * collection_id.846		#[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]847		#[transactional]848		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {849			let sender = ensure_signed(origin)?;850851			let mut target_collection = Self::get_collection(collection_id)?;852			Self::check_owner_permissions(&target_collection, &sender)?;853854			target_collection.sponsorship = SponsorshipState::Disabled;855			Self::save_collection(target_collection);856857			Ok(())858		}859860		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.861		///862		/// # Permissions863		///864		/// * Collection Owner.865		/// * Collection Admin.866		/// * Anyone if867		///     * White List is enabled, and868		///     * Address is added to white list, and869		///     * MintPermission is enabled (see SetMintPermission method)870		///871		/// # Arguments872		///873		/// * collection_id: ID of the collection.874		///875		/// * owner: Address, initial owner of the NFT.876		///877		/// * data: Token data to store on chain.878		// #[weight =879		// (130_000_000 as Weight)880		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))881		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))882		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]883884		#[weight = <T as Config>::WeightInfo::create_item(data.data_size())]885		#[transactional]886		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {887			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);888			let collection = Self::get_collection(collection_id)?;889890			Self::create_item_internal(&sender, &collection, &owner, data)?;891892			// Self::submit_logs(collection)?;893			Ok(())894		}895896		/// This method creates multiple items in a collection created with CreateCollection method.897		///898		/// # Permissions899		///900		/// * Collection Owner.901		/// * Collection Admin.902		/// * Anyone if903		///     * White List is enabled, and904		///     * Address is added to white list, and905		///     * MintPermission is enabled (see SetMintPermission method)906		///907		/// # Arguments908		///909		/// * collection_id: ID of the collection.910		///911		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].912		///913		/// * owner: Address, initial owner of the NFT.914		#[weight = <T as Config>::WeightInfo::create_item(items_data.iter()915							   .map(|data| { data.data_size() })916							   .sum())]917		#[transactional]918		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {919920			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);921			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);922			let collection = Self::get_collection(collection_id)?;923924			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;925926			// Self::submit_logs(collection)?;927			Ok(())928		}929930		// TODO! transaction weight931		/// Set meta_update_permission value for particular collection932		///933		/// # Permissions934		///935		/// * Collection Owner.936		///937		/// # Arguments938		///939		/// * collection_id: ID of the collection.940		///941		/// * value: New flag value.942		#[weight = <T as Config>::WeightInfo::burn_item()]943		#[transactional]944		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {945946			let sender = ensure_signed(origin)?;947			let mut target_collection = Self::get_collection(collection_id)?;948949			ensure!(950				target_collection.meta_update_permission != MetaUpdatePermission::None,951				Error::<T>::MetadataFlagFrozen952			);953			Self::check_owner_permissions(&target_collection, &sender)?;954955			target_collection.meta_update_permission = value;956			Self::save_collection(target_collection);957958			Ok(())959		}960961		/// Destroys a concrete instance of NFT.962		///963		/// # Permissions964		///965		/// * Collection Owner.966		/// * Collection Admin.967		/// * Current NFT Owner.968		///969		/// # Arguments970		///971		/// * collection_id: ID of the collection.972		///973		/// * item_id: ID of NFT to burn.974		#[weight = <T as Config>::WeightInfo::burn_item()]975		#[transactional]976		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {977978			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);979			let target_collection = Self::get_collection(collection_id)?;980981			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;982983			// Self::submit_logs(target_collection)?;984			Ok(())985		}986987		/// Change ownership of the token.988		///989		/// # Permissions990		///991		/// * Collection Owner992		/// * Collection Admin993		/// * Current NFT owner994		///995		/// # Arguments996		///997		/// * recipient: Address of token recipient.998		///999		/// * collection_id.1000		///1001		/// * item_id: ID of the item1002		///     * Non-Fungible Mode: Required.1003		///     * Fungible Mode: Ignored.1004		///     * Re-Fungible Mode: Required.1005		///1006		/// * value: Amount to transfer.1007		///     * Non-Fungible Mode: Ignored1008		///     * Fungible Mode: Must specify transferred amount1009		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1010		#[weight = <T as Config>::WeightInfo::transfer()]1011		#[transactional]1012		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1013			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1014			let collection = Self::get_collection(collection_id)?;10151016			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10171018			// Self::submit_logs(collection)?;1019			Ok(())1020		}10211022		/// Set, change, or remove approved address to transfer the ownership of the NFT.1023		///1024		/// # Permissions1025		///1026		/// * Collection Owner1027		/// * Collection Admin1028		/// * Current NFT owner1029		///1030		/// # Arguments1031		///1032		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1033		///1034		/// * collection_id.1035		///1036		/// * item_id: ID of the item.1037		#[weight = <T as Config>::WeightInfo::approve()]1038		#[transactional]1039		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1040			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1041			let collection = Self::get_collection(collection_id)?;10421043			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10441045			// Self::submit_logs(collection)?;1046			Ok(())1047		}10481049		/// 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.1050		///1051		/// # Permissions1052		/// * Collection Owner1053		/// * Collection Admin1054		/// * Current NFT owner1055		/// * Address approved by current NFT owner1056		///1057		/// # Arguments1058		///1059		/// * from: Address that owns token.1060		///1061		/// * recipient: Address of token recipient.1062		///1063		/// * collection_id.1064		///1065		/// * item_id: ID of the item.1066		///1067		/// * value: Amount to transfer.1068		#[weight = <T as Config>::WeightInfo::transfer_from()]1069		#[transactional]1070		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1071			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1072			let collection = Self::get_collection(collection_id)?;10731074			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10751076			// Self::submit_logs(collection)?;1077			Ok(())1078		}1079		// #[weight = 0]1080		//     // let no_perm_mes = "You do not have permissions to modify this collection";1081		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1082		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1083		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10841085		//     // // on_nft_received  call10861087		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10881089		//     Ok(())1090		// }10911092		/// Set off-chain data schema.1093		///1094		/// # Permissions1095		///1096		/// * Collection Owner1097		/// * Collection Admin1098		///1099		/// # Arguments1100		///1101		/// * collection_id.1102		///1103		/// * schema: String representing the offchain data schema.1104		#[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1105		#[transactional]1106		pub fn set_variable_meta_data (1107			origin,1108			collection_id: CollectionId,1109			item_id: TokenId,1110			data: Vec<u8>1111		) -> DispatchResult {1112			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11131114			let collection = Self::get_collection(collection_id)?;11151116			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11171118			Ok(())1119		}11201121		/// Set schema standard1122		/// ImageURL1123		/// Unique1124		///1125		/// # Permissions1126		///1127		/// * Collection Owner1128		/// * Collection Admin1129		///1130		/// # Arguments1131		///1132		/// * collection_id.1133		///1134		/// * schema: SchemaVersion: enum1135		#[weight = <T as Config>::WeightInfo::set_schema_version()]1136		#[transactional]1137		pub fn set_schema_version(1138			origin,1139			collection_id: CollectionId,1140			version: SchemaVersion1141		) -> DispatchResult {1142			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1143			let mut target_collection = Self::get_collection(collection_id)?;1144			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1145			target_collection.schema_version = version;1146			Self::save_collection(target_collection);11471148			Ok(())1149		}11501151		/// Set off-chain data schema.1152		///1153		/// # Permissions1154		///1155		/// * Collection Owner1156		/// * Collection Admin1157		///1158		/// # Arguments1159		///1160		/// * collection_id.1161		///1162		/// * schema: String representing the offchain data schema.1163		#[weight = <T as Config>::WeightInfo::set_offchain_schema()]1164		#[transactional]1165		pub fn set_offchain_schema(1166			origin,1167			collection_id: CollectionId,1168			schema: Vec<u8>1169		) -> DispatchResult {1170			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1171			let mut target_collection = Self::get_collection(collection_id)?;1172			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11731174			// check schema limit1175			ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");11761177			target_collection.offchain_schema = schema;1178			Self::save_collection(target_collection);11791180			Ok(())1181		}11821183		/// Set const on-chain data schema.1184		///1185		/// # Permissions1186		///1187		/// * Collection Owner1188		/// * Collection Admin1189		///1190		/// # Arguments1191		///1192		/// * collection_id.1193		///1194		/// * schema: String representing the const on-chain data schema.1195		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1196		#[transactional]1197		pub fn set_const_on_chain_schema (1198			origin,1199			collection_id: CollectionId,1200			schema: Vec<u8>1201		) -> DispatchResult {1202			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1203			let mut target_collection = Self::get_collection(collection_id)?;1204			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12051206			// check schema limit1207			ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");12081209			target_collection.const_on_chain_schema = schema;1210			Self::save_collection(target_collection);12111212			Ok(())1213		}12141215		/// Set variable on-chain data schema.1216		///1217		/// # Permissions1218		///1219		/// * Collection Owner1220		/// * Collection Admin1221		///1222		/// # Arguments1223		///1224		/// * collection_id.1225		///1226		/// * schema: String representing the variable on-chain data schema.1227		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1228		#[transactional]1229		pub fn set_variable_on_chain_schema (1230			origin,1231			collection_id: CollectionId,1232			schema: Vec<u8>1233		) -> DispatchResult {1234			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1235			let mut target_collection = Self::get_collection(collection_id)?;1236			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12371238			// check schema limit1239			ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");12401241			target_collection.variable_on_chain_schema = schema;1242			Self::save_collection(target_collection);12431244			Ok(())1245		}12461247		// Sudo permissions function1248		#[weight = <T as Config>::WeightInfo::set_chain_limits()]1249		#[transactional]1250		pub fn set_chain_limits(1251			origin,1252			limits: ChainLimits1253		) -> DispatchResult {12541255			#[cfg(not(feature = "runtime-benchmarks"))]1256			ensure_root(origin)?;12571258			<ChainLimit>::put(limits);1259			Ok(())1260		}12611262		#[weight = <T as Config>::WeightInfo::set_collection_limits()]1263		#[transactional]1264		pub fn set_collection_limits(1265			origin,1266			collection_id: u32,1267			new_limits: CollectionLimits<T::BlockNumber>,1268		) -> DispatchResult {1269			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1270			let mut target_collection = Self::get_collection(collection_id)?;1271			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1272			let old_limits = &target_collection.limits;1273			let chain_limits = ChainLimit::get();12741275			// collection bounds1276			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1277				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1278				new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1279				Error::<T>::CollectionLimitBoundsExceeded);12801281			// token_limit   check  prev1282			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1283			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12841285			ensure!(1286				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1287				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1288				Error::<T>::OwnerPermissionsCantBeReverted,1289			);12901291			target_collection.limits = new_limits;1292			Self::save_collection(target_collection);12931294			Ok(())1295		}1296	}1297}12981299impl<T: Config> Module<T> {1300	pub fn create_item_internal(1301		sender: &T::CrossAccountId,1302		collection: &CollectionHandle<T>,1303		owner: &T::CrossAccountId,1304		data: CreateItemData,1305	) -> DispatchResult {1306		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1307		Self::validate_create_item_args(collection, &data)?;1308		Self::create_item_no_validation(collection, owner, data)?;13091310		Ok(())1311	}13121313	pub fn transfer_internal(1314		sender: &T::CrossAccountId,1315		recipient: &T::CrossAccountId,1316		target_collection: &CollectionHandle<T>,1317		item_id: TokenId,1318		value: u128,1319	) -> DispatchResult {1320		target_collection.consume_gas(2000000)?;1321		// Limits check1322		Self::is_correct_transfer(target_collection, recipient)?;13231324		// Transfer permissions check1325		ensure!(1326			Self::is_item_owner(sender, target_collection, item_id)1327				|| Self::is_owner_or_admin_permissions(target_collection, sender),1328			Error::<T>::NoPermission1329		);13301331		if target_collection.access == AccessMode::WhiteList {1332			Self::check_white_list(target_collection, sender)?;1333			Self::check_white_list(target_collection, recipient)?;1334		}13351336		match target_collection.mode {1337			CollectionMode::NFT => Self::transfer_nft(1338				target_collection,1339				item_id,1340				sender.clone(),1341				recipient.clone(),1342			)?,1343			CollectionMode::Fungible(_) => {1344				Self::transfer_fungible(target_collection, value, sender, recipient)?1345			}1346			CollectionMode::ReFungible => Self::transfer_refungible(1347				target_collection,1348				item_id,1349				value,1350				sender.clone(),1351				recipient.clone(),1352			)?,1353			_ => (),1354		};13551356		Self::deposit_event(RawEvent::Transfer(1357			target_collection.id,1358			item_id,1359			sender.clone(),1360			recipient.clone(),1361			value,1362		));13631364		Ok(())1365	}13661367	pub fn approve_internal(1368		sender: &T::CrossAccountId,1369		spender: &T::CrossAccountId,1370		collection: &CollectionHandle<T>,1371		item_id: TokenId,1372		amount: u128,1373	) -> DispatchResult {1374		collection.consume_gas(2000000)?;1375		Self::token_exists(collection, item_id)?;13761377		// Transfer permissions check1378		let bypasses_limits = collection.limits.owner_can_transfer1379			&& Self::is_owner_or_admin_permissions(collection, sender);13801381		let allowance_limit = if bypasses_limits {1382			None1383		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id) {1384			Some(amount)1385		} else {1386			fail!(Error::<T>::NoPermission);1387		};13881389		if collection.access == AccessMode::WhiteList {1390			Self::check_white_list(collection, sender)?;1391			Self::check_white_list(collection, spender)?;1392		}13931394		let allowance: u128 = amount1395			.checked_add(<Allowances<T>>::get(1396				collection.id,1397				(item_id, sender.as_sub(), spender.as_sub()),1398			))1399			.ok_or(Error::<T>::NumOverflow)?;1400		if let Some(limit) = allowance_limit {1401			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1402		}1403		<Allowances<T>>::insert(1404			collection.id,1405			(item_id, sender.as_sub(), spender.as_sub()),1406			allowance,1407		);14081409		if matches!(collection.mode, CollectionMode::NFT) {1410			// TODO: NFT: only one owner may exist for token in ERC7211411			collection.log(ERC721Events::Approval {1412				owner: *sender.as_eth(),1413				approved: *spender.as_eth(),1414				token_id: item_id.into(),1415			});1416		}14171418		if matches!(collection.mode, CollectionMode::Fungible(_)) {1419			// TODO: NFT: only one owner may exist for token in ERC201420			collection.log(ERC20Events::Approval {1421				owner: *sender.as_eth(),1422				spender: *spender.as_eth(),1423				value: allowance.into(),1424			});1425		}14261427		Self::deposit_event(RawEvent::Approved(1428			collection.id,1429			item_id,1430			sender.clone(),1431			spender.clone(),1432			allowance,1433		));1434		Ok(())1435	}14361437	pub fn transfer_from_internal(1438		sender: &T::CrossAccountId,1439		from: &T::CrossAccountId,1440		recipient: &T::CrossAccountId,1441		collection: &CollectionHandle<T>,1442		item_id: TokenId,1443		amount: u128,1444	) -> DispatchResult {1445		collection.consume_gas(2000000)?;1446		// Check approval1447		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		if allowance > 0 {1469			<Allowances<T>>::insert(1470				collection.id,1471				(item_id, from.as_sub(), sender.as_sub()),1472				allowance,1473			);1474		} else {1475			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1476		}14771478		match collection.mode {1479			CollectionMode::NFT => {1480				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1481			}1482			CollectionMode::Fungible(_) => {1483				Self::transfer_fungible(collection, amount, from, recipient)?1484			}1485			CollectionMode::ReFungible => Self::transfer_refungible(1486				collection,1487				item_id,1488				amount,1489				from.clone(),1490				recipient.clone(),1491			)?,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			ChainLimit::get().custom_data_limit >= data.len() as u32,1516			Error::<T>::TokenVariableDataLimitExceeded1517		);15181519		// Modify permissions check1520		Self::meta_update_check(sender, collection, item_id)?;15211522		match collection.mode {1523			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1524			CollectionMode::ReFungible => {1525				Self::set_re_fungible_variable_data(collection, item_id, data)?1526			}1527			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1528			_ => fail!(Error::<T>::UnexpectedCollectionType),1529		};15301531		Ok(())1532	}15331534	pub fn meta_update_check(1535		sender: &T::CrossAccountId,1536		collection: &CollectionHandle<T>,1537		item_id: TokenId,1538	) -> DispatchResult {1539		match collection.meta_update_permission {1540			MetaUpdatePermission::ItemOwner => {1541				ensure!(1542					Self::is_item_owner(sender, collection, item_id),1543					Error::<T>::NoPermission1544				);1545			}1546			MetaUpdatePermission::Admin => {1547				ensure!(1548					Self::is_owner_or_admin_permissions(collection, sender),1549					Error::<T>::NoPermission1550				);1551			}1552			MetaUpdatePermission::None => {1553				fail!(Error::<T>::MetadataUpdateDenied);1554			}1555		}15561557		Ok(())1558	}15591560	pub fn create_multiple_items_internal(1561		sender: &T::CrossAccountId,1562		collection: &CollectionHandle<T>,1563		owner: &T::CrossAccountId,1564		items_data: Vec<CreateItemData>,1565	) -> DispatchResult {1566		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15671568		for data in &items_data {1569			Self::validate_create_item_args(collection, data)?;1570		}1571		for data in &items_data {1572			Self::create_item_no_validation(collection, owner, data.clone())?;1573		}15741575		Ok(())1576	}15771578	pub fn burn_item_internal(1579		sender: &T::CrossAccountId,1580		collection: &CollectionHandle<T>,1581		item_id: TokenId,1582		value: u128,1583	) -> DispatchResult {1584		ensure!(1585			Self::is_item_owner(sender, collection, item_id)1586				|| (collection.limits.owner_can_transfer1587					&& Self::is_owner_or_admin_permissions(collection, sender)),1588			Error::<T>::NoPermission1589		);15901591		if collection.access == AccessMode::WhiteList {1592			Self::check_white_list(collection, sender)?;1593		}15941595		match collection.mode {1596			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1597			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1598			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1599			_ => (),1600		};16011602		Ok(())1603	}16041605	pub fn toggle_white_list_internal(1606		sender: &T::CrossAccountId,1607		collection: &CollectionHandle<T>,1608		address: &T::CrossAccountId,1609		whitelisted: bool,1610	) -> DispatchResult {1611		Self::check_owner_or_admin_permissions(collection, sender)?;16121613		if whitelisted {1614			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1615		} else {1616			<WhiteList<T>>::remove(collection.id, address.as_sub());1617		}16181619		Ok(())1620	}16211622	fn is_correct_transfer(1623		collection: &CollectionHandle<T>,1624		recipient: &T::CrossAccountId,1625	) -> DispatchResult {1626		let collection_id = collection.id;16271628		// check token limit and account token limit1629		let account_items: u32 =1630			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1631		ensure!(1632			collection.limits.account_token_ownership_limit > account_items,1633			Error::<T>::AccountTokenLimitExceeded1634		);16351636		Ok(())1637	}16381639	fn can_create_items_in_collection(1640		collection: &CollectionHandle<T>,1641		sender: &T::CrossAccountId,1642		owner: &T::CrossAccountId,1643		amount: u32,1644	) -> DispatchResult {1645		let collection_id = collection.id;16461647		// check token limit and account token limit1648		let total_items: u32 = ItemListIndex::get(collection_id)1649			.checked_add(amount)1650			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1651		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1652			as u32)1653			.checked_add(amount)1654			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1655		ensure!(1656			collection.limits.token_limit >= total_items,1657			Error::<T>::CollectionTokenLimitExceeded1658		);1659		ensure!(1660			collection.limits.account_token_ownership_limit >= account_items,1661			Error::<T>::AccountTokenLimitExceeded1662		);16631664		if !Self::is_owner_or_admin_permissions(collection, sender) {1665			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1666			Self::check_white_list(collection, owner)?;1667			Self::check_white_list(collection, sender)?;1668		}16691670		Ok(())1671	}16721673	fn validate_create_item_args(1674		target_collection: &CollectionHandle<T>,1675		data: &CreateItemData,1676	) -> DispatchResult {1677		match target_collection.mode {1678			CollectionMode::NFT => {1679				if let CreateItemData::NFT(data) = data {1680					// check sizes1681					ensure!(1682						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1683						Error::<T>::TokenConstDataLimitExceeded1684					);1685					ensure!(1686						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1687						Error::<T>::TokenVariableDataLimitExceeded1688					);1689				} else {1690					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1691				}1692			}1693			CollectionMode::Fungible(_) => {1694				if let CreateItemData::Fungible(_) = data {1695				} else {1696					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1697				}1698			}1699			CollectionMode::ReFungible => {1700				if let CreateItemData::ReFungible(data) = data {1701					// check sizes1702					ensure!(1703						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1704						Error::<T>::TokenConstDataLimitExceeded1705					);1706					ensure!(1707						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1708						Error::<T>::TokenVariableDataLimitExceeded1709					);17101711					// Check refungibility limits1712					ensure!(1713						data.pieces <= MAX_REFUNGIBLE_PIECES,1714						Error::<T>::WrongRefungiblePieces1715					);1716					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1717				} else {1718					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1719				}1720			}1721			_ => {1722				fail!(Error::<T>::UnexpectedCollectionType);1723			}1724		};17251726		Ok(())1727	}17281729	fn create_item_no_validation(1730		collection: &CollectionHandle<T>,1731		owner: &T::CrossAccountId,1732		data: CreateItemData,1733	) -> DispatchResult {1734		match data {1735			CreateItemData::NFT(data) => {1736				let item = NftItemType {1737					owner: owner.clone(),1738					const_data: data.const_data,1739					variable_data: data.variable_data,1740				};17411742				Self::add_nft_item(collection, item)?;1743			}1744			CreateItemData::Fungible(data) => {1745				Self::add_fungible_item(collection, owner, data.value)?;1746			}1747			CreateItemData::ReFungible(data) => {1748				let owner_list = vec![Ownership {1749					owner: owner.clone(),1750					fraction: data.pieces,1751				}];17521753				let item = ReFungibleItemType {1754					owner: owner_list,1755					const_data: data.const_data,1756					variable_data: data.variable_data,1757				};17581759				Self::add_refungible_item(collection, item)?;1760			}1761		};17621763		Ok(())1764	}17651766	fn add_fungible_item(1767		collection: &CollectionHandle<T>,1768		owner: &T::CrossAccountId,1769		value: u128,1770	) -> DispatchResult {1771		let collection_id = collection.id;17721773		// Does new owner already have an account?1774		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17751776		// Mint1777		let item = FungibleItemType {1778			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1779		};1780		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17811782		// Update balance1783		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1784			.checked_add(value)1785			.ok_or(Error::<T>::NumOverflow)?;1786		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17871788		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1789		Ok(())1790	}17911792	fn add_refungible_item(1793		collection: &CollectionHandle<T>,1794		item: ReFungibleItemType<T::CrossAccountId>,1795	) -> DispatchResult {1796		let collection_id = collection.id;17971798		let current_index = <ItemListIndex>::get(collection_id)1799			.checked_add(1)1800			.ok_or(Error::<T>::NumOverflow)?;1801		let itemcopy = item.clone();18021803		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1804		let item_owner = item.owner.first().expect("only one owner is defined");18051806		let value = item_owner.fraction;1807		let owner = item_owner.owner.clone();18081809		Self::add_token_index(collection_id, current_index, &owner)?;18101811		<ItemListIndex>::insert(collection_id, current_index);1812		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18131814		// Update balance1815		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1816			.checked_add(value)1817			.ok_or(Error::<T>::NumOverflow)?;1818		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18191820		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1821		Ok(())1822	}18231824	fn add_nft_item(1825		collection: &CollectionHandle<T>,1826		item: NftItemType<T::CrossAccountId>,1827	) -> DispatchResult {1828		let collection_id = collection.id;18291830		let current_index = <ItemListIndex>::get(collection_id)1831			.checked_add(1)1832			.ok_or(Error::<T>::NumOverflow)?;18331834		let item_owner = item.owner.clone();1835		Self::add_token_index(collection_id, current_index, &item.owner)?;18361837		<ItemListIndex>::insert(collection_id, current_index);1838		<NftItemList<T>>::insert(collection_id, current_index, item);18391840		// Update balance1841		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1842			.checked_add(1)1843			.ok_or(Error::<T>::NumOverflow)?;1844		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18451846		collection.log(ERC721Events::Transfer {1847			from: H160::default(),1848			to: *item_owner.as_eth(),1849			token_id: current_index.into(),1850		});1851		Self::deposit_event(RawEvent::ItemCreated(1852			collection_id,1853			current_index,1854			item_owner,1855		));1856		Ok(())1857	}18581859	fn burn_refungible_item(1860		collection: &CollectionHandle<T>,1861		item_id: TokenId,1862		owner: &T::CrossAccountId,1863	) -> DispatchResult {1864		let collection_id = collection.id;18651866		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1867			.ok_or(Error::<T>::TokenNotFound)?;1868		let rft_balance = token1869			.owner1870			.iter()1871			.find(|&i| i.owner == *owner)1872			.ok_or(Error::<T>::TokenNotFound)?;1873		Self::remove_token_index(collection_id, item_id, owner)?;18741875		// update balance1876		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1877			.checked_sub(rft_balance.fraction)1878			.ok_or(Error::<T>::NumOverflow)?;1879		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18801881		// Re-create owners list with sender removed1882		let index = token1883			.owner1884			.iter()1885			.position(|i| i.owner == *owner)1886			.expect("owned item is exists");1887		token.owner.remove(index);1888		let owner_count = token.owner.len();18891890		// Burn the token completely if this was the last (only) owner1891		if owner_count == 0 {1892			<ReFungibleItemList<T>>::remove(collection_id, item_id);1893			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1894		} else {1895			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1896		}18971898		Ok(())1899	}19001901	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1902		let collection_id = collection.id;19031904		let item =1905			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1906		Self::remove_token_index(collection_id, item_id, &item.owner)?;19071908		// update balance1909		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1910			.checked_sub(1)1911			.ok_or(Error::<T>::NumOverflow)?;1912		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1913		<NftItemList<T>>::remove(collection_id, item_id);1914		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);19151916		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1917		Ok(())1918	}19191920	fn burn_fungible_item(1921		owner: &T::CrossAccountId,1922		collection: &CollectionHandle<T>,1923		value: u128,1924	) -> DispatchResult {1925		let collection_id = collection.id;19261927		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1928		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19291930		// update balance1931		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1932			.checked_sub(value)1933			.ok_or(Error::<T>::NumOverflow)?;1934		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19351936		if balance.value - value > 0 {1937			balance.value -= value;1938			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1939		} else {1940			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1941		}19421943		collection.log(ERC20Events::Transfer {1944			from: *owner.as_eth(),1945			to: H160::default(),1946			value: value.into(),1947		});1948		Ok(())1949	}19501951	pub fn get_collection(1952		collection_id: CollectionId,1953	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1954		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1955	}19561957	fn save_collection(collection: CollectionHandle<T>) {1958		<CollectionById<T>>::insert(collection.id, collection.into_inner());1959	}19601961	pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {1962		if collection.logs.is_empty() {1963			return Ok(());1964		}1965		T::EthereumTransactionSender::submit_logs_transaction(1966			eth::generate_transaction(collection.id, T::EthereumChainId::get()),1967			collection.logs.retrieve_logs(),1968		)1969	}19701971	fn check_owner_permissions(1972		target_collection: &CollectionHandle<T>,1973		subject: &T::AccountId,1974	) -> DispatchResult {1975		ensure!(1976			*subject == target_collection.owner,1977			Error::<T>::NoPermission1978		);19791980		Ok(())1981	}19821983	fn is_owner_or_admin_permissions(1984		collection: &CollectionHandle<T>,1985		subject: &T::CrossAccountId,1986	) -> bool {1987		*subject.as_sub() == collection.owner1988			|| <AdminList<T>>::get(collection.id).contains(subject)1989	}19901991	fn check_owner_or_admin_permissions(1992		collection: &CollectionHandle<T>,1993		subject: &T::CrossAccountId,1994	) -> DispatchResult {1995		ensure!(1996			Self::is_owner_or_admin_permissions(collection, subject),1997			Error::<T>::NoPermission1998		);19992000		Ok(())2001	}20022003	fn owned_amount(2004		subject: &T::CrossAccountId,2005		target_collection: &CollectionHandle<T>,2006		item_id: TokenId,2007	) -> Option<u128> {2008		let collection_id = target_collection.id;20092010		match target_collection.mode {2011			CollectionMode::NFT => {2012				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2013			}2014			CollectionMode::Fungible(_) => {2015				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2016			}2017			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2018				.owner2019				.iter()2020				.find(|i| i.owner == *subject)2021				.map(|i| i.fraction),2022			CollectionMode::Invalid => None,2023		}2024	}20252026	fn is_item_owner(2027		subject: &T::CrossAccountId,2028		target_collection: &CollectionHandle<T>,2029		item_id: TokenId,2030	) -> bool {2031		match target_collection.mode {2032			CollectionMode::Fungible(_) => true,2033			_ => Self::owned_amount(subject, target_collection, item_id).is_some(),2034		}2035	}20362037	fn check_white_list(2038		collection: &CollectionHandle<T>,2039		address: &T::CrossAccountId,2040	) -> DispatchResult {2041		let collection_id = collection.id;20422043		let mes = Error::<T>::AddresNotInWhiteList;2044		ensure!(2045			<WhiteList<T>>::contains_key(collection_id, address.as_sub()),2046			mes2047		);20482049		Ok(())2050	}20512052	/// Check if token exists. In case of Fungible, check if there is an entry for2053	/// the owner in fungible balances double map2054	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2055		let collection_id = target_collection.id;2056		let exists = match target_collection.mode {2057			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2058			CollectionMode::Fungible(_) => true,2059			CollectionMode::ReFungible => {2060				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2061			}2062			_ => false,2063		};20642065		ensure!(exists, Error::<T>::TokenNotFound);2066		Ok(())2067	}20682069	fn transfer_fungible(2070		collection: &CollectionHandle<T>,2071		value: u128,2072		owner: &T::CrossAccountId,2073		recipient: &T::CrossAccountId,2074	) -> DispatchResult {2075		let collection_id = collection.id;20762077		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2078		ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20792080		// Send balance to recipient (updates balanceOf of recipient)2081		Self::add_fungible_item(collection, recipient, value)?;20822083		// update balanceOf of sender2084		<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);20852086		// Reduce or remove sender2087		if balance.value == value {2088			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2089		} else {2090			balance.value -= value;2091			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2092		}20932094		collection.log(ERC20Events::Transfer {2095			from: *owner.as_eth(),2096			to: *recipient.as_eth(),2097			value: value.into(),2098		});2099		Self::deposit_event(RawEvent::Transfer(2100			collection.id,2101			1,2102			owner.clone(),2103			recipient.clone(),2104			value,2105		));21062107		Ok(())2108	}21092110	fn transfer_refungible(2111		collection: &CollectionHandle<T>,2112		item_id: TokenId,2113		value: u128,2114		owner: T::CrossAccountId,2115		new_owner: T::CrossAccountId,2116	) -> DispatchResult {2117		let collection_id = collection.id;2118		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2119			.ok_or(Error::<T>::TokenNotFound)?;21202121		let item = full_item2122			.owner2123			.iter()2124			.find(|i| i.owner == owner)2125			.ok_or(Error::<T>::TokenNotFound)?;2126		let amount = item.fraction;21272128		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21292130		// update balance2131		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2132			.checked_sub(value)2133			.ok_or(Error::<T>::NumOverflow)?;2134		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21352136		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2137			.checked_add(value)2138			.ok_or(Error::<T>::NumOverflow)?;2139		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21402141		let old_owner = item.owner.clone();2142		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21432144		let mut new_full_item = full_item.clone();2145		// transfer2146		if amount == value && !new_owner_has_account {2147			// change owner2148			// new owner do not have account2149			new_full_item2150				.owner2151				.iter_mut()2152				.find(|i| i.owner == owner)2153				.expect("old owner does present in refungible")2154				.owner = new_owner.clone();2155			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21562157			// update index collection2158			Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2159		} else {2160			new_full_item2161				.owner2162				.iter_mut()2163				.find(|i| i.owner == owner)2164				.expect("old owner does present in refungible")2165				.fraction -= value;21662167			// separate amount2168			if new_owner_has_account {2169				// new owner has account2170				new_full_item2171					.owner2172					.iter_mut()2173					.find(|i| i.owner == new_owner)2174					.expect("new owner has account")2175					.fraction += value;2176			} else {2177				// new owner do not have account2178				new_full_item.owner.push(Ownership {2179					owner: new_owner.clone(),2180					fraction: value,2181				});2182				Self::add_token_index(collection_id, item_id, &new_owner)?;2183			}21842185			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2186		}21872188		Self::deposit_event(RawEvent::Transfer(2189			collection.id,2190			item_id,2191			owner,2192			new_owner,2193			amount,2194		));21952196		Ok(())2197	}21982199	fn transfer_nft(2200		collection: &CollectionHandle<T>,2201		item_id: TokenId,2202		sender: T::CrossAccountId,2203		new_owner: T::CrossAccountId,2204	) -> DispatchResult {2205		let collection_id = collection.id;2206		let mut item =2207			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22082209		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22102211		// update balance2212		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2213			.checked_sub(1)2214			.ok_or(Error::<T>::NumOverflow)?;2215		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22162217		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2218			.checked_add(1)2219			.ok_or(Error::<T>::NumOverflow)?;2220		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22212222		// change owner2223		let old_owner = item.owner.clone();2224		item.owner = new_owner.clone();2225		<NftItemList<T>>::insert(collection_id, item_id, item);22262227		// update index collection2228		Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22292230		collection.log(ERC721Events::Transfer {2231			from: *sender.as_eth(),2232			to: *new_owner.as_eth(),2233			token_id: item_id.into(),2234		});2235		Self::deposit_event(RawEvent::Transfer(2236			collection.id,2237			item_id,2238			sender,2239			new_owner,2240			1,2241		));22422243		Ok(())2244	}22452246	fn set_re_fungible_variable_data(2247		collection: &CollectionHandle<T>,2248		item_id: TokenId,2249		data: Vec<u8>,2250	) -> DispatchResult {2251		let collection_id = collection.id;2252		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2253			.ok_or(Error::<T>::TokenNotFound)?;22542255		item.variable_data = data;22562257		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22582259		Ok(())2260	}22612262	fn set_nft_variable_data(2263		collection: &CollectionHandle<T>,2264		item_id: TokenId,2265		data: Vec<u8>,2266	) -> DispatchResult {2267		let collection_id = collection.id;2268		let mut item =2269			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22702271		item.variable_data = data;22722273		<NftItemList<T>>::insert(collection_id, item_id, item);22742275		Ok(())2276	}22772278	#[allow(dead_code)]2279	fn init_collection(item: &Collection<T>) {2280		// check params2281		assert!(2282			item.decimal_points <= MAX_DECIMAL_POINTS,2283			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2284		);2285		assert!(2286			item.name.len() <= 64,2287			"Collection name can not be longer than 63 char"2288		);2289		assert!(2290			item.name.len() <= 256,2291			"Collection description can not be longer than 255 char"2292		);2293		assert!(2294			item.token_prefix.len() <= 16,2295			"Token prefix can not be longer than 15 char"2296		);22972298		// Generate next collection ID2299		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23002301		CreatedCollectionCount::put(next_id);2302	}23032304	#[allow(dead_code)]2305	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2306		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23072308		Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23092310		<ItemListIndex>::insert(collection_id, current_index);23112312		// Update balance2313		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2314			.checked_add(1)2315			.unwrap();2316		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2317	}23182319	#[allow(dead_code)]2320	fn init_fungible_token(2321		collection_id: CollectionId,2322		owner: &T::CrossAccountId,2323		item: &FungibleItemType,2324	) {2325		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23262327		Self::add_token_index(collection_id, current_index, owner).unwrap();23282329		<ItemListIndex>::insert(collection_id, current_index);23302331		// Update balance2332		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2333			.checked_add(item.value)2334			.unwrap();2335		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2336	}23372338	#[allow(dead_code)]2339	fn init_refungible_token(2340		collection_id: CollectionId,2341		item: &ReFungibleItemType<T::CrossAccountId>,2342	) {2343		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23442345		let value = item.owner.first().unwrap().fraction;2346		let owner = item.owner.first().unwrap().owner.clone();23472348		Self::add_token_index(collection_id, current_index, &owner).unwrap();23492350		<ItemListIndex>::insert(collection_id, current_index);23512352		// Update balance2353		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2354			.checked_add(value)2355			.unwrap();2356		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2357	}23582359	fn add_token_index(2360		collection_id: CollectionId,2361		item_index: TokenId,2362		owner: &T::CrossAccountId,2363	) -> DispatchResult {2364		// add to account limit2365		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2366			// bound Owned tokens by a single address2367			let count = <AccountItemCount<T>>::get(owner.as_sub());2368			ensure!(2369				count < ChainLimit::get().account_token_ownership_limit,2370				Error::<T>::AddressOwnershipLimitExceeded2371			);23722373			<AccountItemCount<T>>::insert(2374				owner.as_sub(),2375				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2376			);2377		} else {2378			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2379		}23802381		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2382		if list_exists {2383			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2384			let item_contains = list.contains(&item_index.clone());23852386			if !item_contains {2387				list.push(item_index);2388			}23892390			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2391		} else {2392			let itm = vec![item_index];2393			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2394		}23952396		Ok(())2397	}23982399	fn remove_token_index(2400		collection_id: CollectionId,2401		item_index: TokenId,2402		owner: &T::CrossAccountId,2403	) -> DispatchResult {2404		// update counter2405		<AccountItemCount<T>>::insert(2406			owner.as_sub(),2407			<AccountItemCount<T>>::get(owner.as_sub())2408				.checked_sub(1)2409				.ok_or(Error::<T>::NumOverflow)?,2410		);24112412		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2413		if list_exists {2414			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2415			let item_contains = list.contains(&item_index.clone());24162417			if item_contains {2418				list.retain(|&item| item != item_index);2419				<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2420			}2421		}24222423		Ok(())2424	}24252426	fn move_token_index(2427		collection_id: CollectionId,2428		item_index: TokenId,2429		old_owner: &T::CrossAccountId,2430		new_owner: &T::CrossAccountId,2431	) -> DispatchResult {2432		Self::remove_token_index(collection_id, item_index, old_owner)?;2433		Self::add_token_index(collection_id, item_index, new_owner)?;24342435		Ok(())2436	}2437}24382439sp_api::decl_runtime_apis! {2440	pub trait NftApi {2441		/// Used for ethereum integration2442		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2443	}2444}