git.delta.rocks / unique-network / refs/commits / 31e089cf67a7

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 nft_data_structs::{40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41	AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits, CollectionId,42	CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,43	FungibleItemType, ReFungibleItemType,44};4546#[cfg(test)]47mod mock;4849#[cfg(test)]50mod tests;5152mod default_weights;53mod eth;54mod sponsorship;55pub use sponsorship::NftSponsorshipHandler;56pub use eth::sponsoring::NftEthSponsorshipHandler;5758pub use eth::NftErcSupport;59pub use eth::account::*;60use eth::erc::{ERC20Events, ERC721Events};6162#[cfg(feature = "runtime-benchmarks")]63mod benchmarking;6465pub trait WeightInfo {66	fn create_collection() -> Weight;67	fn destroy_collection() -> Weight;68	fn add_to_white_list() -> Weight;69	fn remove_from_white_list() -> Weight;70	fn set_public_access_mode() -> Weight;71	fn set_mint_permission() -> Weight;72	fn change_collection_owner() -> Weight;73	fn add_collection_admin() -> Weight;74	fn remove_collection_admin() -> Weight;75	fn set_collection_sponsor() -> Weight;76	fn confirm_sponsorship() -> Weight;77	fn remove_collection_sponsor() -> Weight;78	fn create_item(s: usize) -> Weight;79	fn burn_item() -> Weight;80	fn transfer() -> Weight;81	fn approve() -> Weight;82	fn transfer_from() -> Weight;83	fn set_offchain_schema() -> Weight;84	fn set_const_on_chain_schema() -> Weight;85	fn set_variable_on_chain_schema() -> Weight;86	fn set_variable_meta_data() -> Weight;87	fn enable_contract_sponsoring() -> Weight;88	fn set_schema_version() -> Weight;89	fn set_chain_limits() -> Weight;90	fn set_contract_sponsoring_rate_limit() -> Weight;91	fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;92	fn toggle_contract_white_list() -> Weight;93	fn add_to_contract_white_list() -> Weight;94	fn remove_from_contract_white_list() -> Weight;95	fn set_collection_limits() -> Weight;96}9798decl_error! {99	/// Error for non-fungible-token module.100	pub enum Error for Module<T: Config> {101		/// Total collections bound exceeded.102		TotalCollectionsLimitExceeded,103		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.104		CollectionDecimalPointLimitExceeded,105		/// Collection name can not be longer than 63 char.106		CollectionNameLimitExceeded,107		/// Collection description can not be longer than 255 char.108		CollectionDescriptionLimitExceeded,109		/// Token prefix can not be longer than 15 char.110		CollectionTokenPrefixLimitExceeded,111		/// This collection does not exist.112		CollectionNotFound,113		/// Item not exists.114		TokenNotFound,115		/// Admin not found116		AdminNotFound,117		/// Arithmetic calculation overflow.118		NumOverflow,119		/// Account already has admin role.120		AlreadyAdmin,121		/// You do not own this collection.122		NoPermission,123		/// This address is not set as sponsor, use setCollectionSponsor first.124		ConfirmUnsetSponsorFail,125		/// Collection is not in mint mode.126		PublicMintingNotAllowed,127		/// Sender parameter and item owner must be equal.128		MustBeTokenOwner,129		/// Item balance not enough.130		TokenValueTooLow,131		/// Size of item is too large.132		NftSizeLimitExceeded,133		/// No approve found134		ApproveNotFound,135		/// Requested value more than approved.136		TokenValueNotEnough,137		/// Only approved addresses can call this method.138		ApproveRequired,139		/// Address is not in white list.140		AddresNotInWhiteList,141		/// Number of collection admins bound exceeded.142		CollectionAdminsLimitExceeded,143		/// Owned tokens by a single address bound exceeded.144		AddressOwnershipLimitExceeded,145		/// Length of items properties must be greater than 0.146		EmptyArgument,147		/// const_data exceeded data limit.148		TokenConstDataLimitExceeded,149		/// variable_data exceeded data limit.150		TokenVariableDataLimitExceeded,151		/// Not NFT item data used to mint in NFT collection.152		NotNftDataUsedToMintNftCollectionToken,153		/// Not Fungible item data used to mint in Fungible collection.154		NotFungibleDataUsedToMintFungibleCollectionToken,155		/// Not Re Fungible item data used to mint in Re Fungible collection.156		NotReFungibleDataUsedToMintReFungibleCollectionToken,157		/// Unexpected collection type.158		UnexpectedCollectionType,159		/// Can't store metadata in fungible tokens.160		CantStoreMetadataInFungibleTokens,161		/// Collection token limit exceeded162		CollectionTokenLimitExceeded,163		/// Account token limit exceeded per collection164		AccountTokenLimitExceeded,165		/// Collection limit bounds per collection exceeded166		CollectionLimitBoundsExceeded,167		/// Tried to enable permissions which are only permitted to be disabled168		OwnerPermissionsCantBeReverted,169		/// Schema data size limit bound exceeded170		SchemaDataLimitExceeded,171		/// Maximum refungibility exceeded172		WrongRefungiblePieces,173		/// createRefungible should be called with one owner174		BadCreateRefungibleCall,175		/// Gas limit exceeded176		OutOfGas,177	}178}179180#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]181pub struct CollectionHandle<T: Config> {182	pub id: CollectionId,183	collection: Collection<T>,184	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,185}186impl<T: Config> CollectionHandle<T> {187	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {188		<CollectionById<T>>::get(id).map(|collection| Self {189			id,190			collection,191			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(192				eth::collection_id_to_address(id),193				gas_limit,194			),195		})196	}197	pub fn get(id: CollectionId) -> Option<Self> {198		Self::get_with_gas_limit(id, u64::MAX)199	}200	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {201		self.recorder.log_sub(log)202	}203	fn consume_gas(&self, gas: u64) -> DispatchResult {204		self.recorder.consume_gas_sub(gas)205	}206	pub fn submit_logs(self) -> DispatchResult {207		self.recorder.submit_logs()208	}209	pub fn save(self) -> DispatchResult {210		self.recorder.submit_logs()?;211		<CollectionById<T>>::insert(self.id, self.collection);212		Ok(())213	}214}215impl<T: Config> Deref for CollectionHandle<T> {216	type Target = Collection<T>;217218	fn deref(&self) -> &Self::Target {219		&self.collection220	}221}222223impl<T: Config> DerefMut for CollectionHandle<T> {224	fn deref_mut(&mut self) -> &mut Self::Target {225		&mut self.collection226	}227}228229pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {230	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;231232	/// Weight information for extrinsics in this pallet.233	type WeightInfo: WeightInfo;234235	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;236	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;237238	type CrossAccountId: CrossAccountId<Self::AccountId>;239	type Currency: Currency<Self::AccountId>;240	type CollectionCreationPrice: Get<241		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,242	>;243	type TreasuryAccountId: Get<Self::AccountId>;244}245246// # Used definitions247//248// ## User control levels249//250// chain-controlled - key is uncontrolled by user251//                    i.e autoincrementing index252//                    can use non-cryptographic hash253// real - key is controlled by user254//        but it is hard to generate enough colliding values, i.e owner of signed txs255//        can use non-cryptographic hash256// controlled - key is completly controlled by users257//              i.e maps with mutable keys258//              should use cryptographic hash259//260// ## User control level downgrade reasons261//262// ?1 - chain-controlled -> controlled263//      collections/tokens can be destroyed, resulting in massive holes264// ?2 - chain-controlled -> controlled265//      same as ?1, but can be only added, resulting in easier exploitation266// ?3 - real -> controlled267//      no confirmation required, so addresses can be easily generated268decl_storage! {269	trait Store for Module<T: Config> as Nft {270271		//#region Private members272		/// Id of next collection273		CreatedCollectionCount: u32;274		/// Used for migrations275		ChainVersion: u64;276		/// Id of last collection token277		/// Collection id (controlled?1)278		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;279		//#endregion280281		//#region Chain limits struct282		pub ChainLimit get(fn chain_limit) config(): ChainLimits;283		//#endregion284285		//#region Bound counters286		/// Amount of collections destroyed, used for total amount tracking with287		/// CreatedCollectionCount288		DestroyedCollectionCount: u32;289		/// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)290		/// Account id (real)291		pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;292		//#endregion293294		//#region Basic collections295		/// Collection info296		/// Collection id (controlled?1)297		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;298		/// List of collection admins299		/// Collection id (controlled?2)300		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;301		/// Whitelisted collection users302		/// Collection id (controlled?2), user id (controlled?3)303		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;304		//#endregion305306		/// How many of collection items user have307		/// Collection id (controlled?2), account id (real)308		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;309310		/// Amount of items which spender can transfer out of owners account (via transferFrom)311		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))312		/// TODO: Off chain worker should remove from this map when token gets removed313		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;314315		//#region Item collections316		/// Collection id (controlled?2), token id (controlled?1)317		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;318		/// Collection id (controlled?2), owner (controlled?2)319		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;320		/// Collection id (controlled?2), token id (controlled?1)321		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;322		//#endregion323324		//#region Index list325		/// Collection id (controlled?2), tokens owner (controlled?2)326		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;327		//#endregion328329		//#region Tokens transfer rate limit baskets330		/// (Collection id (controlled?2), who created (real))331		/// TODO: Off chain worker should remove from this map when collection gets removed332		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;333		/// Collection id (controlled?2), token id (controlled?2)334		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;335		/// Collection id (controlled?2), owning user (real)336		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;337		/// Collection id (controlled?2), token id (controlled?2)338		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;339		//#endregion340341		/// Variable metadata sponsoring342		/// Collection id (controlled?2), token id (controlled?2)343		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;344	}345	add_extra_genesis {346		build(|config: &GenesisConfig<T>| {347			// Modification of storage348			for (_num, _c) in &config.collection_id {349				<Module<T>>::init_collection(_c);350			}351352			for (_num, _c, _i) in &config.nft_item_id {353				<Module<T>>::init_nft_token(*_c, _i);354			}355356			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {357				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);358			}359360			for (_num, _c, _i) in &config.refungible_item_id {361				<Module<T>>::init_refungible_token(*_c, _i);362			}363		})364	}365}366367decl_event!(368	pub enum Event<T>369	where370		AccountId = <T as frame_system::Config>::AccountId,371		CrossAccountId = <T as Config>::CrossAccountId,372	{373		/// New collection was created374		///375		/// # Arguments376		///377		/// * collection_id: Globally unique identifier of newly created collection.378		///379		/// * mode: [CollectionMode] converted into u8.380		///381		/// * account_id: Collection owner.382		CollectionCreated(CollectionId, u8, AccountId),383384		/// New item was created.385		///386		/// # Arguments387		///388		/// * collection_id: Id of the collection where item was created.389		///390		/// * item_id: Id of an item. Unique within the collection.391		///392		/// * recipient: Owner of newly created item393		ItemCreated(CollectionId, TokenId, CrossAccountId),394395		/// Collection item was burned.396		///397		/// # Arguments398		///399		/// collection_id.400		///401		/// item_id: Identifier of burned NFT.402		ItemDestroyed(CollectionId, TokenId),403404		/// Item was transferred405		///406		/// * collection_id: Id of collection to which item is belong407		///408		/// * item_id: Id of an item409		///410		/// * sender: Original owner of item411		///412		/// * recipient: New owner of item413		///414		/// * amount: Always 1 for NFT415		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),416417		/// * collection_id418		///419		/// * item_id420		///421		/// * sender422		///423		/// * spender424		///425		/// * amount426		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),427	}428);429430decl_module! {431	pub struct Module<T: Config> for enum Call432	where433		origin: T::Origin434	{435		fn deposit_event() = default;436		type Error = Error<T>;437438		fn on_initialize(_now: T::BlockNumber) -> Weight {439			0440		}441442		/// 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.443		///444		/// # Permissions445		///446		/// * Anyone.447		///448		/// # Arguments449		///450		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.451		///452		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.453		///454		/// * token_prefix: UTF-8 string with token prefix.455		///456		/// * mode: [CollectionMode] collection type and type dependent data.457		// returns collection ID458		#[weight = <T as Config>::WeightInfo::create_collection()]459		#[transactional]460		pub fn create_collection(origin,461								 collection_name: Vec<u16>,462								 collection_description: Vec<u16>,463								 token_prefix: Vec<u8>,464								 mode: CollectionMode) -> DispatchResult {465466			// Anyone can create a collection467			let who = ensure_signed(origin)?;468469			// Take a (non-refundable) deposit of collection creation470			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();471			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(472				&T::TreasuryAccountId::get(),473				T::CollectionCreationPrice::get(),474			));475			<T as Config>::Currency::settle(476				&who,477				imbalance,478				WithdrawReasons::TRANSFER,479				ExistenceRequirement::KeepAlive,480			).map_err(|_| Error::<T>::NoPermission)?;481482			let decimal_points = match mode {483				CollectionMode::Fungible(points) => points,484				_ => 0485			};486487			let chain_limit = ChainLimit::get();488489			let created_count = CreatedCollectionCount::get();490			let destroyed_count = DestroyedCollectionCount::get();491492			// bound Total number of collections493			ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);494495			// check params496			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);497			ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);498			ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);499			ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);500501			// Generate next collection ID502			let next_id = created_count503				.checked_add(1)504				.ok_or(Error::<T>::NumOverflow)?;505506			CreatedCollectionCount::put(next_id);507508			let limits = CollectionLimits {509				sponsored_data_size: chain_limit.custom_data_limit,510				..Default::default()511			};512513			// Create new collection514			let new_collection = Collection {515				owner: who.clone(),516				name: collection_name,517				mode: mode.clone(),518				mint_mode: false,519				access: AccessMode::Normal,520				description: collection_description,521				decimal_points,522				token_prefix,523				offchain_schema: Vec::new(),524				schema_version: SchemaVersion::ImageURL,525				sponsorship: SponsorshipState::Disabled,526				variable_on_chain_schema: Vec::new(),527				const_on_chain_schema: Vec::new(),528				limits,529			};530531			// Add new collection to map532			<CollectionById<T>>::insert(next_id, new_collection);533534			// call event535			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));536537			Ok(())538		}539540		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.541		///542		/// # Permissions543		///544		/// * Collection Owner.545		///546		/// # Arguments547		///548		/// * collection_id: collection to destroy.549		#[weight = <T as Config>::WeightInfo::destroy_collection()]550		#[transactional]551		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {552553			let sender = ensure_signed(origin)?;554			let collection = Self::get_collection(collection_id)?;555			Self::check_owner_permissions(&collection, &sender)?;556			if !collection.limits.owner_can_destroy {557				fail!(Error::<T>::NoPermission);558			}559560			<AddressTokens<T>>::remove_prefix(collection_id, None);561			<Allowances<T>>::remove_prefix(collection_id, None);562			<Balance<T>>::remove_prefix(collection_id, None);563			<ItemListIndex>::remove(collection_id);564			<AdminList<T>>::remove(collection_id);565			<CollectionById<T>>::remove(collection_id);566			<WhiteList<T>>::remove_prefix(collection_id, None);567568			<NftItemList<T>>::remove_prefix(collection_id, None);569			<FungibleItemList<T>>::remove_prefix(collection_id, None);570			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);571572			<NftTransferBasket<T>>::remove_prefix(collection_id, None);573			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);574			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);575576			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);577578			DestroyedCollectionCount::put(DestroyedCollectionCount::get()579				.checked_add(1)580				.ok_or(Error::<T>::NumOverflow)?);581582			Ok(())583		}584585		/// Add an address to white list.586		///587		/// # Permissions588		///589		/// * Collection Owner590		/// * Collection Admin591		///592		/// # Arguments593		///594		/// * collection_id.595		///596		/// * address.597		#[weight = <T as Config>::WeightInfo::add_to_white_list()]598		#[transactional]599		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{600601			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);602			let collection = Self::get_collection(collection_id)?;603604			Self::toggle_white_list_internal(605				&sender,606				&collection,607				&address,608				true,609			)?;610611			Ok(())612		}613614		/// Remove an address from white list.615		///616		/// # Permissions617		///618		/// * Collection Owner619		/// * Collection Admin620		///621		/// # Arguments622		///623		/// * collection_id.624		///625		/// * address.626		#[weight = <T as Config>::WeightInfo::remove_from_white_list()]627		#[transactional]628		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{629630			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);631			let collection = Self::get_collection(collection_id)?;632633			Self::toggle_white_list_internal(634				&sender,635				&collection,636				&address,637				false,638			)?;639640			Ok(())641		}642643		/// Toggle between normal and white list access for the methods with access for `Anyone`.644		///645		/// # Permissions646		///647		/// * Collection Owner.648		///649		/// # Arguments650		///651		/// * collection_id.652		///653		/// * mode: [AccessMode]654		#[weight = <T as Config>::WeightInfo::set_public_access_mode()]655		#[transactional]656		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult657		{658			let sender = ensure_signed(origin)?;659660			let mut target_collection = Self::get_collection(collection_id)?;661			Self::check_owner_permissions(&target_collection, &sender)?;662			target_collection.access = mode;663			target_collection.save()664		}665666		/// Allows Anyone to create tokens if:667		/// * White List is enabled, and668		/// * Address is added to white list, and669		/// * This method was called with True parameter670		///671		/// # Permissions672		/// * Collection Owner673		///674		/// # Arguments675		///676		/// * collection_id.677		///678		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.679		#[weight = <T as Config>::WeightInfo::set_mint_permission()]680		#[transactional]681		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult682		{683			let sender = ensure_signed(origin)?;684685			let mut target_collection = Self::get_collection(collection_id)?;686			Self::check_owner_permissions(&target_collection, &sender)?;687			target_collection.mint_mode = mint_permission;688			target_collection.save()689		}690691		/// Change the owner of the collection.692		///693		/// # Permissions694		///695		/// * Collection Owner.696		///697		/// # Arguments698		///699		/// * collection_id.700		///701		/// * new_owner.702		#[weight = <T as Config>::WeightInfo::change_collection_owner()]703		#[transactional]704		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {705706			let sender = ensure_signed(origin)?;707			let mut target_collection = Self::get_collection(collection_id)?;708			Self::check_owner_permissions(&target_collection, &sender)?;709			target_collection.owner = new_owner;710			target_collection.save()711		}712713		/// Adds an admin of the Collection.714		/// 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.715		///716		/// # Permissions717		///718		/// * Collection Owner.719		/// * Collection Admin.720		///721		/// # Arguments722		///723		/// * collection_id: ID of the Collection to add admin for.724		///725		/// * new_admin_id: Address of new admin to add.726		#[weight = <T as Config>::WeightInfo::add_collection_admin()]727		#[transactional]728		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {729			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);730			let collection = Self::get_collection(collection_id)?;731			Self::check_owner_or_admin_permissions(&collection, &sender)?;732			let mut admin_arr = <AdminList<T>>::get(collection_id);733734			match admin_arr.binary_search(&new_admin_id) {735				Ok(_) => {},736				Err(idx) => {737					let limits = ChainLimit::get();738					ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);739					admin_arr.insert(idx, new_admin_id);740					<AdminList<T>>::insert(collection_id, admin_arr);741				}742			}743			Ok(())744		}745746		/// 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.747		///748		/// # Permissions749		///750		/// * Collection Owner.751		/// * Collection Admin.752		///753		/// # Arguments754		///755		/// * collection_id: ID of the Collection to remove admin for.756		///757		/// * account_id: Address of admin to remove.758		#[weight = <T as Config>::WeightInfo::remove_collection_admin()]759		#[transactional]760		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {761			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);762			let collection = Self::get_collection(collection_id)?;763			Self::check_owner_or_admin_permissions(&collection, &sender)?;764			let mut admin_arr = <AdminList<T>>::get(collection_id);765766			if let Ok(idx) = admin_arr.binary_search(&account_id) {767				admin_arr.remove(idx);768				<AdminList<T>>::insert(collection_id, admin_arr);769			}770			Ok(())771		}772773		/// # Permissions774		///775		/// * Collection Owner776		///777		/// # Arguments778		///779		/// * collection_id.780		///781		/// * new_sponsor.782		#[weight = <T as Config>::WeightInfo::set_collection_sponsor()]783		#[transactional]784		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {785			let sender = ensure_signed(origin)?;786			let mut target_collection = Self::get_collection(collection_id)?;787			Self::check_owner_permissions(&target_collection, &sender)?;788789			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);790			target_collection.save()791		}792793		/// # Permissions794		///795		/// * Sponsor.796		///797		/// # Arguments798		///799		/// * collection_id.800		#[weight = <T as Config>::WeightInfo::confirm_sponsorship()]801		#[transactional]802		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {803			let sender = ensure_signed(origin)?;804805			let mut target_collection = Self::get_collection(collection_id)?;806			ensure!(807				target_collection.sponsorship.pending_sponsor() == Some(&sender),808				Error::<T>::ConfirmUnsetSponsorFail809			);810811			target_collection.sponsorship = SponsorshipState::Confirmed(sender);812			target_collection.save()813		}814815		/// Switch back to pay-per-own-transaction model.816		///817		/// # Permissions818		///819		/// * Collection owner.820		///821		/// # Arguments822		///823		/// * collection_id.824		#[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]825		#[transactional]826		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {827			let sender = ensure_signed(origin)?;828829			let mut target_collection = Self::get_collection(collection_id)?;830			Self::check_owner_permissions(&target_collection, &sender)?;831832			target_collection.sponsorship = SponsorshipState::Disabled;833			target_collection.save()834		}835836		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.837		///838		/// # Permissions839		///840		/// * Collection Owner.841		/// * Collection Admin.842		/// * Anyone if843		///     * White List is enabled, and844		///     * Address is added to white list, and845		///     * MintPermission is enabled (see SetMintPermission method)846		///847		/// # Arguments848		///849		/// * collection_id: ID of the collection.850		///851		/// * owner: Address, initial owner of the NFT.852		///853		/// * data: Token data to store on chain.854		// #[weight =855		// (130_000_000 as Weight)856		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))857		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))858		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]859860		#[weight = <T as Config>::WeightInfo::create_item(data.data_size())]861		#[transactional]862		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {863			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);864			let collection = Self::get_collection(collection_id)?;865866			Self::create_item_internal(&sender, &collection, &owner, data)?;867868			collection.submit_logs()869		}870871		/// This method creates multiple items in a collection created with CreateCollection method.872		///873		/// # Permissions874		///875		/// * Collection Owner.876		/// * Collection Admin.877		/// * Anyone if878		///     * White List is enabled, and879		///     * Address is added to white list, and880		///     * MintPermission is enabled (see SetMintPermission method)881		///882		/// # Arguments883		///884		/// * collection_id: ID of the collection.885		///886		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].887		///888		/// * owner: Address, initial owner of the NFT.889		#[weight = <T as Config>::WeightInfo::create_item(items_data.iter()890							   .map(|data| { data.data_size() })891							   .sum())]892		#[transactional]893		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {894895			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);896			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);897			let collection = Self::get_collection(collection_id)?;898899			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;900901			collection.submit_logs()902		}903904		/// Destroys a concrete instance of NFT.905		///906		/// # Permissions907		///908		/// * Collection Owner.909		/// * Collection Admin.910		/// * Current NFT Owner.911		///912		/// # Arguments913		///914		/// * collection_id: ID of the collection.915		///916		/// * item_id: ID of NFT to burn.917		#[weight = <T as Config>::WeightInfo::burn_item()]918		#[transactional]919		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {920921			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);922			let target_collection = Self::get_collection(collection_id)?;923924			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;925926			target_collection.submit_logs()927		}928929		/// Change ownership of the token.930		///931		/// # Permissions932		///933		/// * Collection Owner934		/// * Collection Admin935		/// * Current NFT owner936		///937		/// # Arguments938		///939		/// * recipient: Address of token recipient.940		///941		/// * collection_id.942		///943		/// * item_id: ID of the item944		///     * Non-Fungible Mode: Required.945		///     * Fungible Mode: Ignored.946		///     * Re-Fungible Mode: Required.947		///948		/// * value: Amount to transfer.949		///     * Non-Fungible Mode: Ignored950		///     * Fungible Mode: Must specify transferred amount951		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)952		#[weight = <T as Config>::WeightInfo::transfer()]953		#[transactional]954		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {955			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);956			let collection = Self::get_collection(collection_id)?;957958			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;959960			collection.submit_logs()961		}962963		/// Set, change, or remove approved address to transfer the ownership of the NFT.964		///965		/// # Permissions966		///967		/// * Collection Owner968		/// * Collection Admin969		/// * Current NFT owner970		///971		/// # Arguments972		///973		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).974		///975		/// * collection_id.976		///977		/// * item_id: ID of the item.978		#[weight = <T as Config>::WeightInfo::approve()]979		#[transactional]980		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {981			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);982			let collection = Self::get_collection(collection_id)?;983984			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;985986			collection.submit_logs()987		}988989		/// 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.990		///991		/// # Permissions992		/// * Collection Owner993		/// * Collection Admin994		/// * Current NFT owner995		/// * Address approved by current NFT owner996		///997		/// # Arguments998		///999		/// * from: Address that owns token.1000		///1001		/// * recipient: Address of token recipient.1002		///1003		/// * collection_id.1004		///1005		/// * item_id: ID of the item.1006		///1007		/// * value: Amount to transfer.1008		#[weight = <T as Config>::WeightInfo::transfer_from()]1009		#[transactional]1010		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1011			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1012			let collection = Self::get_collection(collection_id)?;10131014			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10151016			collection.submit_logs()1017		}1018		// #[weight = 0]1019		//     // let no_perm_mes = "You do not have permissions to modify this collection";1020		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1021		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1022		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10231024		//     // // on_nft_received  call10251026		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10271028		//     Ok(())1029		// }10301031		/// Set off-chain data schema.1032		///1033		/// # Permissions1034		///1035		/// * Collection Owner1036		/// * Collection Admin1037		///1038		/// # Arguments1039		///1040		/// * collection_id.1041		///1042		/// * schema: String representing the offchain data schema.1043		#[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1044		#[transactional]1045		pub fn set_variable_meta_data (1046			origin,1047			collection_id: CollectionId,1048			item_id: TokenId,1049			data: Vec<u8>1050		) -> DispatchResult {1051			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10521053			let collection = Self::get_collection(collection_id)?;10541055			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10561057			Ok(())1058		}10591060		/// Set schema standard1061		/// ImageURL1062		/// Unique1063		///1064		/// # Permissions1065		///1066		/// * Collection Owner1067		/// * Collection Admin1068		///1069		/// # Arguments1070		///1071		/// * collection_id.1072		///1073		/// * schema: SchemaVersion: enum1074		#[weight = <T as Config>::WeightInfo::set_schema_version()]1075		#[transactional]1076		pub fn set_schema_version(1077			origin,1078			collection_id: CollectionId,1079			version: SchemaVersion1080		) -> DispatchResult {1081			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1082			let mut target_collection = Self::get_collection(collection_id)?;1083			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1084			target_collection.schema_version = version;1085			target_collection.save()1086		}10871088		/// Set off-chain data schema.1089		///1090		/// # Permissions1091		///1092		/// * Collection Owner1093		/// * Collection Admin1094		///1095		/// # Arguments1096		///1097		/// * collection_id.1098		///1099		/// * schema: String representing the offchain data schema.1100		#[weight = <T as Config>::WeightInfo::set_offchain_schema()]1101		#[transactional]1102		pub fn set_offchain_schema(1103			origin,1104			collection_id: CollectionId,1105			schema: Vec<u8>1106		) -> DispatchResult {1107			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1108			let mut target_collection = Self::get_collection(collection_id)?;1109			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11101111			// check schema limit1112			ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");11131114			target_collection.offchain_schema = schema;1115			target_collection.save()1116		}11171118		/// Set const on-chain data schema.1119		///1120		/// # Permissions1121		///1122		/// * Collection Owner1123		/// * Collection Admin1124		///1125		/// # Arguments1126		///1127		/// * collection_id.1128		///1129		/// * schema: String representing the const on-chain data schema.1130		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1131		#[transactional]1132		pub fn set_const_on_chain_schema (1133			origin,1134			collection_id: CollectionId,1135			schema: Vec<u8>1136		) -> 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)?;11401141			// check schema limit1142			ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");11431144			target_collection.const_on_chain_schema = schema;1145			target_collection.save()1146		}11471148		/// Set variable on-chain data schema.1149		///1150		/// # Permissions1151		///1152		/// * Collection Owner1153		/// * Collection Admin1154		///1155		/// # Arguments1156		///1157		/// * collection_id.1158		///1159		/// * schema: String representing the variable on-chain data schema.1160		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1161		#[transactional]1162		pub fn set_variable_on_chain_schema (1163			origin,1164			collection_id: CollectionId,1165			schema: Vec<u8>1166		) -> DispatchResult {1167			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1168			let mut target_collection = Self::get_collection(collection_id)?;1169			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11701171			// check schema limit1172			ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");11731174			target_collection.variable_on_chain_schema = schema;1175			target_collection.save()1176		}11771178		// Sudo permissions function1179		#[weight = <T as Config>::WeightInfo::set_chain_limits()]1180		#[transactional]1181		pub fn set_chain_limits(1182			origin,1183			limits: ChainLimits1184		) -> DispatchResult {11851186			#[cfg(not(feature = "runtime-benchmarks"))]1187			ensure_root(origin)?;11881189			<ChainLimit>::put(limits);1190			Ok(())1191		}11921193		#[weight = <T as Config>::WeightInfo::set_collection_limits()]1194		#[transactional]1195		pub fn set_collection_limits(1196			origin,1197			collection_id: u32,1198			new_limits: CollectionLimits<T::BlockNumber>,1199		) -> DispatchResult {1200			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1201			let mut target_collection = Self::get_collection(collection_id)?;1202			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1203			let old_limits = &target_collection.limits;1204			let chain_limits = ChainLimit::get();12051206			// collection bounds1207			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1208				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1209				new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1210				Error::<T>::CollectionLimitBoundsExceeded);12111212			// token_limit   check  prev1213			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1214			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12151216			ensure!(1217				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1218				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1219				Error::<T>::OwnerPermissionsCantBeReverted,1220			);12211222			target_collection.limits = new_limits;12231224			target_collection.save()1225		}1226	}1227}12281229impl<T: Config> Module<T> {1230	pub fn create_item_internal(1231		sender: &T::CrossAccountId,1232		collection: &CollectionHandle<T>,1233		owner: &T::CrossAccountId,1234		data: CreateItemData,1235	) -> DispatchResult {1236		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1237		Self::validate_create_item_args(collection, &data)?;1238		Self::create_item_no_validation(collection, owner, data)?;12391240		Ok(())1241	}12421243	pub fn transfer_internal(1244		sender: &T::CrossAccountId,1245		recipient: &T::CrossAccountId,1246		target_collection: &CollectionHandle<T>,1247		item_id: TokenId,1248		value: u128,1249	) -> DispatchResult {1250		target_collection.consume_gas(2000000)?;1251		// Limits check1252		Self::is_correct_transfer(target_collection, recipient)?;12531254		// Transfer permissions check1255		ensure!(1256			Self::is_item_owner(sender, target_collection, item_id)1257				|| Self::is_owner_or_admin_permissions(target_collection, sender),1258			Error::<T>::NoPermission1259		);12601261		if target_collection.access == AccessMode::WhiteList {1262			Self::check_white_list(target_collection, sender)?;1263			Self::check_white_list(target_collection, recipient)?;1264		}12651266		match target_collection.mode {1267			CollectionMode::NFT => Self::transfer_nft(1268				target_collection,1269				item_id,1270				sender.clone(),1271				recipient.clone(),1272			)?,1273			CollectionMode::Fungible(_) => {1274				Self::transfer_fungible(target_collection, value, sender, recipient)?1275			}1276			CollectionMode::ReFungible => Self::transfer_refungible(1277				target_collection,1278				item_id,1279				value,1280				sender.clone(),1281				recipient.clone(),1282			)?,1283			_ => (),1284		};12851286		Self::deposit_event(RawEvent::Transfer(1287			target_collection.id,1288			item_id,1289			sender.clone(),1290			recipient.clone(),1291			value,1292		));12931294		Ok(())1295	}12961297	pub fn approve_internal(1298		sender: &T::CrossAccountId,1299		spender: &T::CrossAccountId,1300		collection: &CollectionHandle<T>,1301		item_id: TokenId,1302		amount: u128,1303	) -> DispatchResult {1304		collection.consume_gas(2000000)?;1305		Self::token_exists(collection, item_id)?;13061307		// Transfer permissions check1308		let bypasses_limits = collection.limits.owner_can_transfer1309			&& Self::is_owner_or_admin_permissions(collection, sender);13101311		let allowance_limit = if bypasses_limits {1312			None1313		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id) {1314			Some(amount)1315		} else {1316			fail!(Error::<T>::NoPermission);1317		};13181319		if collection.access == AccessMode::WhiteList {1320			Self::check_white_list(collection, sender)?;1321			Self::check_white_list(collection, spender)?;1322		}13231324		let allowance: u128 = amount1325			.checked_add(<Allowances<T>>::get(1326				collection.id,1327				(item_id, sender.as_sub(), spender.as_sub()),1328			))1329			.ok_or(Error::<T>::NumOverflow)?;1330		if let Some(limit) = allowance_limit {1331			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1332		}1333		<Allowances<T>>::insert(1334			collection.id,1335			(item_id, sender.as_sub(), spender.as_sub()),1336			allowance,1337		);13381339		if matches!(collection.mode, CollectionMode::NFT) {1340			// TODO: NFT: only one owner may exist for token in ERC7211341			collection.log(ERC721Events::Approval {1342				owner: *sender.as_eth(),1343				approved: *spender.as_eth(),1344				token_id: item_id.into(),1345			})?;1346		}13471348		if matches!(collection.mode, CollectionMode::Fungible(_)) {1349			// TODO: NFT: only one owner may exist for token in ERC201350			collection.log(ERC20Events::Approval {1351				owner: *sender.as_eth(),1352				spender: *spender.as_eth(),1353				value: allowance.into(),1354			})?;1355		}13561357		Self::deposit_event(RawEvent::Approved(1358			collection.id,1359			item_id,1360			sender.clone(),1361			spender.clone(),1362			allowance,1363		));1364		Ok(())1365	}13661367	pub fn transfer_from_internal(1368		sender: &T::CrossAccountId,1369		from: &T::CrossAccountId,1370		recipient: &T::CrossAccountId,1371		collection: &CollectionHandle<T>,1372		item_id: TokenId,1373		amount: u128,1374	) -> DispatchResult {1375		collection.consume_gas(2000000)?;1376		// Check approval1377		let approval: u128 =1378			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));13791380		// Limits check1381		Self::is_correct_transfer(collection, recipient)?;13821383		// Transfer permissions check1384		ensure!(1385			approval >= amount1386				|| (collection.limits.owner_can_transfer1387					&& Self::is_owner_or_admin_permissions(collection, sender)),1388			Error::<T>::NoPermission1389		);13901391		if collection.access == AccessMode::WhiteList {1392			Self::check_white_list(collection, sender)?;1393			Self::check_white_list(collection, recipient)?;1394		}13951396		// Reduce approval by transferred amount or remove if remaining approval drops to 01397		let allowance = approval.saturating_sub(amount);1398		if allowance > 0 {1399			<Allowances<T>>::insert(1400				collection.id,1401				(item_id, from.as_sub(), sender.as_sub()),1402				allowance,1403			);1404		} else {1405			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1406		}14071408		match collection.mode {1409			CollectionMode::NFT => {1410				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1411			}1412			CollectionMode::Fungible(_) => {1413				Self::transfer_fungible(collection, amount, from, recipient)?1414			}1415			CollectionMode::ReFungible => Self::transfer_refungible(1416				collection,1417				item_id,1418				amount,1419				from.clone(),1420				recipient.clone(),1421			)?,1422			_ => (),1423		};14241425		if matches!(collection.mode, CollectionMode::Fungible(_)) {1426			collection.log(ERC20Events::Approval {1427				owner: *from.as_eth(),1428				spender: *sender.as_eth(),1429				value: allowance.into(),1430			})?;1431		}14321433		Ok(())1434	}14351436	pub fn set_variable_meta_data_internal(1437		sender: &T::CrossAccountId,1438		collection: &CollectionHandle<T>,1439		item_id: TokenId,1440		data: Vec<u8>,1441	) -> DispatchResult {1442		Self::token_exists(collection, item_id)?;14431444		ensure!(1445			ChainLimit::get().custom_data_limit >= data.len() as u32,1446			Error::<T>::TokenVariableDataLimitExceeded1447		);14481449		// Modify permissions check1450		ensure!(1451			Self::is_item_owner(sender, collection, item_id)1452				|| Self::is_owner_or_admin_permissions(collection, sender),1453			Error::<T>::NoPermission1454		);14551456		match collection.mode {1457			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1458			CollectionMode::ReFungible => {1459				Self::set_re_fungible_variable_data(collection, item_id, data)?1460			}1461			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1462			_ => fail!(Error::<T>::UnexpectedCollectionType),1463		};14641465		Ok(())1466	}14671468	pub fn create_multiple_items_internal(1469		sender: &T::CrossAccountId,1470		collection: &CollectionHandle<T>,1471		owner: &T::CrossAccountId,1472		items_data: Vec<CreateItemData>,1473	) -> DispatchResult {1474		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;14751476		for data in &items_data {1477			Self::validate_create_item_args(collection, data)?;1478		}1479		for data in &items_data {1480			Self::create_item_no_validation(collection, owner, data.clone())?;1481		}14821483		Ok(())1484	}14851486	pub fn burn_item_internal(1487		sender: &T::CrossAccountId,1488		collection: &CollectionHandle<T>,1489		item_id: TokenId,1490		value: u128,1491	) -> DispatchResult {1492		ensure!(1493			Self::is_item_owner(sender, collection, item_id)1494				|| (collection.limits.owner_can_transfer1495					&& Self::is_owner_or_admin_permissions(collection, sender)),1496			Error::<T>::NoPermission1497		);14981499		if collection.access == AccessMode::WhiteList {1500			Self::check_white_list(collection, sender)?;1501		}15021503		match collection.mode {1504			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1505			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1506			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1507			_ => (),1508		};15091510		Ok(())1511	}15121513	pub fn toggle_white_list_internal(1514		sender: &T::CrossAccountId,1515		collection: &CollectionHandle<T>,1516		address: &T::CrossAccountId,1517		whitelisted: bool,1518	) -> DispatchResult {1519		Self::check_owner_or_admin_permissions(collection, sender)?;15201521		if whitelisted {1522			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1523		} else {1524			<WhiteList<T>>::remove(collection.id, address.as_sub());1525		}15261527		Ok(())1528	}15291530	fn is_correct_transfer(1531		collection: &CollectionHandle<T>,1532		recipient: &T::CrossAccountId,1533	) -> DispatchResult {1534		let collection_id = collection.id;15351536		// check token limit and account token limit1537		let account_items: u32 =1538			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1539		ensure!(1540			collection.limits.account_token_ownership_limit > account_items,1541			Error::<T>::AccountTokenLimitExceeded1542		);15431544		Ok(())1545	}15461547	fn can_create_items_in_collection(1548		collection: &CollectionHandle<T>,1549		sender: &T::CrossAccountId,1550		owner: &T::CrossAccountId,1551		amount: u32,1552	) -> DispatchResult {1553		let collection_id = collection.id;15541555		// check token limit and account token limit1556		let total_items: u32 = ItemListIndex::get(collection_id)1557			.checked_add(amount)1558			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1559		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1560			as u32)1561			.checked_add(amount)1562			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1563		ensure!(1564			collection.limits.token_limit >= total_items,1565			Error::<T>::CollectionTokenLimitExceeded1566		);1567		ensure!(1568			collection.limits.account_token_ownership_limit >= account_items,1569			Error::<T>::AccountTokenLimitExceeded1570		);15711572		if !Self::is_owner_or_admin_permissions(collection, sender) {1573			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1574			Self::check_white_list(collection, owner)?;1575			Self::check_white_list(collection, sender)?;1576		}15771578		Ok(())1579	}15801581	fn validate_create_item_args(1582		target_collection: &CollectionHandle<T>,1583		data: &CreateItemData,1584	) -> DispatchResult {1585		match target_collection.mode {1586			CollectionMode::NFT => {1587				if let CreateItemData::NFT(data) = data {1588					// check sizes1589					ensure!(1590						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1591						Error::<T>::TokenConstDataLimitExceeded1592					);1593					ensure!(1594						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1595						Error::<T>::TokenVariableDataLimitExceeded1596					);1597				} else {1598					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1599				}1600			}1601			CollectionMode::Fungible(_) => {1602				if let CreateItemData::Fungible(_) = data {1603				} else {1604					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1605				}1606			}1607			CollectionMode::ReFungible => {1608				if let CreateItemData::ReFungible(data) = data {1609					// check sizes1610					ensure!(1611						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1612						Error::<T>::TokenConstDataLimitExceeded1613					);1614					ensure!(1615						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1616						Error::<T>::TokenVariableDataLimitExceeded1617					);16181619					// Check refungibility limits1620					ensure!(1621						data.pieces <= MAX_REFUNGIBLE_PIECES,1622						Error::<T>::WrongRefungiblePieces1623					);1624					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1625				} else {1626					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1627				}1628			}1629			_ => {1630				fail!(Error::<T>::UnexpectedCollectionType);1631			}1632		};16331634		Ok(())1635	}16361637	fn create_item_no_validation(1638		collection: &CollectionHandle<T>,1639		owner: &T::CrossAccountId,1640		data: CreateItemData,1641	) -> DispatchResult {1642		match data {1643			CreateItemData::NFT(data) => {1644				let item = NftItemType {1645					owner: owner.clone(),1646					const_data: data.const_data,1647					variable_data: data.variable_data,1648				};16491650				Self::add_nft_item(collection, item)?;1651			}1652			CreateItemData::Fungible(data) => {1653				Self::add_fungible_item(collection, owner, data.value)?;1654			}1655			CreateItemData::ReFungible(data) => {1656				let owner_list = vec![Ownership {1657					owner: owner.clone(),1658					fraction: data.pieces,1659				}];16601661				let item = ReFungibleItemType {1662					owner: owner_list,1663					const_data: data.const_data,1664					variable_data: data.variable_data,1665				};16661667				Self::add_refungible_item(collection, item)?;1668			}1669		};16701671		Ok(())1672	}16731674	fn add_fungible_item(1675		collection: &CollectionHandle<T>,1676		owner: &T::CrossAccountId,1677		value: u128,1678	) -> DispatchResult {1679		let collection_id = collection.id;16801681		// Does new owner already have an account?1682		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;16831684		// Mint1685		let item = FungibleItemType {1686			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1687		};1688		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);16891690		// Update balance1691		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1692			.checked_add(value)1693			.ok_or(Error::<T>::NumOverflow)?;1694		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);16951696		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1697		Ok(())1698	}16991700	fn add_refungible_item(1701		collection: &CollectionHandle<T>,1702		item: ReFungibleItemType<T::CrossAccountId>,1703	) -> DispatchResult {1704		let collection_id = collection.id;17051706		let current_index = <ItemListIndex>::get(collection_id)1707			.checked_add(1)1708			.ok_or(Error::<T>::NumOverflow)?;1709		let itemcopy = item.clone();17101711		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1712		let item_owner = item.owner.first().expect("only one owner is defined");17131714		let value = item_owner.fraction;1715		let owner = item_owner.owner.clone();17161717		Self::add_token_index(collection_id, current_index, &owner)?;17181719		<ItemListIndex>::insert(collection_id, current_index);1720		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17211722		// Update balance1723		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1724			.checked_add(value)1725			.ok_or(Error::<T>::NumOverflow)?;1726		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17271728		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1729		Ok(())1730	}17311732	fn add_nft_item(1733		collection: &CollectionHandle<T>,1734		item: NftItemType<T::CrossAccountId>,1735	) -> DispatchResult {1736		let collection_id = collection.id;17371738		let current_index = <ItemListIndex>::get(collection_id)1739			.checked_add(1)1740			.ok_or(Error::<T>::NumOverflow)?;17411742		let item_owner = item.owner.clone();1743		Self::add_token_index(collection_id, current_index, &item.owner)?;17441745		<ItemListIndex>::insert(collection_id, current_index);1746		<NftItemList<T>>::insert(collection_id, current_index, item);17471748		// Update balance1749		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1750			.checked_add(1)1751			.ok_or(Error::<T>::NumOverflow)?;1752		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17531754		collection.log(ERC721Events::Transfer {1755			from: H160::default(),1756			to: *item_owner.as_eth(),1757			token_id: current_index.into(),1758		})?;1759		Self::deposit_event(RawEvent::ItemCreated(1760			collection_id,1761			current_index,1762			item_owner,1763		));1764		Ok(())1765	}17661767	fn burn_refungible_item(1768		collection: &CollectionHandle<T>,1769		item_id: TokenId,1770		owner: &T::CrossAccountId,1771	) -> DispatchResult {1772		let collection_id = collection.id;17731774		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1775			.ok_or(Error::<T>::TokenNotFound)?;1776		let rft_balance = token1777			.owner1778			.iter()1779			.find(|&i| i.owner == *owner)1780			.ok_or(Error::<T>::TokenNotFound)?;1781		Self::remove_token_index(collection_id, item_id, owner)?;17821783		// update balance1784		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1785			.checked_sub(rft_balance.fraction)1786			.ok_or(Error::<T>::NumOverflow)?;1787		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);17881789		// Re-create owners list with sender removed1790		let index = token1791			.owner1792			.iter()1793			.position(|i| i.owner == *owner)1794			.expect("owned item is exists");1795		token.owner.remove(index);1796		let owner_count = token.owner.len();17971798		// Burn the token completely if this was the last (only) owner1799		if owner_count == 0 {1800			<ReFungibleItemList<T>>::remove(collection_id, item_id);1801			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1802		} else {1803			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1804		}18051806		Ok(())1807	}18081809	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1810		let collection_id = collection.id;18111812		let item =1813			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1814		Self::remove_token_index(collection_id, item_id, &item.owner)?;18151816		// update balance1817		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1818			.checked_sub(1)1819			.ok_or(Error::<T>::NumOverflow)?;1820		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1821		<NftItemList<T>>::remove(collection_id, item_id);1822		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);18231824		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1825		Ok(())1826	}18271828	fn burn_fungible_item(1829		owner: &T::CrossAccountId,1830		collection: &CollectionHandle<T>,1831		value: u128,1832	) -> DispatchResult {1833		let collection_id = collection.id;18341835		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1836		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18371838		// update balance1839		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1840			.checked_sub(value)1841			.ok_or(Error::<T>::NumOverflow)?;1842		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18431844		if balance.value - value > 0 {1845			balance.value -= value;1846			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1847		} else {1848			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1849		}18501851		collection.log(ERC20Events::Transfer {1852			from: *owner.as_eth(),1853			to: H160::default(),1854			value: value.into(),1855		})?;1856		Ok(())1857	}18581859	pub fn get_collection(1860		collection_id: CollectionId,1861	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1862		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1863	}18641865	fn check_owner_permissions(1866		target_collection: &CollectionHandle<T>,1867		subject: &T::AccountId,1868	) -> DispatchResult {1869		ensure!(1870			*subject == target_collection.owner,1871			Error::<T>::NoPermission1872		);18731874		Ok(())1875	}18761877	fn is_owner_or_admin_permissions(1878		collection: &CollectionHandle<T>,1879		subject: &T::CrossAccountId,1880	) -> bool {1881		*subject.as_sub() == collection.owner1882			|| <AdminList<T>>::get(collection.id).contains(subject)1883	}18841885	fn check_owner_or_admin_permissions(1886		collection: &CollectionHandle<T>,1887		subject: &T::CrossAccountId,1888	) -> DispatchResult {1889		ensure!(1890			Self::is_owner_or_admin_permissions(collection, subject),1891			Error::<T>::NoPermission1892		);18931894		Ok(())1895	}18961897	fn owned_amount(1898		subject: &T::CrossAccountId,1899		target_collection: &CollectionHandle<T>,1900		item_id: TokenId,1901	) -> Option<u128> {1902		let collection_id = target_collection.id;19031904		match target_collection.mode {1905			CollectionMode::NFT => {1906				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1907			}1908			CollectionMode::Fungible(_) => {1909				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1910			}1911			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1912				.owner1913				.iter()1914				.find(|i| i.owner == *subject)1915				.map(|i| i.fraction),1916			CollectionMode::Invalid => None,1917		}1918	}19191920	fn is_item_owner(1921		subject: &T::CrossAccountId,1922		target_collection: &CollectionHandle<T>,1923		item_id: TokenId,1924	) -> bool {1925		match target_collection.mode {1926			CollectionMode::Fungible(_) => true,1927			_ => Self::owned_amount(subject, target_collection, item_id).is_some(),1928		}1929	}19301931	fn check_white_list(1932		collection: &CollectionHandle<T>,1933		address: &T::CrossAccountId,1934	) -> DispatchResult {1935		let collection_id = collection.id;19361937		let mes = Error::<T>::AddresNotInWhiteList;1938		ensure!(1939			<WhiteList<T>>::contains_key(collection_id, address.as_sub()),1940			mes1941		);19421943		Ok(())1944	}19451946	/// Check if token exists. In case of Fungible, check if there is an entry for1947	/// the owner in fungible balances double map1948	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1949		let collection_id = target_collection.id;1950		let exists = match target_collection.mode {1951			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1952			CollectionMode::Fungible(_) => true,1953			CollectionMode::ReFungible => {1954				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)1955			}1956			_ => false,1957		};19581959		ensure!(exists, Error::<T>::TokenNotFound);1960		Ok(())1961	}19621963	fn transfer_fungible(1964		collection: &CollectionHandle<T>,1965		value: u128,1966		owner: &T::CrossAccountId,1967		recipient: &T::CrossAccountId,1968	) -> DispatchResult {1969		let collection_id = collection.id;19701971		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1972		ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);19731974		// Send balance to recipient (updates balanceOf of recipient)1975		Self::add_fungible_item(collection, recipient, value)?;19761977		// update balanceOf of sender1978		<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);19791980		// Reduce or remove sender1981		if balance.value == value {1982			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1983		} else {1984			balance.value -= value;1985			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1986		}19871988		collection.log(ERC20Events::Transfer {1989			from: *owner.as_eth(),1990			to: *recipient.as_eth(),1991			value: value.into(),1992		})?;1993		Self::deposit_event(RawEvent::Transfer(1994			collection.id,1995			1,1996			owner.clone(),1997			recipient.clone(),1998			value,1999		));20002001		Ok(())2002	}20032004	fn transfer_refungible(2005		collection: &CollectionHandle<T>,2006		item_id: TokenId,2007		value: u128,2008		owner: T::CrossAccountId,2009		new_owner: T::CrossAccountId,2010	) -> DispatchResult {2011		let collection_id = collection.id;2012		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2013			.ok_or(Error::<T>::TokenNotFound)?;20142015		let item = full_item2016			.owner2017			.iter()2018			.find(|i| i.owner == owner)2019			.ok_or(Error::<T>::TokenNotFound)?;2020		let amount = item.fraction;20212022		ensure!(amount >= value, Error::<T>::TokenValueTooLow);20232024		// update balance2025		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2026			.checked_sub(value)2027			.ok_or(Error::<T>::NumOverflow)?;2028		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20292030		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2031			.checked_add(value)2032			.ok_or(Error::<T>::NumOverflow)?;2033		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20342035		let old_owner = item.owner.clone();2036		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20372038		let mut new_full_item = full_item.clone();2039		// transfer2040		if amount == value && !new_owner_has_account {2041			// change owner2042			// new owner do not have account2043			new_full_item2044				.owner2045				.iter_mut()2046				.find(|i| i.owner == owner)2047				.expect("old owner does present in refungible")2048				.owner = new_owner.clone();2049			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20502051			// update index collection2052			Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2053		} else {2054			new_full_item2055				.owner2056				.iter_mut()2057				.find(|i| i.owner == owner)2058				.expect("old owner does present in refungible")2059				.fraction -= value;20602061			// separate amount2062			if new_owner_has_account {2063				// new owner has account2064				new_full_item2065					.owner2066					.iter_mut()2067					.find(|i| i.owner == new_owner)2068					.expect("new owner has account")2069					.fraction += value;2070			} else {2071				// new owner do not have account2072				new_full_item.owner.push(Ownership {2073					owner: new_owner.clone(),2074					fraction: value,2075				});2076				Self::add_token_index(collection_id, item_id, &new_owner)?;2077			}20782079			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2080		}20812082		Self::deposit_event(RawEvent::Transfer(2083			collection.id,2084			item_id,2085			owner,2086			new_owner,2087			amount,2088		));20892090		Ok(())2091	}20922093	fn transfer_nft(2094		collection: &CollectionHandle<T>,2095		item_id: TokenId,2096		sender: T::CrossAccountId,2097		new_owner: T::CrossAccountId,2098	) -> DispatchResult {2099		let collection_id = collection.id;2100		let mut item =2101			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21022103		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21042105		// update balance2106		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2107			.checked_sub(1)2108			.ok_or(Error::<T>::NumOverflow)?;2109		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21102111		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2112			.checked_add(1)2113			.ok_or(Error::<T>::NumOverflow)?;2114		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21152116		// change owner2117		let old_owner = item.owner.clone();2118		item.owner = new_owner.clone();2119		<NftItemList<T>>::insert(collection_id, item_id, item);21202121		// update index collection2122		Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21232124		collection.log(ERC721Events::Transfer {2125			from: *sender.as_eth(),2126			to: *new_owner.as_eth(),2127			token_id: item_id.into(),2128		})?;2129		Self::deposit_event(RawEvent::Transfer(2130			collection.id,2131			item_id,2132			sender,2133			new_owner,2134			1,2135		));21362137		Ok(())2138	}21392140	fn set_re_fungible_variable_data(2141		collection: &CollectionHandle<T>,2142		item_id: TokenId,2143		data: Vec<u8>,2144	) -> DispatchResult {2145		let collection_id = collection.id;2146		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2147			.ok_or(Error::<T>::TokenNotFound)?;21482149		item.variable_data = data;21502151		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);21522153		Ok(())2154	}21552156	fn set_nft_variable_data(2157		collection: &CollectionHandle<T>,2158		item_id: TokenId,2159		data: Vec<u8>,2160	) -> DispatchResult {2161		let collection_id = collection.id;2162		let mut item =2163			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21642165		item.variable_data = data;21662167		<NftItemList<T>>::insert(collection_id, item_id, item);21682169		Ok(())2170	}21712172	#[allow(dead_code)]2173	fn init_collection(item: &Collection<T>) {2174		// check params2175		assert!(2176			item.decimal_points <= MAX_DECIMAL_POINTS,2177			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2178		);2179		assert!(2180			item.name.len() <= 64,2181			"Collection name can not be longer than 63 char"2182		);2183		assert!(2184			item.name.len() <= 256,2185			"Collection description can not be longer than 255 char"2186		);2187		assert!(2188			item.token_prefix.len() <= 16,2189			"Token prefix can not be longer than 15 char"2190		);21912192		// Generate next collection ID2193		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();21942195		CreatedCollectionCount::put(next_id);2196	}21972198	#[allow(dead_code)]2199	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2200		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22012202		Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22032204		<ItemListIndex>::insert(collection_id, current_index);22052206		// Update balance2207		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2208			.checked_add(1)2209			.unwrap();2210		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2211	}22122213	#[allow(dead_code)]2214	fn init_fungible_token(2215		collection_id: CollectionId,2216		owner: &T::CrossAccountId,2217		item: &FungibleItemType,2218	) {2219		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22202221		Self::add_token_index(collection_id, current_index, owner).unwrap();22222223		<ItemListIndex>::insert(collection_id, current_index);22242225		// Update balance2226		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2227			.checked_add(item.value)2228			.unwrap();2229		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2230	}22312232	#[allow(dead_code)]2233	fn init_refungible_token(2234		collection_id: CollectionId,2235		item: &ReFungibleItemType<T::CrossAccountId>,2236	) {2237		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22382239		let value = item.owner.first().unwrap().fraction;2240		let owner = item.owner.first().unwrap().owner.clone();22412242		Self::add_token_index(collection_id, current_index, &owner).unwrap();22432244		<ItemListIndex>::insert(collection_id, current_index);22452246		// Update balance2247		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2248			.checked_add(value)2249			.unwrap();2250		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2251	}22522253	fn add_token_index(2254		collection_id: CollectionId,2255		item_index: TokenId,2256		owner: &T::CrossAccountId,2257	) -> DispatchResult {2258		// add to account limit2259		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2260			// bound Owned tokens by a single address2261			let count = <AccountItemCount<T>>::get(owner.as_sub());2262			ensure!(2263				count < ChainLimit::get().account_token_ownership_limit,2264				Error::<T>::AddressOwnershipLimitExceeded2265			);22662267			<AccountItemCount<T>>::insert(2268				owner.as_sub(),2269				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2270			);2271		} else {2272			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2273		}22742275		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2276		if list_exists {2277			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2278			let item_contains = list.contains(&item_index.clone());22792280			if !item_contains {2281				list.push(item_index);2282			}22832284			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2285		} else {2286			let itm = vec![item_index];2287			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2288		}22892290		Ok(())2291	}22922293	fn remove_token_index(2294		collection_id: CollectionId,2295		item_index: TokenId,2296		owner: &T::CrossAccountId,2297	) -> DispatchResult {2298		// update counter2299		<AccountItemCount<T>>::insert(2300			owner.as_sub(),2301			<AccountItemCount<T>>::get(owner.as_sub())2302				.checked_sub(1)2303				.ok_or(Error::<T>::NumOverflow)?,2304		);23052306		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2307		if list_exists {2308			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2309			let item_contains = list.contains(&item_index.clone());23102311			if item_contains {2312				list.retain(|&item| item != item_index);2313				<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2314			}2315		}23162317		Ok(())2318	}23192320	fn move_token_index(2321		collection_id: CollectionId,2322		item_index: TokenId,2323		old_owner: &T::CrossAccountId,2324		new_owner: &T::CrossAccountId,2325	) -> DispatchResult {2326		Self::remove_token_index(collection_id, item_index, old_owner)?;2327		Self::add_token_index(collection_id, item_index, new_owner)?;23282329		Ok(())2330	}2331}23322333sp_api::decl_runtime_apis! {2334	pub trait NftApi {2335		/// Used for ethereum integration2336		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2337	}2338}