git.delta.rocks / unique-network / refs/commits / 931d0a96210f

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,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		/// Collection settings not allowing items transferring179		TransferNotAllowed,180	}181}182183pub struct CollectionHandle<T: Config> {184	pub id: CollectionId,185	collection: Collection<T>,186	logs: eth::log::LogRecorder,187	evm_address: H160,188	gas_limit: RefCell<u64>,189}190impl<T: Config> CollectionHandle<T> {191	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {192		<CollectionById<T>>::get(id).map(|collection| Self {193			id,194			collection,195			logs: eth::log::LogRecorder::default(),196			evm_address: eth::collection_id_to_address(id),197			gas_limit: RefCell::new(gas_limit),198		})199	}200	pub fn get(id: CollectionId) -> Option<Self> {201		Self::get_with_gas_limit(id, u64::MAX)202	}203	pub fn gas_left(&self) -> u64 {204		*self.gas_limit.borrow()205	}206	pub fn consume_gas(&self, gas: u64) -> DispatchResult {207		let mut gas_limit = self.gas_limit.borrow_mut();208		if *gas_limit < gas {209			fail!(Error::<T>::OutOfGas);210		}211		*gas_limit -= gas;212		Ok(())213	}214	pub fn log(&self, log: impl evm_coder::ToLog) {215		self.logs.log(log.to_log(self.evm_address))216	}217	pub fn into_inner(self) -> Collection<T> {218		self.collection219	}220}221impl<T: Config> Deref for CollectionHandle<T> {222	type Target = Collection<T>;223224	fn deref(&self) -> &Self::Target {225		&self.collection226	}227}228229impl<T: Config> DerefMut for CollectionHandle<T> {230	fn deref_mut(&mut self) -> &mut Self::Target {231		&mut self.collection232	}233}234235pub trait Config: system::Config + Sized {236	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;237238	/// Weight information for extrinsics in this pallet.239	type WeightInfo: WeightInfo;240241	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;242	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;243244	type CrossAccountId: CrossAccountId<Self::AccountId>;245	type Currency: Currency<Self::AccountId>;246	type CollectionCreationPrice: Get<247		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,248	>;249	type TreasuryAccountId: Get<Self::AccountId>;250251	type EthereumChainId: Get<u64>;252	type EthereumTransactionSender: pallet_ethereum::EthereumTransactionSender;253}254255// # Used definitions256//257// ## User control levels258//259// chain-controlled - key is uncontrolled by user260//                    i.e autoincrementing index261//                    can use non-cryptographic hash262// real - key is controlled by user263//        but it is hard to generate enough colliding values, i.e owner of signed txs264//        can use non-cryptographic hash265// controlled - key is completly controlled by users266//              i.e maps with mutable keys267//              should use cryptographic hash268//269// ## User control level downgrade reasons270//271// ?1 - chain-controlled -> controlled272//      collections/tokens can be destroyed, resulting in massive holes273// ?2 - chain-controlled -> controlled274//      same as ?1, but can be only added, resulting in easier exploitation275// ?3 - real -> controlled276//      no confirmation required, so addresses can be easily generated277decl_storage! {278	trait Store for Module<T: Config> as Nft {279280		//#region Private members281		/// Id of next collection282		CreatedCollectionCount: u32;283		/// Used for migrations284		ChainVersion: u64;285		/// Id of last collection token286		/// Collection id (controlled?1)287		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;288		//#endregion289290		//#region Chain limits struct291		pub ChainLimit get(fn chain_limit) config(): ChainLimits;292		//#endregion293294		//#region Bound counters295		/// Amount of collections destroyed, used for total amount tracking with296		/// CreatedCollectionCount297		DestroyedCollectionCount: u32;298		/// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)299		/// Account id (real)300		pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;301		//#endregion302303		//#region Basic collections304		/// Collection info305		/// Collection id (controlled?1)306		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;307		/// List of collection admins308		/// Collection id (controlled?2)309		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;310		/// Whitelisted collection users311		/// Collection id (controlled?2), user id (controlled?3)312		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;313		//#endregion314315		/// How many of collection items user have316		/// Collection id (controlled?2), account id (real)317		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;318319		/// Amount of items which spender can transfer out of owners account (via transferFrom)320		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))321		/// TODO: Off chain worker should remove from this map when token gets removed322		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;323324		//#region Item collections325		/// Collection id (controlled?2), token id (controlled?1)326		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;327		/// Collection id (controlled?2), owner (controlled?2)328		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;329		/// Collection id (controlled?2), token id (controlled?1)330		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;331		//#endregion332333		//#region Index list334		/// Collection id (controlled?2), tokens owner (controlled?2)335		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;336		//#endregion337338		//#region Tokens transfer rate limit baskets339		/// (Collection id (controlled?2), who created (real))340		/// TODO: Off chain worker should remove from this map when collection gets removed341		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;342		/// Collection id (controlled?2), token id (controlled?2)343		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;344		/// Collection id (controlled?2), owning user (real)345		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;346		/// Collection id (controlled?2), token id (controlled?2)347		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;348		//#endregion349350		/// Variable metadata sponsoring351		/// Collection id (controlled?2), token id (controlled?2)352		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;353	}354	add_extra_genesis {355		build(|config: &GenesisConfig<T>| {356			// Modification of storage357			for (_num, _c) in &config.collection_id {358				<Module<T>>::init_collection(_c);359			}360361			for (_num, _c, _i) in &config.nft_item_id {362				<Module<T>>::init_nft_token(*_c, _i);363			}364365			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {366				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);367			}368369			for (_num, _c, _i) in &config.refungible_item_id {370				<Module<T>>::init_refungible_token(*_c, _i);371			}372		})373	}374}375376decl_event!(377	pub enum Event<T>378	where379		AccountId = <T as frame_system::Config>::AccountId,380		CrossAccountId = <T as Config>::CrossAccountId,381	{382		/// New collection was created383		///384		/// # Arguments385		///386		/// * collection_id: Globally unique identifier of newly created collection.387		///388		/// * mode: [CollectionMode] converted into u8.389		///390		/// * account_id: Collection owner.391		CollectionCreated(CollectionId, u8, AccountId),392393		/// New item was created.394		///395		/// # Arguments396		///397		/// * collection_id: Id of the collection where item was created.398		///399		/// * item_id: Id of an item. Unique within the collection.400		///401		/// * recipient: Owner of newly created item402		ItemCreated(CollectionId, TokenId, CrossAccountId),403404		/// Collection item was burned.405		///406		/// # Arguments407		///408		/// collection_id.409		///410		/// item_id: Identifier of burned NFT.411		ItemDestroyed(CollectionId, TokenId),412413		/// Item was transferred414		///415		/// * collection_id: Id of collection to which item is belong416		///417		/// * item_id: Id of an item418		///419		/// * sender: Original owner of item420		///421		/// * recipient: New owner of item422		///423		/// * amount: Always 1 for NFT424		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),425426		/// * collection_id427		///428		/// * item_id429		///430		/// * sender431		///432		/// * spender433		///434		/// * amount435		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),436	}437);438439decl_module! {440	pub struct Module<T: Config> for enum Call441	where442		origin: T::Origin443	{444		fn deposit_event() = default;445		type Error = Error<T>;446447		fn on_initialize(_now: T::BlockNumber) -> Weight {448			0449		}450451		/// 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.452		///453		/// # Permissions454		///455		/// * Anyone.456		///457		/// # Arguments458		///459		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.460		///461		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.462		///463		/// * token_prefix: UTF-8 string with token prefix.464		///465		/// * mode: [CollectionMode] collection type and type dependent data.466		// returns collection ID467		#[weight = <T as Config>::WeightInfo::create_collection()]468		#[transactional]469		pub fn create_collection(origin,470								 collection_name: Vec<u16>,471								 collection_description: Vec<u16>,472								 token_prefix: Vec<u8>,473								 mode: CollectionMode) -> DispatchResult {474475			// Anyone can create a collection476			let who = ensure_signed(origin)?;477478			// Take a (non-refundable) deposit of collection creation479			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();480			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(481				&T::TreasuryAccountId::get(),482				T::CollectionCreationPrice::get(),483			));484			<T as Config>::Currency::settle(485				&who,486				imbalance,487				WithdrawReasons::TRANSFER,488				ExistenceRequirement::KeepAlive,489			).map_err(|_| Error::<T>::NoPermission)?;490491			let decimal_points = match mode {492				CollectionMode::Fungible(points) => points,493				_ => 0494			};495496			let chain_limit = ChainLimit::get();497498			let created_count = CreatedCollectionCount::get();499			let destroyed_count = DestroyedCollectionCount::get();500501			// bound Total number of collections502			ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);503504			// check params505			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);506			ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);507			ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);508			ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);509510			// Generate next collection ID511			let next_id = created_count512				.checked_add(1)513				.ok_or(Error::<T>::NumOverflow)?;514515			CreatedCollectionCount::put(next_id);516517			let limits = CollectionLimits {518				sponsored_data_size: chain_limit.custom_data_limit,519				..Default::default()520			};521522			// Create new collection523			let new_collection = Collection {524				owner: who.clone(),525				name: collection_name,526				mode: mode.clone(),527				mint_mode: false,528				access: AccessMode::Normal,529				description: collection_description,530				decimal_points,531				token_prefix,532				offchain_schema: Vec::new(),533				schema_version: SchemaVersion::ImageURL,534				sponsorship: SponsorshipState::Disabled,535				variable_on_chain_schema: Vec::new(),536				const_on_chain_schema: Vec::new(),537				limits,538				transfers_enabled: true,539			};540541			// Add new collection to map542			<CollectionById<T>>::insert(next_id, new_collection);543544			// call event545			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));546547			Ok(())548		}549550		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.551		///552		/// # Permissions553		///554		/// * Collection Owner.555		///556		/// # Arguments557		///558		/// * collection_id: collection to destroy.559		#[weight = <T as Config>::WeightInfo::destroy_collection()]560		#[transactional]561		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {562563			let sender = ensure_signed(origin)?;564			let collection = Self::get_collection(collection_id)?;565			Self::check_owner_permissions(&collection, &sender)?;566			if !collection.limits.owner_can_destroy {567				fail!(Error::<T>::NoPermission);568			}569570			<AddressTokens<T>>::remove_prefix(collection_id);571			<Allowances<T>>::remove_prefix(collection_id);572			<Balance<T>>::remove_prefix(collection_id);573			<ItemListIndex>::remove(collection_id);574			<AdminList<T>>::remove(collection_id);575			<CollectionById<T>>::remove(collection_id);576			<WhiteList<T>>::remove_prefix(collection_id);577578			<NftItemList<T>>::remove_prefix(collection_id);579			<FungibleItemList<T>>::remove_prefix(collection_id);580			<ReFungibleItemList<T>>::remove_prefix(collection_id);581582			<NftTransferBasket<T>>::remove_prefix(collection_id);583			<FungibleTransferBasket<T>>::remove_prefix(collection_id);584			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id);585586			<VariableMetaDataBasket<T>>::remove_prefix(collection_id);587588			DestroyedCollectionCount::put(DestroyedCollectionCount::get()589				.checked_add(1)590				.ok_or(Error::<T>::NumOverflow)?);591592			Ok(())593		}594595		/// Add an address to white list.596		///597		/// # Permissions598		///599		/// * Collection Owner600		/// * Collection Admin601		///602		/// # Arguments603		///604		/// * collection_id.605		///606		/// * address.607		#[weight = <T as Config>::WeightInfo::add_to_white_list()]608		#[transactional]609		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{610611			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);612			let collection = Self::get_collection(collection_id)?;613614			Self::toggle_white_list_internal(615				&sender,616				&collection,617				&address,618				true,619			)?;620621			Ok(())622		}623624		/// Remove an address from white list.625		///626		/// # Permissions627		///628		/// * Collection Owner629		/// * Collection Admin630		///631		/// # Arguments632		///633		/// * collection_id.634		///635		/// * address.636		#[weight = <T as Config>::WeightInfo::remove_from_white_list()]637		#[transactional]638		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{639640			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);641			let collection = Self::get_collection(collection_id)?;642643			Self::toggle_white_list_internal(644				&sender,645				&collection,646				&address,647				false,648			)?;649650			Ok(())651		}652653		/// Toggle between normal and white list access for the methods with access for `Anyone`.654		///655		/// # Permissions656		///657		/// * Collection Owner.658		///659		/// # Arguments660		///661		/// * collection_id.662		///663		/// * mode: [AccessMode]664		#[weight = <T as Config>::WeightInfo::set_public_access_mode()]665		#[transactional]666		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult667		{668			let sender = ensure_signed(origin)?;669670			let mut target_collection = Self::get_collection(collection_id)?;671			Self::check_owner_permissions(&target_collection, &sender)?;672			target_collection.access = mode;673			Self::save_collection(target_collection);674675			Ok(())676		}677678		/// Allows Anyone to create tokens if:679		/// * White List is enabled, and680		/// * Address is added to white list, and681		/// * This method was called with True parameter682		///683		/// # Permissions684		/// * Collection Owner685		///686		/// # Arguments687		///688		/// * collection_id.689		///690		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.691		#[weight = <T as Config>::WeightInfo::set_mint_permission()]692		#[transactional]693		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult694		{695			let sender = ensure_signed(origin)?;696697			let mut target_collection = Self::get_collection(collection_id)?;698			Self::check_owner_permissions(&target_collection, &sender)?;699			target_collection.mint_mode = mint_permission;700			Self::save_collection(target_collection);701702			Ok(())703		}704705		/// Change the owner of the collection.706		///707		/// # Permissions708		///709		/// * Collection Owner.710		///711		/// # Arguments712		///713		/// * collection_id.714		///715		/// * new_owner.716		#[weight = <T as Config>::WeightInfo::change_collection_owner()]717		#[transactional]718		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {719720			let sender = ensure_signed(origin)?;721			let mut target_collection = Self::get_collection(collection_id)?;722			Self::check_owner_permissions(&target_collection, &sender)?;723			target_collection.owner = new_owner;724			Self::save_collection(target_collection);725726			Ok(())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 = <T as Config>::WeightInfo::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					let limits = ChainLimit::get();754					ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);755					admin_arr.insert(idx, new_admin_id);756					<AdminList<T>>::insert(collection_id, admin_arr);757				}758			}759			Ok(())760		}761762		/// 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.763		///764		/// # Permissions765		///766		/// * Collection Owner.767		/// * Collection Admin.768		///769		/// # Arguments770		///771		/// * collection_id: ID of the Collection to remove admin for.772		///773		/// * account_id: Address of admin to remove.774		#[weight = <T as Config>::WeightInfo::remove_collection_admin()]775		#[transactional]776		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {777			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);778			let collection = Self::get_collection(collection_id)?;779			Self::check_owner_or_admin_permissions(&collection, &sender)?;780			let mut admin_arr = <AdminList<T>>::get(collection_id);781782			if let Ok(idx) = admin_arr.binary_search(&account_id) {783				admin_arr.remove(idx);784				<AdminList<T>>::insert(collection_id, admin_arr);785			}786			Ok(())787		}788789		/// # Permissions790		///791		/// * Collection Owner792		///793		/// # Arguments794		///795		/// * collection_id.796		///797		/// * new_sponsor.798		#[weight = <T as Config>::WeightInfo::set_collection_sponsor()]799		#[transactional]800		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {801			let sender = ensure_signed(origin)?;802			let mut target_collection = Self::get_collection(collection_id)?;803			Self::check_owner_permissions(&target_collection, &sender)?;804805			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);806			Self::save_collection(target_collection);807808			Ok(())809		}810811		/// # Permissions812		///813		/// * Sponsor.814		///815		/// # Arguments816		///817		/// * collection_id.818		#[weight = <T as Config>::WeightInfo::confirm_sponsorship()]819		#[transactional]820		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {821			let sender = ensure_signed(origin)?;822823			let mut target_collection = Self::get_collection(collection_id)?;824			ensure!(825				target_collection.sponsorship.pending_sponsor() == Some(&sender),826				Error::<T>::ConfirmUnsetSponsorFail827			);828829			target_collection.sponsorship = SponsorshipState::Confirmed(sender);830			Self::save_collection(target_collection);831832			Ok(())833		}834835		/// Switch back to pay-per-own-transaction model.836		///837		/// # Permissions838		///839		/// * Collection owner.840		///841		/// # Arguments842		///843		/// * collection_id.844		#[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]845		#[transactional]846		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {847			let sender = ensure_signed(origin)?;848849			let mut target_collection = Self::get_collection(collection_id)?;850			Self::check_owner_permissions(&target_collection, &sender)?;851852			target_collection.sponsorship = SponsorshipState::Disabled;853			Self::save_collection(target_collection);854855			Ok(())856		}857858		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.859		///860		/// # Permissions861		///862		/// * Collection Owner.863		/// * Collection Admin.864		/// * Anyone if865		///     * White List is enabled, and866		///     * Address is added to white list, and867		///     * MintPermission is enabled (see SetMintPermission method)868		///869		/// # Arguments870		///871		/// * collection_id: ID of the collection.872		///873		/// * owner: Address, initial owner of the NFT.874		///875		/// * data: Token data to store on chain.876		// #[weight =877		// (130_000_000 as Weight)878		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))879		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))880		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]881882		#[weight = <T as Config>::WeightInfo::create_item(data.data_size())]883		#[transactional]884		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {885			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);886			let collection = Self::get_collection(collection_id)?;887888			Self::create_item_internal(&sender, &collection, &owner, data)?;889890			// Self::submit_logs(collection)?;891			Ok(())892		}893894		/// This method creates multiple items in a collection created with CreateCollection method.895		///896		/// # Permissions897		///898		/// * Collection Owner.899		/// * Collection Admin.900		/// * Anyone if901		///     * White List is enabled, and902		///     * Address is added to white list, and903		///     * MintPermission is enabled (see SetMintPermission method)904		///905		/// # Arguments906		///907		/// * collection_id: ID of the collection.908		///909		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].910		///911		/// * owner: Address, initial owner of the NFT.912		#[weight = <T as Config>::WeightInfo::create_item(items_data.iter()913							   .map(|data| { data.data_size() })914							   .sum())]915		#[transactional]916		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {917918			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);919			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);920			let collection = Self::get_collection(collection_id)?;921922			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;923924			// Self::submit_logs(collection)?;925			Ok(())926		}927928		// TODO! transaction weight929930		/// Set transfers_enabled value for particular collection931		///932		/// # Permissions933		///934		/// * Collection Owner.935		///936		/// # Arguments937		///938		/// * collection_id: ID of the collection.939		///940		/// * value: New flag value.941		#[weight = <T as Config>::WeightInfo::burn_item()]942		#[transactional]943		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {944945			let sender = ensure_signed(origin)?;946			let mut target_collection = Self::get_collection(collection_id)?;947948			Self::check_owner_permissions(&target_collection, &sender)?;949950			target_collection.transfers_enabled = value;951			Self::save_collection(target_collection);952953			Ok(())954		}955956		/// Destroys a concrete instance of NFT.957		///958		/// # Permissions959		///960		/// * Collection Owner.961		/// * Collection Admin.962		/// * Current NFT Owner.963		///964		/// # Arguments965		///966		/// * collection_id: ID of the collection.967		///968		/// * item_id: ID of NFT to burn.969		#[weight = <T as Config>::WeightInfo::burn_item()]970		#[transactional]971		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {972973			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);974			let target_collection = Self::get_collection(collection_id)?;975976			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;977978			// Self::submit_logs(target_collection)?;979			Ok(())980		}981982		/// Change ownership of the token.983		///984		/// # Permissions985		///986		/// * Collection Owner987		/// * Collection Admin988		/// * Current NFT owner989		///990		/// # Arguments991		///992		/// * recipient: Address of token recipient.993		///994		/// * collection_id.995		///996		/// * item_id: ID of the item997		///     * Non-Fungible Mode: Required.998		///     * Fungible Mode: Ignored.999		///     * Re-Fungible Mode: Required.1000		///1001		/// * value: Amount to transfer.1002		///     * Non-Fungible Mode: Ignored1003		///     * Fungible Mode: Must specify transferred amount1004		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1005		#[weight = <T as Config>::WeightInfo::transfer()]1006		#[transactional]1007		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1008			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1009			let collection = Self::get_collection(collection_id)?;10101011			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10121013			// Self::submit_logs(collection)?;1014			Ok(())1015		}10161017		/// Set, change, or remove approved address to transfer the ownership of the NFT.1018		///1019		/// # Permissions1020		///1021		/// * Collection Owner1022		/// * Collection Admin1023		/// * Current NFT owner1024		///1025		/// # Arguments1026		///1027		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1028		///1029		/// * collection_id.1030		///1031		/// * item_id: ID of the item.1032		#[weight = <T as Config>::WeightInfo::approve()]1033		#[transactional]1034		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1035			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1036			let collection = Self::get_collection(collection_id)?;10371038			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10391040			// Self::submit_logs(collection)?;1041			Ok(())1042		}10431044		/// 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.1045		///1046		/// # Permissions1047		/// * Collection Owner1048		/// * Collection Admin1049		/// * Current NFT owner1050		/// * Address approved by current NFT owner1051		///1052		/// # Arguments1053		///1054		/// * from: Address that owns token.1055		///1056		/// * recipient: Address of token recipient.1057		///1058		/// * collection_id.1059		///1060		/// * item_id: ID of the item.1061		///1062		/// * value: Amount to transfer.1063		#[weight = <T as Config>::WeightInfo::transfer_from()]1064		#[transactional]1065		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1066			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1067			let collection = Self::get_collection(collection_id)?;10681069			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10701071			// Self::submit_logs(collection)?;1072			Ok(())1073		}1074		// #[weight = 0]1075		//     // let no_perm_mes = "You do not have permissions to modify this collection";1076		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1077		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1078		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10791080		//     // // on_nft_received  call10811082		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10831084		//     Ok(())1085		// }10861087		/// Set off-chain data schema.1088		///1089		/// # Permissions1090		///1091		/// * Collection Owner1092		/// * Collection Admin1093		///1094		/// # Arguments1095		///1096		/// * collection_id.1097		///1098		/// * schema: String representing the offchain data schema.1099		#[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1100		#[transactional]1101		pub fn set_variable_meta_data (1102			origin,1103			collection_id: CollectionId,1104			item_id: TokenId,1105			data: Vec<u8>1106		) -> DispatchResult {1107			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11081109			let collection = Self::get_collection(collection_id)?;11101111			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11121113			Ok(())1114		}11151116		/// Set schema standard1117		/// ImageURL1118		/// Unique1119		///1120		/// # Permissions1121		///1122		/// * Collection Owner1123		/// * Collection Admin1124		///1125		/// # Arguments1126		///1127		/// * collection_id.1128		///1129		/// * schema: SchemaVersion: enum1130		#[weight = <T as Config>::WeightInfo::set_schema_version()]1131		#[transactional]1132		pub fn set_schema_version(1133			origin,1134			collection_id: CollectionId,1135			version: SchemaVersion1136		) -> DispatchResult {1137			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1138			let mut target_collection = Self::get_collection(collection_id)?;1139			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1140			target_collection.schema_version = version;1141			Self::save_collection(target_collection);11421143			Ok(())1144		}11451146		/// Set off-chain data schema.1147		///1148		/// # Permissions1149		///1150		/// * Collection Owner1151		/// * Collection Admin1152		///1153		/// # Arguments1154		///1155		/// * collection_id.1156		///1157		/// * schema: String representing the offchain data schema.1158		#[weight = <T as Config>::WeightInfo::set_offchain_schema()]1159		#[transactional]1160		pub fn set_offchain_schema(1161			origin,1162			collection_id: CollectionId,1163			schema: Vec<u8>1164		) -> DispatchResult {1165			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1166			let mut target_collection = Self::get_collection(collection_id)?;1167			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11681169			// check schema limit1170			ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");11711172			target_collection.offchain_schema = schema;1173			Self::save_collection(target_collection);11741175			Ok(())1176		}11771178		/// Set const on-chain data schema.1179		///1180		/// # Permissions1181		///1182		/// * Collection Owner1183		/// * Collection Admin1184		///1185		/// # Arguments1186		///1187		/// * collection_id.1188		///1189		/// * schema: String representing the const on-chain data schema.1190		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1191		#[transactional]1192		pub fn set_const_on_chain_schema (1193			origin,1194			collection_id: CollectionId,1195			schema: Vec<u8>1196		) -> DispatchResult {1197			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1198			let mut target_collection = Self::get_collection(collection_id)?;1199			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12001201			// check schema limit1202			ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");12031204			target_collection.const_on_chain_schema = schema;1205			Self::save_collection(target_collection);12061207			Ok(())1208		}12091210		/// Set variable on-chain data schema.1211		///1212		/// # Permissions1213		///1214		/// * Collection Owner1215		/// * Collection Admin1216		///1217		/// # Arguments1218		///1219		/// * collection_id.1220		///1221		/// * schema: String representing the variable on-chain data schema.1222		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1223		#[transactional]1224		pub fn set_variable_on_chain_schema (1225			origin,1226			collection_id: CollectionId,1227			schema: Vec<u8>1228		) -> DispatchResult {1229			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1230			let mut target_collection = Self::get_collection(collection_id)?;1231			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12321233			// check schema limit1234			ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");12351236			target_collection.variable_on_chain_schema = schema;1237			Self::save_collection(target_collection);12381239			Ok(())1240		}12411242		// Sudo permissions function1243		#[weight = <T as Config>::WeightInfo::set_chain_limits()]1244		#[transactional]1245		pub fn set_chain_limits(1246			origin,1247			limits: ChainLimits1248		) -> DispatchResult {12491250			#[cfg(not(feature = "runtime-benchmarks"))]1251			ensure_root(origin)?;12521253			<ChainLimit>::put(limits);1254			Ok(())1255		}12561257		#[weight = <T as Config>::WeightInfo::set_collection_limits()]1258		#[transactional]1259		pub fn set_collection_limits(1260			origin,1261			collection_id: u32,1262			new_limits: CollectionLimits<T::BlockNumber>,1263		) -> DispatchResult {1264			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1265			let mut target_collection = Self::get_collection(collection_id)?;1266			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1267			let old_limits = &target_collection.limits;1268			let chain_limits = ChainLimit::get();12691270			// collection bounds1271			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1272				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1273				new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1274				Error::<T>::CollectionLimitBoundsExceeded);12751276			// token_limit   check  prev1277			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1278			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12791280			ensure!(1281				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1282				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1283				Error::<T>::OwnerPermissionsCantBeReverted,1284			);12851286			target_collection.limits = new_limits;1287			Self::save_collection(target_collection);12881289			Ok(())1290		}1291	}1292}12931294impl<T: Config> Module<T> {1295	pub fn create_item_internal(1296		sender: &T::CrossAccountId,1297		collection: &CollectionHandle<T>,1298		owner: &T::CrossAccountId,1299		data: CreateItemData,1300	) -> DispatchResult {1301		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1302		Self::validate_create_item_args(collection, &data)?;1303		Self::create_item_no_validation(collection, owner, data)?;13041305		Ok(())1306	}13071308	pub fn transfer_internal(1309		sender: &T::CrossAccountId,1310		recipient: &T::CrossAccountId,1311		target_collection: &CollectionHandle<T>,1312		item_id: TokenId,1313		value: u128,1314	) -> DispatchResult {1315		target_collection.consume_gas(2000000)?;1316		// Limits check1317		Self::is_correct_transfer(target_collection, recipient)?;13181319		// Transfer permissions check1320		ensure!(1321			Self::is_item_owner(sender, target_collection, item_id)1322				|| Self::is_owner_or_admin_permissions(target_collection, sender),1323			Error::<T>::NoPermission1324		);13251326		if target_collection.access == AccessMode::WhiteList {1327			Self::check_white_list(target_collection, sender)?;1328			Self::check_white_list(target_collection, recipient)?;1329		}13301331		match target_collection.mode {1332			CollectionMode::NFT => Self::transfer_nft(1333				target_collection,1334				item_id,1335				sender.clone(),1336				recipient.clone(),1337			)?,1338			CollectionMode::Fungible(_) => {1339				Self::transfer_fungible(target_collection, value, sender, recipient)?1340			}1341			CollectionMode::ReFungible => Self::transfer_refungible(1342				target_collection,1343				item_id,1344				value,1345				sender.clone(),1346				recipient.clone(),1347			)?,1348			_ => (),1349		};13501351		Self::deposit_event(RawEvent::Transfer(1352			target_collection.id,1353			item_id,1354			sender.clone(),1355			recipient.clone(),1356			value,1357		));13581359		Ok(())1360	}13611362	pub fn approve_internal(1363		sender: &T::CrossAccountId,1364		spender: &T::CrossAccountId,1365		collection: &CollectionHandle<T>,1366		item_id: TokenId,1367		amount: u128,1368	) -> DispatchResult {1369		collection.consume_gas(2000000)?;1370		Self::token_exists(collection, item_id)?;13711372		// Transfer permissions check1373		let bypasses_limits = collection.limits.owner_can_transfer1374			&& Self::is_owner_or_admin_permissions(collection, sender);13751376		let allowance_limit = if bypasses_limits {1377			None1378		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id) {1379			Some(amount)1380		} else {1381			fail!(Error::<T>::NoPermission);1382		};13831384		if collection.access == AccessMode::WhiteList {1385			Self::check_white_list(collection, sender)?;1386			Self::check_white_list(collection, spender)?;1387		}13881389		let allowance: u128 = amount1390			.checked_add(<Allowances<T>>::get(1391				collection.id,1392				(item_id, sender.as_sub(), spender.as_sub()),1393			))1394			.ok_or(Error::<T>::NumOverflow)?;1395		if let Some(limit) = allowance_limit {1396			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1397		}1398		<Allowances<T>>::insert(1399			collection.id,1400			(item_id, sender.as_sub(), spender.as_sub()),1401			allowance,1402		);14031404		if matches!(collection.mode, CollectionMode::NFT) {1405			// TODO: NFT: only one owner may exist for token in ERC7211406			collection.log(ERC721Events::Approval {1407				owner: *sender.as_eth(),1408				approved: *spender.as_eth(),1409				token_id: item_id.into(),1410			});1411		}14121413		if matches!(collection.mode, CollectionMode::Fungible(_)) {1414			// TODO: NFT: only one owner may exist for token in ERC201415			collection.log(ERC20Events::Approval {1416				owner: *sender.as_eth(),1417				spender: *spender.as_eth(),1418				value: allowance.into(),1419			});1420		}14211422		Self::deposit_event(RawEvent::Approved(1423			collection.id,1424			item_id,1425			sender.clone(),1426			spender.clone(),1427			allowance,1428		));1429		Ok(())1430	}14311432	pub fn transfer_from_internal(1433		sender: &T::CrossAccountId,1434		from: &T::CrossAccountId,1435		recipient: &T::CrossAccountId,1436		collection: &CollectionHandle<T>,1437		item_id: TokenId,1438		amount: u128,1439	) -> DispatchResult {1440		collection.consume_gas(2000000)?;1441		// Check approval1442		let approval: u128 =1443			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14441445		// Limits check1446		Self::is_correct_transfer(collection, recipient)?;14471448		// Transfer permissions check1449		ensure!(1450			approval >= amount1451				|| (collection.limits.owner_can_transfer1452					&& Self::is_owner_or_admin_permissions(collection, sender)),1453			Error::<T>::NoPermission1454		);14551456		if collection.access == AccessMode::WhiteList {1457			Self::check_white_list(collection, sender)?;1458			Self::check_white_list(collection, recipient)?;1459		}14601461		// Reduce approval by transferred amount or remove if remaining approval drops to 01462		let allowance = approval.saturating_sub(amount);1463		if allowance > 0 {1464			<Allowances<T>>::insert(1465				collection.id,1466				(item_id, from.as_sub(), sender.as_sub()),1467				allowance,1468			);1469		} else {1470			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1471		}14721473		match collection.mode {1474			CollectionMode::NFT => {1475				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1476			}1477			CollectionMode::Fungible(_) => {1478				Self::transfer_fungible(collection, amount, from, recipient)?1479			}1480			CollectionMode::ReFungible => Self::transfer_refungible(1481				collection,1482				item_id,1483				amount,1484				from.clone(),1485				recipient.clone(),1486			)?,1487			_ => (),1488		};14891490		if matches!(collection.mode, CollectionMode::Fungible(_)) {1491			collection.log(ERC20Events::Approval {1492				owner: *from.as_eth(),1493				spender: *sender.as_eth(),1494				value: allowance.into(),1495			});1496		}14971498		Ok(())1499	}15001501	pub fn set_variable_meta_data_internal(1502		sender: &T::CrossAccountId,1503		collection: &CollectionHandle<T>,1504		item_id: TokenId,1505		data: Vec<u8>,1506	) -> DispatchResult {1507		Self::token_exists(collection, item_id)?;15081509		ensure!(1510			ChainLimit::get().custom_data_limit >= data.len() as u32,1511			Error::<T>::TokenVariableDataLimitExceeded1512		);15131514		// Modify permissions check1515		ensure!(1516			Self::is_item_owner(sender, collection, item_id)1517				|| Self::is_owner_or_admin_permissions(collection, sender),1518			Error::<T>::NoPermission1519		);15201521		match collection.mode {1522			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1523			CollectionMode::ReFungible => {1524				Self::set_re_fungible_variable_data(collection, item_id, data)?1525			}1526			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1527			_ => fail!(Error::<T>::UnexpectedCollectionType),1528		};15291530		Ok(())1531	}15321533	pub fn create_multiple_items_internal(1534		sender: &T::CrossAccountId,1535		collection: &CollectionHandle<T>,1536		owner: &T::CrossAccountId,1537		items_data: Vec<CreateItemData>,1538	) -> DispatchResult {1539		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15401541		for data in &items_data {1542			Self::validate_create_item_args(collection, data)?;1543		}1544		for data in &items_data {1545			Self::create_item_no_validation(collection, owner, data.clone())?;1546		}15471548		Ok(())1549	}15501551	pub fn burn_item_internal(1552		sender: &T::CrossAccountId,1553		collection: &CollectionHandle<T>,1554		item_id: TokenId,1555		value: u128,1556	) -> DispatchResult {1557		ensure!(1558			Self::is_item_owner(sender, collection, item_id)1559				|| (collection.limits.owner_can_transfer1560					&& Self::is_owner_or_admin_permissions(collection, sender)),1561			Error::<T>::NoPermission1562		);15631564		if collection.access == AccessMode::WhiteList {1565			Self::check_white_list(collection, sender)?;1566		}15671568		match collection.mode {1569			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1570			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1571			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1572			_ => (),1573		};15741575		Ok(())1576	}15771578	pub fn toggle_white_list_internal(1579		sender: &T::CrossAccountId,1580		collection: &CollectionHandle<T>,1581		address: &T::CrossAccountId,1582		whitelisted: bool,1583	) -> DispatchResult {1584		Self::check_owner_or_admin_permissions(collection, sender)?;15851586		if whitelisted {1587			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1588		} else {1589			<WhiteList<T>>::remove(collection.id, address.as_sub());1590		}15911592		Ok(())1593	}15941595	fn is_correct_transfer(1596		collection: &CollectionHandle<T>,1597		recipient: &T::CrossAccountId,1598	) -> DispatchResult {1599		let collection_id = collection.id;16001601		// check token limit and account token limit1602		let account_items: u32 =1603			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1604		ensure!(1605			collection.limits.account_token_ownership_limit > account_items,1606			Error::<T>::AccountTokenLimitExceeded1607		);16081609		// preliminary transfer check1610		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16111612		Ok(())1613	}16141615	fn can_create_items_in_collection(1616		collection: &CollectionHandle<T>,1617		sender: &T::CrossAccountId,1618		owner: &T::CrossAccountId,1619		amount: u32,1620	) -> DispatchResult {1621		let collection_id = collection.id;16221623		// check token limit and account token limit1624		let total_items: u32 = ItemListIndex::get(collection_id)1625			.checked_add(amount)1626			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1627		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1628			as u32)1629			.checked_add(amount)1630			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1631		ensure!(1632			collection.limits.token_limit >= total_items,1633			Error::<T>::CollectionTokenLimitExceeded1634		);1635		ensure!(1636			collection.limits.account_token_ownership_limit >= account_items,1637			Error::<T>::AccountTokenLimitExceeded1638		);16391640		if !Self::is_owner_or_admin_permissions(collection, sender) {1641			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1642			Self::check_white_list(collection, owner)?;1643			Self::check_white_list(collection, sender)?;1644		}16451646		Ok(())1647	}16481649	fn validate_create_item_args(1650		target_collection: &CollectionHandle<T>,1651		data: &CreateItemData,1652	) -> DispatchResult {1653		match target_collection.mode {1654			CollectionMode::NFT => {1655				if let CreateItemData::NFT(data) = data {1656					// check sizes1657					ensure!(1658						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1659						Error::<T>::TokenConstDataLimitExceeded1660					);1661					ensure!(1662						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1663						Error::<T>::TokenVariableDataLimitExceeded1664					);1665				} else {1666					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1667				}1668			}1669			CollectionMode::Fungible(_) => {1670				if let CreateItemData::Fungible(_) = data {1671				} else {1672					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1673				}1674			}1675			CollectionMode::ReFungible => {1676				if let CreateItemData::ReFungible(data) = data {1677					// check sizes1678					ensure!(1679						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1680						Error::<T>::TokenConstDataLimitExceeded1681					);1682					ensure!(1683						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1684						Error::<T>::TokenVariableDataLimitExceeded1685					);16861687					// Check refungibility limits1688					ensure!(1689						data.pieces <= MAX_REFUNGIBLE_PIECES,1690						Error::<T>::WrongRefungiblePieces1691					);1692					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1693				} else {1694					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1695				}1696			}1697			_ => {1698				fail!(Error::<T>::UnexpectedCollectionType);1699			}1700		};17011702		Ok(())1703	}17041705	fn create_item_no_validation(1706		collection: &CollectionHandle<T>,1707		owner: &T::CrossAccountId,1708		data: CreateItemData,1709	) -> DispatchResult {1710		match data {1711			CreateItemData::NFT(data) => {1712				let item = NftItemType {1713					owner: owner.clone(),1714					const_data: data.const_data,1715					variable_data: data.variable_data,1716				};17171718				Self::add_nft_item(collection, item)?;1719			}1720			CreateItemData::Fungible(data) => {1721				Self::add_fungible_item(collection, owner, data.value)?;1722			}1723			CreateItemData::ReFungible(data) => {1724				let owner_list = vec![Ownership {1725					owner: owner.clone(),1726					fraction: data.pieces,1727				}];17281729				let item = ReFungibleItemType {1730					owner: owner_list,1731					const_data: data.const_data,1732					variable_data: data.variable_data,1733				};17341735				Self::add_refungible_item(collection, item)?;1736			}1737		};17381739		Ok(())1740	}17411742	fn add_fungible_item(1743		collection: &CollectionHandle<T>,1744		owner: &T::CrossAccountId,1745		value: u128,1746	) -> DispatchResult {1747		let collection_id = collection.id;17481749		// Does new owner already have an account?1750		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17511752		// Mint1753		let item = FungibleItemType {1754			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1755		};1756		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17571758		// Update balance1759		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1760			.checked_add(value)1761			.ok_or(Error::<T>::NumOverflow)?;1762		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17631764		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1765		Ok(())1766	}17671768	fn add_refungible_item(1769		collection: &CollectionHandle<T>,1770		item: ReFungibleItemType<T::CrossAccountId>,1771	) -> DispatchResult {1772		let collection_id = collection.id;17731774		let current_index = <ItemListIndex>::get(collection_id)1775			.checked_add(1)1776			.ok_or(Error::<T>::NumOverflow)?;1777		let itemcopy = item.clone();17781779		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1780		let item_owner = item.owner.first().expect("only one owner is defined");17811782		let value = item_owner.fraction;1783		let owner = item_owner.owner.clone();17841785		Self::add_token_index(collection_id, current_index, &owner)?;17861787		<ItemListIndex>::insert(collection_id, current_index);1788		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17891790		// Update balance1791		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1792			.checked_add(value)1793			.ok_or(Error::<T>::NumOverflow)?;1794		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17951796		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1797		Ok(())1798	}17991800	fn add_nft_item(1801		collection: &CollectionHandle<T>,1802		item: NftItemType<T::CrossAccountId>,1803	) -> DispatchResult {1804		let collection_id = collection.id;18051806		let current_index = <ItemListIndex>::get(collection_id)1807			.checked_add(1)1808			.ok_or(Error::<T>::NumOverflow)?;18091810		let item_owner = item.owner.clone();1811		Self::add_token_index(collection_id, current_index, &item.owner)?;18121813		<ItemListIndex>::insert(collection_id, current_index);1814		<NftItemList<T>>::insert(collection_id, current_index, item);18151816		// Update balance1817		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1818			.checked_add(1)1819			.ok_or(Error::<T>::NumOverflow)?;1820		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18211822		collection.log(ERC721Events::Transfer {1823			from: H160::default(),1824			to: *item_owner.as_eth(),1825			token_id: current_index.into(),1826		});1827		Self::deposit_event(RawEvent::ItemCreated(1828			collection_id,1829			current_index,1830			item_owner,1831		));1832		Ok(())1833	}18341835	fn burn_refungible_item(1836		collection: &CollectionHandle<T>,1837		item_id: TokenId,1838		owner: &T::CrossAccountId,1839	) -> DispatchResult {1840		let collection_id = collection.id;18411842		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1843			.ok_or(Error::<T>::TokenNotFound)?;1844		let rft_balance = token1845			.owner1846			.iter()1847			.find(|&i| i.owner == *owner)1848			.ok_or(Error::<T>::TokenNotFound)?;1849		Self::remove_token_index(collection_id, item_id, owner)?;18501851		// update balance1852		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1853			.checked_sub(rft_balance.fraction)1854			.ok_or(Error::<T>::NumOverflow)?;1855		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18561857		// Re-create owners list with sender removed1858		let index = token1859			.owner1860			.iter()1861			.position(|i| i.owner == *owner)1862			.expect("owned item is exists");1863		token.owner.remove(index);1864		let owner_count = token.owner.len();18651866		// Burn the token completely if this was the last (only) owner1867		if owner_count == 0 {1868			<ReFungibleItemList<T>>::remove(collection_id, item_id);1869			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1870		} else {1871			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1872		}18731874		Ok(())1875	}18761877	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1878		let collection_id = collection.id;18791880		let item =1881			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1882		Self::remove_token_index(collection_id, item_id, &item.owner)?;18831884		// update balance1885		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1886			.checked_sub(1)1887			.ok_or(Error::<T>::NumOverflow)?;1888		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1889		<NftItemList<T>>::remove(collection_id, item_id);1890		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);18911892		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1893		Ok(())1894	}18951896	fn burn_fungible_item(1897		owner: &T::CrossAccountId,1898		collection: &CollectionHandle<T>,1899		value: u128,1900	) -> DispatchResult {1901		let collection_id = collection.id;19021903		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1904		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19051906		// update balance1907		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1908			.checked_sub(value)1909			.ok_or(Error::<T>::NumOverflow)?;1910		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19111912		if balance.value - value > 0 {1913			balance.value -= value;1914			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1915		} else {1916			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1917		}19181919		collection.log(ERC20Events::Transfer {1920			from: *owner.as_eth(),1921			to: H160::default(),1922			value: value.into(),1923		});1924		Ok(())1925	}19261927	pub fn get_collection(1928		collection_id: CollectionId,1929	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1930		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1931	}19321933	fn save_collection(collection: CollectionHandle<T>) {1934		<CollectionById<T>>::insert(collection.id, collection.into_inner());1935	}19361937	pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {1938		if collection.logs.is_empty() {1939			return Ok(());1940		}1941		T::EthereumTransactionSender::submit_logs_transaction(1942			eth::generate_transaction(collection.id, T::EthereumChainId::get()),1943			collection.logs.retrieve_logs(),1944		)1945	}19461947	fn check_owner_permissions(1948		target_collection: &CollectionHandle<T>,1949		subject: &T::AccountId,1950	) -> DispatchResult {1951		ensure!(1952			*subject == target_collection.owner,1953			Error::<T>::NoPermission1954		);19551956		Ok(())1957	}19581959	fn is_owner_or_admin_permissions(1960		collection: &CollectionHandle<T>,1961		subject: &T::CrossAccountId,1962	) -> bool {1963		*subject.as_sub() == collection.owner1964			|| <AdminList<T>>::get(collection.id).contains(subject)1965	}19661967	fn check_owner_or_admin_permissions(1968		collection: &CollectionHandle<T>,1969		subject: &T::CrossAccountId,1970	) -> DispatchResult {1971		ensure!(1972			Self::is_owner_or_admin_permissions(collection, subject),1973			Error::<T>::NoPermission1974		);19751976		Ok(())1977	}19781979	fn owned_amount(1980		subject: &T::CrossAccountId,1981		target_collection: &CollectionHandle<T>,1982		item_id: TokenId,1983	) -> Option<u128> {1984		let collection_id = target_collection.id;19851986		match target_collection.mode {1987			CollectionMode::NFT => {1988				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1989			}1990			CollectionMode::Fungible(_) => {1991				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1992			}1993			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1994				.owner1995				.iter()1996				.find(|i| i.owner == *subject)1997				.map(|i| i.fraction),1998			CollectionMode::Invalid => None,1999		}2000	}20012002	fn is_item_owner(2003		subject: &T::CrossAccountId,2004		target_collection: &CollectionHandle<T>,2005		item_id: TokenId,2006	) -> bool {2007		match target_collection.mode {2008			CollectionMode::Fungible(_) => true,2009			_ => Self::owned_amount(subject, target_collection, item_id).is_some(),2010		}2011	}20122013	fn check_white_list(2014		collection: &CollectionHandle<T>,2015		address: &T::CrossAccountId,2016	) -> DispatchResult {2017		let collection_id = collection.id;20182019		let mes = Error::<T>::AddresNotInWhiteList;2020		ensure!(2021			<WhiteList<T>>::contains_key(collection_id, address.as_sub()),2022			mes2023		);20242025		Ok(())2026	}20272028	/// Check if token exists. In case of Fungible, check if there is an entry for2029	/// the owner in fungible balances double map2030	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2031		let collection_id = target_collection.id;2032		let exists = match target_collection.mode {2033			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2034			CollectionMode::Fungible(_) => true,2035			CollectionMode::ReFungible => {2036				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2037			}2038			_ => false,2039		};20402041		ensure!(exists, Error::<T>::TokenNotFound);2042		Ok(())2043	}20442045	fn transfer_fungible(2046		collection: &CollectionHandle<T>,2047		value: u128,2048		owner: &T::CrossAccountId,2049		recipient: &T::CrossAccountId,2050	) -> DispatchResult {2051		let collection_id = collection.id;20522053		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2054		ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20552056		// Send balance to recipient (updates balanceOf of recipient)2057		Self::add_fungible_item(collection, recipient, value)?;20582059		// update balanceOf of sender2060		<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);20612062		// Reduce or remove sender2063		if balance.value == value {2064			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2065		} else {2066			balance.value -= value;2067			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2068		}20692070		collection.log(ERC20Events::Transfer {2071			from: *owner.as_eth(),2072			to: *recipient.as_eth(),2073			value: value.into(),2074		});2075		Self::deposit_event(RawEvent::Transfer(2076			collection.id,2077			1,2078			owner.clone(),2079			recipient.clone(),2080			value,2081		));20822083		Ok(())2084	}20852086	fn transfer_refungible(2087		collection: &CollectionHandle<T>,2088		item_id: TokenId,2089		value: u128,2090		owner: T::CrossAccountId,2091		new_owner: T::CrossAccountId,2092	) -> DispatchResult {2093		let collection_id = collection.id;2094		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2095			.ok_or(Error::<T>::TokenNotFound)?;20962097		let item = full_item2098			.owner2099			.iter()2100			.find(|i| i.owner == owner)2101			.ok_or(Error::<T>::TokenNotFound)?;2102		let amount = item.fraction;21032104		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21052106		// update balance2107		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2108			.checked_sub(value)2109			.ok_or(Error::<T>::NumOverflow)?;2110		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21112112		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2113			.checked_add(value)2114			.ok_or(Error::<T>::NumOverflow)?;2115		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21162117		let old_owner = item.owner.clone();2118		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21192120		let mut new_full_item = full_item.clone();2121		// transfer2122		if amount == value && !new_owner_has_account {2123			// change owner2124			// new owner do not have account2125			new_full_item2126				.owner2127				.iter_mut()2128				.find(|i| i.owner == owner)2129				.expect("old owner does present in refungible")2130				.owner = new_owner.clone();2131			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21322133			// update index collection2134			Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2135		} else {2136			new_full_item2137				.owner2138				.iter_mut()2139				.find(|i| i.owner == owner)2140				.expect("old owner does present in refungible")2141				.fraction -= value;21422143			// separate amount2144			if new_owner_has_account {2145				// new owner has account2146				new_full_item2147					.owner2148					.iter_mut()2149					.find(|i| i.owner == new_owner)2150					.expect("new owner has account")2151					.fraction += value;2152			} else {2153				// new owner do not have account2154				new_full_item.owner.push(Ownership {2155					owner: new_owner.clone(),2156					fraction: value,2157				});2158				Self::add_token_index(collection_id, item_id, &new_owner)?;2159			}21602161			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2162		}21632164		Self::deposit_event(RawEvent::Transfer(2165			collection.id,2166			item_id,2167			owner,2168			new_owner,2169			amount,2170		));21712172		Ok(())2173	}21742175	fn transfer_nft(2176		collection: &CollectionHandle<T>,2177		item_id: TokenId,2178		sender: T::CrossAccountId,2179		new_owner: T::CrossAccountId,2180	) -> DispatchResult {2181		let collection_id = collection.id;2182		let mut item =2183			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21842185		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21862187		// update balance2188		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2189			.checked_sub(1)2190			.ok_or(Error::<T>::NumOverflow)?;2191		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21922193		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2194			.checked_add(1)2195			.ok_or(Error::<T>::NumOverflow)?;2196		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21972198		// change owner2199		let old_owner = item.owner.clone();2200		item.owner = new_owner.clone();2201		<NftItemList<T>>::insert(collection_id, item_id, item);22022203		// update index collection2204		Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22052206		collection.log(ERC721Events::Transfer {2207			from: *sender.as_eth(),2208			to: *new_owner.as_eth(),2209			token_id: item_id.into(),2210		});2211		Self::deposit_event(RawEvent::Transfer(2212			collection.id,2213			item_id,2214			sender,2215			new_owner,2216			1,2217		));22182219		Ok(())2220	}22212222	fn set_re_fungible_variable_data(2223		collection: &CollectionHandle<T>,2224		item_id: TokenId,2225		data: Vec<u8>,2226	) -> DispatchResult {2227		let collection_id = collection.id;2228		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2229			.ok_or(Error::<T>::TokenNotFound)?;22302231		item.variable_data = data;22322233		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22342235		Ok(())2236	}22372238	fn set_nft_variable_data(2239		collection: &CollectionHandle<T>,2240		item_id: TokenId,2241		data: Vec<u8>,2242	) -> DispatchResult {2243		let collection_id = collection.id;2244		let mut item =2245			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22462247		item.variable_data = data;22482249		<NftItemList<T>>::insert(collection_id, item_id, item);22502251		Ok(())2252	}22532254	#[allow(dead_code)]2255	fn init_collection(item: &Collection<T>) {2256		// check params2257		assert!(2258			item.decimal_points <= MAX_DECIMAL_POINTS,2259			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2260		);2261		assert!(2262			item.name.len() <= 64,2263			"Collection name can not be longer than 63 char"2264		);2265		assert!(2266			item.name.len() <= 256,2267			"Collection description can not be longer than 255 char"2268		);2269		assert!(2270			item.token_prefix.len() <= 16,2271			"Token prefix can not be longer than 15 char"2272		);22732274		// Generate next collection ID2275		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22762277		CreatedCollectionCount::put(next_id);2278	}22792280	#[allow(dead_code)]2281	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2282		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22832284		Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22852286		<ItemListIndex>::insert(collection_id, current_index);22872288		// Update balance2289		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2290			.checked_add(1)2291			.unwrap();2292		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2293	}22942295	#[allow(dead_code)]2296	fn init_fungible_token(2297		collection_id: CollectionId,2298		owner: &T::CrossAccountId,2299		item: &FungibleItemType,2300	) {2301		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23022303		Self::add_token_index(collection_id, current_index, owner).unwrap();23042305		<ItemListIndex>::insert(collection_id, current_index);23062307		// Update balance2308		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2309			.checked_add(item.value)2310			.unwrap();2311		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2312	}23132314	#[allow(dead_code)]2315	fn init_refungible_token(2316		collection_id: CollectionId,2317		item: &ReFungibleItemType<T::CrossAccountId>,2318	) {2319		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23202321		let value = item.owner.first().unwrap().fraction;2322		let owner = item.owner.first().unwrap().owner.clone();23232324		Self::add_token_index(collection_id, current_index, &owner).unwrap();23252326		<ItemListIndex>::insert(collection_id, current_index);23272328		// Update balance2329		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2330			.checked_add(value)2331			.unwrap();2332		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2333	}23342335	fn add_token_index(2336		collection_id: CollectionId,2337		item_index: TokenId,2338		owner: &T::CrossAccountId,2339	) -> DispatchResult {2340		// add to account limit2341		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2342			// bound Owned tokens by a single address2343			let count = <AccountItemCount<T>>::get(owner.as_sub());2344			ensure!(2345				count < ChainLimit::get().account_token_ownership_limit,2346				Error::<T>::AddressOwnershipLimitExceeded2347			);23482349			<AccountItemCount<T>>::insert(2350				owner.as_sub(),2351				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2352			);2353		} else {2354			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2355		}23562357		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2358		if list_exists {2359			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2360			let item_contains = list.contains(&item_index.clone());23612362			if !item_contains {2363				list.push(item_index);2364			}23652366			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2367		} else {2368			let itm = vec![item_index];2369			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2370		}23712372		Ok(())2373	}23742375	fn remove_token_index(2376		collection_id: CollectionId,2377		item_index: TokenId,2378		owner: &T::CrossAccountId,2379	) -> DispatchResult {2380		// update counter2381		<AccountItemCount<T>>::insert(2382			owner.as_sub(),2383			<AccountItemCount<T>>::get(owner.as_sub())2384				.checked_sub(1)2385				.ok_or(Error::<T>::NumOverflow)?,2386		);23872388		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2389		if list_exists {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.retain(|&item| item != item_index);2395				<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2396			}2397		}23982399		Ok(())2400	}24012402	fn move_token_index(2403		collection_id: CollectionId,2404		item_index: TokenId,2405		old_owner: &T::CrossAccountId,2406		new_owner: &T::CrossAccountId,2407	) -> DispatchResult {2408		Self::remove_token_index(collection_id, item_index, old_owner)?;2409		Self::add_token_index(collection_id, item_index, new_owner)?;24102411		Ok(())2412	}2413}24142415sp_api::decl_runtime_apis! {2416	pub trait NftApi {2417		/// Used for ethereum integration2418		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2419	}2420}