git.delta.rocks / unique-network / refs/commits / 281677a9f1f9

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};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41	CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46	FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70	/// Error for non-fungible-token module.71	pub enum Error for Module<T: Config> {72		/// Total collections bound exceeded.73		TotalCollectionsLimitExceeded,74		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75		CollectionDecimalPointLimitExceeded,76		/// Collection name can not be longer than 63 char.77		CollectionNameLimitExceeded,78		/// Collection description can not be longer than 255 char.79		CollectionDescriptionLimitExceeded,80		/// Token prefix can not be longer than 15 char.81		CollectionTokenPrefixLimitExceeded,82		/// This collection does not exist.83		CollectionNotFound,84		/// Item not exists.85		TokenNotFound,86		/// Admin not found87		AdminNotFound,88		/// Arithmetic calculation overflow.89		NumOverflow,90		/// Account already has admin role.91		AlreadyAdmin,92		/// You do not own this collection.93		NoPermission,94		/// This address is not set as sponsor, use setCollectionSponsor first.95		ConfirmUnsetSponsorFail,96		/// Collection is not in mint mode.97		PublicMintingNotAllowed,98		/// Sender parameter and item owner must be equal.99		MustBeTokenOwner,100		/// Item balance not enough.101		TokenValueTooLow,102		/// Size of item is too large.103		NftSizeLimitExceeded,104		/// No approve found105		ApproveNotFound,106		/// Requested value more than approved.107		TokenValueNotEnough,108		/// Only approved addresses can call this method.109		ApproveRequired,110		/// Address is not in white list.111		AddresNotInWhiteList,112		/// Number of collection admins bound exceeded.113		CollectionAdminsLimitExceeded,114		/// Owned tokens by a single address bound exceeded.115		AddressOwnershipLimitExceeded,116		/// Length of items properties must be greater than 0.117		EmptyArgument,118		/// const_data exceeded data limit.119		TokenConstDataLimitExceeded,120		/// variable_data exceeded data limit.121		TokenVariableDataLimitExceeded,122		/// Not NFT item data used to mint in NFT collection.123		NotNftDataUsedToMintNftCollectionToken,124		/// Not Fungible item data used to mint in Fungible collection.125		NotFungibleDataUsedToMintFungibleCollectionToken,126		/// Not Re Fungible item data used to mint in Re Fungible collection.127		NotReFungibleDataUsedToMintReFungibleCollectionToken,128		/// Unexpected collection type.129		UnexpectedCollectionType,130		/// Can't store metadata in fungible tokens.131		CantStoreMetadataInFungibleTokens,132		/// Collection token limit exceeded133		CollectionTokenLimitExceeded,134		/// Account token limit exceeded per collection135		AccountTokenLimitExceeded,136		/// Collection limit bounds per collection exceeded137		CollectionLimitBoundsExceeded,138		/// Tried to enable permissions which are only permitted to be disabled139		OwnerPermissionsCantBeReverted,140		/// Schema data size limit bound exceeded141		SchemaDataLimitExceeded,142		/// Maximum refungibility exceeded143		WrongRefungiblePieces,144		/// createRefungible should be called with one owner145		BadCreateRefungibleCall,146		/// Gas limit exceeded147		OutOfGas,148		/// Metadata update denied by collection settings149		MetadataUpdateDenied,150		/// Metadata update flag become unmutable with None option151		MetadataFlagFrozen,152		/// Collection settings not allowing items transferring153		TransferNotAllowed,154		/// Can't transfer tokens to ethereum zero address155		AddressIsZero,156	}157}158159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]160pub struct CollectionHandle<T: Config> {161	pub id: CollectionId,162	collection: Collection<T>,163	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,164}165impl<T: Config> CollectionHandle<T> {166	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {167		<CollectionById<T>>::get(id).map(|collection| Self {168			id,169			collection,170			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(171				eth::collection_id_to_address(id),172				gas_limit,173			),174		})175	}176	pub fn get(id: CollectionId) -> Option<Self> {177		Self::get_with_gas_limit(id, u64::MAX)178	}179	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {180		self.recorder.log_sub(log)181	}182	#[allow(dead_code)]183	fn consume_gas(&self, gas: u64) -> DispatchResult {184		self.recorder.consume_gas_sub(gas)185	}186	fn consume_sload(&self) -> DispatchResult {187		self.recorder.consume_sload_sub()188	}189	fn consume_sstore(&self) -> DispatchResult {190		self.recorder.consume_sstore_sub()191	}192	pub fn submit_logs(self) -> DispatchResult {193		self.recorder.submit_logs()194	}195	pub fn save(self) -> DispatchResult {196		self.recorder.submit_logs()?;197		<CollectionById<T>>::insert(self.id, self.collection);198		Ok(())199	}200}201impl<T: Config> Deref for CollectionHandle<T> {202	type Target = Collection<T>;203204	fn deref(&self) -> &Self::Target {205		&self.collection206	}207}208209impl<T: Config> DerefMut for CollectionHandle<T> {210	fn deref_mut(&mut self) -> &mut Self::Target {211		&mut self.collection212	}213}214215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {216	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;217218	/// Weight information for extrinsics in this pallet.219	type WeightInfo: WeightInfo;220221	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;222	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;223224	type CrossAccountId: CrossAccountId<Self::AccountId>;225	type Currency: Currency<Self::AccountId>;226	type CollectionCreationPrice: Get<227		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,228	>;229	type TreasuryAccountId: Get<Self::AccountId>;230}231232type SelfWeightOf<T> = <T as Config>::WeightInfo;233234trait WeightInfoHelpers: WeightInfo {235	fn transfer() -> Weight {236		Self::transfer_nft()237			.max(Self::transfer_fungible())238			.max(Self::transfer_refungible())239	}240	fn transfer_from() -> Weight {241		Self::transfer_from_nft()242			.max(Self::transfer_from_fungible())243			.max(Self::transfer_from_refungible())244	}245	fn approve() -> Weight {246		// TODO: refungible, fungible247		Self::approve_nft()248	}249	fn set_variable_meta_data(data: u32) -> Weight {250		// TODO: refungible251		Self::set_variable_meta_data_nft(data)252	}253	fn create_item(data: u32) -> Weight {254		Self::create_item_nft(data)255			.max(Self::create_item_fungible())256			.max(Self::create_item_refungible(data))257	}258	fn burn_item() -> Weight {259		// TODO: refungible, fungible260		Self::burn_item_nft()261	}262}263impl<T: WeightInfo> WeightInfoHelpers for T {}264265// # Used definitions266//267// ## User control levels268//269// chain-controlled - key is uncontrolled by user270//                    i.e autoincrementing index271//                    can use non-cryptographic hash272// real - key is controlled by user273//        but it is hard to generate enough colliding values, i.e owner of signed txs274//        can use non-cryptographic hash275// controlled - key is completly controlled by users276//              i.e maps with mutable keys277//              should use cryptographic hash278//279// ## User control level downgrade reasons280//281// ?1 - chain-controlled -> controlled282//      collections/tokens can be destroyed, resulting in massive holes283// ?2 - chain-controlled -> controlled284//      same as ?1, but can be only added, resulting in easier exploitation285// ?3 - real -> controlled286//      no confirmation required, so addresses can be easily generated287decl_storage! {288	trait Store for Module<T: Config> as Nft {289290		//#region Private members291		/// Id of next collection292		CreatedCollectionCount: u32;293		/// Used for migrations294		ChainVersion: u64;295		/// Id of last collection token296		/// Collection id (controlled?1)297		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;298		//#endregion299300		//#region Bound counters301		/// Amount of collections destroyed, used for total amount tracking with302		/// CreatedCollectionCount303		DestroyedCollectionCount: u32;304		/// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)305		/// Account id (real)306		pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;307		//#endregion308309		//#region Basic collections310		/// Collection info311		/// Collection id (controlled?1)312		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;313		/// List of collection admins314		/// Collection id (controlled?2)315		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;316		/// Whitelisted collection users317		/// Collection id (controlled?2), user id (controlled?3)318		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;319		//#endregion320321		/// How many of collection items user have322		/// Collection id (controlled?2), account id (real)323		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;324325		/// Amount of items which spender can transfer out of owners account (via transferFrom)326		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))327		/// TODO: Off chain worker should remove from this map when token gets removed328		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;329330		//#region Item collections331		/// Collection id (controlled?2), token id (controlled?1)332		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;333		/// Collection id (controlled?2), owner (controlled?2)334		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;335		/// Collection id (controlled?2), token id (controlled?1)336		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;337		//#endregion338339		//#region Index list340		/// Collection id (controlled?2), tokens owner (controlled?2)341		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;342		//#endregion343344		//#region Tokens transfer rate limit baskets345		/// (Collection id (controlled?2), who created (real))346		/// TODO: Off chain worker should remove from this map when collection gets removed347		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;348		/// Collection id (controlled?2), token id (controlled?2)349		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;350		/// Collection id (controlled?2), owning user (real)351		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;352		/// Collection id (controlled?2), token id (controlled?2)353		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;354		//#endregion355356		/// Variable metadata sponsoring357		/// Collection id (controlled?2), token id (controlled?2)358		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;359	}360	add_extra_genesis {361		build(|config: &GenesisConfig<T>| {362			// Modification of storage363			for (_num, _c) in &config.collection_id {364				<Module<T>>::init_collection(_c);365			}366367			for (_num, _c, _i) in &config.nft_item_id {368				<Module<T>>::init_nft_token(*_c, _i);369			}370371			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {372				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);373			}374375			for (_num, _c, _i) in &config.refungible_item_id {376				<Module<T>>::init_refungible_token(*_c, _i);377			}378		})379	}380}381382decl_event!(383	pub enum Event<T>384	where385		AccountId = <T as frame_system::Config>::AccountId,386		CrossAccountId = <T as Config>::CrossAccountId,387	{388		/// New collection was created389		///390		/// # Arguments391		///392		/// * collection_id: Globally unique identifier of newly created collection.393		///394		/// * mode: [CollectionMode] converted into u8.395		///396		/// * account_id: Collection owner.397		CollectionCreated(CollectionId, u8, AccountId),398399		/// New item was created.400		///401		/// # Arguments402		///403		/// * collection_id: Id of the collection where item was created.404		///405		/// * item_id: Id of an item. Unique within the collection.406		///407		/// * recipient: Owner of newly created item408		ItemCreated(CollectionId, TokenId, CrossAccountId),409410		/// Collection item was burned.411		///412		/// # Arguments413		///414		/// collection_id.415		///416		/// item_id: Identifier of burned NFT.417		ItemDestroyed(CollectionId, TokenId),418419		/// Item was transferred420		///421		/// * collection_id: Id of collection to which item is belong422		///423		/// * item_id: Id of an item424		///425		/// * sender: Original owner of item426		///427		/// * recipient: New owner of item428		///429		/// * amount: Always 1 for NFT430		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),431432		/// * collection_id433		///434		/// * item_id435		///436		/// * sender437		///438		/// * spender439		///440		/// * amount441		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),442	}443);444445decl_module! {446	pub struct Module<T: Config> for enum Call447	where448		origin: T::Origin449	{450		fn deposit_event() = default;451		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;452		type Error = Error<T>;453454		fn on_initialize(_now: T::BlockNumber) -> Weight {455			0456		}457458		/// 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.459		///460		/// # Permissions461		///462		/// * Anyone.463		///464		/// # Arguments465		///466		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.467		///468		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.469		///470		/// * token_prefix: UTF-8 string with token prefix.471		///472		/// * mode: [CollectionMode] collection type and type dependent data.473		// returns collection ID474		#[weight = <SelfWeightOf<T>>::create_collection()]475		#[transactional]476		pub fn create_collection(origin,477								 collection_name: Vec<u16>,478								 collection_description: Vec<u16>,479								 token_prefix: Vec<u8>,480								 mode: CollectionMode) -> DispatchResult {481482			// Anyone can create a collection483			let who = ensure_signed(origin)?;484485			// Take a (non-refundable) deposit of collection creation486			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();487			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(488				&T::TreasuryAccountId::get(),489				T::CollectionCreationPrice::get(),490			));491			<T as Config>::Currency::settle(492				&who,493				imbalance,494				WithdrawReasons::TRANSFER,495				ExistenceRequirement::KeepAlive,496			).map_err(|_| Error::<T>::NoPermission)?;497498			let decimal_points = match mode {499				CollectionMode::Fungible(points) => points,500				_ => 0501			};502503			let created_count = CreatedCollectionCount::get();504			let destroyed_count = DestroyedCollectionCount::get();505506			// bound Total number of collections507			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);508509			// check params510			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);511			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);512			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);513			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);514515			// Generate next collection ID516			let next_id = created_count517				.checked_add(1)518				.ok_or(Error::<T>::NumOverflow)?;519520			CreatedCollectionCount::put(next_id);521522			let limits = CollectionLimits {523				sponsored_data_size: CUSTOM_DATA_LIMIT,524				..Default::default()525			};526527			// Create new collection528			let new_collection = Collection {529				owner: who.clone(),530				name: collection_name,531				mode: mode.clone(),532				mint_mode: false,533				access: AccessMode::Normal,534				description: collection_description,535				decimal_points,536				token_prefix,537				offchain_schema: Vec::new(),538				schema_version: SchemaVersion::ImageURL,539				sponsorship: SponsorshipState::Disabled,540				variable_on_chain_schema: Vec::new(),541				const_on_chain_schema: Vec::new(),542				limits,543				meta_update_permission: MetaUpdatePermission::default(),544				transfers_enabled: true,545			};546547			// Add new collection to map548			<CollectionById<T>>::insert(next_id, new_collection);549550			// call event551			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));552553			Ok(())554		}555556		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.557		///558		/// # Permissions559		///560		/// * Collection Owner.561		///562		/// # Arguments563		///564		/// * collection_id: collection to destroy.565		#[weight = <SelfWeightOf<T>>::destroy_collection()]566		#[transactional]567		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {568569			let sender = ensure_signed(origin)?;570			let collection = Self::get_collection(collection_id)?;571			Self::check_owner_permissions(&collection, &sender)?;572			if !collection.limits.owner_can_destroy {573				fail!(Error::<T>::NoPermission);574			}575576			<AddressTokens<T>>::remove_prefix(collection_id, None);577			<Allowances<T>>::remove_prefix(collection_id, None);578			<Balance<T>>::remove_prefix(collection_id, None);579			<ItemListIndex>::remove(collection_id);580			<AdminList<T>>::remove(collection_id);581			<CollectionById<T>>::remove(collection_id);582			<WhiteList<T>>::remove_prefix(collection_id, None);583584			<NftItemList<T>>::remove_prefix(collection_id, None);585			<FungibleItemList<T>>::remove_prefix(collection_id, None);586			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);587588			<NftTransferBasket<T>>::remove_prefix(collection_id, None);589			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);590			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);591592			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);593594			DestroyedCollectionCount::put(DestroyedCollectionCount::get()595				.checked_add(1)596				.ok_or(Error::<T>::NumOverflow)?);597598			Ok(())599		}600601		/// Add an address to white list.602		///603		/// # Permissions604		///605		/// * Collection Owner606		/// * Collection Admin607		///608		/// # Arguments609		///610		/// * collection_id.611		///612		/// * address.613		#[weight = <SelfWeightOf<T>>::add_to_white_list()]614		#[transactional]615		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{616617			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);618			let collection = Self::get_collection(collection_id)?;619620			Self::toggle_white_list_internal(621				&sender,622				&collection,623				&address,624				true,625			)?;626627			Ok(())628		}629630		/// Remove an address from white list.631		///632		/// # Permissions633		///634		/// * Collection Owner635		/// * Collection Admin636		///637		/// # Arguments638		///639		/// * collection_id.640		///641		/// * address.642		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]643		#[transactional]644		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{645646			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);647			let collection = Self::get_collection(collection_id)?;648649			Self::toggle_white_list_internal(650				&sender,651				&collection,652				&address,653				false,654			)?;655656			Ok(())657		}658659		/// Toggle between normal and white list access for the methods with access for `Anyone`.660		///661		/// # Permissions662		///663		/// * Collection Owner.664		///665		/// # Arguments666		///667		/// * collection_id.668		///669		/// * mode: [AccessMode]670		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]671		#[transactional]672		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult673		{674			let sender = ensure_signed(origin)?;675676			let mut target_collection = Self::get_collection(collection_id)?;677			Self::check_owner_permissions(&target_collection, &sender)?;678			target_collection.access = mode;679			target_collection.save()680		}681682		/// Allows Anyone to create tokens if:683		/// * White List is enabled, and684		/// * Address is added to white list, and685		/// * This method was called with True parameter686		///687		/// # Permissions688		/// * Collection Owner689		///690		/// # Arguments691		///692		/// * collection_id.693		///694		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.695		#[weight = <SelfWeightOf<T>>::set_mint_permission()]696		#[transactional]697		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult698		{699			let sender = ensure_signed(origin)?;700701			let mut target_collection = Self::get_collection(collection_id)?;702			Self::check_owner_permissions(&target_collection, &sender)?;703			target_collection.mint_mode = mint_permission;704			target_collection.save()705		}706707		/// Change the owner of the collection.708		///709		/// # Permissions710		///711		/// * Collection Owner.712		///713		/// # Arguments714		///715		/// * collection_id.716		///717		/// * new_owner.718		#[weight = <SelfWeightOf<T>>::change_collection_owner()]719		#[transactional]720		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {721722			let sender = ensure_signed(origin)?;723			let mut target_collection = Self::get_collection(collection_id)?;724			Self::check_owner_permissions(&target_collection, &sender)?;725			target_collection.owner = new_owner;726			target_collection.save()727		}728729		/// Adds an admin of the Collection.730		/// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.731		///732		/// # Permissions733		///734		/// * Collection Owner.735		/// * Collection Admin.736		///737		/// # Arguments738		///739		/// * collection_id: ID of the Collection to add admin for.740		///741		/// * new_admin_id: Address of new admin to add.742		#[weight = <SelfWeightOf<T>>::add_collection_admin()]743		#[transactional]744		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {745			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);746			let collection = Self::get_collection(collection_id)?;747			Self::check_owner_or_admin_permissions(&collection, &sender)?;748			let mut admin_arr = <AdminList<T>>::get(collection_id);749750			match admin_arr.binary_search(&new_admin_id) {751				Ok(_) => {},752				Err(idx) => {753					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);754					admin_arr.insert(idx, new_admin_id);755					<AdminList<T>>::insert(collection_id, admin_arr);756				}757			}758			Ok(())759		}760761		/// 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.762		///763		/// # Permissions764		///765		/// * Collection Owner.766		/// * Collection Admin.767		///768		/// # Arguments769		///770		/// * collection_id: ID of the Collection to remove admin for.771		///772		/// * account_id: Address of admin to remove.773		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]774		#[transactional]775		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {776			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);777			let collection = Self::get_collection(collection_id)?;778			Self::check_owner_or_admin_permissions(&collection, &sender)?;779			let mut admin_arr = <AdminList<T>>::get(collection_id);780781			if let Ok(idx) = admin_arr.binary_search(&account_id) {782				admin_arr.remove(idx);783				<AdminList<T>>::insert(collection_id, admin_arr);784			}785			Ok(())786		}787788		/// # Permissions789		///790		/// * Collection Owner791		///792		/// # Arguments793		///794		/// * collection_id.795		///796		/// * new_sponsor.797		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]798		#[transactional]799		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {800			let sender = ensure_signed(origin)?;801			let mut target_collection = Self::get_collection(collection_id)?;802			Self::check_owner_permissions(&target_collection, &sender)?;803804			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);805			target_collection.save()806		}807808		/// # Permissions809		///810		/// * Sponsor.811		///812		/// # Arguments813		///814		/// * collection_id.815		#[weight = <SelfWeightOf<T>>::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			target_collection.save()828		}829830		/// Switch back to pay-per-own-transaction model.831		///832		/// # Permissions833		///834		/// * Collection owner.835		///836		/// # Arguments837		///838		/// * collection_id.839		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]840		#[transactional]841		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {842			let sender = ensure_signed(origin)?;843844			let mut target_collection = Self::get_collection(collection_id)?;845			Self::check_owner_permissions(&target_collection, &sender)?;846847			target_collection.sponsorship = SponsorshipState::Disabled;848			target_collection.save()849		}850851		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.852		///853		/// # Permissions854		///855		/// * Collection Owner.856		/// * Collection Admin.857		/// * Anyone if858		///     * White List is enabled, and859		///     * Address is added to white list, and860		///     * MintPermission is enabled (see SetMintPermission method)861		///862		/// # Arguments863		///864		/// * collection_id: ID of the collection.865		///866		/// * owner: Address, initial owner of the NFT.867		///868		/// * data: Token data to store on chain.869		// #[weight =870		// (130_000_000 as Weight)871		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))872		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))873		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]874875		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]876		#[transactional]877		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {878			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);879			let collection = Self::get_collection(collection_id)?;880881			Self::create_item_internal(&sender, &collection, &owner, data)?;882883			collection.submit_logs()884		}885886		/// This method creates multiple items in a collection created with CreateCollection method.887		///888		/// # Permissions889		///890		/// * Collection Owner.891		/// * Collection Admin.892		/// * Anyone if893		///     * White List is enabled, and894		///     * Address is added to white list, and895		///     * MintPermission is enabled (see SetMintPermission method)896		///897		/// # Arguments898		///899		/// * collection_id: ID of the collection.900		///901		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].902		///903		/// * owner: Address, initial owner of the NFT.904		#[weight = <SelfWeightOf<T>>::create_item(items_data.iter()905							   .map(|data| { data.data_size() as u32 })906							   .sum())]907		#[transactional]908		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {909910			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);911			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);912			let collection = Self::get_collection(collection_id)?;913914			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;915916			collection.submit_logs()917		}918919		// TODO! transaction weight920921		/// Set transfers_enabled value for particular collection922		///923		/// # Permissions924		///925		/// * Collection Owner.926		///927		/// # Arguments928		///929		/// * collection_id: ID of the collection.930		///931		/// * value: New flag value.932		#[weight = <SelfWeightOf<T>>::burn_item()]933		#[transactional]934		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {935936			let sender = ensure_signed(origin)?;937			let mut target_collection = Self::get_collection(collection_id)?;938939			Self::check_owner_permissions(&target_collection, &sender)?;940941			target_collection.transfers_enabled = value;942			target_collection.save()943		}944945		// TODO! transaction weight946		/// Set meta_update_permission value for particular collection947		///948		/// # Permissions949		///950		/// * Collection Owner.951		///952		/// # Arguments953		///954		/// * collection_id: ID of the collection.955		///956		/// * value: New flag value.957		#[weight = <T as Config>::WeightInfo::burn_item()]958		#[transactional]959		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {960961			let sender = ensure_signed(origin)?;962			let mut target_collection = Self::get_collection(collection_id)?;963964			ensure!(965				target_collection.meta_update_permission != MetaUpdatePermission::None,966				Error::<T>::MetadataFlagFrozen967			);968			Self::check_owner_permissions(&target_collection, &sender)?;969970			target_collection.meta_update_permission = value;971			Self::save_collection(target_collection);972973			Ok(())974		}975976		/// Destroys a concrete instance of NFT.977		///978		/// # Permissions979		///980		/// * Collection Owner.981		/// * Collection Admin.982		/// * Current NFT Owner.983		///984		/// # Arguments985		///986		/// * collection_id: ID of the collection.987		///988		/// * item_id: ID of NFT to burn.989		#[weight = <SelfWeightOf<T>>::burn_item()]990		#[transactional]991		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {992993			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);994			let target_collection = Self::get_collection(collection_id)?;995996			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;997998			target_collection.submit_logs()999		}10001001		/// Change ownership of the token.1002		///1003		/// # Permissions1004		///1005		/// * Collection Owner1006		/// * Collection Admin1007		/// * Current NFT owner1008		///1009		/// # Arguments1010		///1011		/// * recipient: Address of token recipient.1012		///1013		/// * collection_id.1014		///1015		/// * item_id: ID of the item1016		///     * Non-Fungible Mode: Required.1017		///     * Fungible Mode: Ignored.1018		///     * Re-Fungible Mode: Required.1019		///1020		/// * value: Amount to transfer.1021		///     * Non-Fungible Mode: Ignored1022		///     * Fungible Mode: Must specify transferred amount1023		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1024		#[weight = <SelfWeightOf<T>>::transfer()]1025		#[transactional]1026		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1027			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1028			let collection = Self::get_collection(collection_id)?;10291030			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10311032			collection.submit_logs()1033		}10341035		/// Set, change, or remove approved address to transfer the ownership of the NFT.1036		///1037		/// # Permissions1038		///1039		/// * Collection Owner1040		/// * Collection Admin1041		/// * Current NFT owner1042		///1043		/// # Arguments1044		///1045		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1046		///1047		/// * collection_id.1048		///1049		/// * item_id: ID of the item.1050		#[weight = <SelfWeightOf<T>>::approve()]1051		#[transactional]1052		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1053			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1054			let collection = Self::get_collection(collection_id)?;10551056			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10571058			collection.submit_logs()1059		}10601061		/// 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.1062		///1063		/// # Permissions1064		/// * Collection Owner1065		/// * Collection Admin1066		/// * Current NFT owner1067		/// * Address approved by current NFT owner1068		///1069		/// # Arguments1070		///1071		/// * from: Address that owns token.1072		///1073		/// * recipient: Address of token recipient.1074		///1075		/// * collection_id.1076		///1077		/// * item_id: ID of the item.1078		///1079		/// * value: Amount to transfer.1080		#[weight = <SelfWeightOf<T>>::transfer_from()]1081		#[transactional]1082		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1083			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1084			let collection = Self::get_collection(collection_id)?;10851086			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10871088			collection.submit_logs()1089		}1090		// #[weight = 0]1091		//     // let no_perm_mes = "You do not have permissions to modify this collection";1092		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1093		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1094		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10951096		//     // // on_nft_received  call10971098		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10991100		//     Ok(())1101		// }11021103		/// Set off-chain data schema.1104		///1105		/// # Permissions1106		///1107		/// * Collection Owner1108		/// * Collection Admin1109		///1110		/// # Arguments1111		///1112		/// * collection_id.1113		///1114		/// * schema: String representing the offchain data schema.1115		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1116		#[transactional]1117		pub fn set_variable_meta_data (1118			origin,1119			collection_id: CollectionId,1120			item_id: TokenId,1121			data: Vec<u8>1122		) -> DispatchResult {1123			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11241125			let collection = Self::get_collection(collection_id)?;11261127			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11281129			Ok(())1130		}11311132		/// Set schema standard1133		/// ImageURL1134		/// Unique1135		///1136		/// # Permissions1137		///1138		/// * Collection Owner1139		/// * Collection Admin1140		///1141		/// # Arguments1142		///1143		/// * collection_id.1144		///1145		/// * schema: SchemaVersion: enum1146		#[weight = <SelfWeightOf<T>>::set_schema_version()]1147		#[transactional]1148		pub fn set_schema_version(1149			origin,1150			collection_id: CollectionId,1151			version: SchemaVersion1152		) -> DispatchResult {1153			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1154			let mut target_collection = Self::get_collection(collection_id)?;1155			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1156			target_collection.schema_version = version;1157			target_collection.save()1158		}11591160		/// Set off-chain data schema.1161		///1162		/// # Permissions1163		///1164		/// * Collection Owner1165		/// * Collection Admin1166		///1167		/// # Arguments1168		///1169		/// * collection_id.1170		///1171		/// * schema: String representing the offchain data schema.1172		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1173		#[transactional]1174		pub fn set_offchain_schema(1175			origin,1176			collection_id: CollectionId,1177			schema: Vec<u8>1178		) -> DispatchResult {1179			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1180			let mut target_collection = Self::get_collection(collection_id)?;1181			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11821183			// check schema limit1184			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11851186			target_collection.offchain_schema = schema;1187			target_collection.save()1188		}11891190		/// Set const on-chain data schema.1191		///1192		/// # Permissions1193		///1194		/// * Collection Owner1195		/// * Collection Admin1196		///1197		/// # Arguments1198		///1199		/// * collection_id.1200		///1201		/// * schema: String representing the const on-chain data schema.1202		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1203		#[transactional]1204		pub fn set_const_on_chain_schema (1205			origin,1206			collection_id: CollectionId,1207			schema: Vec<u8>1208		) -> DispatchResult {1209			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1210			let mut target_collection = Self::get_collection(collection_id)?;1211			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12121213			// check schema limit1214			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12151216			target_collection.const_on_chain_schema = schema;1217			target_collection.save()1218		}12191220		/// Set variable on-chain data schema.1221		///1222		/// # Permissions1223		///1224		/// * Collection Owner1225		/// * Collection Admin1226		///1227		/// # Arguments1228		///1229		/// * collection_id.1230		///1231		/// * schema: String representing the variable on-chain data schema.1232		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1233		#[transactional]1234		pub fn set_variable_on_chain_schema (1235			origin,1236			collection_id: CollectionId,1237			schema: Vec<u8>1238		) -> DispatchResult {1239			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1240			let mut target_collection = Self::get_collection(collection_id)?;1241			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12421243			// check schema limit1244			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12451246			target_collection.variable_on_chain_schema = schema;1247			target_collection.save()1248		}12491250		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1251		#[transactional]1252		pub fn set_collection_limits(1253			origin,1254			collection_id: u32,1255			new_limits: CollectionLimits<T::BlockNumber>,1256		) -> DispatchResult {1257			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1258			let mut target_collection = Self::get_collection(collection_id)?;1259			Self::check_owner_permissions(&target_collection, sender.as_sub())?;1260			let old_limits = &target_collection.limits;12611262			// collection bounds1263			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1264				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1265				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1266				Error::<T>::CollectionLimitBoundsExceeded);12671268			// token_limit   check  prev1269			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1270			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12711272			ensure!(1273				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1274				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1275				Error::<T>::OwnerPermissionsCantBeReverted,1276			);12771278			target_collection.limits = new_limits;12791280			target_collection.save()1281		}1282	}1283}12841285impl<T: Config> Module<T> {1286	pub fn create_item_internal(1287		sender: &T::CrossAccountId,1288		collection: &CollectionHandle<T>,1289		owner: &T::CrossAccountId,1290		data: CreateItemData,1291	) -> DispatchResult {1292		ensure!(1293			owner != &T::CrossAccountId::from_eth(H160([0; 20])),1294			Error::<T>::AddressIsZero1295		);12961297		Self::can_create_items_in_collection(collection, sender, owner, 1)?;1298		Self::validate_create_item_args(collection, &data)?;1299		Self::create_item_no_validation(collection, owner, data)?;13001301		Ok(())1302	}13031304	pub fn transfer_internal(1305		sender: &T::CrossAccountId,1306		recipient: &T::CrossAccountId,1307		target_collection: &CollectionHandle<T>,1308		item_id: TokenId,1309		value: u128,1310	) -> DispatchResult {1311		ensure!(1312			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1313			Error::<T>::AddressIsZero1314		);13151316		// Limits check1317		Self::is_correct_transfer(target_collection, recipient)?;13181319		// Transfer permissions check1320		ensure!(1321			Self::is_item_owner(sender, target_collection, item_id)?1322				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,1323			Error::<T>::NoPermission1324		);13251326		if target_collection.access == AccessMode::WhiteList {1327			Self::check_white_list(target_collection, sender)?;1328			Self::check_white_list(target_collection, recipient)?;1329		}13301331		match target_collection.mode {1332			CollectionMode::NFT => Self::transfer_nft(1333				target_collection,1334				item_id,1335				sender.clone(),1336				recipient.clone(),1337			)?,1338			CollectionMode::Fungible(_) => {1339				Self::transfer_fungible(target_collection, value, sender, recipient)?1340			}1341			CollectionMode::ReFungible => Self::transfer_refungible(1342				target_collection,1343				item_id,1344				value,1345				sender.clone(),1346				recipient.clone(),1347			)?,1348			_ => (),1349		};13501351		Self::deposit_event(RawEvent::Transfer(1352			target_collection.id,1353			item_id,1354			sender.clone(),1355			recipient.clone(),1356			value,1357		));13581359		Ok(())1360	}13611362	pub fn approve_internal(1363		sender: &T::CrossAccountId,1364		spender: &T::CrossAccountId,1365		collection: &CollectionHandle<T>,1366		item_id: TokenId,1367		amount: u128,1368	) -> DispatchResult {1369		Self::token_exists(collection, item_id)?;13701371		// Transfer permissions check1372		let bypasses_limits = collection.limits.owner_can_transfer1373			&& Self::is_owner_or_admin_permissions(collection, sender)?;13741375		let allowance_limit = if bypasses_limits {1376			None1377		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1378			Some(amount)1379		} else {1380			fail!(Error::<T>::NoPermission);1381		};13821383		if collection.access == AccessMode::WhiteList {1384			Self::check_white_list(collection, sender)?;1385			Self::check_white_list(collection, spender)?;1386		}13871388		collection.consume_sload()?;1389		let allowance: u128 = amount1390			.checked_add(<Allowances<T>>::get(1391				collection.id,1392				(item_id, sender.as_sub(), spender.as_sub()),1393			))1394			.ok_or(Error::<T>::NumOverflow)?;1395		if let Some(limit) = allowance_limit {1396			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1397		}1398		collection.consume_sstore()?;1399		<Allowances<T>>::insert(1400			collection.id,1401			(item_id, sender.as_sub(), spender.as_sub()),1402			allowance,1403		);14041405		if matches!(collection.mode, CollectionMode::NFT) {1406			// TODO: NFT: only one owner may exist for token in ERC7211407			collection.log(ERC721Events::Approval {1408				owner: *sender.as_eth(),1409				approved: *spender.as_eth(),1410				token_id: item_id.into(),1411			})?;1412		}14131414		if matches!(collection.mode, CollectionMode::Fungible(_)) {1415			// TODO: NFT: only one owner may exist for token in ERC201416			collection.log(ERC20Events::Approval {1417				owner: *sender.as_eth(),1418				spender: *spender.as_eth(),1419				value: allowance.into(),1420			})?;1421		}14221423		Self::deposit_event(RawEvent::Approved(1424			collection.id,1425			item_id,1426			sender.clone(),1427			spender.clone(),1428			allowance,1429		));1430		Ok(())1431	}14321433	pub fn transfer_from_internal(1434		sender: &T::CrossAccountId,1435		from: &T::CrossAccountId,1436		recipient: &T::CrossAccountId,1437		collection: &CollectionHandle<T>,1438		item_id: TokenId,1439		amount: u128,1440	) -> DispatchResult {1441		if sender == from {1442			// Transfer by `from`, because it is either equal to sender, or derived from him1443			return Self::transfer_internal(from, recipient, collection, item_id, amount);1444		}14451446		// Check approval1447		collection.consume_sload()?;1448		let approval: u128 =1449			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14501451		// Limits check1452		Self::is_correct_transfer(collection, recipient)?;14531454		// Transfer permissions check1455		ensure!(1456			approval >= amount1457				|| (collection.limits.owner_can_transfer1458					&& Self::is_owner_or_admin_permissions(collection, sender)?),1459			Error::<T>::NoPermission1460		);14611462		if collection.access == AccessMode::WhiteList {1463			Self::check_white_list(collection, sender)?;1464			Self::check_white_list(collection, recipient)?;1465		}14661467		// Reduce approval by transferred amount or remove if remaining approval drops to 01468		let allowance = approval.saturating_sub(amount);1469		collection.consume_sstore()?;1470		if allowance > 0 {1471			<Allowances<T>>::insert(1472				collection.id,1473				(item_id, from.as_sub(), sender.as_sub()),1474				allowance,1475			);1476		} else {1477			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1478		}14791480		match collection.mode {1481			CollectionMode::NFT => {1482				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1483			}1484			CollectionMode::Fungible(_) => {1485				Self::transfer_fungible(collection, amount, from, recipient)?1486			}1487			CollectionMode::ReFungible => Self::transfer_refungible(1488				collection,1489				item_id,1490				amount,1491				from.clone(),1492				recipient.clone(),1493			)?,1494			_ => (),1495		};14961497		if matches!(collection.mode, CollectionMode::Fungible(_)) {1498			collection.log(ERC20Events::Approval {1499				owner: *from.as_eth(),1500				spender: *sender.as_eth(),1501				value: allowance.into(),1502			})?;1503		}15041505		Ok(())1506	}15071508	pub fn set_variable_meta_data_internal(1509		sender: &T::CrossAccountId,1510		collection: &CollectionHandle<T>,1511		item_id: TokenId,1512		data: Vec<u8>,1513	) -> DispatchResult {1514		Self::token_exists(collection, item_id)?;15151516		ensure!(1517			CUSTOM_DATA_LIMIT >= data.len() as u32,1518			Error::<T>::TokenVariableDataLimitExceeded1519		);15201521		// Modify permissions check1522		ensure!(1523			Self::is_item_owner(sender, collection, item_id)?1524				|| Self::is_owner_or_admin_permissions(collection, sender)?,1525			Error::<T>::NoPermission1526		);15271528		match collection.mode {1529			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1530			CollectionMode::ReFungible => {1531				Self::set_re_fungible_variable_data(collection, item_id, data)?1532			}1533			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1534			_ => fail!(Error::<T>::UnexpectedCollectionType),1535		};15361537		Ok(())1538	}15391540	pub fn meta_update_check(1541		sender: &T::CrossAccountId,1542		collection: &CollectionHandle<T>,1543		item_id: TokenId,1544	) -> DispatchResult {1545		match collection.meta_update_permission {1546			MetaUpdatePermission::ItemOwner => {1547				ensure!(1548					Self::is_item_owner(sender, collection, item_id),1549					Error::<T>::NoPermission1550				);1551			}1552			MetaUpdatePermission::Admin => {1553				ensure!(1554					Self::is_owner_or_admin_permissions(collection, sender),1555					Error::<T>::NoPermission1556				);1557			}1558			MetaUpdatePermission::None => {1559				fail!(Error::<T>::MetadataUpdateDenied);1560			}1561		}15621563		Ok(())1564	}15651566	pub fn create_multiple_items_internal(1567		sender: &T::CrossAccountId,1568		collection: &CollectionHandle<T>,1569		owner: &T::CrossAccountId,1570		items_data: Vec<CreateItemData>,1571	) -> DispatchResult {1572		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15731574		for data in &items_data {1575			Self::validate_create_item_args(collection, data)?;1576		}1577		for data in &items_data {1578			Self::create_item_no_validation(collection, owner, data.clone())?;1579		}15801581		Ok(())1582	}15831584	pub fn burn_item_internal(1585		sender: &T::CrossAccountId,1586		collection: &CollectionHandle<T>,1587		item_id: TokenId,1588		value: u128,1589	) -> DispatchResult {1590		ensure!(1591			Self::is_item_owner(sender, collection, item_id)?1592				|| (collection.limits.owner_can_transfer1593					&& Self::is_owner_or_admin_permissions(collection, sender)?),1594			Error::<T>::NoPermission1595		);15961597		if collection.access == AccessMode::WhiteList {1598			Self::check_white_list(collection, sender)?;1599		}16001601		match collection.mode {1602			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1603			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1604			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1605			_ => (),1606		};16071608		Ok(())1609	}16101611	pub fn toggle_white_list_internal(1612		sender: &T::CrossAccountId,1613		collection: &CollectionHandle<T>,1614		address: &T::CrossAccountId,1615		whitelisted: bool,1616	) -> DispatchResult {1617		Self::check_owner_or_admin_permissions(collection, sender)?;16181619		if whitelisted {1620			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1621		} else {1622			<WhiteList<T>>::remove(collection.id, address.as_sub());1623		}16241625		Ok(())1626	}16271628	fn is_correct_transfer(1629		collection: &CollectionHandle<T>,1630		recipient: &T::CrossAccountId,1631	) -> DispatchResult {1632		let collection_id = collection.id;16331634		// check token limit and account token limit1635		collection.consume_sload()?;1636		let account_items: u32 =1637			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1638		ensure!(1639			collection.limits.account_token_ownership_limit > account_items,1640			Error::<T>::AccountTokenLimitExceeded1641		);16421643		// preliminary transfer check1644		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16451646		Ok(())1647	}16481649	fn can_create_items_in_collection(1650		collection: &CollectionHandle<T>,1651		sender: &T::CrossAccountId,1652		owner: &T::CrossAccountId,1653		amount: u32,1654	) -> DispatchResult {1655		let collection_id = collection.id;16561657		// check token limit and account token limit1658		let total_items: u32 = ItemListIndex::get(collection_id)1659			.checked_add(amount)1660			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1661		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1662			as u32)1663			.checked_add(amount)1664			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;1665		ensure!(1666			collection.limits.token_limit >= total_items,1667			Error::<T>::CollectionTokenLimitExceeded1668		);1669		ensure!(1670			collection.limits.account_token_ownership_limit >= account_items,1671			Error::<T>::AccountTokenLimitExceeded1672		);16731674		if !Self::is_owner_or_admin_permissions(collection, sender)? {1675			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1676			Self::check_white_list(collection, owner)?;1677			Self::check_white_list(collection, sender)?;1678		}16791680		Ok(())1681	}16821683	fn validate_create_item_args(1684		target_collection: &CollectionHandle<T>,1685		data: &CreateItemData,1686	) -> DispatchResult {1687		match target_collection.mode {1688			CollectionMode::NFT => {1689				if !matches!(data, CreateItemData::NFT(_)) {1690					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1691				}1692			}1693			CollectionMode::Fungible(_) => {1694				if !matches!(data, CreateItemData::Fungible(_)) {1695					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1696				}1697			}1698			CollectionMode::ReFungible => {1699				if let CreateItemData::ReFungible(data) = data {1700					// Check refungibility limits1701					ensure!(1702						data.pieces <= MAX_REFUNGIBLE_PIECES,1703						Error::<T>::WrongRefungiblePieces1704					);1705					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1706				} else {1707					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1708				}1709			}1710			_ => {1711				fail!(Error::<T>::UnexpectedCollectionType);1712			}1713		};17141715		Ok(())1716	}17171718	fn create_item_no_validation(1719		collection: &CollectionHandle<T>,1720		owner: &T::CrossAccountId,1721		data: CreateItemData,1722	) -> DispatchResult {1723		match data {1724			CreateItemData::NFT(data) => {1725				let item = NftItemType {1726					owner: owner.clone(),1727					const_data: data.const_data.into_inner(),1728					variable_data: data.variable_data.into_inner(),1729				};17301731				Self::add_nft_item(collection, item)?;1732			}1733			CreateItemData::Fungible(data) => {1734				Self::add_fungible_item(collection, owner, data.value)?;1735			}1736			CreateItemData::ReFungible(data) => {1737				let owner_list = vec![Ownership {1738					owner: owner.clone(),1739					fraction: data.pieces,1740				}];17411742				let item = ReFungibleItemType {1743					owner: owner_list,1744					const_data: data.const_data.into_inner(),1745					variable_data: data.variable_data.into_inner(),1746				};17471748				Self::add_refungible_item(collection, item)?;1749			}1750		};17511752		Ok(())1753	}17541755	fn add_fungible_item(1756		collection: &CollectionHandle<T>,1757		owner: &T::CrossAccountId,1758		value: u128,1759	) -> DispatchResult {1760		let collection_id = collection.id;17611762		// Does new owner already have an account?1763		collection.consume_sload()?;1764		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17651766		// Mint1767		let item = FungibleItemType {1768			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1769		};1770		collection.consume_sstore()?;1771		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17721773		// Update balance1774		collection.consume_sload()?;1775		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1776			.checked_add(value)1777			.ok_or(Error::<T>::NumOverflow)?;1778		collection.consume_sstore()?;1779		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17801781		collection.log(ERC20Events::Transfer {1782			from: H160::default(),1783			to: *owner.as_eth(),1784			value: value.into(),1785		})?;1786		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1787		Ok(())1788	}17891790	fn add_refungible_item(1791		collection: &CollectionHandle<T>,1792		item: ReFungibleItemType<T::CrossAccountId>,1793	) -> DispatchResult {1794		let collection_id = collection.id;17951796		let current_index = <ItemListIndex>::get(collection_id)1797			.checked_add(1)1798			.ok_or(Error::<T>::NumOverflow)?;1799		let itemcopy = item.clone();18001801		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1802		let item_owner = item.owner.first().expect("only one owner is defined");18031804		let value = item_owner.fraction;1805		let owner = item_owner.owner.clone();18061807		Self::add_token_index(collection, current_index, &owner)?;18081809		<ItemListIndex>::insert(collection_id, current_index);1810		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18111812		// Update balance1813		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1814			.checked_add(value)1815			.ok_or(Error::<T>::NumOverflow)?;1816		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18171818		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1819		Ok(())1820	}18211822	fn add_nft_item(1823		collection: &CollectionHandle<T>,1824		item: NftItemType<T::CrossAccountId>,1825	) -> DispatchResult {1826		let collection_id = collection.id;18271828		let current_index = <ItemListIndex>::get(collection_id)1829			.checked_add(1)1830			.ok_or(Error::<T>::NumOverflow)?;18311832		let item_owner = item.owner.clone();1833		Self::add_token_index(collection, current_index, &item.owner)?;18341835		<ItemListIndex>::insert(collection_id, current_index);1836		<NftItemList<T>>::insert(collection_id, current_index, item);18371838		// Update balance1839		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1840			.checked_add(1)1841			.ok_or(Error::<T>::NumOverflow)?;1842		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18431844		collection.log(ERC721Events::Transfer {1845			from: H160::default(),1846			to: *item_owner.as_eth(),1847			token_id: current_index.into(),1848		})?;1849		Self::deposit_event(RawEvent::ItemCreated(1850			collection_id,1851			current_index,1852			item_owner,1853		));1854		Ok(())1855	}18561857	fn burn_refungible_item(1858		collection: &CollectionHandle<T>,1859		item_id: TokenId,1860		owner: &T::CrossAccountId,1861	) -> DispatchResult {1862		let collection_id = collection.id;18631864		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1865			.ok_or(Error::<T>::TokenNotFound)?;1866		let rft_balance = token1867			.owner1868			.iter()1869			.find(|&i| i.owner == *owner)1870			.ok_or(Error::<T>::TokenNotFound)?;1871		Self::remove_token_index(collection, item_id, owner)?;18721873		// update balance1874		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1875			.checked_sub(rft_balance.fraction)1876			.ok_or(Error::<T>::NumOverflow)?;1877		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18781879		// Re-create owners list with sender removed1880		let index = token1881			.owner1882			.iter()1883			.position(|i| i.owner == *owner)1884			.expect("owned item is exists");1885		token.owner.remove(index);1886		let owner_count = token.owner.len();18871888		// Burn the token completely if this was the last (only) owner1889		if owner_count == 0 {1890			<ReFungibleItemList<T>>::remove(collection_id, item_id);1891			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1892		} else {1893			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1894		}18951896		Ok(())1897	}18981899	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1900		let collection_id = collection.id;19011902		let item =1903			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1904		Self::remove_token_index(collection, item_id, &item.owner)?;19051906		// update balance1907		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1908			.checked_sub(1)1909			.ok_or(Error::<T>::NumOverflow)?;1910		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1911		<NftItemList<T>>::remove(collection_id, item_id);1912		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);19131914		collection.log(ERC721Events::Transfer {1915			from: *item.owner.as_eth(),1916			to: H160::default(),1917			token_id: item_id.into(),1918		})?;1919		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1920		Ok(())1921	}19221923	fn burn_fungible_item(1924		owner: &T::CrossAccountId,1925		collection: &CollectionHandle<T>,1926		value: u128,1927	) -> DispatchResult {1928		let collection_id = collection.id;19291930		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1931		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19321933		// update balance1934		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1935			.checked_sub(value)1936			.ok_or(Error::<T>::NumOverflow)?;1937		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19381939		if balance.value - value > 0 {1940			balance.value -= value;1941			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1942		} else {1943			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1944		}19451946		collection.log(ERC20Events::Transfer {1947			from: *owner.as_eth(),1948			to: H160::default(),1949			value: value.into(),1950		})?;1951		Ok(())1952	}19531954	pub fn get_collection(1955		collection_id: CollectionId,1956	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1957		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1958	}19591960	fn check_owner_permissions(1961		target_collection: &CollectionHandle<T>,1962		subject: &T::AccountId,1963	) -> DispatchResult {1964		ensure!(1965			*subject == target_collection.owner,1966			Error::<T>::NoPermission1967		);19681969		Ok(())1970	}19711972	fn is_owner_or_admin_permissions(1973		collection: &CollectionHandle<T>,1974		subject: &T::CrossAccountId,1975	) -> Result<bool, DispatchError> {1976		collection.consume_sload()?;1977		Ok(*subject.as_sub() == collection.owner1978			|| <AdminList<T>>::get(collection.id).contains(subject))1979	}19801981	fn check_owner_or_admin_permissions(1982		collection: &CollectionHandle<T>,1983		subject: &T::CrossAccountId,1984	) -> DispatchResult {1985		ensure!(1986			Self::is_owner_or_admin_permissions(collection, subject)?,1987			Error::<T>::NoPermission1988		);19891990		Ok(())1991	}19921993	fn owned_amount(1994		subject: &T::CrossAccountId,1995		collection: &CollectionHandle<T>,1996		item_id: TokenId,1997	) -> Result<Option<u128>, DispatchError> {1998		collection.consume_sload()?;1999		Ok(Self::owned_amount_unchecked(subject, collection, item_id))2000	}20012002	fn owned_amount_unchecked(2003		subject: &T::CrossAccountId,2004		target_collection: &CollectionHandle<T>,2005		item_id: TokenId,2006	) -> Option<u128> {2007		let collection_id = target_collection.id;20082009		match target_collection.mode {2010			CollectionMode::NFT => {2011				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2012			}2013			CollectionMode::Fungible(_) => {2014				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2015			}2016			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2017				.owner2018				.iter()2019				.find(|i| i.owner == *subject)2020				.map(|i| i.fraction),2021			CollectionMode::Invalid => None,2022		}2023	}20242025	fn is_item_owner(2026		subject: &T::CrossAccountId,2027		target_collection: &CollectionHandle<T>,2028		item_id: TokenId,2029	) -> Result<bool, DispatchError> {2030		Ok(match target_collection.mode {2031			CollectionMode::Fungible(_) => true,2032			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2033		})2034	}20352036	fn check_white_list(2037		collection: &CollectionHandle<T>,2038		address: &T::CrossAccountId,2039	) -> DispatchResult {2040		collection.consume_sload()?;2041		ensure!(2042			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),2043			Error::<T>::AddresNotInWhiteList,2044		);2045		Ok(())2046	}20472048	/// Check if token exists. In case of Fungible, check if there is an entry for2049	/// the owner in fungible balances double map2050	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2051		let collection_id = target_collection.id;2052		let exists = match target_collection.mode {2053			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2054			CollectionMode::Fungible(_) => true,2055			CollectionMode::ReFungible => {2056				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2057			}2058			_ => false,2059		};20602061		ensure!(exists, Error::<T>::TokenNotFound);2062		Ok(())2063	}20642065	fn transfer_fungible(2066		collection: &CollectionHandle<T>,2067		value: u128,2068		owner: &T::CrossAccountId,2069		recipient: &T::CrossAccountId,2070	) -> DispatchResult {2071		let collection_id = collection.id;20722073		collection.consume_sload()?;2074		collection.consume_sload()?;2075		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2076		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());20772078		recipient_balance.value = recipient_balance2079			.value2080			.checked_add(value)2081			.ok_or(Error::<T>::NumOverflow)?;2082		balance.value = balance2083			.value2084			.checked_sub(value)2085			.ok_or(Error::<T>::TokenValueTooLow)?;20862087		// update balanceOf2088		collection.consume_sstore()?;2089		collection.consume_sstore()?;2090		if balance.value != 0 {2091			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2092		} else {2093			<Balance<T>>::remove(collection_id, owner.as_sub());2094		}2095		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);20962097		// Reduce or remove sender2098		collection.consume_sstore()?;2099		collection.consume_sstore()?;2100		if balance.value != 0 {2101			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2102		} else {2103			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2104		}2105		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21062107		collection.log(ERC20Events::Transfer {2108			from: *owner.as_eth(),2109			to: *recipient.as_eth(),2110			value: value.into(),2111		})?;2112		Self::deposit_event(RawEvent::Transfer(2113			collection.id,2114			1,2115			owner.clone(),2116			recipient.clone(),2117			value,2118		));21192120		Ok(())2121	}21222123	fn transfer_refungible(2124		collection: &CollectionHandle<T>,2125		item_id: TokenId,2126		value: u128,2127		owner: T::CrossAccountId,2128		new_owner: T::CrossAccountId,2129	) -> DispatchResult {2130		let collection_id = collection.id;2131		collection.consume_sload()?;2132		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2133			.ok_or(Error::<T>::TokenNotFound)?;21342135		let item = full_item2136			.owner2137			.iter()2138			.find(|i| i.owner == owner)2139			.ok_or(Error::<T>::TokenNotFound)?;2140		let amount = item.fraction;21412142		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21432144		collection.consume_sload()?;2145		// update balance2146		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2147			.checked_sub(value)2148			.ok_or(Error::<T>::NumOverflow)?;2149		collection.consume_sstore()?;2150		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21512152		collection.consume_sload()?;2153		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2154			.checked_add(value)2155			.ok_or(Error::<T>::NumOverflow)?;2156		collection.consume_sstore()?;2157		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21582159		let old_owner = item.owner.clone();2160		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21612162		let mut new_full_item = full_item.clone();2163		// transfer2164		if amount == value && !new_owner_has_account {2165			// change owner2166			// new owner do not have account2167			new_full_item2168				.owner2169				.iter_mut()2170				.find(|i| i.owner == owner)2171				.expect("old owner does present in refungible")2172				.owner = new_owner.clone();2173			collection.consume_sstore()?;2174			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21752176			// update index collection2177			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2178		} else {2179			new_full_item2180				.owner2181				.iter_mut()2182				.find(|i| i.owner == owner)2183				.expect("old owner does present in refungible")2184				.fraction -= value;21852186			// separate amount2187			if new_owner_has_account {2188				// new owner has account2189				new_full_item2190					.owner2191					.iter_mut()2192					.find(|i| i.owner == new_owner)2193					.expect("new owner has account")2194					.fraction += value;2195			} else {2196				// new owner do not have account2197				new_full_item.owner.push(Ownership {2198					owner: new_owner.clone(),2199					fraction: value,2200				});2201				Self::add_token_index(collection, item_id, &new_owner)?;2202			}22032204			collection.consume_sstore()?;2205			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2206		}22072208		Self::deposit_event(RawEvent::Transfer(2209			collection.id,2210			item_id,2211			owner,2212			new_owner,2213			amount,2214		));22152216		Ok(())2217	}22182219	fn transfer_nft(2220		collection: &CollectionHandle<T>,2221		item_id: TokenId,2222		sender: T::CrossAccountId,2223		new_owner: T::CrossAccountId,2224	) -> DispatchResult {2225		let collection_id = collection.id;2226		collection.consume_sload()?;2227		let mut item =2228			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22292230		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22312232		collection.consume_sload()?;2233		// update balance2234		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2235			.checked_sub(1)2236			.ok_or(Error::<T>::NumOverflow)?;2237		collection.consume_sstore()?;2238		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22392240		collection.consume_sload()?;2241		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2242			.checked_add(1)2243			.ok_or(Error::<T>::NumOverflow)?;2244		collection.consume_sstore()?;2245		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22462247		// change owner2248		let old_owner = item.owner.clone();2249		item.owner = new_owner.clone();2250		collection.consume_sstore()?;2251		<NftItemList<T>>::insert(collection_id, item_id, item);22522253		// update index collection2254		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22552256		collection.log(ERC721Events::Transfer {2257			from: *sender.as_eth(),2258			to: *new_owner.as_eth(),2259			token_id: item_id.into(),2260		})?;2261		Self::deposit_event(RawEvent::Transfer(2262			collection.id,2263			item_id,2264			sender,2265			new_owner,2266			1,2267		));22682269		Ok(())2270	}22712272	fn set_re_fungible_variable_data(2273		collection: &CollectionHandle<T>,2274		item_id: TokenId,2275		data: Vec<u8>,2276	) -> DispatchResult {2277		let collection_id = collection.id;2278		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2279			.ok_or(Error::<T>::TokenNotFound)?;22802281		item.variable_data = data;22822283		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);22842285		Ok(())2286	}22872288	fn set_nft_variable_data(2289		collection: &CollectionHandle<T>,2290		item_id: TokenId,2291		data: Vec<u8>,2292	) -> DispatchResult {2293		let collection_id = collection.id;2294		let mut item =2295			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22962297		item.variable_data = data;22982299		<NftItemList<T>>::insert(collection_id, item_id, item);23002301		Ok(())2302	}23032304	#[allow(dead_code)]2305	fn init_collection(item: &Collection<T>) {2306		// check params2307		assert!(2308			item.decimal_points <= MAX_DECIMAL_POINTS,2309			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2310		);2311		assert!(2312			item.name.len() <= 64,2313			"Collection name can not be longer than 63 char"2314		);2315		assert!(2316			item.name.len() <= 256,2317			"Collection description can not be longer than 255 char"2318		);2319		assert!(2320			item.token_prefix.len() <= 16,2321			"Token prefix can not be longer than 15 char"2322		);23232324		// Generate next collection ID2325		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23262327		CreatedCollectionCount::put(next_id);2328	}23292330	#[allow(dead_code)]2331	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2332		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23332334		Self::add_token_index(2335			&CollectionHandle::get(collection_id).unwrap(),2336			current_index,2337			&item.owner,2338		)2339		.unwrap();23402341		<ItemListIndex>::insert(collection_id, current_index);23422343		// Update balance2344		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2345			.checked_add(1)2346			.unwrap();2347		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2348	}23492350	#[allow(dead_code)]2351	fn init_fungible_token(2352		collection_id: CollectionId,2353		owner: &T::CrossAccountId,2354		item: &FungibleItemType,2355	) {2356		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23572358		Self::add_token_index(2359			&CollectionHandle::get(collection_id).unwrap(),2360			current_index,2361			owner,2362		)2363		.unwrap();23642365		<ItemListIndex>::insert(collection_id, current_index);23662367		// Update balance2368		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2369			.checked_add(item.value)2370			.unwrap();2371		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2372	}23732374	#[allow(dead_code)]2375	fn init_refungible_token(2376		collection_id: CollectionId,2377		item: &ReFungibleItemType<T::CrossAccountId>,2378	) {2379		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23802381		let value = item.owner.first().unwrap().fraction;2382		let owner = item.owner.first().unwrap().owner.clone();23832384		Self::add_token_index(2385			&CollectionHandle::get(collection_id).unwrap(),2386			current_index,2387			&owner,2388		)2389		.unwrap();23902391		<ItemListIndex>::insert(collection_id, current_index);23922393		// Update balance2394		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2395			.checked_add(value)2396			.unwrap();2397		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2398	}23992400	fn add_token_index(2401		collection: &CollectionHandle<T>,2402		item_index: TokenId,2403		owner: &T::CrossAccountId,2404	) -> DispatchResult {2405		// add to account limit2406		collection.consume_sload()?;2407		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2408			// bound Owned tokens by a single address2409			collection.consume_sload()?;2410			let count = <AccountItemCount<T>>::get(owner.as_sub());2411			ensure!(2412				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2413				Error::<T>::AddressOwnershipLimitExceeded2414			);24152416			collection.consume_sstore()?;2417			<AccountItemCount<T>>::insert(2418				owner.as_sub(),2419				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2420			);2421		} else {2422			collection.consume_sstore()?;2423			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2424		}24252426		collection.consume_sload()?;2427		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2428		if list_exists {2429			collection.consume_sload()?;2430			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2431			let item_contains = list.contains(&item_index.clone());24322433			if !item_contains {2434				list.push(item_index);2435			}24362437			collection.consume_sstore()?;2438			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2439		} else {2440			let itm = vec![item_index];2441			collection.consume_sstore()?;2442			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2443		}24442445		Ok(())2446	}24472448	fn remove_token_index(2449		collection: &CollectionHandle<T>,2450		item_index: TokenId,2451		owner: &T::CrossAccountId,2452	) -> DispatchResult {2453		// update counter2454		collection.consume_sload()?;2455		collection.consume_sstore()?;2456		<AccountItemCount<T>>::insert(2457			owner.as_sub(),2458			<AccountItemCount<T>>::get(owner.as_sub())2459				.checked_sub(1)2460				.ok_or(Error::<T>::NumOverflow)?,2461		);24622463		collection.consume_sload()?;2464		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2465		if list_exists {2466			collection.consume_sload()?;2467			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2468			let item_contains = list.contains(&item_index.clone());24692470			if item_contains {2471				list.retain(|&item| item != item_index);2472				collection.consume_sstore()?;2473				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2474			}2475		}24762477		Ok(())2478	}24792480	fn move_token_index(2481		collection: &CollectionHandle<T>,2482		item_index: TokenId,2483		old_owner: &T::CrossAccountId,2484		new_owner: &T::CrossAccountId,2485	) -> DispatchResult {2486		Self::remove_token_index(collection, item_index, old_owner)?;2487		Self::add_token_index(collection, item_index, new_owner)?;24882489		Ok(())2490	}2491}24922493sp_api::decl_runtime_apis! {2494	pub trait NftApi {2495		/// Used for ethereum integration2496		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2497	}2498}