git.delta.rocks / unique-network / refs/commits / 4e76702c569f

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(1509			&collection,1510			&sender,1511			&owner,1512			items_data.len() as u32,1513		)?;15141515		for data in &items_data {1516			Self::validate_create_item_args(&collection, data)?;1517		}1518		for data in &items_data {1519			Self::create_item_no_validation(&collection, owner, data.clone())?;1520		}15211522		Ok(())1523	}15241525	pub fn burn_item_internal(1526		sender: &T::CrossAccountId,1527		collection: &CollectionHandle<T>,1528		item_id: TokenId,1529		value: u128,1530	) -> DispatchResult {1531		ensure!(1532			Self::is_item_owner(&sender, &collection, item_id)1533				|| (collection.limits.owner_can_transfer1534					&& Self::is_owner_or_admin_permissions(&collection, &sender)),1535			Error::<T>::NoPermission1536		);15371538		if collection.access == AccessMode::WhiteList {1539			Self::check_white_list(&collection, &sender)?;1540		}15411542		match collection.mode {1543			CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1544			CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &collection, value)?,1545			CollectionMode::ReFungible => {1546				Self::burn_refungible_item(&collection, item_id, &sender)?1547			}1548			_ => (),1549		};15501551		Ok(())1552	}15531554	pub fn toggle_white_list_internal(1555		sender: &T::CrossAccountId,1556		collection: &CollectionHandle<T>,1557		address: &T::CrossAccountId,1558		whitelisted: bool,1559	) -> DispatchResult {1560		Self::check_owner_or_admin_permissions(&collection, &sender)?;15611562		if whitelisted {1563			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1564		} else {1565			<WhiteList<T>>::remove(collection.id, address.as_sub());1566		}15671568		Ok(())1569	}15701571	fn is_correct_transfer(1572		collection: &CollectionHandle<T>,1573		recipient: &T::CrossAccountId,1574	) -> DispatchResult {1575		let collection_id = collection.id;15761577		// check token limit and account token limit1578		let account_items: u32 =1579			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1580		ensure!(1581			collection.limits.account_token_ownership_limit > account_items,1582			Error::<T>::AccountTokenLimitExceeded1583		);15841585		Ok(())1586	}15871588	fn can_create_items_in_collection(1589		collection: &CollectionHandle<T>,1590		sender: &T::CrossAccountId,1591		owner: &T::CrossAccountId,1592		amount: u32,1593	) -> DispatchResult {1594		let collection_id = collection.id;15951596		// check token limit and account token limit1597		let total_items: u32 = ItemListIndex::get(collection_id)1598			.checked_add(amount)1599			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1600		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1601			as u32)1602			.checked_add(amount)1603			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1604		ensure!(1605			collection.limits.token_limit >= total_items,1606			Error::<T>::CollectionTokenLimitExceeded1607		);1608		ensure!(1609			collection.limits.account_token_ownership_limit >= account_items,1610			Error::<T>::AccountTokenLimitExceeded1611		);16121613		if !Self::is_owner_or_admin_permissions(collection, &sender) {1614			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1615			Self::check_white_list(collection, owner)?;1616			Self::check_white_list(collection, sender)?;1617		}16181619		Ok(())1620	}16211622	fn validate_create_item_args(1623		target_collection: &CollectionHandle<T>,1624		data: &CreateItemData,1625	) -> DispatchResult {1626		match target_collection.mode {1627			CollectionMode::NFT => {1628				if let CreateItemData::NFT(data) = data {1629					// check sizes1630					ensure!(1631						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1632						Error::<T>::TokenConstDataLimitExceeded1633					);1634					ensure!(1635						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1636						Error::<T>::TokenVariableDataLimitExceeded1637					);1638				} else {1639					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1640				}1641			}1642			CollectionMode::Fungible(_) => {1643				if let CreateItemData::Fungible(_) = data {1644				} else {1645					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1646				}1647			}1648			CollectionMode::ReFungible => {1649				if let CreateItemData::ReFungible(data) = data {1650					// check sizes1651					ensure!(1652						ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1653						Error::<T>::TokenConstDataLimitExceeded1654					);1655					ensure!(1656						ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1657						Error::<T>::TokenVariableDataLimitExceeded1658					);16591660					// Check refungibility limits1661					ensure!(1662						data.pieces <= MAX_REFUNGIBLE_PIECES,1663						Error::<T>::WrongRefungiblePieces1664					);1665					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1666				} else {1667					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1668				}1669			}1670			_ => {1671				fail!(Error::<T>::UnexpectedCollectionType);1672			}1673		};16741675		Ok(())1676	}16771678	fn create_item_no_validation(1679		collection: &CollectionHandle<T>,1680		owner: &T::CrossAccountId,1681		data: CreateItemData,1682	) -> DispatchResult {1683		match data {1684			CreateItemData::NFT(data) => {1685				let item = NftItemType {1686					owner: owner.clone(),1687					const_data: data.const_data,1688					variable_data: data.variable_data,1689				};16901691				Self::add_nft_item(collection, item)?;1692			}1693			CreateItemData::Fungible(data) => {1694				Self::add_fungible_item(collection, &owner, data.value)?;1695			}1696			CreateItemData::ReFungible(data) => {1697				let owner_list = vec![Ownership {1698					owner: owner.clone(),1699					fraction: data.pieces,1700				}];17011702				let item = ReFungibleItemType {1703					owner: owner_list,1704					const_data: data.const_data,1705					variable_data: data.variable_data,1706				};17071708				Self::add_refungible_item(collection, item)?;1709			}1710		};17111712		Ok(())1713	}17141715	fn add_fungible_item(1716		collection: &CollectionHandle<T>,1717		owner: &T::CrossAccountId,1718		value: u128,1719	) -> DispatchResult {1720		let collection_id = collection.id;17211722		// Does new owner already have an account?1723		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17241725		// Mint1726		let item = FungibleItemType {1727			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1728		};1729		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17301731		// Update balance1732		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1733			.checked_add(value)1734			.ok_or(Error::<T>::NumOverflow)?;1735		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17361737		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1738		Ok(())1739	}17401741	fn add_refungible_item(1742		collection: &CollectionHandle<T>,1743		item: ReFungibleItemType<T::CrossAccountId>,1744	) -> DispatchResult {1745		let collection_id = collection.id;17461747		let current_index = <ItemListIndex>::get(collection_id)1748			.checked_add(1)1749			.ok_or(Error::<T>::NumOverflow)?;1750		let itemcopy = item.clone();17511752		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1753		let item_owner = item.owner.first().expect("only one owner is defined");17541755		let value = item_owner.fraction;1756		let owner = item_owner.owner.clone();17571758		Self::add_token_index(collection_id, current_index, &owner)?;17591760		<ItemListIndex>::insert(collection_id, current_index);1761		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17621763		// Update balance1764		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1765			.checked_add(value)1766			.ok_or(Error::<T>::NumOverflow)?;1767		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17681769		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1770		Ok(())1771	}17721773	fn add_nft_item(1774		collection: &CollectionHandle<T>,1775		item: NftItemType<T::CrossAccountId>,1776	) -> DispatchResult {1777		let collection_id = collection.id;17781779		let current_index = <ItemListIndex>::get(collection_id)1780			.checked_add(1)1781			.ok_or(Error::<T>::NumOverflow)?;17821783		let item_owner = item.owner.clone();1784		Self::add_token_index(collection_id, current_index, &item.owner)?;17851786		<ItemListIndex>::insert(collection_id, current_index);1787		<NftItemList<T>>::insert(collection_id, current_index, item);17881789		// Update balance1790		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1791			.checked_add(1)1792			.ok_or(Error::<T>::NumOverflow)?;1793		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17941795		collection.log(ERC721Events::Transfer {1796			from: H160::default(),1797			to: *item_owner.as_eth(),1798			token_id: current_index.into(),1799		});1800		Self::deposit_event(RawEvent::ItemCreated(1801			collection_id,1802			current_index,1803			item_owner,1804		));1805		Ok(())1806	}18071808	fn burn_refungible_item(1809		collection: &CollectionHandle<T>,1810		item_id: TokenId,1811		owner: &T::CrossAccountId,1812	) -> DispatchResult {1813		let collection_id = collection.id;18141815		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1816			.ok_or(Error::<T>::TokenNotFound)?;1817		let rft_balance = token1818			.owner1819			.iter()1820			.find(|&i| i.owner == *owner)1821			.ok_or(Error::<T>::TokenNotFound)?;1822		Self::remove_token_index(collection_id, item_id, owner)?;18231824		// update balance1825		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1826			.checked_sub(rft_balance.fraction)1827			.ok_or(Error::<T>::NumOverflow)?;1828		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18291830		// Re-create owners list with sender removed1831		let index = token1832			.owner1833			.iter()1834			.position(|i| i.owner == *owner)1835			.expect("owned item is exists");1836		token.owner.remove(index);1837		let owner_count = token.owner.len();18381839		// Burn the token completely if this was the last (only) owner1840		if owner_count == 0 {1841			<ReFungibleItemList<T>>::remove(collection_id, item_id);1842			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1843		} else {1844			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1845		}18461847		Ok(())1848	}18491850	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1851		let collection_id = collection.id;18521853		let item =1854			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1855		Self::remove_token_index(collection_id, item_id, &item.owner)?;18561857		// update balance1858		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1859			.checked_sub(1)1860			.ok_or(Error::<T>::NumOverflow)?;1861		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1862		<NftItemList<T>>::remove(collection_id, item_id);1863		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);18641865		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1866		Ok(())1867	}18681869	fn burn_fungible_item(1870		owner: &T::CrossAccountId,1871		collection: &CollectionHandle<T>,1872		value: u128,1873	) -> DispatchResult {1874		let collection_id = collection.id;18751876		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1877		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18781879		// update balance1880		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1881			.checked_sub(value)1882			.ok_or(Error::<T>::NumOverflow)?;1883		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18841885		if balance.value - value > 0 {1886			balance.value -= value;1887			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1888		} else {1889			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1890		}18911892		collection.log(ERC20Events::Transfer {1893			from: *owner.as_eth(),1894			to: H160::default(),1895			value: value.into(),1896		});1897		Ok(())1898	}18991900	pub fn get_collection(1901		collection_id: CollectionId,1902	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1903		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1904	}19051906	fn save_collection(collection: CollectionHandle<T>) {1907		<CollectionById<T>>::insert(collection.id, collection.into_inner());1908	}19091910	pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {1911		if collection.logs.is_empty() {1912			return Ok(());1913		}1914		T::EthereumTransactionSender::submit_logs_transaction(1915			eth::generate_transaction(collection.id, T::EthereumChainId::get()),1916			collection.logs.retrieve_logs(),1917		)1918	}19191920	fn check_owner_permissions(1921		target_collection: &CollectionHandle<T>,1922		subject: &T::AccountId,1923	) -> DispatchResult {1924		ensure!(1925			*subject == target_collection.owner,1926			Error::<T>::NoPermission1927		);19281929		Ok(())1930	}19311932	fn is_owner_or_admin_permissions(1933		collection: &CollectionHandle<T>,1934		subject: &T::CrossAccountId,1935	) -> bool {1936		*subject.as_sub() == collection.owner1937			|| <AdminList<T>>::get(collection.id).contains(&subject)1938	}19391940	fn check_owner_or_admin_permissions(1941		collection: &CollectionHandle<T>,1942		subject: &T::CrossAccountId,1943	) -> DispatchResult {1944		ensure!(1945			Self::is_owner_or_admin_permissions(collection, subject),1946			Error::<T>::NoPermission1947		);19481949		Ok(())1950	}19511952	fn owned_amount(1953		subject: &T::CrossAccountId,1954		target_collection: &CollectionHandle<T>,1955		item_id: TokenId,1956	) -> Option<u128> {1957		let collection_id = target_collection.id;19581959		match target_collection.mode {1960			CollectionMode::NFT => {1961				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1962			}1963			CollectionMode::Fungible(_) => {1964				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1965			}1966			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1967				.owner1968				.iter()1969				.find(|i| i.owner == *subject)1970				.map(|i| i.fraction),1971			CollectionMode::Invalid => None,1972		}1973	}19741975	fn is_item_owner(1976		subject: &T::CrossAccountId,1977		target_collection: &CollectionHandle<T>,1978		item_id: TokenId,1979	) -> bool {1980		match target_collection.mode {1981			CollectionMode::Fungible(_) => true,1982			_ => Self::owned_amount(&subject, target_collection, item_id).is_some(),1983		}1984	}19851986	fn check_white_list(1987		collection: &CollectionHandle<T>,1988		address: &T::CrossAccountId,1989	) -> DispatchResult {1990		let collection_id = collection.id;19911992		let mes = Error::<T>::AddresNotInWhiteList;1993		ensure!(1994			<WhiteList<T>>::contains_key(collection_id, address.as_sub()),1995			mes1996		);19971998		Ok(())1999	}20002001	/// Check if token exists. In case of Fungible, check if there is an entry for2002	/// the owner in fungible balances double map2003	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2004		let collection_id = target_collection.id;2005		let exists = match target_collection.mode {2006			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2007			CollectionMode::Fungible(_) => true,2008			CollectionMode::ReFungible => {2009				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2010			}2011			_ => false,2012		};20132014		ensure!(exists, Error::<T>::TokenNotFound);2015		Ok(())2016	}20172018	fn transfer_fungible(2019		collection: &CollectionHandle<T>,2020		value: u128,2021		owner: &T::CrossAccountId,2022		recipient: &T::CrossAccountId,2023	) -> DispatchResult {2024		let collection_id = collection.id;20252026		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2027		ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20282029		// Send balance to recipient (updates balanceOf of recipient)2030		Self::add_fungible_item(collection, recipient, value)?;20312032		// update balanceOf of sender2033		<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);20342035		// Reduce or remove sender2036		if balance.value == value {2037			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2038		} else {2039			balance.value -= value;2040			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2041		}20422043		collection.log(ERC20Events::Transfer {2044			from: *owner.as_eth(),2045			to: *recipient.as_eth(),2046			value: value.into(),2047		});2048		Self::deposit_event(RawEvent::Transfer(2049			collection.id,2050			1,2051			owner.clone(),2052			recipient.clone(),2053			value,2054		));20552056		Ok(())2057	}20582059	fn transfer_refungible(2060		collection: &CollectionHandle<T>,2061		item_id: TokenId,2062		value: u128,2063		owner: T::CrossAccountId,2064		new_owner: T::CrossAccountId,2065	) -> DispatchResult {2066		let collection_id = collection.id;2067		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2068			.ok_or(Error::<T>::TokenNotFound)?;20692070		let item = full_item2071			.owner2072			.iter()2073			.find(|i| i.owner == owner)2074			.ok_or(Error::<T>::TokenNotFound)?;2075		let amount = item.fraction;20762077		ensure!(amount >= value, Error::<T>::TokenValueTooLow);20782079		// update balance2080		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2081			.checked_sub(value)2082			.ok_or(Error::<T>::NumOverflow)?;2083		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20842085		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2086			.checked_add(value)2087			.ok_or(Error::<T>::NumOverflow)?;2088		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20892090		let old_owner = item.owner.clone();2091		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20922093		let mut new_full_item = full_item.clone();2094		// transfer2095		if amount == value && !new_owner_has_account {2096			// change owner2097			// new owner do not have account2098			new_full_item2099				.owner2100				.iter_mut()2101				.find(|i| i.owner == owner)2102				.expect("old owner does present in refungible")2103				.owner = new_owner.clone();2104			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21052106			// update index collection2107			Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2108		} else {2109			new_full_item2110				.owner2111				.iter_mut()2112				.find(|i| i.owner == owner)2113				.expect("old owner does present in refungible")2114				.fraction -= value;21152116			// separate amount2117			if new_owner_has_account {2118				// new owner has account2119				new_full_item2120					.owner2121					.iter_mut()2122					.find(|i| i.owner == new_owner)2123					.expect("new owner has account")2124					.fraction += value;2125			} else {2126				// new owner do not have account2127				new_full_item.owner.push(Ownership {2128					owner: new_owner.clone(),2129					fraction: value,2130				});2131				Self::add_token_index(collection_id, item_id, &new_owner)?;2132			}21332134			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2135		}21362137		Self::deposit_event(RawEvent::Transfer(2138			collection.id,2139			item_id,2140			owner,2141			new_owner,2142			amount,2143		));21442145		Ok(())2146	}21472148	fn transfer_nft(2149		collection: &CollectionHandle<T>,2150		item_id: TokenId,2151		sender: T::CrossAccountId,2152		new_owner: T::CrossAccountId,2153	) -> DispatchResult {2154		let collection_id = collection.id;2155		let mut item =2156			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21572158		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21592160		// update balance2161		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2162			.checked_sub(1)2163			.ok_or(Error::<T>::NumOverflow)?;2164		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21652166		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2167			.checked_add(1)2168			.ok_or(Error::<T>::NumOverflow)?;2169		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21702171		// change owner2172		let old_owner = item.owner.clone();2173		item.owner = new_owner.clone();2174		<NftItemList<T>>::insert(collection_id, item_id, item);21752176		// update index collection2177		Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21782179		collection.log(ERC721Events::Transfer {2180			from: *sender.as_eth(),2181			to: *new_owner.as_eth(),2182			token_id: item_id.into(),2183		});2184		Self::deposit_event(RawEvent::Transfer(2185			collection.id,2186			item_id,2187			sender,2188			new_owner,2189			1,2190		));21912192		Ok(())2193	}21942195	fn set_re_fungible_variable_data(2196		collection: &CollectionHandle<T>,2197		item_id: TokenId,2198		data: Vec<u8>,2199	) -> DispatchResult {2200		let collection_id = collection.id;2201		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2202			.ok_or(Error::<T>::TokenNotFound)?;22032204		item.variable_data = data;22052206		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22072208		Ok(())2209	}22102211	fn set_nft_variable_data(2212		collection: &CollectionHandle<T>,2213		item_id: TokenId,2214		data: Vec<u8>,2215	) -> DispatchResult {2216		let collection_id = collection.id;2217		let mut item =2218			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22192220		item.variable_data = data;22212222		<NftItemList<T>>::insert(collection_id, item_id, item);22232224		Ok(())2225	}22262227	#[allow(dead_code)]2228	fn init_collection(item: &Collection<T>) {2229		// check params2230		assert!(2231			item.decimal_points <= MAX_DECIMAL_POINTS,2232			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2233		);2234		assert!(2235			item.name.len() <= 64,2236			"Collection name can not be longer than 63 char"2237		);2238		assert!(2239			item.name.len() <= 256,2240			"Collection description can not be longer than 255 char"2241		);2242		assert!(2243			item.token_prefix.len() <= 16,2244			"Token prefix can not be longer than 15 char"2245		);22462247		// Generate next collection ID2248		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22492250		CreatedCollectionCount::put(next_id);2251	}22522253	#[allow(dead_code)]2254	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2255		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22562257		Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22582259		<ItemListIndex>::insert(collection_id, current_index);22602261		// Update balance2262		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2263			.checked_add(1)2264			.unwrap();2265		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2266	}22672268	#[allow(dead_code)]2269	fn init_fungible_token(2270		collection_id: CollectionId,2271		owner: &T::CrossAccountId,2272		item: &FungibleItemType,2273	) {2274		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22752276		Self::add_token_index(collection_id, current_index, owner).unwrap();22772278		<ItemListIndex>::insert(collection_id, current_index);22792280		// Update balance2281		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2282			.checked_add(item.value)2283			.unwrap();2284		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2285	}22862287	#[allow(dead_code)]2288	fn init_refungible_token(2289		collection_id: CollectionId,2290		item: &ReFungibleItemType<T::CrossAccountId>,2291	) {2292		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22932294		let value = item.owner.first().unwrap().fraction;2295		let owner = item.owner.first().unwrap().owner.clone();22962297		Self::add_token_index(collection_id, current_index, &owner).unwrap();22982299		<ItemListIndex>::insert(collection_id, current_index);23002301		// Update balance2302		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2303			.checked_add(value)2304			.unwrap();2305		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2306	}23072308	fn add_token_index(2309		collection_id: CollectionId,2310		item_index: TokenId,2311		owner: &T::CrossAccountId,2312	) -> DispatchResult {2313		// add to account limit2314		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2315			// bound Owned tokens by a single address2316			let count = <AccountItemCount<T>>::get(owner.as_sub());2317			ensure!(2318				count < ChainLimit::get().account_token_ownership_limit,2319				Error::<T>::AddressOwnershipLimitExceeded2320			);23212322			<AccountItemCount<T>>::insert(2323				owner.as_sub(),2324				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2325			);2326		} else {2327			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2328		}23292330		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2331		if list_exists {2332			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2333			let item_contains = list.contains(&item_index.clone());23342335			if !item_contains {2336				list.push(item_index);2337			}23382339			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2340		} else {2341			let itm = vec![item_index];2342			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2343		}23442345		Ok(())2346	}23472348	fn remove_token_index(2349		collection_id: CollectionId,2350		item_index: TokenId,2351		owner: &T::CrossAccountId,2352	) -> DispatchResult {2353		// update counter2354		<AccountItemCount<T>>::insert(2355			owner.as_sub(),2356			<AccountItemCount<T>>::get(owner.as_sub())2357				.checked_sub(1)2358				.ok_or(Error::<T>::NumOverflow)?,2359		);23602361		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2362		if list_exists {2363			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2364			let item_contains = list.contains(&item_index.clone());23652366			if item_contains {2367				list.retain(|&item| item != item_index);2368				<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2369			}2370		}23712372		Ok(())2373	}23742375	fn move_token_index(2376		collection_id: CollectionId,2377		item_index: TokenId,2378		old_owner: &T::CrossAccountId,2379		new_owner: &T::CrossAccountId,2380	) -> DispatchResult {2381		Self::remove_token_index(collection_id, item_index, old_owner)?;2382		Self::add_token_index(collection_id, item_index, new_owner)?;23832384		Ok(())2385	}2386}23872388sp_api::decl_runtime_apis! {2389	pub trait NftApi {2390		/// Used for ethereum integration2391		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2392	}2393}