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

27    'pallet-timestamp/std',27    'pallet-timestamp/std',
28    'pallet-randomness-collective-flip/std',28    'pallet-randomness-collective-flip/std',
29    'pallet-transaction-payment/std',29    'pallet-transaction-payment/std',
30    'pallet-common/std',
31    'pallet-fungible/std',
32    'pallet-nonfungible/std',
33    'pallet-refungible/std',
30    'fp-evm/std',34    'fp-evm/std',
31    'nft-data-structs/std',35    'nft-data-structs/std',
32    'up-sponsorship/std',36    'up-sponsorship/std',
155fp-evm = { default-features = false, version = '3.0.0-dev', git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.10" }159fp-evm = { default-features = false, version = '3.0.0-dev', git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.10" }
156hex-literal = "0.3.3"160hex-literal = "0.3.3"
161
162pallet-common = { default-features = false, path = "../common" }
163pallet-fungible = { default-features = false, path = "../fungible" }
164pallet-nonfungible = { default-features = false, path = "../nonfungible" }
165pallet-refungible = { default-features = false, path = "../refungible" }
157166

16pub use serde::{Serialize, Deserialize};16pub use serde::{Serialize, Deserialize};
1717
18pub use frame_support::{18pub use frame_support::{
19	construct_runtime, decl_event, decl_module, decl_storage, decl_error,19	construct_runtime, decl_module, decl_storage, decl_error,
20	dispatch::DispatchResult,20	dispatch::DispatchResult,
21	ensure, fail, parameter_types,21	ensure, fail, parameter_types,
22	traits::{22	traits::{
23		Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23		ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced, Randomness,
24		Randomness, IsSubType, WithdrawReasons,24		IsSubType, WithdrawReasons,
25	},25	},
26	weights::{26	weights::{
27		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},
28		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,
29		WeightToFeePolynomial, DispatchClass,29		WeightToFeePolynomial, DispatchClass,
30	},30	},
31	StorageValue, transactional,31	StorageValue, transactional,
32	pallet_prelude::DispatchResultWithPostInfo,
32};33};
33
34use frame_system::{self as system, ensure_signed};34use frame_system::{self as system, ensure_signed};
35use sp_core::H160;35use sp_runtime::{sp_std::prelude::Vec};
36use sp_std::vec;
37use sp_runtime::{DispatchError, sp_std::prelude::Vec};
38use core::ops::{Deref, DerefMut};
39use nft_data_structs::{36use nft_data_structs::{
40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,37	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, CUSTOM_DATA_LIMIT,
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,38	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,39	OFFCHAIN_SCHEMA_LIMIT, AccessMode, Collection, CreateItemData, CollectionLimits, CollectionId,
44	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,
45	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,40	CollectionMode, TokenId, SchemaVersion, SponsorshipState, MetaUpdatePermission,
46	MetaUpdatePermission, FungibleItemType, ReFungibleItemType,
47};41};
42use pallet_common::{
43	account::CrossAccountId, CollectionHandle, IsAdmin, Pallet as PalletCommon,
44	Error as CommonError, CommonWeightInfo,
45};
46use pallet_refungible::{Pallet as PalletRefungible, RefungibleHandle};
47use pallet_fungible::{Pallet as PalletFungible, FungibleHandle};
48use pallet_nonfungible::{Pallet as PalletNonfungible, NonfungibleHandle};
4849
49#[cfg(test)]50#[cfg(test)]
50mod mock;51mod mock;
58pub use eth::sponsoring::NftEthSponsorshipHandler;59pub use eth::sponsoring::NftEthSponsorshipHandler;
5960
60pub use eth::NftErcSupport;61pub use eth::NftErcSupport;
61pub use eth::account::*;
62use eth::erc::{ERC20Events, ERC721Events};
6362
63pub mod common;
64use common::CommonWeights;
65pub mod dispatch;
66use dispatch::dispatch_call;
67
64#[cfg(feature = "runtime-benchmarks")]68#[cfg(feature = "runtime-benchmarks")]
65mod benchmarking;69mod benchmarking;
66pub mod weights;70pub mod weights;
125			.max(Self::create_multiple_items_fungible(amount))129			.max(Self::create_multiple_items_fungible(amount))
126			.max(Self::create_multiple_items_refungible(amount))130			.max(Self::create_multiple_items_refungible(amount))
127	}131	}
128	fn burn_item() -> Weight {
129		// TODO: refungible, fungible
130		Self::burn_item_nft()
131	}
132}132}
133impl<T: WeightInfo> WeightInfoHelpers for T {}133impl<T: WeightInfo> WeightInfoHelpers for T {}
134134
219			// Anyone can create a collection219			// Anyone can create a collection
220			let who = ensure_signed(origin)?;220			let who = ensure_signed(origin)?;
221221
222			// Take a (non-refundable) deposit of collection creation222			let limits = CollectionLimits::<T::BlockNumber> {
223			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();
224			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(
225				&T::TreasuryAccountId::get(),
226				T::CollectionCreationPrice::get(),
227			));
228			<T as Config>::Currency::settle(
229				&who,
230				imbalance,
231				WithdrawReasons::TRANSFER,
232				ExistenceRequirement::KeepAlive,
233			).map_err(|_| Error::<T>::NoPermission)?;
234
235			let decimal_points = match mode {
236				CollectionMode::Fungible(points) => points,
237				_ => 0
238			};
239
240			let created_count = CreatedCollectionCount::get();
241			let destroyed_count = DestroyedCollectionCount::get();
242
243			// bound Total number of collections
244			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);
245
246			// check params
247			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
248			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);
249			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);
250			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);
251
252			// Generate next collection ID
253			let next_id = created_count
254				.checked_add(1)
255				.ok_or(Error::<T>::NumOverflow)?;
256
257			CreatedCollectionCount::put(next_id);
258
259			let limits = CollectionLimits {
260				sponsored_data_size: CUSTOM_DATA_LIMIT,223				sponsored_data_size: CUSTOM_DATA_LIMIT,
261				..Default::default()224				..Default::default()
262			};225			};
263226
264			// Create new collection227			// Create new collection
265			let new_collection = Collection {228			let new_collection = Collection::<T> {
266				owner: who.clone(),229				owner: who.clone(),
267				name: collection_name,230				name: collection_name,
268				mode: mode.clone(),231				mode: mode.clone(),
269				mint_mode: false,232				mint_mode: false,
270				access: AccessMode::Normal,233				access: AccessMode::Normal,
271				description: collection_description,234				description: collection_description,
272				decimal_points,
273				token_prefix,235				token_prefix,
274				offchain_schema: Vec::new(),236				offchain_schema: Vec::new(),
275				schema_version: SchemaVersion::ImageURL,237				schema_version: SchemaVersion::ImageURL,
276				sponsorship: SponsorshipState::Disabled,238				sponsorship: SponsorshipState::Disabled,
277				variable_on_chain_schema: Vec::new(),239				variable_on_chain_schema: Vec::new(),
278				const_on_chain_schema: Vec::new(),240				const_on_chain_schema: Vec::new(),
279				limits,241				limits,
280				meta_update_permission: MetaUpdatePermission::default(),
281				transfers_enabled: true,242				transfers_enabled: true,
243				meta_update_permission: Default::default(),
282			};244			};
283245
284			// Add new collection to map246			let _id = match mode {
285			<CollectionById<T>>::insert(next_id, new_collection);247				CollectionMode::NFT => {PalletNonfungible::init_collection(new_collection)?},
248				CollectionMode::Fungible(decimal_points) => {
249					// check params
250					ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
251					PalletFungible::init_collection(new_collection)?
252				}
253				CollectionMode::ReFungible => {
254					PalletRefungible::init_collection(new_collection)?
255				}
256			};
286257
287			// call event
288			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));
289
290			Ok(())258			Ok(())
291		}259		}
292260
302		#[weight = <SelfWeightOf<T>>::destroy_collection()]270		#[weight = <SelfWeightOf<T>>::destroy_collection()]
303		#[transactional]271		#[transactional]
304		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {272		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {
273			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
305274
306			let sender = ensure_signed(origin)?;275			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
307			let collection = Self::get_collection(collection_id)?;
308			Self::check_owner_permissions(&collection, &sender)?;276			collection.check_is_owner(&sender)?;
309			if !collection.limits.owner_can_destroy {
310				fail!(Error::<T>::NoPermission);
311			}
312277
313			<AddressTokens<T>>::remove_prefix(collection_id, None);278			// =========
314			<Allowances<T>>::remove_prefix(collection_id, None);
315			<Balance<T>>::remove_prefix(collection_id, None);
316			<ItemListIndex>::remove(collection_id);
317			<AdminList<T>>::remove(collection_id);
318			<CollectionById<T>>::remove(collection_id);
319			<WhiteList<T>>::remove_prefix(collection_id, None);
320279
321			<NftItemList<T>>::remove_prefix(collection_id, None);280			match collection.mode {
281				CollectionMode::ReFungible => PalletRefungible::destroy_collection(RefungibleHandle::cast(collection), &sender)?,
322			<FungibleItemList<T>>::remove_prefix(collection_id, None);282				CollectionMode::Fungible(_) => PalletFungible::destroy_collection(FungibleHandle::cast(collection), &sender)?,
323			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);283				CollectionMode::NFT => PalletNonfungible::destroy_collection(NonfungibleHandle::cast(collection), &sender)?,
284			}
324285
325			<NftTransferBasket<T>>::remove_prefix(collection_id, None);286			<NftTransferBasket<T>>::remove_prefix(collection_id, None);
326			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);287			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);
327			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);288			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);
328289
329			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);290			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);
330291
331			DestroyedCollectionCount::put(DestroyedCollectionCount::get()
332				.checked_add(1)
333				.ok_or(Error::<T>::NumOverflow)?);
334
335			Ok(())292			Ok(())
336		}293		}
337294
352		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{309		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
353310
354			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);311			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
355			let collection = Self::get_collection(collection_id)?;312			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
356313
357			Self::toggle_white_list_internal(314			<PalletCommon<T>>::toggle_whitelist(
358				&sender,
359				&collection,315				&collection,
316				&sender,
360				&address,317				&address,
361				true,318				true,
362			)?;319			)?;
381		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{338		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
382339
383			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);340			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
384			let collection = Self::get_collection(collection_id)?;341			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
385342
386			Self::toggle_white_list_internal(343			<PalletCommon<T>>::toggle_whitelist(
387				&sender,
388				&collection,344				&collection,
345				&sender,
389				&address,346				&address,
390				false,347				false,
391			)?;348			)?;
408		#[transactional]365		#[transactional]
409		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult366		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult
410		{367		{
411			let sender = ensure_signed(origin)?;368			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
412369
413			let mut target_collection = Self::get_collection(collection_id)?;370			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
414			Self::check_owner_permissions(&target_collection, &sender)?;371			target_collection.check_is_owner(&sender)?;
372
415			target_collection.access = mode;373			target_collection.access = mode;
416			target_collection.save()374			target_collection.save()
433		#[transactional]391		#[transactional]
434		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult392		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult
435		{393		{
436			let sender = ensure_signed(origin)?;394			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
437395
438			let mut target_collection = Self::get_collection(collection_id)?;396			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
439			Self::check_owner_permissions(&target_collection, &sender)?;397			target_collection.check_is_owner(&sender)?;
398
440			target_collection.mint_mode = mint_permission;399			target_collection.mint_mode = mint_permission;
441			target_collection.save()400			target_collection.save()
456		#[transactional]415		#[transactional]
457		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {416		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {
458417
459			let sender = ensure_signed(origin)?;418			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
419
460			let mut target_collection = Self::get_collection(collection_id)?;420			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
461			Self::check_owner_permissions(&target_collection, &sender)?;421			target_collection.check_is_owner(&sender)?;
422
462			target_collection.owner = new_owner;423			target_collection.owner = new_owner;
463			target_collection.save()424			target_collection.save()
480		#[transactional]441		#[transactional]
481		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {442		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {
482			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);443			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
483			let collection = Self::get_collection(collection_id)?;
484			Self::check_owner_or_admin_permissions(&collection, &sender)?;
485			let mut admin_arr = <AdminList<T>>::get(collection_id);
486444
487			match admin_arr.binary_search(&new_admin_id) {445			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
488				Ok(_) => {},
489				Err(idx) => {
490					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);
491					admin_arr.insert(idx, new_admin_id);446			collection.check_is_owner_or_admin(&sender)?;
447
492					<AdminList<T>>::insert(collection_id, admin_arr);448			<IsAdmin<T>>::insert((collection_id, new_admin_id.as_sub()), true);
493				}
494			}
495			Ok(())449			Ok(())
496		}450		}
497451
511		#[transactional]465		#[transactional]
512		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {466		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {
513			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);467			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
514			let collection = Self::get_collection(collection_id)?;
515			Self::check_owner_or_admin_permissions(&collection, &sender)?;
516			let mut admin_arr = <AdminList<T>>::get(collection_id);
517468
518			if let Ok(idx) = admin_arr.binary_search(&account_id) {469			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
519				admin_arr.remove(idx);470			collection.check_is_owner_or_admin(&sender)?;
471
520				<AdminList<T>>::insert(collection_id, admin_arr);472			<IsAdmin<T>>::remove((collection_id, account_id.as_sub()));
521			}
522			Ok(())473			Ok(())
523		}474		}
524475
534		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]485		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]
535		#[transactional]486		#[transactional]
536		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {487		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {
537			let sender = ensure_signed(origin)?;488			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
538			let mut target_collection = Self::get_collection(collection_id)?;
539			Self::check_owner_permissions(&target_collection, &sender)?;
540489
490			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
491			target_collection.check_is_owner_or_admin(&sender)?;
492
541			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);493			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);
542			target_collection.save()494			target_collection.save()
543		}495		}
554		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {506		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {
555			let sender = ensure_signed(origin)?;507			let sender = ensure_signed(origin)?;
556508
557			let mut target_collection = Self::get_collection(collection_id)?;509			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
558			ensure!(510			ensure!(
559				target_collection.sponsorship.pending_sponsor() == Some(&sender),511				target_collection.sponsorship.pending_sponsor() == Some(&sender),
560				Error::<T>::ConfirmUnsetSponsorFail512				Error::<T>::ConfirmUnsetSponsorFail
576		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]528		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]
577		#[transactional]529		#[transactional]
578		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {530		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {
579			let sender = ensure_signed(origin)?;531			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
580532
581			let mut target_collection = Self::get_collection(collection_id)?;533			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
582			Self::check_owner_permissions(&target_collection, &sender)?;534			target_collection.check_is_owner(&sender)?;
583535
584			target_collection.sponsorship = SponsorshipState::Disabled;536			target_collection.sponsorship = SponsorshipState::Disabled;
585			target_collection.save()537			target_collection.save()
603		/// * owner: Address, initial owner of the NFT.555		/// * owner: Address, initial owner of the NFT.
604		///556		///
605		/// * data: Token data to store on chain.557		/// * data: Token data to store on chain.
606		// #[weight =558		#[weight = <CommonWeights<T>>::create_item()]
607		// (130_000_000 as Weight)
608		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))
609		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))
610		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]
611
612		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]
613		#[transactional]559		#[transactional]
614		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {560		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResultWithPostInfo {
615			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);561			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
616			let collection = Self::get_collection(collection_id)?;
617562
618			Self::create_item_internal(&sender, &collection, &owner, data)?;563			dispatch_call::<T, _>(collection_id, |d| d.create_item(sender, owner, data))
619
620			collection.submit_logs()
621		}564		}
622565
623		/// This method creates multiple items in a collection created with CreateCollection method.566		/// This method creates multiple items in a collection created with CreateCollection method.
638		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].581		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].
639		///582		///
640		/// * owner: Address, initial owner of the NFT.583		/// * owner: Address, initial owner of the NFT.
641		#[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]584		#[weight = <CommonWeights<T>>::create_multiple_items(items_data.len() as u32)]
642		#[transactional]585		#[transactional]
643		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {586		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResultWithPostInfo {
644
645			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);587			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);
646			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);588			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
647			let collection = Self::get_collection(collection_id)?;
648589
649			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;590			dispatch_call::<T, _>(collection_id, |d| d.create_multiple_items(sender, owner, items_data))
650
651			collection.submit_logs()
652		}591		}
653592
654		// TODO! transaction weight593		// TODO! transaction weight
667		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]606		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]
668		#[transactional]607		#[transactional]
669		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {608		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {
609			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
610			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
611			target_collection.check_is_owner(&sender)?;
670612
671			let sender = ensure_signed(origin)?;613			// =========
672			let mut target_collection = Self::get_collection(collection_id)?;
673614
674			Self::check_owner_permissions(&target_collection, &sender)?;
675
676			target_collection.transfers_enabled = value;615			target_collection.transfers_enabled = value;
677			target_collection.save()616			target_collection.save()
678		}617		}
679618
680		// TODO! transaction weight
681		/// Set meta_update_permission value for particular collection
682		///
683		/// # Permissions
684		///
685		/// * Collection Owner.
686		///
687		/// # Arguments
688		///
689		/// * collection_id: ID of the collection.
690		///
691		/// * value: New flag value.
692		#[weight = <T as Config>::WeightInfo::burn_item()]
693		#[transactional]
694		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {
695
696			let sender = ensure_signed(origin)?;
697			let mut target_collection = Self::get_collection(collection_id)?;
698
699			ensure!(
700				target_collection.meta_update_permission != MetaUpdatePermission::None,
701				Error::<T>::MetadataFlagFrozen
702			);
703			Self::check_owner_permissions(&target_collection, &sender)?;
704
705			target_collection.meta_update_permission = value;
706
707			target_collection.save()
708		}
709
710		/// Destroys a concrete instance of NFT.619		/// Destroys a concrete instance of NFT.
711		///620		///
712		/// # Permissions621		/// # Permissions
720		/// * collection_id: ID of the collection.629		/// * collection_id: ID of the collection.
721		///630		///
722		/// * item_id: ID of NFT to burn.631		/// * item_id: ID of NFT to burn.
723		#[weight = <SelfWeightOf<T>>::burn_item()]632		#[weight = <CommonWeights<T>>::burn_item()]
724		#[transactional]633		#[transactional]
725		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {634		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {
726
727			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);635			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
728			let target_collection = Self::get_collection(collection_id)?;
729636
730			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;637			dispatch_call::<T, _>(collection_id, |d| d.burn_item(sender, item_id, value))
731
732			target_collection.submit_logs()
733		}638		}
734639
735		/// Change ownership of the token.640		/// Change ownership of the token.
755		///     * Non-Fungible Mode: Ignored660		///     * Non-Fungible Mode: Ignored
756		///     * Fungible Mode: Must specify transferred amount661		///     * Fungible Mode: Must specify transferred amount
757		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)662		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)
758		#[weight = <SelfWeightOf<T>>::transfer()]663		#[weight = <CommonWeights<T>>::transfer()]
759		#[transactional]664		#[transactional]
760		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {665		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {
761			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);666			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
762			let collection = Self::get_collection(collection_id)?;
763667
764			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;668			dispatch_call::<T, _>(collection_id, |d| d.transfer(sender, recipient, item_id, value))
765
766			collection.submit_logs()
767		}669		}
768670
769		/// Set, change, or remove approved address to transfer the ownership of the NFT.671		/// Set, change, or remove approved address to transfer the ownership of the NFT.
781		/// * collection_id.683		/// * collection_id.
782		///684		///
783		/// * item_id: ID of the item.685		/// * item_id: ID of the item.
784		#[weight = <SelfWeightOf<T>>::approve()]686		#[weight = <CommonWeights<T>>::approve()]
785		#[transactional]687		#[transactional]
786		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {688		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResultWithPostInfo {
787			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);689			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
788			let collection = Self::get_collection(collection_id)?;
789690
790			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;691			dispatch_call::<T, _>(collection_id, |d| d.approve(sender, spender, item_id, amount))
791
792			collection.submit_logs()
793		}692		}
794693
795		/// 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.694		/// 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.
811		/// * item_id: ID of the item.710		/// * item_id: ID of the item.
812		///711		///
813		/// * value: Amount to transfer.712		/// * value: Amount to transfer.
814		#[weight = <SelfWeightOf<T>>::transfer_from()]713		#[weight = <CommonWeights<T>>::transfer_from()]
815		#[transactional]714		#[transactional]
816		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {715		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResultWithPostInfo {
817			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);716			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
818			let collection = Self::get_collection(collection_id)?;
819717
820			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;718			dispatch_call::<T, _>(collection_id, |d| d.transfer_from(sender, from, recipient, item_id, value))
821
822			collection.submit_logs()
823		}719		}
824		// #[weight = 0]
825		//     // let no_perm_mes = "You do not have permissions to modify this collection";
826		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);
827		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));
828		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);
829720
830		//     // // on_nft_received  call
831
832		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;
833
834		//     Ok(())
835		// }
836
837		/// Set off-chain data schema.721		/// Set off-chain data schema.
838		///722		///
839		/// # Permissions723		/// # Permissions
846		/// * collection_id.730		/// * collection_id.
847		///731		///
848		/// * schema: String representing the offchain data schema.732		/// * schema: String representing the offchain data schema.
849		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]733		#[weight = <CommonWeights<T>>::set_variable_metadata(data.len() as u32)]
850		#[transactional]734		#[transactional]
851		pub fn set_variable_meta_data (735		pub fn set_variable_meta_data (
852			origin,736			origin,
853			collection_id: CollectionId,737			collection_id: CollectionId,
854			item_id: TokenId,738			item_id: TokenId,
855			data: Vec<u8>739			data: Vec<u8>
856		) -> DispatchResult {740		) -> DispatchResultWithPostInfo {
857			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);741			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
858742
859			let collection = Self::get_collection(collection_id)?;743			dispatch_call::<T, _>(collection_id, |d| d.set_variable_metadata(sender, item_id, data))
860			Self::meta_update_check(&sender, &collection, item_id)?;744		}
861745
862			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;746		/// Set meta_update_permission value for particular collection
747		///
748		/// # Permissions
749		///
750		/// * Collection Owner.
751		///
752		/// # Arguments
753		///
754		/// * collection_id: ID of the collection.
755		///
756		/// * value: New flag value.
757		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(0)]
758		#[transactional]
759		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {
760			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
761			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
863762
864			Ok(())763			ensure!(
764				target_collection.meta_update_permission != MetaUpdatePermission::None,
765				<CommonError<T>>::MetadataFlagFrozen,
766			);
767			target_collection.check_is_owner(&sender)?;
768
769			target_collection.meta_update_permission = value;
770
771			target_collection.save()
865		}772		}
866773
867		/// Set schema standard774		/// Set schema standard
886			version: SchemaVersion793			version: SchemaVersion
887		) -> DispatchResult {794		) -> DispatchResult {
888			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);795			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
889			let mut target_collection = Self::get_collection(collection_id)?;796			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
890			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;797			target_collection.check_is_owner_or_admin(&sender)?;
891			target_collection.schema_version = version;798			target_collection.schema_version = version;
892			target_collection.save()799			target_collection.save()
893		}800		}
912			schema: Vec<u8>819			schema: Vec<u8>
913		) -> DispatchResult {820		) -> DispatchResult {
914			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);821			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
915			let mut target_collection = Self::get_collection(collection_id)?;822			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
916			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;823			target_collection.check_is_owner_or_admin(&sender)?;
917824
918			// check schema limit825			// check schema limit
919			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");826			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");
942			schema: Vec<u8>849			schema: Vec<u8>
943		) -> DispatchResult {850		) -> DispatchResult {
944			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);851			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
945			let mut target_collection = Self::get_collection(collection_id)?;852			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
946			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;853			target_collection.check_is_owner_or_admin(&sender)?;
947854
948			// check schema limit855			// check schema limit
949			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");856			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");
972			schema: Vec<u8>879			schema: Vec<u8>
973		) -> DispatchResult {880		) -> DispatchResult {
974			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
975			let mut target_collection = Self::get_collection(collection_id)?;882			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
976			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;883			target_collection.check_is_owner_or_admin(&sender)?;
977884
978			// check schema limit885			// check schema limit
979			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");886			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");
986		#[transactional]893		#[transactional]
987		pub fn set_collection_limits(894		pub fn set_collection_limits(
988			origin,895			origin,
989			collection_id: u32,896			collection_id: CollectionId,
990			new_limits: CollectionLimits<T::BlockNumber>,897			new_limits: CollectionLimits<T::BlockNumber>,
991		) -> DispatchResult {898		) -> DispatchResult {
992			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);899			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
993			let mut target_collection = Self::get_collection(collection_id)?;900			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
994			Self::check_owner_permissions(&target_collection, sender.as_sub())?;901			target_collection.check_is_owner(&sender)?;
995			let old_limits = &target_collection.limits;902			let old_limits = &target_collection.limits;
996903
997			// collection bounds904			// collection bounds
998			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&905			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&
999				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&906				new_limits.account_token_ownership_limit.unwrap_or(0) <= MAX_TOKEN_OWNERSHIP &&
1000				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,907				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,
1001				Error::<T>::CollectionLimitBoundsExceeded);908				Error::<T>::CollectionLimitBoundsExceeded);
1002909
1003			// token_limit   check  prev910			// token_limit   check  prev
1004			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);911			ensure!(old_limits.token_limit >= new_limits.token_limit, <CommonError<T>>::CollectionTokenLimitExceeded);
1005			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);912			ensure!(new_limits.token_limit > 0, <CommonError<T>>::CollectionTokenLimitExceeded);
1006913
1007			ensure!(914			ensure!(
1008				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&915				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&
1014921
1015			target_collection.save()922			target_collection.save()
1016		}923		}
1017	}
1018}
1019
1020impl<T: Config> Module<T> {
1021	pub fn create_item_internal(
1022		sender: &T::CrossAccountId,
1023		collection: &CollectionHandle<T>,
1024		owner: &T::CrossAccountId,
1025		data: CreateItemData,
1026	) -> DispatchResult {
1027		ensure!(
1028			owner != &T::CrossAccountId::from_eth(H160([0; 20])),
1029			Error::<T>::AddressIsZero
1030		);
1031
1032		Self::can_create_items_in_collection(collection, sender, owner, 1)?;
1033		Self::validate_create_item_args(collection, &data)?;
1034		Self::create_item_no_validation(collection, owner, data)?;
1035
1036		Ok(())
1037	}
1038
1039	pub fn transfer_internal(
1040		sender: &T::CrossAccountId,
1041		recipient: &T::CrossAccountId,
1042		target_collection: &CollectionHandle<T>,
1043		item_id: TokenId,
1044		value: u128,
1045	) -> DispatchResult {
1046		ensure!(
1047			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),
1048			Error::<T>::AddressIsZero
1049		);
1050
1051		// Limits check
1052		Self::is_correct_transfer(target_collection, recipient)?;
1053
1054		// Transfer permissions check
1055		ensure!(
1056			Self::is_item_owner(sender, target_collection, item_id)?
1057				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,
1058			Error::<T>::NoPermission
1059		);
1060
1061		if target_collection.access == AccessMode::WhiteList {
1062			Self::check_white_list(target_collection, sender)?;
1063			Self::check_white_list(target_collection, recipient)?;
1064		}
1065
1066		match target_collection.mode {
1067			CollectionMode::NFT => Self::transfer_nft(
1068				target_collection,
1069				item_id,
1070				sender.clone(),
1071				recipient.clone(),
1072			)?,
1073			CollectionMode::Fungible(_) => {
1074				Self::transfer_fungible(target_collection, value, sender, recipient)?
1075			}
1076			CollectionMode::ReFungible => Self::transfer_refungible(
1077				target_collection,
1078				item_id,
1079				value,
1080				sender.clone(),
1081				recipient.clone(),
1082			)?,
1083		};
1084
1085		Self::deposit_event(RawEvent::Transfer(
1086			target_collection.id,
1087			item_id,
1088			sender.clone(),
1089			recipient.clone(),
1090			value,
1091		));
1092
1093		Ok(())
1094	}
1095
1096	pub fn approve_internal(
1097		sender: &T::CrossAccountId,
1098		spender: &T::CrossAccountId,
1099		collection: &CollectionHandle<T>,
1100		item_id: TokenId,
1101		amount: u128,
1102	) -> DispatchResult {
1103		Self::token_exists(collection, item_id)?;
1104
1105		// Transfer permissions check
1106		let bypasses_limits = collection.limits.owner_can_transfer
1107			&& Self::is_owner_or_admin_permissions(collection, sender)?;
1108
1109		let allowance_limit = if bypasses_limits {
1110			None
1111		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {
1112			Some(amount)
1113		} else {
1114			fail!(Error::<T>::NoPermission);
1115		};
1116
1117		if collection.access == AccessMode::WhiteList {
1118			Self::check_white_list(collection, sender)?;
1119			Self::check_white_list(collection, spender)?;
1120		}
1121
1122		collection.consume_sload()?;
1123		let allowance: u128 = amount
1124			.checked_add(<Allowances<T>>::get(
1125				collection.id,
1126				(item_id, sender.as_sub(), spender.as_sub()),
1127			))
1128			.ok_or(Error::<T>::NumOverflow)?;
1129		if let Some(limit) = allowance_limit {
1130			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);
1131		}
1132		collection.consume_sstore()?;
1133		<Allowances<T>>::insert(
1134			collection.id,
1135			(item_id, sender.as_sub(), spender.as_sub()),
1136			allowance,
1137		);
1138
1139		if matches!(collection.mode, CollectionMode::NFT) {
1140			// TODO: NFT: only one owner may exist for token in ERC721
1141			collection.log(ERC721Events::Approval {
1142				owner: *sender.as_eth(),
1143				approved: *spender.as_eth(),
1144				token_id: item_id.into(),
1145			})?;
1146		}
1147
1148		if matches!(collection.mode, CollectionMode::Fungible(_)) {
1149			// TODO: NFT: only one owner may exist for token in ERC20
1150			collection.log(ERC20Events::Approval {
1151				owner: *sender.as_eth(),
1152				spender: *spender.as_eth(),
1153				value: allowance.into(),
1154			})?;
1155		}
1156
1157		Self::deposit_event(RawEvent::Approved(
1158			collection.id,
1159			item_id,
1160			sender.clone(),
1161			spender.clone(),
1162			allowance,
1163		));
1164		Ok(())
1165	}
1166
1167	pub fn transfer_from_internal(
1168		sender: &T::CrossAccountId,
1169		from: &T::CrossAccountId,
1170		recipient: &T::CrossAccountId,
1171		collection: &CollectionHandle<T>,
1172		item_id: TokenId,
1173		amount: u128,
1174	) -> DispatchResult {
1175		if sender == from {
1176			// Transfer by `from`, because it is either equal to sender, or derived from him
1177			return Self::transfer_internal(from, recipient, collection, item_id, amount);
1178		}
1179
1180		// Check approval
1181		collection.consume_sload()?;
1182		let approval: u128 =
1183			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));
1184
1185		// Limits check
1186		Self::is_correct_transfer(collection, recipient)?;
1187
1188		// Transfer permissions check
1189		ensure!(
1190			approval >= amount
1191				|| (collection.limits.owner_can_transfer
1192					&& Self::is_owner_or_admin_permissions(collection, sender)?),
1193			Error::<T>::NoPermission
1194		);
1195
1196		if collection.access == AccessMode::WhiteList {
1197			Self::check_white_list(collection, sender)?;
1198			Self::check_white_list(collection, recipient)?;
1199		}
1200
1201		// Reduce approval by transferred amount or remove if remaining approval drops to 0
1202		let allowance = approval.saturating_sub(amount);
1203		collection.consume_sstore()?;
1204		if allowance > 0 {
1205			<Allowances<T>>::insert(
1206				collection.id,
1207				(item_id, from.as_sub(), sender.as_sub()),
1208				allowance,
1209			);
1210		} else {
1211			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));
1212		}
1213
1214		match collection.mode {
1215			CollectionMode::NFT => {
1216				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?
1217			}
1218			CollectionMode::Fungible(_) => {
1219				Self::transfer_fungible(collection, amount, from, recipient)?
1220			}
1221			CollectionMode::ReFungible => Self::transfer_refungible(
1222				collection,
1223				item_id,
1224				amount,
1225				from.clone(),
1226				recipient.clone(),
1227			)?,
1228		};
1229
1230		if matches!(collection.mode, CollectionMode::Fungible(_)) {
1231			collection.log(ERC20Events::Approval {
1232				owner: *from.as_eth(),
1233				spender: *sender.as_eth(),
1234				value: allowance.into(),
1235			})?;
1236		}
1237
1238		Ok(())
1239	}
1240
1241	pub fn set_variable_meta_data_internal(
1242		sender: &T::CrossAccountId,
1243		collection: &CollectionHandle<T>,
1244		item_id: TokenId,
1245		data: Vec<u8>,
1246	) -> DispatchResult {
1247		Self::token_exists(collection, item_id)?;
1248
1249		ensure!(
1250			CUSTOM_DATA_LIMIT >= data.len() as u32,
1251			Error::<T>::TokenVariableDataLimitExceeded
1252		);
1253
1254		ensure!(
1255			(Self::is_item_owner(sender, collection, item_id)?
1256				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)
1257				|| (Self::is_owner_or_admin_permissions(collection, sender)?
1258					&& collection.meta_update_permission == MetaUpdatePermission::Admin),
1259			Error::<T>::NoPermission
1260		);
1261
1262		match collection.mode {
1263			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,
1264			CollectionMode::ReFungible => {
1265				Self::set_re_fungible_variable_data(collection, item_id, data)?
1266			}
1267			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),
1268		};
1269
1270		Ok(())
1271	}
1272
1273	pub fn meta_update_check(
1274		sender: &T::CrossAccountId,
1275		collection: &CollectionHandle<T>,
1276		item_id: TokenId,
1277	) -> DispatchResult {
1278		match collection.meta_update_permission {
1279			MetaUpdatePermission::ItemOwner => ensure!(
1280				Self::is_item_owner(sender, collection, item_id)?,
1281				Error::<T>::NoPermission
1282			),
1283			MetaUpdatePermission::Admin => ensure!(
1284				Self::is_owner_or_admin_permissions(collection, sender)?,
1285				Error::<T>::NoPermission
1286			),
1287			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),
1288		}
1289
1290		Ok(())
1291	}
1292
1293	pub fn get_variable_metadata(
1294		collection: &CollectionHandle<T>,
1295		item_id: TokenId,
1296	) -> Result<Vec<u8>, DispatchError> {
1297		Ok(match collection.mode {
1298			CollectionMode::NFT => {
1299				<NftItemList<T>>::get(collection.id, item_id)
1300					.ok_or(Error::<T>::TokenNotFound)?
1301					.variable_data
1302			}
1303			CollectionMode::ReFungible => {
1304				<ReFungibleItemList<T>>::get(collection.id, item_id)
1305					.ok_or(Error::<T>::TokenNotFound)?
1306					.variable_data
1307			}
1308			_ => fail!(Error::<T>::UnexpectedCollectionType),
1309		})
1310	}
1311
1312	pub fn create_multiple_items_internal(
1313		sender: &T::CrossAccountId,
1314		collection: &CollectionHandle<T>,
1315		owner: &T::CrossAccountId,
1316		items_data: Vec<CreateItemData>,
1317	) -> DispatchResult {
1318		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;
1319
1320		for data in &items_data {
1321			Self::validate_create_item_args(collection, data)?;
1322		}
1323		for data in &items_data {
1324			Self::create_item_no_validation(collection, owner, data.clone())?;
1325		}
1326
1327		Ok(())
1328	}
1329
1330	pub fn burn_item_internal(
1331		sender: &T::CrossAccountId,
1332		collection: &CollectionHandle<T>,
1333		item_id: TokenId,
1334		value: u128,
1335	) -> DispatchResult {
1336		ensure!(
1337			Self::is_item_owner(sender, collection, item_id)?
1338				|| (collection.limits.owner_can_transfer
1339					&& Self::is_owner_or_admin_permissions(collection, sender)?),
1340			Error::<T>::NoPermission
1341		);
1342
1343		if collection.access == AccessMode::WhiteList {
1344			Self::check_white_list(collection, sender)?;
1345		}
1346
1347		match collection.mode {
1348			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,
1349			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,
1350			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,
1351		};
1352
1353		Ok(())
1354	}
1355
1356	pub fn toggle_white_list_internal(
1357		sender: &T::CrossAccountId,
1358		collection: &CollectionHandle<T>,
1359		address: &T::CrossAccountId,
1360		whitelisted: bool,
1361	) -> DispatchResult {
1362		Self::check_owner_or_admin_permissions(collection, sender)?;
1363
1364		if whitelisted {
1365			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);
1366		} else {
1367			<WhiteList<T>>::remove(collection.id, address.as_sub());
1368		}
1369
1370		Ok(())
1371	}
1372
1373	fn is_correct_transfer(
1374		collection: &CollectionHandle<T>,
1375		recipient: &T::CrossAccountId,
1376	) -> DispatchResult {
1377		let collection_id = collection.id;
1378
1379		// check token limit and account token limit
1380		collection.consume_sload()?;
1381		let account_items: u32 =
1382			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;
1383
1384		// zero limit means collection limit is disabled
1385		// otherwise get lower value
1386		let limit = if collection.limits.account_token_ownership_limit == 0
1387			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT
1388		{
1389			ACCOUNT_TOKEN_OWNERSHIP_LIMIT
1390		} else {
1391			collection.limits.account_token_ownership_limit
1392		};
1393
1394		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);
1395
1396		// preliminary transfer check
1397		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);
1398
1399		Ok(())
1400	}
1401
1402	fn can_create_items_in_collection(
1403		collection: &CollectionHandle<T>,
1404		sender: &T::CrossAccountId,
1405		owner: &T::CrossAccountId,
1406		amount: u32,
1407	) -> DispatchResult {
1408		let collection_id = collection.id;
1409
1410		// check token limit and account token limit
1411		let total_items: u32 = ItemListIndex::get(collection_id)
1412			.checked_add(amount)
1413			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;
1414		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()
1415			as u32)
1416			.checked_add(amount)
1417			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;
1418
1419		// zero limit means collection limit is disabled
1420		// otherwise get lower value
1421		let account_token_limit = if collection.limits.account_token_ownership_limit == 0
1422			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT
1423		{
1424			ACCOUNT_TOKEN_OWNERSHIP_LIMIT
1425		} else {
1426			collection.limits.account_token_ownership_limit
1427		};
1428
1429		ensure!(
1430			collection.limits.token_limit >= total_items,
1431			Error::<T>::CollectionTokenLimitExceeded
1432		);
1433		ensure!(
1434			account_token_limit >= account_items,
1435			Error::<T>::AccountTokenLimitExceeded
1436		);
1437
1438		if !Self::is_owner_or_admin_permissions(collection, sender)? {
1439			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);
1440			Self::check_white_list(collection, owner)?;
1441			Self::check_white_list(collection, sender)?;
1442		}
1443
1444		Ok(())
1445	}
1446
1447	fn validate_create_item_args(
1448		target_collection: &CollectionHandle<T>,
1449		data: &CreateItemData,
1450	) -> DispatchResult {
1451		match target_collection.mode {
1452			CollectionMode::NFT => {
1453				if !matches!(data, CreateItemData::NFT(_)) {
1454					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);
1455				}
1456			}
1457			CollectionMode::Fungible(_) => {
1458				if !matches!(data, CreateItemData::Fungible(_)) {
1459					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);
1460				}
1461			}
1462			CollectionMode::ReFungible => {
1463				if let CreateItemData::ReFungible(data) = data {
1464					// Check refungibility limits
1465					ensure!(
1466						data.pieces <= MAX_REFUNGIBLE_PIECES,
1467						Error::<T>::WrongRefungiblePieces
1468					);
1469					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);
1470				} else {
1471					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);
1472				}
1473			}
1474		};
1475
1476		Ok(())
1477	}
1478
1479	fn create_item_no_validation(
1480		collection: &CollectionHandle<T>,
1481		owner: &T::CrossAccountId,
1482		data: CreateItemData,
1483	) -> DispatchResult {
1484		match data {
1485			CreateItemData::NFT(data) => {
1486				let item = NftItemType {
1487					owner: owner.clone(),
1488					const_data: data.const_data.into_inner(),
1489					variable_data: data.variable_data.into_inner(),
1490				};
1491
1492				Self::add_nft_item(collection, item)?;
1493			}
1494			CreateItemData::Fungible(data) => {
1495				Self::add_fungible_item(collection, owner, data.value)?;
1496			}
1497			CreateItemData::ReFungible(data) => {
1498				let owner_list = vec![Ownership {
1499					owner: owner.clone(),
1500					fraction: data.pieces,
1501				}];
1502
1503				let item = ReFungibleItemType {
1504					owner: owner_list,
1505					const_data: data.const_data.into_inner(),
1506					variable_data: data.variable_data.into_inner(),
1507				};
1508
1509				Self::add_refungible_item(collection, item)?;
1510			}
1511		};
1512
1513		Ok(())
1514	}
1515
1516	fn add_fungible_item(
1517		collection: &CollectionHandle<T>,
1518		owner: &T::CrossAccountId,
1519		value: u128,
1520	) -> DispatchResult {
1521		let collection_id = collection.id;
1522
1523		// Does new owner already have an account?
1524		collection.consume_sload()?;
1525		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;
1526
1527		// Mint
1528		let item = FungibleItemType {
1529			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,
1530		};
1531		collection.consume_sstore()?;
1532		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);
1533
1534		// Update balance
1535		collection.consume_sload()?;
1536		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
1537			.checked_add(value)
1538			.ok_or(Error::<T>::NumOverflow)?;
1539		collection.consume_sstore()?;
1540		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
1541
1542		collection.log(ERC20Events::Transfer {
1543			from: H160::default(),
1544			to: *owner.as_eth(),
1545			value: value.into(),
1546		})?;
1547		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));
1548		Ok(())
1549	}
1550
1551	fn add_refungible_item(
1552		collection: &CollectionHandle<T>,
1553		item: ReFungibleItemType<T::CrossAccountId>,
1554	) -> DispatchResult {
1555		let collection_id = collection.id;
1556
1557		let current_index = <ItemListIndex>::get(collection_id)
1558			.checked_add(1)
1559			.ok_or(Error::<T>::NumOverflow)?;
1560		let itemcopy = item.clone();
1561
1562		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);
1563		let item_owner = item.owner.first().expect("only one owner is defined");
1564
1565		let value = item_owner.fraction;
1566		let owner = item_owner.owner.clone();
1567
1568		Self::add_token_index(collection, current_index, &owner)?;
1569
1570		<ItemListIndex>::insert(collection_id, current_index);
1571		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);
1572
1573		// Update balance
1574		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
1575			.checked_add(value)
1576			.ok_or(Error::<T>::NumOverflow)?;
1577		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
1578
1579		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));
1580		Ok(())
1581	}
1582
1583	fn add_nft_item(
1584		collection: &CollectionHandle<T>,
1585		item: NftItemType<T::CrossAccountId>,
1586	) -> DispatchResult {
1587		let collection_id = collection.id;
1588
1589		let current_index = <ItemListIndex>::get(collection_id)
1590			.checked_add(1)
1591			.ok_or(Error::<T>::NumOverflow)?;
1592
1593		let item_owner = item.owner.clone();
1594		Self::add_token_index(collection, current_index, &item.owner)?;
1595
1596		<ItemListIndex>::insert(collection_id, current_index);
1597		<NftItemList<T>>::insert(collection_id, current_index, item);
1598
1599		// Update balance
1600		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())
1601			.checked_add(1)
1602			.ok_or(Error::<T>::NumOverflow)?;
1603		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);
1604
1605		collection.log(ERC721Events::Transfer {
1606			from: H160::default(),
1607			to: *item_owner.as_eth(),
1608			token_id: current_index.into(),
1609		})?;
1610		Self::deposit_event(RawEvent::ItemCreated(
1611			collection_id,
1612			current_index,
1613			item_owner,
1614		));
1615		Ok(())
1616	}
1617
1618	fn burn_refungible_item(
1619		collection: &CollectionHandle<T>,
1620		item_id: TokenId,
1621		owner: &T::CrossAccountId,
1622	) -> DispatchResult {
1623		let collection_id = collection.id;
1624
1625		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)
1626			.ok_or(Error::<T>::TokenNotFound)?;
1627		let rft_balance = token
1628			.owner
1629			.iter()
1630			.find(|&i| i.owner == *owner)
1631			.ok_or(Error::<T>::TokenNotFound)?;
1632		Self::remove_token_index(collection, item_id, owner)?;
1633
1634		// update balance
1635		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())
1636			.checked_sub(rft_balance.fraction)
1637			.ok_or(Error::<T>::NumOverflow)?;
1638		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);
1639
1640		// Re-create owners list with sender removed
1641		let index = token
1642			.owner
1643			.iter()
1644			.position(|i| i.owner == *owner)
1645			.expect("owned item is exists");
1646		token.owner.remove(index);
1647		let owner_count = token.owner.len();
1648
1649		// Burn the token completely if this was the last (only) owner
1650		if owner_count == 0 {
1651			<ReFungibleItemList<T>>::remove(collection_id, item_id);
1652			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);
1653		} else {
1654			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);
1655		}
1656
1657		Ok(())
1658	}
1659
1660	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {
1661		let collection_id = collection.id;
1662
1663		let item =
1664			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
1665		Self::remove_token_index(collection, item_id, &item.owner)?;
1666
1667		// update balance
1668		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())
1669			.checked_sub(1)
1670			.ok_or(Error::<T>::NumOverflow)?;
1671		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);
1672		<NftItemList<T>>::remove(collection_id, item_id);
1673		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);
1674
1675		collection.log(ERC721Events::Transfer {
1676			from: *item.owner.as_eth(),
1677			to: H160::default(),
1678			token_id: item_id.into(),
1679		})?;
1680		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));
1681		Ok(())
1682	}
1683
1684	fn burn_fungible_item(
1685		owner: &T::CrossAccountId,
1686		collection: &CollectionHandle<T>,
1687		value: u128,
1688	) -> DispatchResult {
1689		let collection_id = collection.id;
1690
1691		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());
1692		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);
1693
1694		// update balance
1695		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
1696			.checked_sub(value)
1697			.ok_or(Error::<T>::NumOverflow)?;
1698		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
1699
1700		if balance.value - value > 0 {
1701			balance.value -= value;
1702			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);
1703		} else {
1704			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());
1705		}
1706
1707		collection.log(ERC20Events::Transfer {
1708			from: *owner.as_eth(),
1709			to: H160::default(),
1710			value: value.into(),
1711		})?;
1712		Ok(())
1713	}
1714
1715	pub fn get_collection(
1716		collection_id: CollectionId,
1717	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {
1718		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)
1719	}
1720
1721	fn check_owner_permissions(
1722		target_collection: &CollectionHandle<T>,
1723		subject: &T::AccountId,
1724	) -> DispatchResult {
1725		ensure!(
1726			*subject == target_collection.owner,
1727			Error::<T>::NoPermission
1728		);
1729
1730		Ok(())
1731	}
1732
1733	fn is_owner_or_admin_permissions(
1734		collection: &CollectionHandle<T>,
1735		subject: &T::CrossAccountId,
1736	) -> Result<bool, DispatchError> {
1737		collection.consume_sload()?;
1738		Ok(*subject.as_sub() == collection.owner
1739			|| <AdminList<T>>::get(collection.id).contains(subject))
1740	}
1741
1742	fn check_owner_or_admin_permissions(
1743		collection: &CollectionHandle<T>,
1744		subject: &T::CrossAccountId,
1745	) -> DispatchResult {
1746		ensure!(
1747			Self::is_owner_or_admin_permissions(collection, subject)?,
1748			Error::<T>::NoPermission
1749		);
1750
1751		Ok(())
1752	}
1753
1754	fn owned_amount(
1755		subject: &T::CrossAccountId,
1756		collection: &CollectionHandle<T>,
1757		item_id: TokenId,
1758	) -> Result<Option<u128>, DispatchError> {
1759		collection.consume_sload()?;
1760		Ok(Self::owned_amount_unchecked(subject, collection, item_id))
1761	}
1762
1763	fn owned_amount_unchecked(
1764		subject: &T::CrossAccountId,
1765		target_collection: &CollectionHandle<T>,
1766		item_id: TokenId,
1767	) -> Option<u128> {
1768		let collection_id = target_collection.id;
1769
1770		match target_collection.mode {
1771			CollectionMode::NFT => {
1772				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)
1773			}
1774			CollectionMode::Fungible(_) => {
1775				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)
1776			}
1777			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?
1778				.owner
1779				.iter()
1780				.find(|i| i.owner == *subject)
1781				.map(|i| i.fraction),
1782		}
1783	}
1784
1785	fn is_item_owner(
1786		subject: &T::CrossAccountId,
1787		target_collection: &CollectionHandle<T>,
1788		item_id: TokenId,
1789	) -> Result<bool, DispatchError> {
1790		Ok(match target_collection.mode {
1791			CollectionMode::Fungible(_) => true,
1792			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),
1793		})
1794	}
1795
1796	fn check_white_list(
1797		collection: &CollectionHandle<T>,
1798		address: &T::CrossAccountId,
1799	) -> DispatchResult {
1800		collection.consume_sload()?;
1801		ensure!(
1802			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),
1803			Error::<T>::AddresNotInWhiteList,
1804		);
1805		Ok(())
1806	}
1807
1808	/// Check if token exists. In case of Fungible, check if there is an entry for
1809	/// the owner in fungible balances double map
1810	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {
1811		let collection_id = target_collection.id;
1812		let exists = match target_collection.mode {
1813			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),
1814			CollectionMode::Fungible(_) => true,
1815			CollectionMode::ReFungible => {
1816				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)
1817			}
1818		};
1819
1820		ensure!(exists, Error::<T>::TokenNotFound);
1821		Ok(())
1822	}
1823
1824	fn transfer_fungible(
1825		collection: &CollectionHandle<T>,
1826		value: u128,
1827		owner: &T::CrossAccountId,
1828		recipient: &T::CrossAccountId,
1829	) -> DispatchResult {
1830		let collection_id = collection.id;
1831
1832		collection.consume_sload()?;
1833		collection.consume_sload()?;
1834		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());
1835		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());
1836
1837		recipient_balance.value = recipient_balance
1838			.value
1839			.checked_add(value)
1840			.ok_or(Error::<T>::NumOverflow)?;
1841		balance.value = balance
1842			.value
1843			.checked_sub(value)
1844			.ok_or(Error::<T>::TokenValueTooLow)?;
1845
1846		// update balanceOf
1847		collection.consume_sstore()?;
1848		collection.consume_sstore()?;
1849		if balance.value != 0 {
1850			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);
1851		} else {
1852			<Balance<T>>::remove(collection_id, owner.as_sub());
1853		}
1854		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);
1855
1856		// Reduce or remove sender
1857		collection.consume_sstore()?;
1858		collection.consume_sstore()?;
1859		if balance.value != 0 {
1860			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);
1861		} else {
1862			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());
1863		}
1864		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);
1865
1866		collection.log(ERC20Events::Transfer {
1867			from: *owner.as_eth(),
1868			to: *recipient.as_eth(),
1869			value: value.into(),
1870		})?;
1871		Self::deposit_event(RawEvent::Transfer(
1872			collection.id,
1873			1,
1874			owner.clone(),
1875			recipient.clone(),
1876			value,
1877		));
1878
1879		Ok(())
1880	}
1881
1882	fn transfer_refungible(
1883		collection: &CollectionHandle<T>,
1884		item_id: TokenId,
1885		value: u128,
1886		owner: T::CrossAccountId,
1887		new_owner: T::CrossAccountId,
1888	) -> DispatchResult {
1889		let collection_id = collection.id;
1890		collection.consume_sload()?;
1891		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)
1892			.ok_or(Error::<T>::TokenNotFound)?;
1893
1894		let item = full_item
1895			.owner
1896			.iter()
1897			.find(|i| i.owner == owner)
1898			.ok_or(Error::<T>::TokenNotFound)?;
1899		let amount = item.fraction;
1900
1901		ensure!(amount >= value, Error::<T>::TokenValueTooLow);
1902
1903		collection.consume_sload()?;
1904		// update balance
1905		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())
1906			.checked_sub(value)
1907			.ok_or(Error::<T>::NumOverflow)?;
1908		collection.consume_sstore()?;
1909		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);
1910
1911		collection.consume_sload()?;
1912		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())
1913			.checked_add(value)
1914			.ok_or(Error::<T>::NumOverflow)?;
1915		collection.consume_sstore()?;
1916		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);
1917
1918		let old_owner = item.owner.clone();
1919		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);
1920
1921		let mut new_full_item = full_item.clone();
1922		// transfer
1923		if amount == value && !new_owner_has_account {
1924			// change owner
1925			// new owner do not have account
1926			new_full_item
1927				.owner
1928				.iter_mut()
1929				.find(|i| i.owner == owner)
1930				.expect("old owner does present in refungible")
1931				.owner = new_owner.clone();
1932			collection.consume_sstore()?;
1933			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
1934
1935			// update index collection
1936			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;
1937		} else {
1938			new_full_item
1939				.owner
1940				.iter_mut()
1941				.find(|i| i.owner == owner)
1942				.expect("old owner does present in refungible")
1943				.fraction -= value;
1944
1945			// separate amount
1946			if new_owner_has_account {
1947				// new owner has account
1948				new_full_item
1949					.owner
1950					.iter_mut()
1951					.find(|i| i.owner == new_owner)
1952					.expect("new owner has account")
1953					.fraction += value;
1954			} else {
1955				// new owner do not have account
1956				new_full_item.owner.push(Ownership {
1957					owner: new_owner.clone(),
1958					fraction: value,
1959				});
1960				Self::add_token_index(collection, item_id, &new_owner)?;
1961			}
1962
1963			collection.consume_sstore()?;
1964			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
1965		}
1966
1967		Self::deposit_event(RawEvent::Transfer(
1968			collection.id,
1969			item_id,
1970			owner,
1971			new_owner,
1972			amount,
1973		));
1974
1975		Ok(())
1976	}
1977
1978	fn transfer_nft(
1979		collection: &CollectionHandle<T>,
1980		item_id: TokenId,
1981		sender: T::CrossAccountId,
1982		new_owner: T::CrossAccountId,
1983	) -> DispatchResult {
1984		let collection_id = collection.id;
1985		collection.consume_sload()?;
1986		let mut item =
1987			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
1988
1989		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);
1990
1991		collection.consume_sload()?;
1992		// update balance
1993		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())
1994			.checked_sub(1)
1995			.ok_or(Error::<T>::NumOverflow)?;
1996		collection.consume_sstore()?;
1997		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);
1998
1999		collection.consume_sload()?;
2000		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())
2001			.checked_add(1)
2002			.ok_or(Error::<T>::NumOverflow)?;
2003		collection.consume_sstore()?;
2004		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);
2005
2006		// change owner
2007		let old_owner = item.owner.clone();
2008		item.owner = new_owner.clone();
2009		collection.consume_sstore()?;
2010		<NftItemList<T>>::insert(collection_id, item_id, item);
2011
2012		// update index collection
2013		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;
2014
2015		collection.log(ERC721Events::Transfer {
2016			from: *sender.as_eth(),
2017			to: *new_owner.as_eth(),
2018			token_id: item_id.into(),
2019		})?;
2020		Self::deposit_event(RawEvent::Transfer(
2021			collection.id,
2022			item_id,
2023			sender,
2024			new_owner,
2025			1,
2026		));
2027
2028		Ok(())
2029	}
2030
2031	fn set_re_fungible_variable_data(
2032		collection: &CollectionHandle<T>,
2033		item_id: TokenId,
2034		data: Vec<u8>,
2035	) -> DispatchResult {
2036		let collection_id = collection.id;
2037		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)
2038			.ok_or(Error::<T>::TokenNotFound)?;
2039
2040		item.variable_data = data;
2041
2042		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);
2043
2044		Ok(())
2045	}
2046
2047	fn set_nft_variable_data(
2048		collection: &CollectionHandle<T>,
2049		item_id: TokenId,
2050		data: Vec<u8>,
2051	) -> DispatchResult {
2052		let collection_id = collection.id;
2053		let mut item =
2054			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
2055
2056		item.variable_data = data;
2057
2058		<NftItemList<T>>::insert(collection_id, item_id, item);
2059
2060		Ok(())
2061	}
2062
2063	#[allow(dead_code)]
2064	fn init_collection(item: &Collection<T>) {
2065		// check params
2066		assert!(
2067			item.decimal_points <= MAX_DECIMAL_POINTS,
2068			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"
2069		);
2070		assert!(
2071			item.name.len() <= 64,
2072			"Collection name can not be longer than 63 char"
2073		);
2074		assert!(
2075			item.name.len() <= 256,
2076			"Collection description can not be longer than 255 char"
2077		);
2078		assert!(
2079			item.token_prefix.len() <= 16,
2080			"Token prefix can not be longer than 15 char"
2081		);
2082
2083		// Generate next collection ID
2084		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();
2085
2086		CreatedCollectionCount::put(next_id);
2087	}
2088
2089	#[allow(dead_code)]
2090	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {
2091		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
2092
2093		Self::add_token_index(
2094			&CollectionHandle::get(collection_id).unwrap(),
2095			current_index,
2096			&item.owner,
2097		)
2098		.unwrap();
2099
2100		<ItemListIndex>::insert(collection_id, current_index);
2101
2102		// Update balance
2103		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())
2104			.checked_add(1)
2105			.unwrap();
2106		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);
2107	}
2108
2109	#[allow(dead_code)]
2110	fn init_fungible_token(
2111		collection_id: CollectionId,
2112		owner: &T::CrossAccountId,
2113		item: &FungibleItemType,
2114	) {
2115		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
2116
2117		Self::add_token_index(
2118			&CollectionHandle::get(collection_id).unwrap(),
2119			current_index,
2120			owner,
2121		)
2122		.unwrap();
2123
2124		<ItemListIndex>::insert(collection_id, current_index);
2125
2126		// Update balance
2127		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
2128			.checked_add(item.value)
2129			.unwrap();
2130		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
2131	}
2132
2133	#[allow(dead_code)]
2134	fn init_refungible_token(
2135		collection_id: CollectionId,
2136		item: &ReFungibleItemType<T::CrossAccountId>,
2137	) {
2138		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
2139
2140		let value = item.owner.first().unwrap().fraction;
2141		let owner = item.owner.first().unwrap().owner.clone();
2142
2143		Self::add_token_index(
2144			&CollectionHandle::get(collection_id).unwrap(),
2145			current_index,
2146			&owner,
2147		)
2148		.unwrap();
2149
2150		<ItemListIndex>::insert(collection_id, current_index);
2151
2152		// Update balance
2153		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())
2154			.checked_add(value)
2155			.unwrap();
2156		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
2157	}
2158
2159	fn add_token_index(
2160		collection: &CollectionHandle<T>,
2161		item_index: TokenId,
2162		owner: &T::CrossAccountId,
2163	) -> DispatchResult {
2164		collection.consume_sload()?;
2165		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
2166		if list_exists {
2167			collection.consume_sload()?;
2168			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
2169
2170			// bound Owned tokens by a single address in collection
2171			let account_items: u32 = list.len() as u32;
2172			ensure!(
2173				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
2174				Error::<T>::AddressOwnershipLimitExceeded
2175			);
2176
2177			let item_contains = list.contains(&item_index.clone());
2178
2179			if !item_contains {
2180				list.push(item_index);
2181			}
2182
2183			collection.consume_sstore()?;
2184			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);
2185		} else {
2186			let itm = vec![item_index];
2187			collection.consume_sstore()?;
2188			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);
2189		}
2190
2191		Ok(())
2192	}
2193
2194	fn remove_token_index(
2195		collection: &CollectionHandle<T>,
2196		item_index: TokenId,
2197		owner: &T::CrossAccountId,
2198	) -> DispatchResult {
2199		collection.consume_sload()?;
2200		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
2201		if list_exists {
2202			collection.consume_sload()?;
2203			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
2204			let item_contains = list.contains(&item_index.clone());
2205
2206			if item_contains {
2207				list.retain(|&item| item != item_index);
2208				collection.consume_sstore()?;
2209				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);
2210			}
2211		}
2212
2213		Ok(())
2214	}
2215
2216	fn move_token_index(
2217		collection: &CollectionHandle<T>,
2218		item_index: TokenId,
2219		old_owner: &T::CrossAccountId,
2220		new_owner: &T::CrossAccountId,
2221	) -> DispatchResult {
2222		Self::remove_token_index(collection, item_index, old_owner)?;
2223		Self::add_token_index(collection, item_index, new_owner)?;
2224
2225		Ok(())
2226	}
2227}
2228
2229sp_api::decl_runtime_apis! {
2230	pub trait NftApi {
2231		/// Used for ethereum integration
2232		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;
2233	}924	}
2234}925}
2235926