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

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 = T::CrossAccountId::from_sub(ensure_signed(origin)?);946			let mut target_collection = Self::get_collection(collection_id)?;947948			Self::check_owner_permissions(&target_collection, sender.as_sub())?;949			950			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!(1611			collection.transfers_enabled,1612			Error::<T>::TransferNotAllowed1613		);16141615		Ok(())1616	}16171618	fn can_create_items_in_collection(1619		collection: &CollectionHandle<T>,1620		sender: &T::CrossAccountId,1621		owner: &T::CrossAccountId,1622		amount: u32,1623	) -> DispatchResult {1624		let collection_id = collection.id;16251626		// check token limit and account token limit1627		let total_items: u32 = ItemListIndex::get(collection_id)1628			.checked_add(amount)1629			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1630		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1631			as u32)1632			.checked_add(amount)1633			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1634		ensure!(1635			collection.limits.token_limit >= total_items,1636			Error::<T>::CollectionTokenLimitExceeded1637		);1638		ensure!(1639			collection.limits.account_token_ownership_limit >= account_items,1640			Error::<T>::AccountTokenLimitExceeded1641		);16421643		if !Self::is_owner_or_admin_permissions(collection, sender) {1644			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1645			Self::check_white_list(collection, owner)?;1646			Self::check_white_list(collection, sender)?;1647		}16481649		Ok(())1650	}16511652	fn validate_create_item_args(1653		target_collection: &CollectionHandle<T>,1654		data: &CreateItemData,1655	) -> DispatchResult {1656		match target_collection.mode {1657			CollectionMode::NFT => {1658				if let CreateItemData::NFT(data) = data {1659					// check sizes1660					ensure!(1661						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1662						Error::<T>::TokenConstDataLimitExceeded1663					);1664					ensure!(1665						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1666						Error::<T>::TokenVariableDataLimitExceeded1667					);1668				} else {1669					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1670				}1671			}1672			CollectionMode::Fungible(_) => {1673				if let CreateItemData::Fungible(_) = data {1674				} else {1675					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1676				}1677			}1678			CollectionMode::ReFungible => {1679				if let CreateItemData::ReFungible(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					);16891690					// Check refungibility limits1691					ensure!(1692						data.pieces <= MAX_REFUNGIBLE_PIECES,1693						Error::<T>::WrongRefungiblePieces1694					);1695					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1696				} else {1697					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1698				}1699			}1700			_ => {1701				fail!(Error::<T>::UnexpectedCollectionType);1702			}1703		};17041705		Ok(())1706	}17071708	fn create_item_no_validation(1709		collection: &CollectionHandle<T>,1710		owner: &T::CrossAccountId,1711		data: CreateItemData,1712	) -> DispatchResult {1713		match data {1714			CreateItemData::NFT(data) => {1715				let item = NftItemType {1716					owner: owner.clone(),1717					const_data: data.const_data,1718					variable_data: data.variable_data,1719				};17201721				Self::add_nft_item(collection, item)?;1722			}1723			CreateItemData::Fungible(data) => {1724				Self::add_fungible_item(collection, owner, data.value)?;1725			}1726			CreateItemData::ReFungible(data) => {1727				let owner_list = vec![Ownership {1728					owner: owner.clone(),1729					fraction: data.pieces,1730				}];17311732				let item = ReFungibleItemType {1733					owner: owner_list,1734					const_data: data.const_data,1735					variable_data: data.variable_data,1736				};17371738				Self::add_refungible_item(collection, item)?;1739			}1740		};17411742		Ok(())1743	}17441745	fn add_fungible_item(1746		collection: &CollectionHandle<T>,1747		owner: &T::CrossAccountId,1748		value: u128,1749	) -> DispatchResult {1750		let collection_id = collection.id;17511752		// Does new owner already have an account?1753		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17541755		// Mint1756		let item = FungibleItemType {1757			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1758		};1759		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17601761		// Update balance1762		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1763			.checked_add(value)1764			.ok_or(Error::<T>::NumOverflow)?;1765		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17661767		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1768		Ok(())1769	}17701771	fn add_refungible_item(1772		collection: &CollectionHandle<T>,1773		item: ReFungibleItemType<T::CrossAccountId>,1774	) -> DispatchResult {1775		let collection_id = collection.id;17761777		let current_index = <ItemListIndex>::get(collection_id)1778			.checked_add(1)1779			.ok_or(Error::<T>::NumOverflow)?;1780		let itemcopy = item.clone();17811782		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1783		let item_owner = item.owner.first().expect("only one owner is defined");17841785		let value = item_owner.fraction;1786		let owner = item_owner.owner.clone();17871788		Self::add_token_index(collection_id, current_index, &owner)?;17891790		<ItemListIndex>::insert(collection_id, current_index);1791		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17921793		// Update balance1794		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1795			.checked_add(value)1796			.ok_or(Error::<T>::NumOverflow)?;1797		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17981799		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1800		Ok(())1801	}18021803	fn add_nft_item(1804		collection: &CollectionHandle<T>,1805		item: NftItemType<T::CrossAccountId>,1806	) -> DispatchResult {1807		let collection_id = collection.id;18081809		let current_index = <ItemListIndex>::get(collection_id)1810			.checked_add(1)1811			.ok_or(Error::<T>::NumOverflow)?;18121813		let item_owner = item.owner.clone();1814		Self::add_token_index(collection_id, current_index, &item.owner)?;18151816		<ItemListIndex>::insert(collection_id, current_index);1817		<NftItemList<T>>::insert(collection_id, current_index, item);18181819		// Update balance1820		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1821			.checked_add(1)1822			.ok_or(Error::<T>::NumOverflow)?;1823		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18241825		collection.log(ERC721Events::Transfer {1826			from: H160::default(),1827			to: *item_owner.as_eth(),1828			token_id: current_index.into(),1829		});1830		Self::deposit_event(RawEvent::ItemCreated(1831			collection_id,1832			current_index,1833			item_owner,1834		));1835		Ok(())1836	}18371838	fn burn_refungible_item(1839		collection: &CollectionHandle<T>,1840		item_id: TokenId,1841		owner: &T::CrossAccountId,1842	) -> DispatchResult {1843		let collection_id = collection.id;18441845		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1846			.ok_or(Error::<T>::TokenNotFound)?;1847		let rft_balance = token1848			.owner1849			.iter()1850			.find(|&i| i.owner == *owner)1851			.ok_or(Error::<T>::TokenNotFound)?;1852		Self::remove_token_index(collection_id, item_id, owner)?;18531854		// update balance1855		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1856			.checked_sub(rft_balance.fraction)1857			.ok_or(Error::<T>::NumOverflow)?;1858		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18591860		// Re-create owners list with sender removed1861		let index = token1862			.owner1863			.iter()1864			.position(|i| i.owner == *owner)1865			.expect("owned item is exists");1866		token.owner.remove(index);1867		let owner_count = token.owner.len();18681869		// Burn the token completely if this was the last (only) owner1870		if owner_count == 0 {1871			<ReFungibleItemList<T>>::remove(collection_id, item_id);1872			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1873		} else {1874			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1875		}18761877		Ok(())1878	}18791880	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1881		let collection_id = collection.id;18821883		let item =1884			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1885		Self::remove_token_index(collection_id, item_id, &item.owner)?;18861887		// update balance1888		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1889			.checked_sub(1)1890			.ok_or(Error::<T>::NumOverflow)?;1891		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1892		<NftItemList<T>>::remove(collection_id, item_id);1893		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);18941895		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1896		Ok(())1897	}18981899	fn burn_fungible_item(1900		owner: &T::CrossAccountId,1901		collection: &CollectionHandle<T>,1902		value: u128,1903	) -> DispatchResult {1904		let collection_id = collection.id;19051906		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1907		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19081909		// update balance1910		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1911			.checked_sub(value)1912			.ok_or(Error::<T>::NumOverflow)?;1913		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19141915		if balance.value - value > 0 {1916			balance.value -= value;1917			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1918		} else {1919			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1920		}19211922		collection.log(ERC20Events::Transfer {1923			from: *owner.as_eth(),1924			to: H160::default(),1925			value: value.into(),1926		});1927		Ok(())1928	}19291930	pub fn get_collection(1931		collection_id: CollectionId,1932	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1933		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1934	}19351936	fn save_collection(collection: CollectionHandle<T>) {1937		<CollectionById<T>>::insert(collection.id, collection.into_inner());1938	}19391940	pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {1941		if collection.logs.is_empty() {1942			return Ok(());1943		}1944		T::EthereumTransactionSender::submit_logs_transaction(1945			eth::generate_transaction(collection.id, T::EthereumChainId::get()),1946			collection.logs.retrieve_logs(),1947		)1948	}19491950	fn check_owner_permissions(1951		target_collection: &CollectionHandle<T>,1952		subject: &T::AccountId,1953	) -> DispatchResult {1954		ensure!(1955			*subject == target_collection.owner,1956			Error::<T>::NoPermission1957		);19581959		Ok(())1960	}19611962	fn is_owner_or_admin_permissions(1963		collection: &CollectionHandle<T>,1964		subject: &T::CrossAccountId,1965	) -> bool {1966		*subject.as_sub() == collection.owner1967			|| <AdminList<T>>::get(collection.id).contains(subject)1968	}19691970	fn check_owner_or_admin_permissions(1971		collection: &CollectionHandle<T>,1972		subject: &T::CrossAccountId,1973	) -> DispatchResult {1974		ensure!(1975			Self::is_owner_or_admin_permissions(collection, subject),1976			Error::<T>::NoPermission1977		);19781979		Ok(())1980	}19811982	fn owned_amount(1983		subject: &T::CrossAccountId,1984		target_collection: &CollectionHandle<T>,1985		item_id: TokenId,1986	) -> Option<u128> {1987		let collection_id = target_collection.id;19881989		match target_collection.mode {1990			CollectionMode::NFT => {1991				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1992			}1993			CollectionMode::Fungible(_) => {1994				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1995			}1996			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1997				.owner1998				.iter()1999				.find(|i| i.owner == *subject)2000				.map(|i| i.fraction),2001			CollectionMode::Invalid => None,2002		}2003	}20042005	fn is_item_owner(2006		subject: &T::CrossAccountId,2007		target_collection: &CollectionHandle<T>,2008		item_id: TokenId,2009	) -> bool {2010		match target_collection.mode {2011			CollectionMode::Fungible(_) => true,2012			_ => Self::owned_amount(subject, target_collection, item_id).is_some(),2013		}2014	}20152016	fn check_white_list(2017		collection: &CollectionHandle<T>,2018		address: &T::CrossAccountId,2019	) -> DispatchResult {2020		let collection_id = collection.id;20212022		let mes = Error::<T>::AddresNotInWhiteList;2023		ensure!(2024			<WhiteList<T>>::contains_key(collection_id, address.as_sub()),2025			mes2026		);20272028		Ok(())2029	}20302031	/// Check if token exists. In case of Fungible, check if there is an entry for2032	/// the owner in fungible balances double map2033	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2034		let collection_id = target_collection.id;2035		let exists = match target_collection.mode {2036			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2037			CollectionMode::Fungible(_) => true,2038			CollectionMode::ReFungible => {2039				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2040			}2041			_ => false,2042		};20432044		ensure!(exists, Error::<T>::TokenNotFound);2045		Ok(())2046	}20472048	fn transfer_fungible(2049		collection: &CollectionHandle<T>,2050		value: u128,2051		owner: &T::CrossAccountId,2052		recipient: &T::CrossAccountId,2053	) -> DispatchResult {2054		let collection_id = collection.id;20552056		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2057		ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20582059		// Send balance to recipient (updates balanceOf of recipient)2060		Self::add_fungible_item(collection, recipient, value)?;20612062		// update balanceOf of sender2063		<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);20642065		// Reduce or remove sender2066		if balance.value == value {2067			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2068		} else {2069			balance.value -= value;2070			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2071		}20722073		collection.log(ERC20Events::Transfer {2074			from: *owner.as_eth(),2075			to: *recipient.as_eth(),2076			value: value.into(),2077		});2078		Self::deposit_event(RawEvent::Transfer(2079			collection.id,2080			1,2081			owner.clone(),2082			recipient.clone(),2083			value,2084		));20852086		Ok(())2087	}20882089	fn transfer_refungible(2090		collection: &CollectionHandle<T>,2091		item_id: TokenId,2092		value: u128,2093		owner: T::CrossAccountId,2094		new_owner: T::CrossAccountId,2095	) -> DispatchResult {2096		let collection_id = collection.id;2097		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2098			.ok_or(Error::<T>::TokenNotFound)?;20992100		let item = full_item2101			.owner2102			.iter()2103			.find(|i| i.owner == owner)2104			.ok_or(Error::<T>::TokenNotFound)?;2105		let amount = item.fraction;21062107		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21082109		// update balance2110		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2111			.checked_sub(value)2112			.ok_or(Error::<T>::NumOverflow)?;2113		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21142115		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2116			.checked_add(value)2117			.ok_or(Error::<T>::NumOverflow)?;2118		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21192120		let old_owner = item.owner.clone();2121		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21222123		let mut new_full_item = full_item.clone();2124		// transfer2125		if amount == value && !new_owner_has_account {2126			// change owner2127			// new owner do not have account2128			new_full_item2129				.owner2130				.iter_mut()2131				.find(|i| i.owner == owner)2132				.expect("old owner does present in refungible")2133				.owner = new_owner.clone();2134			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21352136			// update index collection2137			Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2138		} else {2139			new_full_item2140				.owner2141				.iter_mut()2142				.find(|i| i.owner == owner)2143				.expect("old owner does present in refungible")2144				.fraction -= value;21452146			// separate amount2147			if new_owner_has_account {2148				// new owner has account2149				new_full_item2150					.owner2151					.iter_mut()2152					.find(|i| i.owner == new_owner)2153					.expect("new owner has account")2154					.fraction += value;2155			} else {2156				// new owner do not have account2157				new_full_item.owner.push(Ownership {2158					owner: new_owner.clone(),2159					fraction: value,2160				});2161				Self::add_token_index(collection_id, item_id, &new_owner)?;2162			}21632164			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2165		}21662167		Self::deposit_event(RawEvent::Transfer(2168			collection.id,2169			item_id,2170			owner,2171			new_owner,2172			amount,2173		));21742175		Ok(())2176	}21772178	fn transfer_nft(2179		collection: &CollectionHandle<T>,2180		item_id: TokenId,2181		sender: T::CrossAccountId,2182		new_owner: T::CrossAccountId,2183	) -> DispatchResult {2184		let collection_id = collection.id;2185		let mut item =2186			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21872188		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21892190		// update balance2191		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2192			.checked_sub(1)2193			.ok_or(Error::<T>::NumOverflow)?;2194		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21952196		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2197			.checked_add(1)2198			.ok_or(Error::<T>::NumOverflow)?;2199		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22002201		// change owner2202		let old_owner = item.owner.clone();2203		item.owner = new_owner.clone();2204		<NftItemList<T>>::insert(collection_id, item_id, item);22052206		// update index collection2207		Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22082209		collection.log(ERC721Events::Transfer {2210			from: *sender.as_eth(),2211			to: *new_owner.as_eth(),2212			token_id: item_id.into(),2213		});2214		Self::deposit_event(RawEvent::Transfer(2215			collection.id,2216			item_id,2217			sender,2218			new_owner,2219			1,2220		));22212222		Ok(())2223	}22242225	fn set_re_fungible_variable_data(2226		collection: &CollectionHandle<T>,2227		item_id: TokenId,2228		data: Vec<u8>,2229	) -> DispatchResult {2230		let collection_id = collection.id;2231		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2232			.ok_or(Error::<T>::TokenNotFound)?;22332234		item.variable_data = data;22352236		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22372238		Ok(())2239	}22402241	fn set_nft_variable_data(2242		collection: &CollectionHandle<T>,2243		item_id: TokenId,2244		data: Vec<u8>,2245	) -> DispatchResult {2246		let collection_id = collection.id;2247		let mut item =2248			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22492250		item.variable_data = data;22512252		<NftItemList<T>>::insert(collection_id, item_id, item);22532254		Ok(())2255	}22562257	#[allow(dead_code)]2258	fn init_collection(item: &Collection<T>) {2259		// check params2260		assert!(2261			item.decimal_points <= MAX_DECIMAL_POINTS,2262			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2263		);2264		assert!(2265			item.name.len() <= 64,2266			"Collection name can not be longer than 63 char"2267		);2268		assert!(2269			item.name.len() <= 256,2270			"Collection description can not be longer than 255 char"2271		);2272		assert!(2273			item.token_prefix.len() <= 16,2274			"Token prefix can not be longer than 15 char"2275		);22762277		// Generate next collection ID2278		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22792280		CreatedCollectionCount::put(next_id);2281	}22822283	#[allow(dead_code)]2284	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2285		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22862287		Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22882289		<ItemListIndex>::insert(collection_id, current_index);22902291		// Update balance2292		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2293			.checked_add(1)2294			.unwrap();2295		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2296	}22972298	#[allow(dead_code)]2299	fn init_fungible_token(2300		collection_id: CollectionId,2301		owner: &T::CrossAccountId,2302		item: &FungibleItemType,2303	) {2304		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23052306		Self::add_token_index(collection_id, current_index, owner).unwrap();23072308		<ItemListIndex>::insert(collection_id, current_index);23092310		// Update balance2311		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2312			.checked_add(item.value)2313			.unwrap();2314		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2315	}23162317	#[allow(dead_code)]2318	fn init_refungible_token(2319		collection_id: CollectionId,2320		item: &ReFungibleItemType<T::CrossAccountId>,2321	) {2322		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23232324		let value = item.owner.first().unwrap().fraction;2325		let owner = item.owner.first().unwrap().owner.clone();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(value)2334			.unwrap();2335		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2336	}23372338	fn add_token_index(2339		collection_id: CollectionId,2340		item_index: TokenId,2341		owner: &T::CrossAccountId,2342	) -> DispatchResult {2343		// add to account limit2344		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2345			// bound Owned tokens by a single address2346			let count = <AccountItemCount<T>>::get(owner.as_sub());2347			ensure!(2348				count < ChainLimit::get().account_token_ownership_limit,2349				Error::<T>::AddressOwnershipLimitExceeded2350			);23512352			<AccountItemCount<T>>::insert(2353				owner.as_sub(),2354				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2355			);2356		} else {2357			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2358		}23592360		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2361		if list_exists {2362			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2363			let item_contains = list.contains(&item_index.clone());23642365			if !item_contains {2366				list.push(item_index);2367			}23682369			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2370		} else {2371			let itm = vec![item_index];2372			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2373		}23742375		Ok(())2376	}23772378	fn remove_token_index(2379		collection_id: CollectionId,2380		item_index: TokenId,2381		owner: &T::CrossAccountId,2382	) -> DispatchResult {2383		// update counter2384		<AccountItemCount<T>>::insert(2385			owner.as_sub(),2386			<AccountItemCount<T>>::get(owner.as_sub())2387				.checked_sub(1)2388				.ok_or(Error::<T>::NumOverflow)?,2389		);23902391		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2392		if list_exists {2393			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2394			let item_contains = list.contains(&item_index.clone());23952396			if item_contains {2397				list.retain(|&item| item != item_index);2398				<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2399			}2400		}24012402		Ok(())2403	}24042405	fn move_token_index(2406		collection_id: CollectionId,2407		item_index: TokenId,2408		old_owner: &T::CrossAccountId,2409		new_owner: &T::CrossAccountId,2410	) -> DispatchResult {2411		Self::remove_token_index(collection_id, item_index, old_owner)?;2412		Self::add_token_index(collection_id, item_index, new_owner)?;24132414		Ok(())2415	}2416}24172418sp_api::decl_runtime_apis! {2419	pub trait NftApi {2420		/// Used for ethereum integration2421		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2422	}2423}