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

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	}179}180181pub struct CollectionHandle<T: Config> {182	pub id: CollectionId,183	collection: Collection<T>,184	logs: eth::log::LogRecorder,185	evm_address: H160,186	gas_limit: RefCell<u64>,187}188impl<T: Config> CollectionHandle<T> {189	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {190		<CollectionById<T>>::get(id).map(|collection| Self {191			id,192			collection,193			logs: eth::log::LogRecorder::default(),194			evm_address: eth::collection_id_to_address(id),195			gas_limit: RefCell::new(gas_limit),196		})197	}198	pub fn get(id: CollectionId) -> Option<Self> {199		Self::get_with_gas_limit(id, u64::MAX)200	}201	pub fn gas_left(&self) -> u64 {202		*self.gas_limit.borrow()203	}204	pub fn consume_gas(&self, gas: u64) -> DispatchResult {205		let mut gas_limit = self.gas_limit.borrow_mut();206		if *gas_limit < gas {207			fail!(Error::<T>::OutOfGas);208		}209		*gas_limit -= gas;210		Ok(())211	}212	pub fn log(&self, log: impl evm_coder::ToLog) {213		self.logs.log(log.to_log(self.evm_address))214	}215	pub fn into_inner(self) -> Collection<T> {216		self.collection217	}218}219impl<T: Config> Deref for CollectionHandle<T> {220	type Target = Collection<T>;221222	fn deref(&self) -> &Self::Target {223		&self.collection224	}225}226227impl<T: Config> DerefMut for CollectionHandle<T> {228	fn deref_mut(&mut self) -> &mut Self::Target {229		&mut self.collection230	}231}232233pub trait Config: system::Config + Sized {234	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;235236	/// Weight information for extrinsics in this pallet.237	type WeightInfo: WeightInfo;238239	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;240	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;241242	type CrossAccountId: CrossAccountId<Self::AccountId>;243	type Currency: Currency<Self::AccountId>;244	type CollectionCreationPrice: Get<245		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,246	>;247	type TreasuryAccountId: Get<Self::AccountId>;248249	type EthereumChainId: Get<u64>;250	type EthereumTransactionSender: pallet_ethereum::EthereumTransactionSender;251}252253// # Used definitions254//255// ## User control levels256//257// chain-controlled - key is uncontrolled by user258//                    i.e autoincrementing index259//                    can use non-cryptographic hash260// real - key is controlled by user261//        but it is hard to generate enough colliding values, i.e owner of signed txs262//        can use non-cryptographic hash263// controlled - key is completly controlled by users264//              i.e maps with mutable keys265//              should use cryptographic hash266//267// ## User control level downgrade reasons268//269// ?1 - chain-controlled -> controlled270//      collections/tokens can be destroyed, resulting in massive holes271// ?2 - chain-controlled -> controlled272//      same as ?1, but can be only added, resulting in easier exploitation273// ?3 - real -> controlled274//      no confirmation required, so addresses can be easily generated275decl_storage! {276	trait Store for Module<T: Config> as Nft {277278		//#region Private members279		/// Id of next collection280		CreatedCollectionCount: u32;281		/// Used for migrations282		ChainVersion: u64;283		/// Id of last collection token284		/// Collection id (controlled?1)285		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;286		//#endregion287288		//#region Chain limits struct289		pub ChainLimit get(fn chain_limit) config(): ChainLimits;290		//#endregion291292		//#region Bound counters293		/// Amount of collections destroyed, used for total amount tracking with294		/// CreatedCollectionCount295		DestroyedCollectionCount: u32;296		/// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)297		/// Account id (real)298		pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;299		//#endregion300301		//#region Basic collections302		/// Collection info303		/// Collection id (controlled?1)304		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;305		/// List of collection admins306		/// Collection id (controlled?2)307		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;308		/// Whitelisted collection users309		/// Collection id (controlled?2), user id (controlled?3)310		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;311		//#endregion312313		/// How many of collection items user have314		/// Collection id (controlled?2), account id (real)315		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;316317		/// Amount of items which spender can transfer out of owners account (via transferFrom)318		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))319		/// TODO: Off chain worker should remove from this map when token gets removed320		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;321322		//#region Item collections323		/// Collection id (controlled?2), token id (controlled?1)324		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;325		/// Collection id (controlled?2), owner (controlled?2)326		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;327		/// Collection id (controlled?2), token id (controlled?1)328		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;329		//#endregion330331		//#region Index list332		/// Collection id (controlled?2), tokens owner (controlled?2)333		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;334		//#endregion335336		//#region Tokens transfer rate limit baskets337		/// (Collection id (controlled?2), who created (real))338		/// TODO: Off chain worker should remove from this map when collection gets removed339		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;340		/// Collection id (controlled?2), token id (controlled?2)341		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;342		/// Collection id (controlled?2), owning user (real)343		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;344		/// Collection id (controlled?2), token id (controlled?2)345		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;346		//#endregion347348		/// Variable metadata sponsoring349		/// Collection id (controlled?2), token id (controlled?2)350		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;351	}352	add_extra_genesis {353		build(|config: &GenesisConfig<T>| {354			// Modification of storage355			for (_num, _c) in &config.collection_id {356				<Module<T>>::init_collection(_c);357			}358359			for (_num, _c, _i) in &config.nft_item_id {360				<Module<T>>::init_nft_token(*_c, _i);361			}362363			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {364				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);365			}366367			for (_num, _c, _i) in &config.refungible_item_id {368				<Module<T>>::init_refungible_token(*_c, _i);369			}370		})371	}372}373374decl_event!(375	pub enum Event<T>376	where377		AccountId = <T as frame_system::Config>::AccountId,378		CrossAccountId = <T as Config>::CrossAccountId,379	{380		/// New collection was created381		///382		/// # Arguments383		///384		/// * collection_id: Globally unique identifier of newly created collection.385		///386		/// * mode: [CollectionMode] converted into u8.387		///388		/// * account_id: Collection owner.389		CollectionCreated(CollectionId, u8, AccountId),390391		/// New item was created.392		///393		/// # Arguments394		///395		/// * collection_id: Id of the collection where item was created.396		///397		/// * item_id: Id of an item. Unique within the collection.398		///399		/// * recipient: Owner of newly created item400		ItemCreated(CollectionId, TokenId, CrossAccountId),401402		/// Collection item was burned.403		///404		/// # Arguments405		///406		/// collection_id.407		///408		/// item_id: Identifier of burned NFT.409		ItemDestroyed(CollectionId, TokenId),410411		/// Item was transferred412		///413		/// * collection_id: Id of collection to which item is belong414		///415		/// * item_id: Id of an item416		///417		/// * sender: Original owner of item418		///419		/// * recipient: New owner of item420		///421		/// * amount: Always 1 for NFT422		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),423424		/// * collection_id425		///426		/// * item_id427		///428		/// * sender429		///430		/// * spender431		///432		/// * amount433		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),434	}435);436437decl_module! {438	pub struct Module<T: Config> for enum Call439	where440		origin: T::Origin441	{442		fn deposit_event() = default;443		type Error = Error<T>;444445		fn on_initialize(_now: T::BlockNumber) -> Weight {446			0447		}448449		/// 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.450		///451		/// # Permissions452		///453		/// * Anyone.454		///455		/// # Arguments456		///457		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.458		///459		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.460		///461		/// * token_prefix: UTF-8 string with token prefix.462		///463		/// * mode: [CollectionMode] collection type and type dependent data.464		// returns collection ID465		#[weight = <T as Config>::WeightInfo::create_collection()]466		#[transactional]467		pub fn create_collection(origin,468								 collection_name: Vec<u16>,469								 collection_description: Vec<u16>,470								 token_prefix: Vec<u8>,471								 mode: CollectionMode) -> DispatchResult {472473			// Anyone can create a collection474			let who = ensure_signed(origin)?;475476			// Take a (non-refundable) deposit of collection creation477			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();478			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(479				&T::TreasuryAccountId::get(),480				T::CollectionCreationPrice::get(),481			));482			<T as Config>::Currency::settle(483				&who,484				imbalance,485				WithdrawReasons::TRANSFER,486				ExistenceRequirement::KeepAlive,487			).map_err(|_| Error::<T>::NoPermission)?;488489			let decimal_points = match mode {490				CollectionMode::Fungible(points) => points,491				_ => 0492			};493494			let chain_limit = ChainLimit::get();495496			let created_count = CreatedCollectionCount::get();497			let destroyed_count = DestroyedCollectionCount::get();498499			// bound Total number of collections500			ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);501502			// check params503			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);504			ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);505			ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);506			ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);507508			// Generate next collection ID509			let next_id = created_count510				.checked_add(1)511				.ok_or(Error::<T>::NumOverflow)?;512513			CreatedCollectionCount::put(next_id);514515			let limits = CollectionLimits {516				sponsored_data_size: chain_limit.custom_data_limit,517				..Default::default()518			};519520			// Create new collection521			let new_collection = Collection {522				owner: who.clone(),523				name: collection_name,524				mode: mode.clone(),525				mint_mode: false,526				access: AccessMode::Normal,527				description: collection_description,528				decimal_points,529				token_prefix,530				offchain_schema: Vec::new(),531				schema_version: SchemaVersion::ImageURL,532				sponsorship: SponsorshipState::Disabled,533				variable_on_chain_schema: Vec::new(),534				const_on_chain_schema: Vec::new(),535				limits,536			};537538			// Add new collection to map539			<CollectionById<T>>::insert(next_id, new_collection);540541			// call event542			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));543544			Ok(())545		}546547		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.548		///549		/// # Permissions550		///551		/// * Collection Owner.552		///553		/// # Arguments554		///555		/// * collection_id: collection to destroy.556		#[weight = <T as Config>::WeightInfo::destroy_collection()]557		#[transactional]558		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {559560			let sender = ensure_signed(origin)?;561			let collection = Self::get_collection(collection_id)?;562			Self::check_owner_permissions(&collection, &sender)?;563			if !collection.limits.owner_can_destroy {564				fail!(Error::<T>::NoPermission);565			}566567			<AddressTokens<T>>::remove_prefix(collection_id);568			<Allowances<T>>::remove_prefix(collection_id);569			<Balance<T>>::remove_prefix(collection_id);570			<ItemListIndex>::remove(collection_id);571			<AdminList<T>>::remove(collection_id);572			<CollectionById<T>>::remove(collection_id);573			<WhiteList<T>>::remove_prefix(collection_id);574575			<NftItemList<T>>::remove_prefix(collection_id);576			<FungibleItemList<T>>::remove_prefix(collection_id);577			<ReFungibleItemList<T>>::remove_prefix(collection_id);578579			<NftTransferBasket<T>>::remove_prefix(collection_id);580			<FungibleTransferBasket<T>>::remove_prefix(collection_id);581			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id);582583			<VariableMetaDataBasket<T>>::remove_prefix(collection_id);584585			DestroyedCollectionCount::put(DestroyedCollectionCount::get()586				.checked_add(1)587				.ok_or(Error::<T>::NumOverflow)?);588589			Ok(())590		}591592		/// Add an address to white list.593		///594		/// # Permissions595		///596		/// * Collection Owner597		/// * Collection Admin598		///599		/// # Arguments600		///601		/// * collection_id.602		///603		/// * address.604		#[weight = <T as Config>::WeightInfo::add_to_white_list()]605		#[transactional]606		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{607608			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);609			let collection = Self::get_collection(collection_id)?;610611			Self::toggle_white_list_internal(612				&sender,613				&collection,614				&address,615				true,616			)?;617618			Ok(())619		}620621		/// Remove an address from white list.622		///623		/// # Permissions624		///625		/// * Collection Owner626		/// * Collection Admin627		///628		/// # Arguments629		///630		/// * collection_id.631		///632		/// * address.633		#[weight = <T as Config>::WeightInfo::remove_from_white_list()]634		#[transactional]635		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{636637			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);638			let collection = Self::get_collection(collection_id)?;639640			Self::toggle_white_list_internal(641				&sender,642				&collection,643				&address,644				false,645			)?;646647			Ok(())648		}649650		/// Toggle between normal and white list access for the methods with access for `Anyone`.651		///652		/// # Permissions653		///654		/// * Collection Owner.655		///656		/// # Arguments657		///658		/// * collection_id.659		///660		/// * mode: [AccessMode]661		#[weight = <T as Config>::WeightInfo::set_public_access_mode()]662		#[transactional]663		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult664		{665			let sender = ensure_signed(origin)?;666667			let mut target_collection = Self::get_collection(collection_id)?;668			Self::check_owner_permissions(&target_collection, &sender)?;669			target_collection.access = mode;670			Self::save_collection(target_collection);671672			Ok(())673		}674675		/// Allows Anyone to create tokens if:676		/// * White List is enabled, and677		/// * Address is added to white list, and678		/// * This method was called with True parameter679		///680		/// # Permissions681		/// * Collection Owner682		///683		/// # Arguments684		///685		/// * collection_id.686		///687		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.688		#[weight = <T as Config>::WeightInfo::set_mint_permission()]689		#[transactional]690		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult691		{692			let sender = ensure_signed(origin)?;693694			let mut target_collection = Self::get_collection(collection_id)?;695			Self::check_owner_permissions(&target_collection, &sender)?;696			target_collection.mint_mode = mint_permission;697			Self::save_collection(target_collection);698699			Ok(())700		}701702		/// Change the owner of the collection.703		///704		/// # Permissions705		///706		/// * Collection Owner.707		///708		/// # Arguments709		///710		/// * collection_id.711		///712		/// * new_owner.713		#[weight = <T as Config>::WeightInfo::change_collection_owner()]714		#[transactional]715		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {716717			let sender = ensure_signed(origin)?;718			let mut target_collection = Self::get_collection(collection_id)?;719			Self::check_owner_permissions(&target_collection, &sender)?;720			target_collection.owner = new_owner;721			Self::save_collection(target_collection);722723			Ok(())724		}725726		/// Adds an admin of the Collection.727		/// 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.728		///729		/// # Permissions730		///731		/// * Collection Owner.732		/// * Collection Admin.733		///734		/// # Arguments735		///736		/// * collection_id: ID of the Collection to add admin for.737		///738		/// * new_admin_id: Address of new admin to add.739		#[weight = <T as Config>::WeightInfo::add_collection_admin()]740		#[transactional]741		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {742			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);743			let collection = Self::get_collection(collection_id)?;744			Self::check_owner_or_admin_permissions(&collection, &sender)?;745			let mut admin_arr = <AdminList<T>>::get(collection_id);746747			match admin_arr.binary_search(&new_admin_id) {748				Ok(_) => {},749				Err(idx) => {750					let limits = ChainLimit::get();751					ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);752					admin_arr.insert(idx, new_admin_id);753					<AdminList<T>>::insert(collection_id, admin_arr);754				}755			}756			Ok(())757		}758759		/// 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.760		///761		/// # Permissions762		///763		/// * Collection Owner.764		/// * Collection Admin.765		///766		/// # Arguments767		///768		/// * collection_id: ID of the Collection to remove admin for.769		///770		/// * account_id: Address of admin to remove.771		#[weight = <T as Config>::WeightInfo::remove_collection_admin()]772		#[transactional]773		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {774			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);775			let collection = Self::get_collection(collection_id)?;776			Self::check_owner_or_admin_permissions(&collection, &sender)?;777			let mut admin_arr = <AdminList<T>>::get(collection_id);778779			if let Ok(idx) = admin_arr.binary_search(&account_id) {780				admin_arr.remove(idx);781				<AdminList<T>>::insert(collection_id, admin_arr);782			}783			Ok(())784		}785786		/// # Permissions787		///788		/// * Collection Owner789		///790		/// # Arguments791		///792		/// * collection_id.793		///794		/// * new_sponsor.795		#[weight = <T as Config>::WeightInfo::set_collection_sponsor()]796		#[transactional]797		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {798			let sender = ensure_signed(origin)?;799			let mut target_collection = Self::get_collection(collection_id)?;800			Self::check_owner_permissions(&target_collection, &sender)?;801802			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);803			Self::save_collection(target_collection);804805			Ok(())806		}807808		/// # Permissions809		///810		/// * Sponsor.811		///812		/// # Arguments813		///814		/// * collection_id.815		#[weight = <T as Config>::WeightInfo::confirm_sponsorship()]816		#[transactional]817		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {818			let sender = ensure_signed(origin)?;819820			let mut target_collection = Self::get_collection(collection_id)?;821			ensure!(822				target_collection.sponsorship.pending_sponsor() == Some(&sender),823				Error::<T>::ConfirmUnsetSponsorFail824			);825826			target_collection.sponsorship = SponsorshipState::Confirmed(sender);827			Self::save_collection(target_collection);828829			Ok(())830		}831832		/// Switch back to pay-per-own-transaction model.833		///834		/// # Permissions835		///836		/// * Collection owner.837		///838		/// # Arguments839		///840		/// * collection_id.841		#[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]842		#[transactional]843		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844			let sender = ensure_signed(origin)?;845846			let mut target_collection = Self::get_collection(collection_id)?;847			Self::check_owner_permissions(&target_collection, &sender)?;848849			target_collection.sponsorship = SponsorshipState::Disabled;850			Self::save_collection(target_collection);851852			Ok(())853		}854855		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.856		///857		/// # Permissions858		///859		/// * Collection Owner.860		/// * Collection Admin.861		/// * Anyone if862		///     * White List is enabled, and863		///     * Address is added to white list, and864		///     * MintPermission is enabled (see SetMintPermission method)865		///866		/// # Arguments867		///868		/// * collection_id: ID of the collection.869		///870		/// * owner: Address, initial owner of the NFT.871		///872		/// * data: Token data to store on chain.873		// #[weight =874		// (130_000_000 as Weight)875		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))876		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))877		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]878879		#[weight = <T as Config>::WeightInfo::create_item(data.data_size())]880		#[transactional]881		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {882			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);883			let collection = Self::get_collection(collection_id)?;884885			Self::create_item_internal(&sender, &collection, &owner, data)?;886887			// Self::submit_logs(collection)?;888			Ok(())889		}890891		/// This method creates multiple items in a collection created with CreateCollection method.892		///893		/// # Permissions894		///895		/// * Collection Owner.896		/// * Collection Admin.897		/// * Anyone if898		///     * White List is enabled, and899		///     * Address is added to white list, and900		///     * MintPermission is enabled (see SetMintPermission method)901		///902		/// # Arguments903		///904		/// * collection_id: ID of the collection.905		///906		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].907		///908		/// * owner: Address, initial owner of the NFT.909		#[weight = <T as Config>::WeightInfo::create_item(items_data.iter()910							   .map(|data| { data.data_size() })911							   .sum())]912		#[transactional]913		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {914915			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);916			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);917			let collection = Self::get_collection(collection_id)?;918919			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;920921			// Self::submit_logs(collection)?;922			Ok(())923		}924925		/// Destroys a concrete instance of NFT.926		///927		/// # Permissions928		///929		/// * Collection Owner.930		/// * Collection Admin.931		/// * Current NFT Owner.932		///933		/// # Arguments934		///935		/// * collection_id: ID of the collection.936		///937		/// * item_id: ID of NFT to burn.938		#[weight = <T as Config>::WeightInfo::burn_item()]939		#[transactional]940		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {941942			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);943			let target_collection = Self::get_collection(collection_id)?;944945			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;946947			// Self::submit_logs(target_collection)?;948			Ok(())949		}950951		/// Change ownership of the token.952		///953		/// # Permissions954		///955		/// * Collection Owner956		/// * Collection Admin957		/// * Current NFT owner958		///959		/// # Arguments960		///961		/// * recipient: Address of token recipient.962		///963		/// * collection_id.964		///965		/// * item_id: ID of the item966		///     * Non-Fungible Mode: Required.967		///     * Fungible Mode: Ignored.968		///     * Re-Fungible Mode: Required.969		///970		/// * value: Amount to transfer.971		///     * Non-Fungible Mode: Ignored972		///     * Fungible Mode: Must specify transferred amount973		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)974		#[weight = <T as Config>::WeightInfo::transfer()]975		#[transactional]976		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {977			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);978			let collection = Self::get_collection(collection_id)?;979980			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;981982			// Self::submit_logs(collection)?;983			Ok(())984		}985986		/// Set, change, or remove approved address to transfer the ownership of the NFT.987		///988		/// # Permissions989		///990		/// * Collection Owner991		/// * Collection Admin992		/// * Current NFT owner993		///994		/// # Arguments995		///996		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).997		///998		/// * collection_id.999		///1000		/// * item_id: ID of the item.1001		#[weight = <T as Config>::WeightInfo::approve()]1002		#[transactional]1003		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1004			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1005			let collection = Self::get_collection(collection_id)?;10061007			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10081009			// Self::submit_logs(collection)?;1010			Ok(())1011		}10121013		/// 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.1014		///1015		/// # Permissions1016		/// * Collection Owner1017		/// * Collection Admin1018		/// * Current NFT owner1019		/// * Address approved by current NFT owner1020		///1021		/// # Arguments1022		///1023		/// * from: Address that owns token.1024		///1025		/// * recipient: Address of token recipient.1026		///1027		/// * collection_id.1028		///1029		/// * item_id: ID of the item.1030		///1031		/// * value: Amount to transfer.1032		#[weight = <T as Config>::WeightInfo::transfer_from()]1033		#[transactional]1034		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1035			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1036			let collection = Self::get_collection(collection_id)?;10371038			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10391040			// Self::submit_logs(collection)?;1041			Ok(())1042		}1043		// #[weight = 0]1044		//     // let no_perm_mes = "You do not have permissions to modify this collection";1045		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1046		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1047		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10481049		//     // // on_nft_received  call10501051		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10521053		//     Ok(())1054		// }10551056		/// Set off-chain data schema.1057		///1058		/// # Permissions1059		///1060		/// * Collection Owner1061		/// * Collection Admin1062		///1063		/// # Arguments1064		///1065		/// * collection_id.1066		///1067		/// * schema: String representing the offchain data schema.1068		#[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1069		#[transactional]1070		pub fn set_variable_meta_data (1071			origin,1072			collection_id: CollectionId,1073			item_id: TokenId,1074			data: Vec<u8>1075		) -> DispatchResult {1076			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10771078			let collection = Self::get_collection(collection_id)?;10791080			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10811082			Ok(())1083		}10841085		/// Set schema standard1086		/// ImageURL1087		/// Unique1088		///1089		/// # Permissions1090		///1091		/// * Collection Owner1092		/// * Collection Admin1093		///1094		/// # Arguments1095		///1096		/// * collection_id.1097		///1098		/// * schema: SchemaVersion: enum1099		#[weight = <T as Config>::WeightInfo::set_schema_version()]1100		#[transactional]1101		pub fn set_schema_version(1102			origin,1103			collection_id: CollectionId,1104			version: SchemaVersion1105		) -> DispatchResult {1106			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1107			let mut target_collection = Self::get_collection(collection_id)?;1108			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1109			target_collection.schema_version = version;1110			Self::save_collection(target_collection);11111112			Ok(())1113		}11141115		/// Set off-chain data schema.1116		///1117		/// # Permissions1118		///1119		/// * Collection Owner1120		/// * Collection Admin1121		///1122		/// # Arguments1123		///1124		/// * collection_id.1125		///1126		/// * schema: String representing the offchain data schema.1127		#[weight = <T as Config>::WeightInfo::set_offchain_schema()]1128		#[transactional]1129		pub fn set_offchain_schema(1130			origin,1131			collection_id: CollectionId,1132			schema: Vec<u8>1133		) -> DispatchResult {1134			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1135			let mut target_collection = Self::get_collection(collection_id)?;1136			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11371138			// check schema limit1139			ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");11401141			target_collection.offchain_schema = schema;1142			Self::save_collection(target_collection);11431144			Ok(())1145		}11461147		/// Set const on-chain data schema.1148		///1149		/// # Permissions1150		///1151		/// * Collection Owner1152		/// * Collection Admin1153		///1154		/// # Arguments1155		///1156		/// * collection_id.1157		///1158		/// * schema: String representing the const on-chain data schema.1159		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1160		#[transactional]1161		pub fn set_const_on_chain_schema (1162			origin,1163			collection_id: CollectionId,1164			schema: Vec<u8>1165		) -> DispatchResult {1166			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1167			let mut target_collection = Self::get_collection(collection_id)?;1168			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11691170			// check schema limit1171			ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");11721173			target_collection.const_on_chain_schema = schema;1174			Self::save_collection(target_collection);11751176			Ok(())1177		}11781179		/// Set variable on-chain data schema.1180		///1181		/// # Permissions1182		///1183		/// * Collection Owner1184		/// * Collection Admin1185		///1186		/// # Arguments1187		///1188		/// * collection_id.1189		///1190		/// * schema: String representing the variable on-chain data schema.1191		#[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1192		#[transactional]1193		pub fn set_variable_on_chain_schema (1194			origin,1195			collection_id: CollectionId,1196			schema: Vec<u8>1197		) -> DispatchResult {1198			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1199			let mut target_collection = Self::get_collection(collection_id)?;1200			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12011202			// check schema limit1203			ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");12041205			target_collection.variable_on_chain_schema = schema;1206			Self::save_collection(target_collection);12071208			Ok(())1209		}12101211		// Sudo permissions function1212		#[weight = <T as Config>::WeightInfo::set_chain_limits()]1213		#[transactional]1214		pub fn set_chain_limits(1215			origin,1216			limits: ChainLimits1217		) -> DispatchResult {12181219			#[cfg(not(feature = "runtime-benchmarks"))]1220			ensure_root(origin)?;12211222			<ChainLimit>::put(limits);1223			Ok(())1224		}12251226		#[weight = <T as Config>::WeightInfo::set_collection_limits()]1227		#[transactional]1228		pub fn set_collection_limits(1229			origin,1230			collection_id: u32,1231			new_limits: CollectionLimits<T::BlockNumber>,1232		) -> DispatchResult {1233			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1234			let mut target_collection = Self::get_collection(collection_id)?;1235			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1236			let old_limits = &target_collection.limits;1237			let chain_limits = ChainLimit::get();12381239			// collection bounds1240			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1241				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1242				new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1243				Error::<T>::CollectionLimitBoundsExceeded);12441245			// token_limit   check  prev1246			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1247			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12481249			ensure!(1250				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1251				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1252				Error::<T>::OwnerPermissionsCantBeReverted,1253			);12541255			target_collection.limits = new_limits;1256			Self::save_collection(target_collection);12571258			Ok(())1259		}1260	}1261}12621263impl<T: Config> Module<T> {1264	pub fn create_item_internal(1265		sender: &T::CrossAccountId,1266		collection: &CollectionHandle<T>,1267		owner: &T::CrossAccountId,1268		data: CreateItemData,1269	) -> DispatchResult {1270		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1271		Self::validate_create_item_args(collection, &data)?;1272		Self::create_item_no_validation(collection, owner, data)?;12731274		Ok(())1275	}12761277	pub fn transfer_internal(1278		sender: &T::CrossAccountId,1279		recipient: &T::CrossAccountId,1280		target_collection: &CollectionHandle<T>,1281		item_id: TokenId,1282		value: u128,1283	) -> DispatchResult {1284		target_collection.consume_gas(2000000)?;1285		// Limits check1286		Self::is_correct_transfer(target_collection, recipient)?;12871288		// Transfer permissions check1289		ensure!(1290			Self::is_item_owner(sender, target_collection, item_id)1291				|| Self::is_owner_or_admin_permissions(target_collection, sender),1292			Error::<T>::NoPermission1293		);12941295		if target_collection.access == AccessMode::WhiteList {1296			Self::check_white_list(target_collection, sender)?;1297			Self::check_white_list(target_collection, recipient)?;1298		}12991300		match target_collection.mode {1301			CollectionMode::NFT => Self::transfer_nft(1302				target_collection,1303				item_id,1304				sender.clone(),1305				recipient.clone(),1306			)?,1307			CollectionMode::Fungible(_) => {1308				Self::transfer_fungible(target_collection, value, sender, recipient)?1309			}1310			CollectionMode::ReFungible => Self::transfer_refungible(1311				target_collection,1312				item_id,1313				value,1314				sender.clone(),1315				recipient.clone(),1316			)?,1317			_ => (),1318		};13191320		Self::deposit_event(RawEvent::Transfer(1321			target_collection.id,1322			item_id,1323			sender.clone(),1324			recipient.clone(),1325			value,1326		));13271328		Ok(())1329	}13301331	pub fn approve_internal(1332		sender: &T::CrossAccountId,1333		spender: &T::CrossAccountId,1334		collection: &CollectionHandle<T>,1335		item_id: TokenId,1336		amount: u128,1337	) -> DispatchResult {1338		collection.consume_gas(2000000)?;1339		Self::token_exists(collection, item_id)?;13401341		// Transfer permissions check1342		let bypasses_limits = collection.limits.owner_can_transfer1343			&& Self::is_owner_or_admin_permissions(collection, sender);13441345		let allowance_limit = if bypasses_limits {1346			None1347		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id) {1348			Some(amount)1349		} else {1350			fail!(Error::<T>::NoPermission);1351		};13521353		if collection.access == AccessMode::WhiteList {1354			Self::check_white_list(collection, sender)?;1355			Self::check_white_list(collection, spender)?;1356		}13571358		let allowance: u128 = amount1359			.checked_add(<Allowances<T>>::get(1360				collection.id,1361				(item_id, sender.as_sub(), spender.as_sub()),1362			))1363			.ok_or(Error::<T>::NumOverflow)?;1364		if let Some(limit) = allowance_limit {1365			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1366		}1367		<Allowances<T>>::insert(1368			collection.id,1369			(item_id, sender.as_sub(), spender.as_sub()),1370			allowance,1371		);13721373		if matches!(collection.mode, CollectionMode::NFT) {1374			// TODO: NFT: only one owner may exist for token in ERC7211375			collection.log(ERC721Events::Approval {1376				owner: *sender.as_eth(),1377				approved: *spender.as_eth(),1378				token_id: item_id.into(),1379			});1380		}13811382		if matches!(collection.mode, CollectionMode::Fungible(_)) {1383			// TODO: NFT: only one owner may exist for token in ERC201384			collection.log(ERC20Events::Approval {1385				owner: *sender.as_eth(),1386				spender: *spender.as_eth(),1387				value: allowance.into(),1388			});1389		}13901391		Self::deposit_event(RawEvent::Approved(1392			collection.id,1393			item_id,1394			sender.clone(),1395			spender.clone(),1396			allowance,1397		));1398		Ok(())1399	}14001401	pub fn transfer_from_internal(1402		sender: &T::CrossAccountId,1403		from: &T::CrossAccountId,1404		recipient: &T::CrossAccountId,1405		collection: &CollectionHandle<T>,1406		item_id: TokenId,1407		amount: u128,1408	) -> DispatchResult {1409		collection.consume_gas(2000000)?;1410		// Check approval1411		let approval: u128 =1412			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14131414		// Limits check1415		Self::is_correct_transfer(collection, recipient)?;14161417		// Transfer permissions check1418		ensure!(1419			approval >= amount1420				|| (collection.limits.owner_can_transfer1421					&& Self::is_owner_or_admin_permissions(collection, sender)),1422			Error::<T>::NoPermission1423		);14241425		if collection.access == AccessMode::WhiteList {1426			Self::check_white_list(collection, sender)?;1427			Self::check_white_list(collection, recipient)?;1428		}14291430		// Reduce approval by transferred amount or remove if remaining approval drops to 01431		let allowance = approval.saturating_sub(amount);1432		if allowance > 0 {1433			<Allowances<T>>::insert(1434				collection.id,1435				(item_id, from.as_sub(), sender.as_sub()),1436				allowance,1437			);1438		} else {1439			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1440		}14411442		match collection.mode {1443			CollectionMode::NFT => {1444				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1445			}1446			CollectionMode::Fungible(_) => {1447				Self::transfer_fungible(collection, amount, from, recipient)?1448			}1449			CollectionMode::ReFungible => Self::transfer_refungible(1450				collection,1451				item_id,1452				amount,1453				from.clone(),1454				recipient.clone(),1455			)?,1456			_ => (),1457		};14581459		if matches!(collection.mode, CollectionMode::Fungible(_)) {1460			collection.log(ERC20Events::Approval {1461				owner: *from.as_eth(),1462				spender: *sender.as_eth(),1463				value: allowance.into(),1464			});1465		}14661467		Ok(())1468	}14691470	pub fn set_variable_meta_data_internal(1471		sender: &T::CrossAccountId,1472		collection: &CollectionHandle<T>,1473		item_id: TokenId,1474		data: Vec<u8>,1475	) -> DispatchResult {1476		Self::token_exists(collection, item_id)?;14771478		ensure!(1479			ChainLimit::get().custom_data_limit >= data.len() as u32,1480			Error::<T>::TokenVariableDataLimitExceeded1481		);14821483		// Modify permissions check1484		ensure!(1485			Self::is_item_owner(sender, collection, item_id)1486				|| Self::is_owner_or_admin_permissions(collection, sender),1487			Error::<T>::NoPermission1488		);14891490		match collection.mode {1491			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1492			CollectionMode::ReFungible => {1493				Self::set_re_fungible_variable_data(collection, item_id, data)?1494			}1495			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1496			_ => fail!(Error::<T>::UnexpectedCollectionType),1497		};14981499		Ok(())1500	}15011502	pub fn create_multiple_items_internal(1503		sender: &T::CrossAccountId,1504		collection: &CollectionHandle<T>,1505		owner: &T::CrossAccountId,1506		items_data: Vec<CreateItemData>,1507	) -> DispatchResult {1508		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15091510		for data in &items_data {1511			Self::validate_create_item_args(collection, data)?;1512		}1513		for data in &items_data {1514			Self::create_item_no_validation(collection, owner, data.clone())?;1515		}15161517		Ok(())1518	}15191520	pub fn burn_item_internal(1521		sender: &T::CrossAccountId,1522		collection: &CollectionHandle<T>,1523		item_id: TokenId,1524		value: u128,1525	) -> DispatchResult {1526		ensure!(1527			Self::is_item_owner(sender, collection, item_id)1528				|| (collection.limits.owner_can_transfer1529					&& Self::is_owner_or_admin_permissions(collection, sender)),1530			Error::<T>::NoPermission1531		);15321533		if collection.access == AccessMode::WhiteList {1534			Self::check_white_list(collection, sender)?;1535		}15361537		match collection.mode {1538			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1539			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1540			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1541			_ => (),1542		};15431544		Ok(())1545	}15461547	pub fn toggle_white_list_internal(1548		sender: &T::CrossAccountId,1549		collection: &CollectionHandle<T>,1550		address: &T::CrossAccountId,1551		whitelisted: bool,1552	) -> DispatchResult {1553		Self::check_owner_or_admin_permissions(collection, sender)?;15541555		if whitelisted {1556			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1557		} else {1558			<WhiteList<T>>::remove(collection.id, address.as_sub());1559		}15601561		Ok(())1562	}15631564	fn is_correct_transfer(1565		collection: &CollectionHandle<T>,1566		recipient: &T::CrossAccountId,1567	) -> DispatchResult {1568		let collection_id = collection.id;15691570		// check token limit and account token limit1571		let account_items: u32 =1572			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1573		ensure!(1574			collection.limits.account_token_ownership_limit > account_items,1575			Error::<T>::AccountTokenLimitExceeded1576		);15771578		Ok(())1579	}15801581	fn can_create_items_in_collection(1582		collection: &CollectionHandle<T>,1583		sender: &T::CrossAccountId,1584		owner: &T::CrossAccountId,1585		amount: u32,1586	) -> DispatchResult {1587		let collection_id = collection.id;15881589		// check token limit and account token limit1590		let total_items: u32 = ItemListIndex::get(collection_id)1591			.checked_add(amount)1592			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1593		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1594			as u32)1595			.checked_add(amount)1596			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1597		ensure!(1598			collection.limits.token_limit >= total_items,1599			Error::<T>::CollectionTokenLimitExceeded1600		);1601		ensure!(1602			collection.limits.account_token_ownership_limit >= account_items,1603			Error::<T>::AccountTokenLimitExceeded1604		);16051606		if !Self::is_owner_or_admin_permissions(collection, sender) {1607			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1608			Self::check_white_list(collection, owner)?;1609			Self::check_white_list(collection, sender)?;1610		}16111612		Ok(())1613	}16141615	fn validate_create_item_args(1616		target_collection: &CollectionHandle<T>,1617		data: &CreateItemData,1618	) -> DispatchResult {1619		match target_collection.mode {1620			CollectionMode::NFT => {1621				if let CreateItemData::NFT(data) = data {1622					// check sizes1623					ensure!(1624						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1625						Error::<T>::TokenConstDataLimitExceeded1626					);1627					ensure!(1628						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1629						Error::<T>::TokenVariableDataLimitExceeded1630					);1631				} else {1632					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1633				}1634			}1635			CollectionMode::Fungible(_) => {1636				if let CreateItemData::Fungible(_) = data {1637				} else {1638					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1639				}1640			}1641			CollectionMode::ReFungible => {1642				if let CreateItemData::ReFungible(data) = data {1643					// check sizes1644					ensure!(1645						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1646						Error::<T>::TokenConstDataLimitExceeded1647					);1648					ensure!(1649						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1650						Error::<T>::TokenVariableDataLimitExceeded1651					);16521653					// Check refungibility limits1654					ensure!(1655						data.pieces <= MAX_REFUNGIBLE_PIECES,1656						Error::<T>::WrongRefungiblePieces1657					);1658					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1659				} else {1660					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1661				}1662			}1663			_ => {1664				fail!(Error::<T>::UnexpectedCollectionType);1665			}1666		};16671668		Ok(())1669	}16701671	fn create_item_no_validation(1672		collection: &CollectionHandle<T>,1673		owner: &T::CrossAccountId,1674		data: CreateItemData,1675	) -> DispatchResult {1676		match data {1677			CreateItemData::NFT(data) => {1678				let item = NftItemType {1679					owner: owner.clone(),1680					const_data: data.const_data,1681					variable_data: data.variable_data,1682				};16831684				Self::add_nft_item(collection, item)?;1685			}1686			CreateItemData::Fungible(data) => {1687				Self::add_fungible_item(collection, owner, data.value)?;1688			}1689			CreateItemData::ReFungible(data) => {1690				let owner_list = vec![Ownership {1691					owner: owner.clone(),1692					fraction: data.pieces,1693				}];16941695				let item = ReFungibleItemType {1696					owner: owner_list,1697					const_data: data.const_data,1698					variable_data: data.variable_data,1699				};17001701				Self::add_refungible_item(collection, item)?;1702			}1703		};17041705		Ok(())1706	}17071708	fn add_fungible_item(1709		collection: &CollectionHandle<T>,1710		owner: &T::CrossAccountId,1711		value: u128,1712	) -> DispatchResult {1713		let collection_id = collection.id;17141715		// Does new owner already have an account?1716		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17171718		// Mint1719		let item = FungibleItemType {1720			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1721		};1722		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17231724		// Update balance1725		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1726			.checked_add(value)1727			.ok_or(Error::<T>::NumOverflow)?;1728		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17291730		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1731		Ok(())1732	}17331734	fn add_refungible_item(1735		collection: &CollectionHandle<T>,1736		item: ReFungibleItemType<T::CrossAccountId>,1737	) -> DispatchResult {1738		let collection_id = collection.id;17391740		let current_index = <ItemListIndex>::get(collection_id)1741			.checked_add(1)1742			.ok_or(Error::<T>::NumOverflow)?;1743		let itemcopy = item.clone();17441745		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1746		let item_owner = item.owner.first().expect("only one owner is defined");17471748		let value = item_owner.fraction;1749		let owner = item_owner.owner.clone();17501751		Self::add_token_index(collection_id, current_index, &owner)?;17521753		<ItemListIndex>::insert(collection_id, current_index);1754		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17551756		// Update balance1757		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1758			.checked_add(value)1759			.ok_or(Error::<T>::NumOverflow)?;1760		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17611762		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1763		Ok(())1764	}17651766	fn add_nft_item(1767		collection: &CollectionHandle<T>,1768		item: NftItemType<T::CrossAccountId>,1769	) -> DispatchResult {1770		let collection_id = collection.id;17711772		let current_index = <ItemListIndex>::get(collection_id)1773			.checked_add(1)1774			.ok_or(Error::<T>::NumOverflow)?;17751776		let item_owner = item.owner.clone();1777		Self::add_token_index(collection_id, current_index, &item.owner)?;17781779		<ItemListIndex>::insert(collection_id, current_index);1780		<NftItemList<T>>::insert(collection_id, current_index, item);17811782		// Update balance1783		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1784			.checked_add(1)1785			.ok_or(Error::<T>::NumOverflow)?;1786		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17871788		collection.log(ERC721Events::Transfer {1789			from: H160::default(),1790			to: *item_owner.as_eth(),1791			token_id: current_index.into(),1792		});1793		Self::deposit_event(RawEvent::ItemCreated(1794			collection_id,1795			current_index,1796			item_owner,1797		));1798		Ok(())1799	}18001801	fn burn_refungible_item(1802		collection: &CollectionHandle<T>,1803		item_id: TokenId,1804		owner: &T::CrossAccountId,1805	) -> DispatchResult {1806		let collection_id = collection.id;18071808		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1809			.ok_or(Error::<T>::TokenNotFound)?;1810		let rft_balance = token1811			.owner1812			.iter()1813			.find(|&i| i.owner == *owner)1814			.ok_or(Error::<T>::TokenNotFound)?;1815		Self::remove_token_index(collection_id, item_id, owner)?;18161817		// update balance1818		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1819			.checked_sub(rft_balance.fraction)1820			.ok_or(Error::<T>::NumOverflow)?;1821		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18221823		// Re-create owners list with sender removed1824		let index = token1825			.owner1826			.iter()1827			.position(|i| i.owner == *owner)1828			.expect("owned item is exists");1829		token.owner.remove(index);1830		let owner_count = token.owner.len();18311832		// Burn the token completely if this was the last (only) owner1833		if owner_count == 0 {1834			<ReFungibleItemList<T>>::remove(collection_id, item_id);1835			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1836		} else {1837			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1838		}18391840		Ok(())1841	}18421843	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1844		let collection_id = collection.id;18451846		let item =1847			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1848		Self::remove_token_index(collection_id, item_id, &item.owner)?;18491850		// update balance1851		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1852			.checked_sub(1)1853			.ok_or(Error::<T>::NumOverflow)?;1854		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1855		<NftItemList<T>>::remove(collection_id, item_id);1856		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);18571858		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1859		Ok(())1860	}18611862	fn burn_fungible_item(1863		owner: &T::CrossAccountId,1864		collection: &CollectionHandle<T>,1865		value: u128,1866	) -> DispatchResult {1867		let collection_id = collection.id;18681869		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1870		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18711872		// update balance1873		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1874			.checked_sub(value)1875			.ok_or(Error::<T>::NumOverflow)?;1876		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18771878		if balance.value - value > 0 {1879			balance.value -= value;1880			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1881		} else {1882			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1883		}18841885		collection.log(ERC20Events::Transfer {1886			from: *owner.as_eth(),1887			to: H160::default(),1888			value: value.into(),1889		});1890		Ok(())1891	}18921893	pub fn get_collection(1894		collection_id: CollectionId,1895	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1896		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1897	}18981899	fn save_collection(collection: CollectionHandle<T>) {1900		<CollectionById<T>>::insert(collection.id, collection.into_inner());1901	}19021903	pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {1904		if collection.logs.is_empty() {1905			return Ok(());1906		}1907		T::EthereumTransactionSender::submit_logs_transaction(1908			eth::generate_transaction(collection.id, T::EthereumChainId::get()),1909			collection.logs.retrieve_logs(),1910		)1911	}19121913	fn check_owner_permissions(1914		target_collection: &CollectionHandle<T>,1915		subject: &T::AccountId,1916	) -> DispatchResult {1917		ensure!(1918			*subject == target_collection.owner,1919			Error::<T>::NoPermission1920		);19211922		Ok(())1923	}19241925	fn is_owner_or_admin_permissions(1926		collection: &CollectionHandle<T>,1927		subject: &T::CrossAccountId,1928	) -> bool {1929		*subject.as_sub() == collection.owner1930			|| <AdminList<T>>::get(collection.id).contains(subject)1931	}19321933	fn check_owner_or_admin_permissions(1934		collection: &CollectionHandle<T>,1935		subject: &T::CrossAccountId,1936	) -> DispatchResult {1937		ensure!(1938			Self::is_owner_or_admin_permissions(collection, subject),1939			Error::<T>::NoPermission1940		);19411942		Ok(())1943	}19441945	fn owned_amount(1946		subject: &T::CrossAccountId,1947		target_collection: &CollectionHandle<T>,1948		item_id: TokenId,1949	) -> Option<u128> {1950		let collection_id = target_collection.id;19511952		match target_collection.mode {1953			CollectionMode::NFT => {1954				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1955			}1956			CollectionMode::Fungible(_) => {1957				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1958			}1959			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1960				.owner1961				.iter()1962				.find(|i| i.owner == *subject)1963				.map(|i| i.fraction),1964			CollectionMode::Invalid => None,1965		}1966	}19671968	fn is_item_owner(1969		subject: &T::CrossAccountId,1970		target_collection: &CollectionHandle<T>,1971		item_id: TokenId,1972	) -> bool {1973		match target_collection.mode {1974			CollectionMode::Fungible(_) => true,1975			_ => Self::owned_amount(subject, target_collection, item_id).is_some(),1976		}1977	}19781979	fn check_white_list(1980		collection: &CollectionHandle<T>,1981		address: &T::CrossAccountId,1982	) -> DispatchResult {1983		let collection_id = collection.id;19841985		let mes = Error::<T>::AddresNotInWhiteList;1986		ensure!(1987			<WhiteList<T>>::contains_key(collection_id, address.as_sub()),1988			mes1989		);19901991		Ok(())1992	}19931994	/// Check if token exists. In case of Fungible, check if there is an entry for1995	/// the owner in fungible balances double map1996	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1997		let collection_id = target_collection.id;1998		let exists = match target_collection.mode {1999			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2000			CollectionMode::Fungible(_) => true,2001			CollectionMode::ReFungible => {2002				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2003			}2004			_ => false,2005		};20062007		ensure!(exists, Error::<T>::TokenNotFound);2008		Ok(())2009	}20102011	fn transfer_fungible(2012		collection: &CollectionHandle<T>,2013		value: u128,2014		owner: &T::CrossAccountId,2015		recipient: &T::CrossAccountId,2016	) -> DispatchResult {2017		let collection_id = collection.id;20182019		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2020		ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20212022		// Send balance to recipient (updates balanceOf of recipient)2023		Self::add_fungible_item(collection, recipient, value)?;20242025		// update balanceOf of sender2026		<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);20272028		// Reduce or remove sender2029		if balance.value == value {2030			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2031		} else {2032			balance.value -= value;2033			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2034		}20352036		collection.log(ERC20Events::Transfer {2037			from: *owner.as_eth(),2038			to: *recipient.as_eth(),2039			value: value.into(),2040		});2041		Self::deposit_event(RawEvent::Transfer(2042			collection.id,2043			1,2044			owner.clone(),2045			recipient.clone(),2046			value,2047		));20482049		Ok(())2050	}20512052	fn transfer_refungible(2053		collection: &CollectionHandle<T>,2054		item_id: TokenId,2055		value: u128,2056		owner: T::CrossAccountId,2057		new_owner: T::CrossAccountId,2058	) -> DispatchResult {2059		let collection_id = collection.id;2060		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2061			.ok_or(Error::<T>::TokenNotFound)?;20622063		let item = full_item2064			.owner2065			.iter()2066			.find(|i| i.owner == owner)2067			.ok_or(Error::<T>::TokenNotFound)?;2068		let amount = item.fraction;20692070		ensure!(amount >= value, Error::<T>::TokenValueTooLow);20712072		// update balance2073		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2074			.checked_sub(value)2075			.ok_or(Error::<T>::NumOverflow)?;2076		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20772078		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2079			.checked_add(value)2080			.ok_or(Error::<T>::NumOverflow)?;2081		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20822083		let old_owner = item.owner.clone();2084		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20852086		let mut new_full_item = full_item.clone();2087		// transfer2088		if amount == value && !new_owner_has_account {2089			// change owner2090			// new owner do not have account2091			new_full_item2092				.owner2093				.iter_mut()2094				.find(|i| i.owner == owner)2095				.expect("old owner does present in refungible")2096				.owner = new_owner.clone();2097			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20982099			// update index collection2100			Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2101		} else {2102			new_full_item2103				.owner2104				.iter_mut()2105				.find(|i| i.owner == owner)2106				.expect("old owner does present in refungible")2107				.fraction -= value;21082109			// separate amount2110			if new_owner_has_account {2111				// new owner has account2112				new_full_item2113					.owner2114					.iter_mut()2115					.find(|i| i.owner == new_owner)2116					.expect("new owner has account")2117					.fraction += value;2118			} else {2119				// new owner do not have account2120				new_full_item.owner.push(Ownership {2121					owner: new_owner.clone(),2122					fraction: value,2123				});2124				Self::add_token_index(collection_id, item_id, &new_owner)?;2125			}21262127			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2128		}21292130		Self::deposit_event(RawEvent::Transfer(2131			collection.id,2132			item_id,2133			owner,2134			new_owner,2135			amount,2136		));21372138		Ok(())2139	}21402141	fn transfer_nft(2142		collection: &CollectionHandle<T>,2143		item_id: TokenId,2144		sender: T::CrossAccountId,2145		new_owner: T::CrossAccountId,2146	) -> DispatchResult {2147		let collection_id = collection.id;2148		let mut item =2149			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21502151		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21522153		// update balance2154		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2155			.checked_sub(1)2156			.ok_or(Error::<T>::NumOverflow)?;2157		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21582159		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2160			.checked_add(1)2161			.ok_or(Error::<T>::NumOverflow)?;2162		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21632164		// change owner2165		let old_owner = item.owner.clone();2166		item.owner = new_owner.clone();2167		<NftItemList<T>>::insert(collection_id, item_id, item);21682169		// update index collection2170		Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21712172		collection.log(ERC721Events::Transfer {2173			from: *sender.as_eth(),2174			to: *new_owner.as_eth(),2175			token_id: item_id.into(),2176		});2177		Self::deposit_event(RawEvent::Transfer(2178			collection.id,2179			item_id,2180			sender,2181			new_owner,2182			1,2183		));21842185		Ok(())2186	}21872188	fn set_re_fungible_variable_data(2189		collection: &CollectionHandle<T>,2190		item_id: TokenId,2191		data: Vec<u8>,2192	) -> DispatchResult {2193		let collection_id = collection.id;2194		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2195			.ok_or(Error::<T>::TokenNotFound)?;21962197		item.variable_data = data;21982199		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22002201		Ok(())2202	}22032204	fn set_nft_variable_data(2205		collection: &CollectionHandle<T>,2206		item_id: TokenId,2207		data: Vec<u8>,2208	) -> DispatchResult {2209		let collection_id = collection.id;2210		let mut item =2211			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22122213		item.variable_data = data;22142215		<NftItemList<T>>::insert(collection_id, item_id, item);22162217		Ok(())2218	}22192220	#[allow(dead_code)]2221	fn init_collection(item: &Collection<T>) {2222		// check params2223		assert!(2224			item.decimal_points <= MAX_DECIMAL_POINTS,2225			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2226		);2227		assert!(2228			item.name.len() <= 64,2229			"Collection name can not be longer than 63 char"2230		);2231		assert!(2232			item.name.len() <= 256,2233			"Collection description can not be longer than 255 char"2234		);2235		assert!(2236			item.token_prefix.len() <= 16,2237			"Token prefix can not be longer than 15 char"2238		);22392240		// Generate next collection ID2241		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22422243		CreatedCollectionCount::put(next_id);2244	}22452246	#[allow(dead_code)]2247	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2248		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22492250		Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22512252		<ItemListIndex>::insert(collection_id, current_index);22532254		// Update balance2255		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2256			.checked_add(1)2257			.unwrap();2258		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2259	}22602261	#[allow(dead_code)]2262	fn init_fungible_token(2263		collection_id: CollectionId,2264		owner: &T::CrossAccountId,2265		item: &FungibleItemType,2266	) {2267		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22682269		Self::add_token_index(collection_id, current_index, owner).unwrap();22702271		<ItemListIndex>::insert(collection_id, current_index);22722273		// Update balance2274		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2275			.checked_add(item.value)2276			.unwrap();2277		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2278	}22792280	#[allow(dead_code)]2281	fn init_refungible_token(2282		collection_id: CollectionId,2283		item: &ReFungibleItemType<T::CrossAccountId>,2284	) {2285		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22862287		let value = item.owner.first().unwrap().fraction;2288		let owner = item.owner.first().unwrap().owner.clone();22892290		Self::add_token_index(collection_id, current_index, &owner).unwrap();22912292		<ItemListIndex>::insert(collection_id, current_index);22932294		// Update balance2295		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2296			.checked_add(value)2297			.unwrap();2298		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2299	}23002301	fn add_token_index(2302		collection_id: CollectionId,2303		item_index: TokenId,2304		owner: &T::CrossAccountId,2305	) -> DispatchResult {2306		// add to account limit2307		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2308			// bound Owned tokens by a single address2309			let count = <AccountItemCount<T>>::get(owner.as_sub());2310			ensure!(2311				count < ChainLimit::get().account_token_ownership_limit,2312				Error::<T>::AddressOwnershipLimitExceeded2313			);23142315			<AccountItemCount<T>>::insert(2316				owner.as_sub(),2317				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2318			);2319		} else {2320			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2321		}23222323		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2324		if list_exists {2325			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2326			let item_contains = list.contains(&item_index.clone());23272328			if !item_contains {2329				list.push(item_index);2330			}23312332			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2333		} else {2334			let itm = vec![item_index];2335			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2336		}23372338		Ok(())2339	}23402341	fn remove_token_index(2342		collection_id: CollectionId,2343		item_index: TokenId,2344		owner: &T::CrossAccountId,2345	) -> DispatchResult {2346		// update counter2347		<AccountItemCount<T>>::insert(2348			owner.as_sub(),2349			<AccountItemCount<T>>::get(owner.as_sub())2350				.checked_sub(1)2351				.ok_or(Error::<T>::NumOverflow)?,2352		);23532354		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2355		if list_exists {2356			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2357			let item_contains = list.contains(&item_index.clone());23582359			if item_contains {2360				list.retain(|&item| item != item_index);2361				<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2362			}2363		}23642365		Ok(())2366	}23672368	fn move_token_index(2369		collection_id: CollectionId,2370		item_index: TokenId,2371		old_owner: &T::CrossAccountId,2372		new_owner: &T::CrossAccountId,2373	) -> DispatchResult {2374		Self::remove_token_index(collection_id, item_index, old_owner)?;2375		Self::add_token_index(collection_id, item_index, new_owner)?;23762377		Ok(())2378	}2379}23802381sp_api::decl_runtime_apis! {2382	pub trait NftApi {2383		/// Used for ethereum integration2384		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2385	}2386}