`57b97ca5400c`

16 files changed

addedpallets/common/Cargo.tomldiff before after both

--- /dev/null
+++ b/pallets/common/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "pallet-common"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies.codec]
+default-features = false
+features = ['derive']
+package = 'parity-scale-codec'
+version = '2.0.0'
+
+[dependencies]
+frame-support = { default-features = false, version = '4.0.0-dev', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.10' }
+frame-system = { default-features = false, version = '4.0.0-dev', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.10' }
+sp-runtime = { default-features = false, version = '4.0.0-dev', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.10' }
+sp-std = { default-features = false, version = '4.0.0-dev', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.10' }
+sp-core = { default-features = false, version = '4.0.0-dev', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.10' }
+nft-data-structs = { default-features = false, path = '../../primitives/nft' }
+pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }
+evm-coder = { default-features = false, path = '../../crates/evm-coder' }
+
+pallet-evm = { default-features = false, version = "6.0.0-dev", git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.10" }
+serde = { version = "1.0.130", default-features = false }
+
+[features]
+default = ["std"]
+std = [
+    "frame-support/std",
+    "frame-system/std",
+    "sp-runtime/std",
+    "sp-std/std",
+    "nft-data-structs/std",
+    "pallet-evm/std",
+]
+runtime-benchmarks = []

addedpallets/common/src/account.rsdiff before after both

--- /dev/null
+++ b/pallets/common/src/account.rs
@@ -0,0 +1,142 @@
+use crate::Config;
+use codec::{Encode, EncodeLike, Decode};
+use sp_core::H160;
+use sp_core::crypto::AccountId32;
+use core::cmp::Ordering;
+use serde::{Serialize, Deserialize};
+use pallet_evm::AddressMapping;
+use sp_std::vec::Vec;
+use sp_std::clone::Clone;
+
+pub trait CrossAccountId<AccountId>:
+	Encode + EncodeLike + Decode + Clone + PartialEq + Ord + core::fmt::Debug + Default
+// +
+// Serialize + Deserialize<'static>
+{
+	fn as_sub(&self) -> &AccountId;
+	fn as_eth(&self) -> &H160;
+
+	fn from_sub(account: AccountId) -> Self;
+	fn from_eth(account: H160) -> Self;
+}
+
+#[derive(Eq, Serialize, Deserialize)]
+pub struct BasicCrossAccountId<T: Config> {
+	/// If true - then ethereum is canonical encoding
+	from_ethereum: bool,
+	substrate: T::AccountId,
+	ethereum: H160,
+}
+
+impl<T: Config> Default for BasicCrossAccountId<T> {
+	fn default() -> Self {
+		Self::from_sub(T::AccountId::default())
+	}
+}
+
+impl<T: Config> core::fmt::Debug for BasicCrossAccountId<T> {
+	fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
+		if self.from_ethereum {
+			fmt.debug_tuple("CrossAccountId::Ethereum")
+				.field(&self.ethereum)
+				.finish()
+		} else {
+			fmt.debug_tuple("CrossAccountId::Substrate")
+				.field(&self.substrate)
+				.finish()
+		}
+	}
+}
+
+impl<T: Config> PartialOrd for BasicCrossAccountId<T> {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(self.substrate.cmp(&other.substrate))
+	}
+}
+
+impl<T: Config> Ord for BasicCrossAccountId<T> {
+	fn cmp(&self, other: &Self) -> Ordering {
+		self.partial_cmp(other)
+			.expect("substrate account is total ordered")
+	}
+}
+
+impl<T: Config> PartialEq for BasicCrossAccountId<T> {
+	fn eq(&self, other: &Self) -> bool {
+		if self.from_ethereum == other.from_ethereum {
+			self.substrate == other.substrate && self.ethereum == other.ethereum
+		} else if self.from_ethereum {
+			// ethereum is canonical encoding, but we need to compare derived address
+			self.substrate == other.substrate
+		} else {
+			self.ethereum == other.ethereum
+		}
+	}
+}
+impl<T: Config> Clone for BasicCrossAccountId<T> {
+	fn clone(&self) -> Self {
+		Self {
+			from_ethereum: self.from_ethereum,
+			substrate: self.substrate.clone(),
+			ethereum: self.ethereum,
+		}
+	}
+}
+impl<T: Config> Encode for BasicCrossAccountId<T> {
+	fn encode(&self) -> Vec<u8> {
+		let as_result = if !self.from_ethereum {
+			Ok(self.substrate.clone())
+		} else {
+			Err(self.ethereum)
+		};
+		as_result.encode()
+	}
+}
+impl<T: Config> EncodeLike for BasicCrossAccountId<T> {}
+impl<T: Config> Decode for BasicCrossAccountId<T> {
+	fn decode<I>(input: &mut I) -> Result<Self, codec::Error>
+	where
+		I: codec::Input,
+	{
+		Ok(match <Result<T::AccountId, H160>>::decode(input)? {
+			Ok(s) => Self::from_sub(s),
+			Err(e) => Self::from_eth(e),
+		})
+	}
+}
+impl<T: Config> CrossAccountId<T::AccountId> for BasicCrossAccountId<T> {
+	fn as_sub(&self) -> &T::AccountId {
+		&self.substrate
+	}
+	fn as_eth(&self) -> &H160 {
+		&self.ethereum
+	}
+	fn from_sub(substrate: T::AccountId) -> Self {
+		Self {
+			ethereum: T::EvmBackwardsAddressMapping::from_account_id(substrate.clone()),
+			substrate,
+			from_ethereum: false,
+		}
+	}
+	fn from_eth(ethereum: H160) -> Self {
+		Self {
+			ethereum,
+			substrate: T::EvmAddressMapping::into_account_id(ethereum),
+			from_ethereum: true,
+		}
+	}
+}
+
+pub trait EvmBackwardsAddressMapping<AccountId> {
+	fn from_account_id(account_id: AccountId) -> H160;
+}
+
+/// Should have same mapping as EnsureAddressTruncated
+pub struct MapBackwardsAddressTruncated;
+impl EvmBackwardsAddressMapping<AccountId32> for MapBackwardsAddressTruncated {
+	fn from_account_id(account_id: AccountId32) -> H160 {
+		let mut out = [0; 20];
+		out.copy_from_slice(&(account_id.as_ref() as &[u8])[0..20]);
+		H160(out)
+	}
+}

addedpallets/common/src/benchmarking.rsdiff before after both

--- /dev/null
+++ b/pallets/common/src/benchmarking.rs
@@ -0,0 +1 @@
+#![cfg(feature = "runtime-benchmarking")]

addedpallets/common/src/erc.rsdiff before after both

--- /dev/null
+++ b/pallets/common/src/erc.rs
@@ -0,0 +1,10 @@
+pub use pallet_evm::PrecompileOutput;
+use sp_core::{H160, U256};
+
+/// Does not always represent a full collection, for RFT it is either
+/// collection (Implementing ERC721), or specific collection token (Implementing ERC20)
+pub trait CommonEvmHandler {
+	const CODE: &'static [u8];
+
+	fn call(self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileOutput>;
+}

addedpallets/common/src/eth.rsdiff before after both

--- /dev/null
+++ b/pallets/common/src/eth.rs
@@ -0,0 +1,50 @@
+use nft_data_structs::{CollectionId, TokenId};
+use sp_core::H160;
+
+// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 1
+// TODO: Unhardcode prefix
+const ETH_ACCOUNT_PREFIX: [u8; 16] = [
+	0x17, 0xc4, 0xe6, 0x45, 0x3c, 0xc4, 0x9a, 0xaa, 0xae, 0xac, 0xa8, 0x94, 0xe6, 0xd9, 0x68, 0x3e,
+];
+
+// 0xf8238ccfff8ed887463fd5e00000000100000002  - collection 1, token 2
+// TODO: Unhardcode prefix
+const ETH_ACCOUNT_TOKEN_PREFIX: [u8; 12] = [
+	0xf8, 0x23, 0x8c, 0xcf, 0xff, 0x8e, 0xd8, 0x87, 0x46, 0x3f, 0xd5, 0xe0,
+];
+
+pub fn map_eth_to_id(eth: &H160) -> Option<CollectionId> {
+	if eth[0..16] != ETH_ACCOUNT_PREFIX {
+		return None;
+	}
+	let mut id_bytes = [0; 4];
+	id_bytes.copy_from_slice(&eth[16..20]);
+	Some(CollectionId(u32::from_be_bytes(id_bytes)))
+}
+pub fn collection_id_to_address(id: CollectionId) -> H160 {
+	let mut out = [0; 20];
+	out[0..16].copy_from_slice(&ETH_ACCOUNT_PREFIX);
+	out[16..20].copy_from_slice(&u32::to_be_bytes(id.0));
+	H160(out)
+}
+
+pub fn map_eth_to_token_id(eth: &H160) -> Option<(CollectionId, TokenId)> {
+	if eth[0..12] != ETH_ACCOUNT_TOKEN_PREFIX {
+		return None;
+	}
+	let mut id_bytes = [0; 4];
+	let mut token_id_bytes = [0; 4];
+	id_bytes.copy_from_slice(&eth[12..16]);
+	token_id_bytes.copy_from_slice(&eth[16..20]);
+	Some((
+		CollectionId(u32::from_be_bytes(id_bytes)),
+		TokenId(u32::from_be_bytes(token_id_bytes)),
+	))
+}
+pub fn collection_token_id_to_address(id: CollectionId, token: TokenId) -> H160 {
+	let mut out = [0; 20];
+	out[0..12].copy_from_slice(&ETH_ACCOUNT_TOKEN_PREFIX);
+	out[12..16].copy_from_slice(&u32::to_be_bytes(id.0));
+	out[16..20].copy_from_slice(&u32::to_be_bytes(token.0));
+	H160(out)
+}

addedpallets/common/src/lib.rsdiff before after both

--- /dev/null
+++ b/pallets/common/src/lib.rs
@@ -0,0 +1,543 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use core::ops::{Deref, DerefMut};
+use sp_std::vec::Vec;
+use account::CrossAccountId;
+use frame_support::{
+	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo},
+	ensure, fail,
+	traits::{Imbalance, Get, Currency},
+};
+use nft_data_structs::{
+	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, ExistenceRequirement,
+	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
+	MetaUpdatePermission, Pays, PostDispatchInfo, TokenId, Weight, WithdrawReasons,
+};
+pub use pallet::*;
+use sp_core::H160;
+use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};
+pub mod account;
+pub mod benchmarking;
+pub mod erc;
+pub mod eth;
+
+#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]
+pub struct CollectionHandle<T: Config> {
+	pub id: CollectionId,
+	collection: Collection<T>,
+	pub recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,
+}
+impl<T: Config> CollectionHandle<T> {
+	pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {
+		<CollectionById<T>>::get(id).map(|collection| Self {
+			id,
+			collection,
+			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(
+				eth::collection_id_to_address(id),
+				gas_limit,
+			),
+		})
+	}
+	pub fn new(id: CollectionId) -> Option<Self> {
+		Self::new_with_gas_limit(id, u64::MAX)
+	}
+	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {
+		Ok(Self::new(id).ok_or_else(|| <Error<T>>::CollectionNotFound)?)
+	}
+	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {
+		self.recorder.log_sub(log)
+	}
+	pub fn log_infallible(&self, log: impl evm_coder::ToLog) {
+		self.recorder.log_infallible(log)
+	}
+	#[allow(dead_code)]
+	fn consume_gas(&self, gas: u64) -> DispatchResult {
+		self.recorder.consume_gas_sub(gas)
+	}
+	pub fn consume_sload(&self) -> DispatchResult {
+		self.recorder.consume_sload_sub()
+	}
+	pub fn consume_sstores(&self, amount: usize) -> DispatchResult {
+		self.recorder.consume_sstores_sub(amount)
+	}
+	pub fn consume_sstore(&self) -> DispatchResult {
+		self.recorder.consume_sstore_sub()
+	}
+	pub fn consume_log(&self, topics: usize, data: usize) -> DispatchResult {
+		self.recorder.consume_log_sub(topics, data)
+	}
+	pub fn submit_logs(self) -> DispatchResult {
+		self.recorder.submit_logs()
+	}
+	pub fn save(self) -> DispatchResult {
+		self.recorder.submit_logs()?;
+		<CollectionById<T>>::insert(self.id, self.collection);
+		Ok(())
+	}
+}
+impl<T: Config> Deref for CollectionHandle<T> {
+	type Target = Collection<T>;
+
+	fn deref(&self) -> &Self::Target {
+		&self.collection
+	}
+}
+
+impl<T: Config> DerefMut for CollectionHandle<T> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.collection
+	}
+}
+
+impl<T: Config> CollectionHandle<T> {
+	pub fn check_is_owner(&self, subject: &T::CrossAccountId) -> DispatchResult {
+		ensure!(*subject.as_sub() == self.owner, <Error<T>>::NoPermission);
+		Ok(())
+	}
+	pub fn is_owner_or_admin(&self, subject: &T::CrossAccountId) -> Result<bool, DispatchError> {
+		self.consume_sload()?;
+
+		Ok(*subject.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, subject.as_sub())))
+	}
+	pub fn check_is_owner_or_admin(&self, subject: &T::CrossAccountId) -> DispatchResult {
+		ensure!(self.is_owner_or_admin(subject)?, <Error<T>>::NoPermission);
+		Ok(())
+	}
+	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> Result<bool, DispatchError> {
+		Ok(self.limits.owner_can_transfer && self.is_owner_or_admin(user)?)
+	}
+	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> Result<bool, DispatchError> {
+		Ok(self.limits.owner_can_transfer && self.is_owner_or_admin(user)?)
+	}
+	pub fn check_whitelist(&self, user: &T::CrossAccountId) -> DispatchResult {
+		self.consume_sload()?;
+
+		ensure!(
+			<WhiteList<T>>::get((self.id, user.as_sub())),
+			<Error<T>>::AddressNotInWhiteList
+		);
+		Ok(())
+	}
+
+	pub fn check_can_update_meta(
+		&self,
+		subject: &T::CrossAccountId,
+		item_owner: &T::CrossAccountId,
+	) -> DispatchResult {
+		match self.meta_update_permission {
+			MetaUpdatePermission::ItemOwner => {
+				ensure!(subject == item_owner, <Error<T>>::NoPermission);
+				Ok(())
+			}
+			MetaUpdatePermission::Admin => self.check_is_owner_or_admin(subject),
+			MetaUpdatePermission::None => fail!(<Error<T>>::NoPermission),
+		}
+	}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{pallet_prelude::*};
+	use frame_support::{Blake2_128Concat, storage::Key};
+	use account::{EvmBackwardsAddressMapping, CrossAccountId};
+	use frame_support::traits::Currency;
+	use nft_data_structs::TokenId;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config + pallet_evm_coder_substrate::Config {
+		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;
+
+		type CrossAccountId: CrossAccountId<Self::AccountId>;
+
+		type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;
+		type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;
+
+		type Currency: Currency<Self::AccountId>;
+		type CollectionCreationPrice: Get<
+			<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,
+		>;
+		type TreasuryAccountId: Get<Self::AccountId>;
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// New collection was created
+		///
+		/// # Arguments
+		///
+		/// * collection_id: Globally unique identifier of newly created collection.
+		///
+		/// * mode: [CollectionMode] converted into u8.
+		///
+		/// * account_id: Collection owner.
+		CollectionCreated(CollectionId, u8, T::AccountId),
+
+		/// New item was created.
+		///
+		/// # Arguments
+		///
+		/// * collection_id: Id of the collection where item was created.
+		///
+		/// * item_id: Id of an item. Unique within the collection.
+		///
+		/// * recipient: Owner of newly created item
+		///
+		/// * amount: Always 1 for NFT
+		ItemCreated(CollectionId, TokenId, T::CrossAccountId, u128),
+
+		/// Collection item was burned.
+		///
+		/// # Arguments
+		///
+		/// * collection_id.
+		///
+		/// * item_id: Identifier of burned NFT.
+		///
+		/// * owner: which user has destroyed its tokens
+		///
+		/// * amount: Always 1 for NFT
+		ItemDestroyed(CollectionId, TokenId, T::CrossAccountId, u128),
+
+		/// Item was transferred
+		///
+		/// * collection_id: Id of collection to which item is belong
+		///
+		/// * item_id: Id of an item
+		///
+		/// * sender: Original owner of item
+		///
+		/// * recipient: New owner of item
+		///
+		/// * amount: Always 1 for NFT
+		Transfer(
+			CollectionId,
+			TokenId,
+			T::CrossAccountId,
+			T::CrossAccountId,
+			u128,
+		),
+
+		/// * collection_id
+		///
+		/// * item_id
+		///
+		/// * sender
+		///
+		/// * spender
+		///
+		/// * amount
+		Approved(
+			CollectionId,
+			TokenId,
+			T::CrossAccountId,
+			T::CrossAccountId,
+			u128,
+		),
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// This collection does not exist.
+		CollectionNotFound,
+		/// Sender parameter and item owner must be equal.
+		MustBeTokenOwner,
+		/// No permission to perform action
+		NoPermission,
+		/// Collection is not in mint mode.
+		PublicMintingNotAllowed,
+		/// Address is not in white list.
+		AddressNotInWhiteList,
+
+		/// Collection name can not be longer than 63 char.
+		CollectionNameLimitExceeded,
+		/// Collection description can not be longer than 255 char.
+		CollectionDescriptionLimitExceeded,
+		/// Token prefix can not be longer than 15 char.
+		CollectionTokenPrefixLimitExceeded,
+		/// Total collections bound exceeded.
+		TotalCollectionsLimitExceeded,
+		/// variable_data exceeded data limit.
+		TokenVariableDataLimitExceeded,
+
+		/// Collection settings not allowing items transferring
+		TransferNotAllowed,
+		/// Account token limit exceeded per collection
+		AccountTokenLimitExceeded,
+		/// Collection token limit exceeded
+		CollectionTokenLimitExceeded,
+		/// Metadata flag frozen
+		MetadataFlagFrozen,
+
+		/// Item not exists.
+		TokenNotFound,
+		/// Item balance not enough.
+		TokenValueTooLow,
+		/// Requested value more than approved.
+		TokenValueNotEnough,
+		/// Tried to approve more than owned
+		CantApproveMoreThanOwned,
+
+		/// Can't transfer tokens to ethereum zero address
+		AddressIsZero,
+		/// Target collection doesn't supports this operation
+		UnsupportedOperation,
+	}
+
+	#[pallet::storage]
+	pub type CreatedCollectionCount<T> = StorageValue<Value = CollectionId, QueryKind = ValueQuery>;
+	#[pallet::storage]
+	pub type DestroyedCollectionCount<T> =
+		StorageValue<Value = CollectionId, QueryKind = ValueQuery>;
+
+	/// Collection info
+	#[pallet::storage]
+	pub type CollectionById<T> = StorageMap<
+		Hasher = Blake2_128Concat,
+		Key = CollectionId,
+		Value = Collection<T>,
+		QueryKind = OptionQuery,
+	>;
+
+	/// List of collection admins
+	#[pallet::storage]
+	pub type IsAdmin<T: Config> = StorageNMap<
+		Key = (
+			Key<Blake2_128Concat, CollectionId>,
+			Key<Blake2_128Concat, T::AccountId>,
+		),
+		Value = bool,
+		QueryKind = ValueQuery,
+	>;
+
+	/// Whitelisted collection users
+	#[pallet::storage]
+	pub type WhiteList<T: Config> = StorageNMap<
+		Key = (
+			Key<Blake2_128Concat, CollectionId>,
+			Key<Blake2_128Concat, T::AccountId>,
+		),
+		Value = bool,
+		QueryKind = ValueQuery,
+	>;
+}
+
+impl<T: Config> Pallet<T> {
+	/// Ethereum receiver 0x0000000000000000000000000000000000000000 is reserved, and shouldn't own tokens
+	pub fn ensure_correct_receiver(receiver: &T::CrossAccountId) -> DispatchResult {
+		ensure!(
+			&T::CrossAccountId::from_eth(H160([0; 20])) != receiver,
+			<Error<T>>::AddressIsZero
+		);
+		Ok(())
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {
+		{
+			ensure!(
+				data.name.len() <= MAX_COLLECTION_NAME_LENGTH,
+				Error::<T>::CollectionNameLimitExceeded
+			);
+			ensure!(
+				data.description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH,
+				Error::<T>::CollectionDescriptionLimitExceeded
+			);
+			ensure!(
+				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH,
+				Error::<T>::CollectionTokenPrefixLimitExceeded
+			);
+		}
+
+		let created_count = <CreatedCollectionCount<T>>::get()
+			.0
+			.checked_add(1)
+			.ok_or(ArithmeticError::Overflow)?;
+		let destroyed_count = <DestroyedCollectionCount<T>>::get().0;
+		let id = CollectionId(created_count);
+
+		// bound Total number of collections
+		ensure!(
+			created_count - destroyed_count < COLLECTION_NUMBER_LIMIT,
+			<Error<T>>::TotalCollectionsLimitExceeded
+		);
+
+		// =========
+
+		// Take a (non-refundable) deposit of collection creation
+		{
+			let mut imbalance =
+				<<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();
+			imbalance.subsume(
+				<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(
+					&T::TreasuryAccountId::get(),
+					T::CollectionCreationPrice::get(),
+				),
+			);
+			<T as Config>::Currency::settle(
+				&data.owner,
+				imbalance,
+				WithdrawReasons::TRANSFER,
+				ExistenceRequirement::KeepAlive,
+			)
+			.map_err(|_| Error::<T>::NoPermission)?;
+		}
+
+		<CreatedCollectionCount<T>>::put(created_count);
+		<Pallet<T>>::deposit_event(Event::CollectionCreated(
+			id,
+			data.mode.id(),
+			data.owner.clone(),
+		));
+		<CollectionById<T>>::insert(id, data);
+		Ok(id)
+	}
+	pub fn destroy_collection(
+		collection: CollectionHandle<T>,
+		sender: &T::CrossAccountId,
+	) -> DispatchResult {
+		if !collection.limits.owner_can_destroy {
+			fail!(Error::<T>::NoPermission);
+		}
+		collection.check_is_owner(&sender)?;
+
+		let destroyed_collections = <DestroyedCollectionCount<T>>::get()
+			.0
+			.checked_add(1)
+			.ok_or(ArithmeticError::Overflow)?;
+
+		// =========
+
+		<DestroyedCollectionCount<T>>::put(destroyed_collections);
+		<CollectionById<T>>::remove(collection.id);
+		<IsAdmin<T>>::remove_prefix((collection.id,), None);
+		<WhiteList<T>>::remove_prefix((collection.id,), None);
+		Ok(())
+	}
+
+	pub fn toggle_whitelist(
+		collection: &CollectionHandle<T>,
+		sender: &T::CrossAccountId,
+		user: &T::CrossAccountId,
+		allowed: bool,
+	) -> DispatchResult {
+		collection.check_is_owner_or_admin(&sender)?;
+
+		// =========
+
+		if allowed {
+			<WhiteList<T>>::insert((collection.id, user.as_sub()), true);
+		} else {
+			<WhiteList<T>>::remove((collection.id, user.as_sub()));
+		}
+
+		Ok(())
+	}
+}
+
+#[macro_export]
+macro_rules! unsupported {
+	() => {
+		Err(<Error<T>>::UnsupportedOperation.into())
+	};
+}
+
+/// Worst cases
+pub trait CommonWeightInfo {
+	fn create_item() -> Weight;
+	fn create_multiple_items(amount: u32) -> Weight;
+	fn burn_item() -> Weight;
+	fn transfer() -> Weight;
+	fn approve() -> Weight;
+	fn transfer_from() -> Weight;
+	fn set_variable_metadata(bytes: u32) -> Weight;
+}
+
+pub trait CommonCollectionOperations<T: Config> {
+	fn create_item(
+		&self,
+		sender: T::CrossAccountId,
+		to: T::CrossAccountId,
+		data: CreateItemData,
+	) -> DispatchResultWithPostInfo;
+	fn create_multiple_items(
+		&self,
+		sender: T::CrossAccountId,
+		to: T::CrossAccountId,
+		data: Vec<CreateItemData>,
+	) -> DispatchResultWithPostInfo;
+	fn burn_item(
+		&self,
+		sender: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResultWithPostInfo;
+
+	fn transfer(
+		&self,
+		sender: T::CrossAccountId,
+		to: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResultWithPostInfo;
+	fn approve(
+		&self,
+		sender: T::CrossAccountId,
+		spender: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResultWithPostInfo;
+	fn transfer_from(
+		&self,
+		sender: T::CrossAccountId,
+		from: T::CrossAccountId,
+		to: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResultWithPostInfo;
+
+	fn set_variable_metadata(
+		&self,
+		sender: T::CrossAccountId,
+		token: TokenId,
+		data: Vec<u8>,
+	) -> DispatchResultWithPostInfo;
+
+	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId>;
+	fn token_exists(&self, token: TokenId) -> bool;
+
+	fn token_owner(&self, token: TokenId) -> T::CrossAccountId;
+	fn const_metadata(&self, token: TokenId) -> Vec<u8>;
+	fn variable_metadata(&self, token: TokenId) -> Vec<u8>;
+
+	/// How many tokens collection contains (Applicable to nonfungible/refungible)
+	fn collection_tokens(&self) -> u32;
+	/// Amount of different tokens account has (Applicable to nonfungible/refungible)
+	fn account_balance(&self, account: T::CrossAccountId) -> u32;
+	/// Amount of specific token account have (Applicable to fungible/refungible)
+	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128;
+	fn allowance(
+		&self,
+		sender: T::CrossAccountId,
+		spender: T::CrossAccountId,
+		token: TokenId,
+	) -> u128;
+}
+
+// Flexible enough for implementing CommonCollectionOperations
+pub fn with_weight(res: DispatchResult, weight: Weight) -> DispatchResultWithPostInfo {
+	let post_info = PostDispatchInfo {
+		actual_weight: Some(weight),
+		pays_fee: Pays::Yes,
+	};
+	match res {
+		Ok(()) => Ok(post_info),
+		Err(error) => Err(DispatchErrorWithPostInfo { post_info, error }),
+	}
+}

deletedpallets/nft/src/eth/account.rsdiff before after both

--- a/pallets/nft/src/eth/account.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-use crate::Config;
-use codec::{Encode, EncodeLike, Decode};
-use sp_core::crypto::AccountId32;
-use primitive_types::H160;
-use core::cmp::Ordering;
-use serde::{Serialize, Deserialize};
-use pallet_evm::AddressMapping;
-use sp_std::vec::Vec;
-use sp_std::clone::Clone;
-
-pub trait CrossAccountId<AccountId>:
-	Encode + EncodeLike + Decode + Clone + PartialEq + Ord + core::fmt::Debug
-// +
-// Serialize + Deserialize<'static>
-{
-	fn as_sub(&self) -> &AccountId;
-	fn as_eth(&self) -> &H160;
-
-	fn from_sub(account: AccountId) -> Self;
-	fn from_eth(account: H160) -> Self;
-}
-
-#[derive(Eq, Serialize, Deserialize)]
-pub struct BasicCrossAccountId<T: Config> {
-	/// If true - then ethereum is canonical encoding
-	from_ethereum: bool,
-	substrate: T::AccountId,
-	ethereum: H160,
-}
-
-impl<T: Config> core::fmt::Debug for BasicCrossAccountId<T> {
-	fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
-		if self.from_ethereum {
-			fmt.debug_tuple("CrossAccountId::Ethereum")
-				.field(&self.ethereum)
-				.finish()
-		} else {
-			fmt.debug_tuple("CrossAccountId::Substrate")
-				.field(&self.substrate)
-				.finish()
-		}
-	}
-}
-
-impl<T: Config> PartialOrd for BasicCrossAccountId<T> {
-	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-		Some(self.substrate.cmp(&other.substrate))
-	}
-}
-
-impl<T: Config> Ord for BasicCrossAccountId<T> {
-	fn cmp(&self, other: &Self) -> Ordering {
-		self.partial_cmp(other)
-			.expect("substrate account is total ordered")
-	}
-}
-
-impl<T: Config> PartialEq for BasicCrossAccountId<T> {
-	fn eq(&self, other: &Self) -> bool {
-		if self.from_ethereum == other.from_ethereum {
-			self.substrate == other.substrate && self.ethereum == other.ethereum
-		} else if self.from_ethereum {
-			// ethereum is canonical encoding, but we need to compare derived address
-			self.substrate == other.substrate
-		} else {
-			self.ethereum == other.ethereum
-		}
-	}
-}
-impl<T: Config> Clone for BasicCrossAccountId<T> {
-	fn clone(&self) -> Self {
-		Self {
-			from_ethereum: self.from_ethereum,
-			substrate: self.substrate.clone(),
-			ethereum: self.ethereum,
-		}
-	}
-}
-impl<T: Config> Encode for BasicCrossAccountId<T> {
-	fn encode(&self) -> Vec<u8> {
-		let as_result = if !self.from_ethereum {
-			Ok(self.substrate.clone())
-		} else {
-			Err(self.ethereum)
-		};
-		as_result.encode()
-	}
-}
-impl<T: Config> EncodeLike for BasicCrossAccountId<T> {}
-impl<T: Config> Decode for BasicCrossAccountId<T> {
-	fn decode<I>(input: &mut I) -> Result<Self, codec::Error>
-	where
-		I: codec::Input,
-	{
-		Ok(match <Result<T::AccountId, H160>>::decode(input)? {
-			Ok(s) => Self::from_sub(s),
-			Err(e) => Self::from_eth(e),
-		})
-	}
-}
-impl<T: Config> CrossAccountId<T::AccountId> for BasicCrossAccountId<T> {
-	fn as_sub(&self) -> &T::AccountId {
-		&self.substrate
-	}
-	fn as_eth(&self) -> &H160 {
-		&self.ethereum
-	}
-	fn from_sub(substrate: T::AccountId) -> Self {
-		Self {
-			ethereum: T::EvmBackwardsAddressMapping::from_account_id(substrate.clone()),
-			substrate,
-			from_ethereum: false,
-		}
-	}
-	fn from_eth(ethereum: H160) -> Self {
-		Self {
-			ethereum,
-			substrate: T::EvmAddressMapping::into_account_id(ethereum),
-			from_ethereum: true,
-		}
-	}
-}
-
-pub trait EvmBackwardsAddressMapping<AccountId> {
-	fn from_account_id(account_id: AccountId) -> H160;
-}
-
-/// Should have same mapping as EnsureAddressTruncated
-pub struct MapBackwardsAddressTruncated;
-impl EvmBackwardsAddressMapping<AccountId32> for MapBackwardsAddressTruncated {
-	fn from_account_id(account_id: AccountId32) -> H160 {
-		let mut out = [0; 20];
-		out.copy_from_slice(&(account_id.as_ref() as &[u8])[0..20]);
-		H160(out)
-	}
-}

deletedpallets/nft/src/eth/erc.rsdiff before after both

--- a/pallets/nft/src/eth/erc.rs
+++ /dev/null
@@ -1,496 +0,0 @@
-use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
-use evm_coder::{ToLog, execution::Result, generate_stubgen, solidity, solidity_interface, types::*};
-use nft_data_structs::{CreateItemData, CreateNftData};
-use core::convert::TryInto;
-use crate::{
-	Allowances, Module, Balance, CollectionHandle, CollectionMode, Config, NftItemList,
-	ItemListIndex,
-};
-use frame_support::storage::{StorageMap, StorageDoubleMap};
-use pallet_evm::AddressMapping;
-use pallet_evm_coder_substrate::dispatch_to_evm;
-use super::account::CrossAccountId;
-use sp_std::{vec, vec::Vec};
-
-#[solidity_interface(name = "ERC165")]
-impl<T: Config> CollectionHandle<T> {
-	fn supports_interface(&self, interface_id: bytes4) -> Result<bool> {
-		Ok(match self.mode {
-			CollectionMode::Fungible(_) => UniqueFungibleCall::supports_interface(interface_id),
-			CollectionMode::NFT => UniqueNFTCall::supports_interface(interface_id),
-			_ => false,
-		})
-	}
-}
-
-#[solidity_interface(name = "InlineNameSymbol")]
-impl<T: Config> CollectionHandle<T> {
-	fn name(&self) -> Result<string> {
-		Ok(decode_utf16(self.name.iter().copied())
-			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
-			.collect::<string>())
-	}
-
-	fn symbol(&self) -> Result<string> {
-		Ok(string::from_utf8_lossy(&self.token_prefix).into())
-	}
-}
-
-#[solidity_interface(name = "InlineTotalSupply")]
-impl<T: Config> CollectionHandle<T> {
-	fn total_supply(&self) -> Result<uint256> {
-		// TODO: we do not track total amount of all tokens
-		Ok(0.into())
-	}
-}
-
-#[solidity_interface(name = "ERC721Metadata", inline_is(InlineNameSymbol))]
-impl<T: Config> CollectionHandle<T> {
-	#[solidity(rename_selector = "tokenURI")]
-	fn token_uri(&self, token_id: uint256) -> Result<string> {
-		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
-		Ok(string::from_utf8_lossy(
-			&<NftItemList<T>>::get(self.id, token_id)
-				.ok_or("token not found")?
-				.const_data,
-		)
-		.into())
-	}
-}
-
-#[solidity_interface(name = "ERC721Enumerable", inline_is(InlineTotalSupply))]
-impl<T: Config> CollectionHandle<T> {
-	fn token_by_index(&self, index: uint256) -> Result<uint256> {
-		Ok(index)
-	}
-
-	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
-		// TODO: Not implemetable
-		Err("not implemented".into())
-	}
-}
-
-#[derive(ToLog)]
-pub enum ERC721Events {
-	Transfer {
-		#[indexed]
-		from: address,
-		#[indexed]
-		to: address,
-		#[indexed]
-		token_id: uint256,
-	},
-	Approval {
-		#[indexed]
-		owner: address,
-		#[indexed]
-		approved: address,
-		#[indexed]
-		token_id: uint256,
-	},
-	#[allow(dead_code)]
-	ApprovalForAll {
-		#[indexed]
-		owner: address,
-		#[indexed]
-		operator: address,
-		approved: bool,
-	},
-}
-
-#[solidity_interface(name = "ERC721", is(ERC165), events(ERC721Events))]
-impl<T: Config> CollectionHandle<T> {
-	#[solidity(rename_selector = "balanceOf")]
-	fn balance_of_nft(&self, owner: address) -> Result<uint256> {
-		let owner = T::EvmAddressMapping::into_account_id(owner);
-		let balance = <Balance<T>>::get(self.id, owner);
-		Ok(balance.into())
-	}
-	fn owner_of(&self, token_id: uint256) -> Result<address> {
-		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
-		let token = <NftItemList<T>>::get(self.id, token_id).ok_or("unknown token")?;
-		Ok(*token.owner.as_eth())
-	}
-	fn safe_transfer_from_with_data(
-		&mut self,
-		_from: address,
-		_to: address,
-		_token_id: uint256,
-		_data: bytes,
-		_value: value,
-	) -> Result<void> {
-		// TODO: Not implemetable
-		Err("not implemented".into())
-	}
-	fn safe_transfer_from(
-		&mut self,
-		_from: address,
-		_to: address,
-		_token_id: uint256,
-		_value: value,
-	) -> Result<void> {
-		// TODO: Not implemetable
-		Err("not implemented".into())
-	}
-
-	fn transfer_from(
-		&mut self,
-		caller: caller,
-		from: address,
-		to: address,
-		token_id: uint256,
-		_value: value,
-	) -> Result<void> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let from = T::CrossAccountId::from_eth(from);
-		let to = T::CrossAccountId::from_eth(to);
-		let token_id = token_id.try_into().map_err(|_| "token_id overflow")?;
-
-		<Module<T>>::transfer_from_internal(&caller, &from, &to, self, token_id, 1)
-			.map_err(|_| "transferFrom error")?;
-		Ok(())
-	}
-
-	fn approve(
-		&mut self,
-		caller: caller,
-		approved: address,
-		token_id: uint256,
-		_value: value,
-	) -> Result<void> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let approved = T::CrossAccountId::from_eth(approved);
-		let token_id = token_id.try_into().map_err(|_| "token_id overflow")?;
-
-		<Module<T>>::approve_internal(&caller, &approved, self, token_id, 1)
-			.map_err(|_| "approve internal")?;
-		Ok(())
-	}
-
-	fn set_approval_for_all(
-		&mut self,
-		_caller: caller,
-		_operator: address,
-		_approved: bool,
-	) -> Result<void> {
-		// TODO: Not implemetable
-		Err("not implemented".into())
-	}
-
-	fn get_approved(&self, _token_id: uint256) -> Result<address> {
-		// TODO: Not implemetable
-		Err("not implemented".into())
-	}
-
-	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {
-		// TODO: Not implemetable
-		Err("not implemented".into())
-	}
-}
-
-#[solidity_interface(name = "ERC721Burnable")]
-impl<T: Config> CollectionHandle<T> {
-	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let token_id = token_id.try_into().map_err(|_| "amount overflow")?;
-
-		<Module<T>>::burn_item_internal(&caller, &self, token_id, 1).map_err(|_| "burn error")?;
-		Ok(())
-	}
-}
-
-#[derive(ToLog)]
-pub enum ERC721MintableEvents {
-	#[allow(dead_code)]
-	MintingFinished {},
-}
-
-#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]
-impl<T: Config> CollectionHandle<T> {
-	fn minting_finished(&self) -> Result<bool> {
-		Ok(false)
-	}
-
-	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let to = T::CrossAccountId::from_eth(to);
-		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;
-		if <ItemListIndex>::get(self.id)
-			.checked_add(1)
-			.ok_or("item id overflow")?
-			!= token_id
-		{
-			return Err("item id should be next".into());
-		}
-
-		<Module<T>>::create_item_internal(
-			&caller,
-			&self,
-			&to,
-			CreateItemData::NFT(CreateNftData {
-				const_data: vec![].try_into().unwrap(),
-				variable_data: vec![].try_into().unwrap(),
-			}),
-		)
-		.map_err(|_| "mint error")?;
-		Ok(true)
-	}
-
-	#[solidity(rename_selector = "mintWithTokenURI")]
-	fn mint_with_token_uri(
-		&mut self,
-		caller: caller,
-		to: address,
-		token_id: uint256,
-		token_uri: string,
-	) -> Result<bool> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let to = T::CrossAccountId::from_eth(to);
-		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;
-		if <ItemListIndex>::get(self.id)
-			.checked_add(1)
-			.ok_or("item id overflow")?
-			!= token_id
-		{
-			return Err("item id should be next".into());
-		}
-
-		<Module<T>>::create_item_internal(
-			&caller,
-			&self,
-			&to,
-			CreateItemData::NFT(CreateNftData {
-				const_data: Vec::<u8>::from(token_uri)
-					.try_into()
-					.map_err(|_| "token uri is too long")?,
-				variable_data: vec![].try_into().unwrap(),
-			}),
-		)
-		.map_err(|_| "mint error")?;
-		Ok(true)
-	}
-
-	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {
-		Err("not implementable".into())
-	}
-}
-
-#[solidity_interface(name = "ERC721UniqueExtensions")]
-impl<T: Config> CollectionHandle<T> {
-	#[solidity(rename_selector = "transfer")]
-	fn transfer_nft(
-		&mut self,
-		caller: caller,
-		to: address,
-		token_id: uint256,
-		_value: value,
-	) -> Result<void> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let to = T::CrossAccountId::from_eth(to);
-		let token_id = token_id.try_into().map_err(|_| "amount overflow")?;
-
-		<Module<T>>::transfer_internal(&caller, &to, self, token_id, 1)
-			.map_err(|_| "transfer error")?;
-		Ok(())
-	}
-
-	fn next_token_id(&self) -> Result<uint256> {
-		Ok(ItemListIndex::get(self.id)
-			.checked_add(1)
-			.ok_or("item id overflow")?
-			.into())
-	}
-
-	fn set_variable_metadata(
-		&mut self,
-		caller: caller,
-		token_id: uint256,
-		data: bytes,
-	) -> Result<void> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let token_id = token_id.try_into().map_err(|_| "token id overflow")?;
-
-		<Module<T>>::set_variable_meta_data_internal(&caller, self, token_id, data)
-			.map_err(dispatch_to_evm::<T>)?;
-		Ok(())
-	}
-
-	fn get_variable_metadata(&self, token_id: uint256) -> Result<bytes> {
-		let token_id = token_id.try_into().map_err(|_| "token id overflow")?;
-
-		<Module<T>>::get_variable_metadata(self, token_id).map_err(dispatch_to_evm::<T>)
-	}
-
-	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let to = T::CrossAccountId::from_eth(to);
-		let mut expected_index = <ItemListIndex>::get(self.id)
-			.checked_add(1)
-			.ok_or("item id overflow")?;
-
-		let total_tokens = token_ids.len();
-		for id in token_ids.into_iter() {
-			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;
-			if id != expected_index {
-				return Err("item id should be next".into());
-			}
-			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
-		}
-
-		let data = (0..total_tokens)
-			.map(|_| {
-				CreateItemData::NFT(CreateNftData {
-					const_data: vec![].try_into().unwrap(),
-					variable_data: vec![].try_into().unwrap(),
-				})
-			})
-			.collect();
-
-		<Module<T>>::create_multiple_items_internal(&caller, self, &to, data)
-			.map_err(dispatch_to_evm::<T>)?;
-		Ok(true)
-	}
-
-	#[solidity(rename_selector = "mintBulkWithTokenURI")]
-	fn mint_bulk_with_token_uri(
-		&mut self,
-		caller: caller,
-		to: address,
-		tokens: Vec<(uint256, string)>,
-	) -> Result<bool> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let to = T::CrossAccountId::from_eth(to);
-		let mut expected_index = <ItemListIndex>::get(self.id)
-			.checked_add(1)
-			.ok_or("item id overflow")?;
-
-		let mut data = Vec::with_capacity(tokens.len());
-		for (id, token_uri) in tokens {
-			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;
-			if id != expected_index {
-				panic!("item id should be next ({}) but got {}", expected_index, id);
-			}
-			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
-
-			data.push(CreateItemData::NFT(CreateNftData {
-				const_data: Vec::<u8>::from(token_uri)
-					.try_into()
-					.map_err(|_| "token uri is too long")?,
-				variable_data: vec![].try_into().unwrap(),
-			}));
-		}
-
-		<Module<T>>::create_multiple_items_internal(&caller, self, &to, data)
-			.map_err(dispatch_to_evm::<T>)?;
-		Ok(true)
-	}
-}
-
-#[solidity_interface(
-	name = "UniqueNFT",
-	is(
-		ERC165,
-		ERC721,
-		ERC721Metadata,
-		ERC721Enumerable,
-		ERC721UniqueExtensions,
-		ERC721Mintable,
-		ERC721Burnable,
-	)
-)]
-impl<T: Config> CollectionHandle<T> {}
-
-#[derive(ToLog)]
-pub enum ERC20Events {
-	Transfer {
-		#[indexed]
-		from: address,
-		#[indexed]
-		to: address,
-		value: uint256,
-	},
-	Approval {
-		#[indexed]
-		owner: address,
-		#[indexed]
-		spender: address,
-		value: uint256,
-	},
-}
-
-#[solidity_interface(
-	name = "ERC20",
-	inline_is(InlineNameSymbol, InlineTotalSupply),
-	events(ERC20Events)
-)]
-impl<T: Config> CollectionHandle<T> {
-	fn decimals(&self) -> Result<uint8> {
-		Ok(if let CollectionMode::Fungible(decimals) = &self.mode {
-			*decimals
-		} else {
-			unreachable!()
-		})
-	}
-	fn balance_of(&self, owner: address) -> Result<uint256> {
-		let owner = T::EvmAddressMapping::into_account_id(owner);
-		let balance = <Balance<T>>::get(self.id, owner);
-		Ok(balance.into())
-	}
-	fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let to = T::CrossAccountId::from_eth(to);
-		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-
-		<Module<T>>::transfer_internal(&caller, &to, self, 1, amount)
-			.map_err(|_| "transfer error")?;
-		Ok(true)
-	}
-	#[solidity(rename_selector = "transferFrom")]
-	fn transfer_from_fungible(
-		&mut self,
-		caller: caller,
-		from: address,
-		to: address,
-		amount: uint256,
-	) -> Result<bool> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let from = T::CrossAccountId::from_eth(from);
-		let to = T::CrossAccountId::from_eth(to);
-		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-
-		<Module<T>>::transfer_from_internal(&caller, &from, &to, self, 1, amount)
-			.map_err(|_| "transferFrom error")?;
-		Ok(true)
-	}
-	#[solidity(rename_selector = "approve")]
-	fn approve_fungible(
-		&mut self,
-		caller: caller,
-		spender: address,
-		amount: uint256,
-	) -> Result<bool> {
-		let caller = T::CrossAccountId::from_eth(caller);
-		let spender = T::CrossAccountId::from_eth(spender);
-		let amount = amount.try_into().map_err(|_| "amount overflow")?;
-
-		<Module<T>>::approve_internal(&caller, &spender, self, 1, amount)
-			.map_err(|_| "approve internal")?;
-		Ok(true)
-	}
-	fn allowance(&self, owner: address, spender: address) -> Result<uint256> {
-		let owner = T::CrossAccountId::from_eth(owner);
-		let spender = T::CrossAccountId::from_eth(spender);
-
-		Ok(<Allowances<T>>::get(self.id, (1, owner.as_sub(), spender.as_sub())).into())
-	}
-}
-
-#[solidity_interface(name = "UniqueFungible", is(ERC165, ERC20))]
-impl<T: Config> CollectionHandle<T> {}
-
-// Not a tests, but code generators
-generate_stubgen!(nft_impl, UniqueNFTCall, true);
-generate_stubgen!(nft_iface, UniqueNFTCall, false);
-
-generate_stubgen!(fungible_impl, UniqueFungibleCall, true);
-generate_stubgen!(fungible_iface, UniqueFungibleCall, false);

modifiedpallets/nft/src/eth/mod.rsdiff before after both

--- a/pallets/nft/src/eth/mod.rs
+++ b/pallets/nft/src/eth/mod.rs
@@ -1,86 +1,21 @@
-pub mod account;
-pub mod erc;
 pub mod sponsoring;
 
-use pallet_evm_coder_substrate::call_internal;
+use pallet_common::{
+	CollectionById,
+	erc::CommonEvmHandler,
+	eth::{map_eth_to_id, map_eth_to_token_id},
+};
+use pallet_fungible::FungibleHandle;
+use pallet_nonfungible::NonfungibleHandle;
+use pallet_refungible::{RefungibleHandle, erc::RefungibleTokenHandle};
 use sp_std::borrow::ToOwned;
 use sp_std::vec::Vec;
 use pallet_evm::{PrecompileOutput};
 use sp_core::{H160, U256};
-use frame_support::storage::StorageMap;
-use crate::{Config, CollectionById, CollectionHandle, CollectionId, CollectionMode};
-use erc::{UniqueFungibleCall, UniqueNFTCall};
+use crate::{CollectionMode, Config, dispatch::Dispatched};
+use pallet_common::CollectionHandle;
 
 pub struct NftErcSupport<T: Config>(core::marker::PhantomData<T>);
-
-// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection
-// TODO: Unhardcode prefix
-const ETH_ACCOUNT_PREFIX: [u8; 16] = [
-	0x17, 0xc4, 0xe6, 0x45, 0x3c, 0xc4, 0x9a, 0xaa, 0xae, 0xac, 0xa8, 0x94, 0xe6, 0xd9, 0x68, 0x3e,
-];
-
-fn map_eth_to_id(eth: &H160) -> Option<CollectionId> {
-	if eth[0..16] != ETH_ACCOUNT_PREFIX {
-		return None;
-	}
-	let mut id_bytes = [0; 4];
-	id_bytes.copy_from_slice(&eth[16..20]);
-	Some(u32::from_be_bytes(id_bytes))
-}
-pub fn collection_id_to_address(id: u32) -> H160 {
-	let mut out = [0; 20];
-	out[0..16].copy_from_slice(&ETH_ACCOUNT_PREFIX);
-	out[16..20].copy_from_slice(&u32::to_be_bytes(id));
-	H160(out)
-}
-
-/*
-fn call_internal<T: Config>(
-	collection: &mut CollectionHandle<T>,
-	caller: caller,
-	method_id: u32,
-	mut input: AbiReader,
-	value: U256,
-) -> Result<Option<AbiWriter>> {
-	match collection.mode.clone() {
-		CollectionMode::Fungible(_) => {
-			call_internal();
-			let call = match UniqueFungibleCall::parse(method_id, &mut input)? {
-				Some(v) => v,
-				None => {
-					#[cfg(feature = "std")]
-					{
-						println!("Method not found");
-					}
-					return Ok(None);
-				}
-			};
-			Ok(Some(<CollectionHandle<T> as UniqueFungible>::call(
-				collection,
-				Msg {
-					call,
-					caller,
-					value,
-				},
-			)?))
-		}
-		CollectionMode::NFT => {
-			let call = match UniqueNFTCall::parse(method_id, &mut input)? {
-				Some(v) => v,
-				None => return Ok(None),
-			};
-			Ok(Some(<CollectionHandle<T> as UniqueNFT>::call(
-				collection,
-				Msg {
-					call,
-					caller,
-					value,
-				},
-			)?))
-		}
-		_ => Err("erc calls only supported to fungible and nft collections for now".into()),
-	}
-}*/
 
 impl<T: Config> pallet_evm::OnMethodCall<T> for NftErcSupport<T> {
 	fn is_reserved(target: &H160) -> bool {
@@ -92,20 +27,26 @@
 			.unwrap_or(false)
 	}
 	fn get_code(target: &H160) -> Option<Vec<u8>> {
-		map_eth_to_id(target)
-			.and_then(<CollectionById<T>>::get)
-			.map(|collection| {
+		if let Some(collection_id) = map_eth_to_id(target) {
+			let collection = <CollectionById<T>>::get(collection_id)?;
+			Some(
 				match collection.mode {
-					CollectionMode::NFT => include_bytes!("stubs/UniqueNFT.raw") as &[u8],
-					CollectionMode::Fungible(_) => {
-						include_bytes!("stubs/UniqueFungible.raw") as &[u8]
-					}
-					CollectionMode::ReFungible => {
-						include_bytes!("stubs/UniqueRefungible.raw") as &[u8]
-					}
+					CollectionMode::NFT => <NonfungibleHandle<T>>::CODE,
+					CollectionMode::Fungible(_) => <FungibleHandle<T>>::CODE,
+					CollectionMode::ReFungible => <RefungibleHandle<T>>::CODE,
 				}
-				.to_owned()
-			})
+				.to_owned(),
+			)
+		} else if let Some((collection_id, _token_id)) = map_eth_to_token_id(target) {
+			let collection = <CollectionById<T>>::get(collection_id)?;
+			if collection.mode != CollectionMode::ReFungible {
+				return None;
+			}
+			// TODO: check token existence
+			Some(<RefungibleTokenHandle<T>>::CODE.to_owned())
+		} else {
+			None
+		}
 	}
 	fn call(
 		source: &H160,
@@ -114,17 +55,26 @@
 		input: &[u8],
 		value: U256,
 	) -> Option<PrecompileOutput> {
-		let mut collection = map_eth_to_id(target)
-			.and_then(|id| <CollectionHandle<T>>::get_with_gas_limit(id, gas_limit))?;
-		let result = match collection.mode {
-			CollectionMode::NFT => {
-				call_internal::<UniqueNFTCall, _>(*source, &mut collection, value, input)
+		if let Some(collection_id) = map_eth_to_id(target) {
+			let collection = <CollectionHandle<T>>::new_with_gas_limit(collection_id, gas_limit)?;
+			let dispatched = Dispatched::dispatch(collection);
+
+			match dispatched {
+				Dispatched::Fungible(h) => h.call(source, input, value),
+				Dispatched::Nonfungible(h) => h.call(source, input, value),
+				Dispatched::Refungible(h) => h.call(source, input, value),
 			}
-			CollectionMode::Fungible(_) => {
-				call_internal::<UniqueFungibleCall, _>(*source, &mut collection, value, input)
+		} else if let Some((collection_id, token_id)) = map_eth_to_token_id(target) {
+			let collection = <CollectionHandle<T>>::new_with_gas_limit(collection_id, gas_limit)?;
+			if collection.mode != CollectionMode::ReFungible {
+				return None;
 			}
-			_ => return None,
-		};
-		collection.recorder.evm_to_precompile_output(result)
+
+			let handle = RefungibleHandle::cast(collection);
+			// TODO: check token existence
+			RefungibleTokenHandle(handle, token_id).call(source, input, value)
+		} else {
+			None
+		}
 	}
 }

modifiedpallets/nft/src/eth/sponsoring.rsdiff before after both

--- a/pallets/nft/src/eth/sponsoring.rs
+++ b/pallets/nft/src/eth/sponsoring.rs
@@ -1,29 +1,30 @@
 //! Implements EVM sponsoring logic via OnChargeEVMTransaction
 
-use crate::{
-	Collection, CollectionById, Config, FungibleTransferBasket, NftTransferBasket,
-	eth::{account::EvmBackwardsAddressMapping, map_eth_to_id},
-};
+use crate::{Collection, Config, FungibleTransferBasket, NftTransferBasket};
 use evm_coder::{Call, abi::AbiReader};
 use frame_support::{
-	storage::{StorageMap, StorageDoubleMap},
+	storage::{StorageDoubleMap},
 };
+use pallet_common::eth::map_eth_to_id;
 use sp_core::H160;
 use sp_std::prelude::*;
 use up_sponsorship::SponsorshipHandler;
-use super::{
-	account::CrossAccountId,
-	erc::{UniqueFungibleCall, UniqueNFTCall, ERC721Call, ERC20Call, ERC721UniqueExtensionsCall},
-};
-use core::convert::TryInto;
 use core::marker::PhantomData;
-use nft_data_structs::{NFT_SPONSOR_TRANSFER_TIMEOUT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT};
+use core::convert::TryInto;
+use nft_data_structs::{CollectionId, NFT_SPONSOR_TRANSFER_TIMEOUT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT};
+use pallet_common::{
+	CollectionById,
+	account::{CrossAccountId, EvmBackwardsAddressMapping},
+};
+
+use pallet_nonfungible::erc::{UniqueNFTCall, ERC721UniqueExtensionsCall, ERC721Call};
+use pallet_fungible::erc::{UniqueFungibleCall, ERC20Call};
 
 struct AnyError;
 
 fn try_sponsor<T: Config>(
 	caller: &H160,
-	collection_id: u32,
+	collection_id: CollectionId,
 	collection: &Collection<T>,
 	call: &[u8],
 ) -> Result<(), AnyError> {

deletedpallets/nft/src/eth/stubs/UniqueFungible.rawdiff before after both

binary blob — no preview

deletedpallets/nft/src/eth/stubs/UniqueFungible.soldiff before after both

--- a/pallets/nft/src/eth/stubs/UniqueFungible.sol
+++ /dev/null
@@ -1,121 +0,0 @@
-// SPDX-License-Identifier: OTHER
-// This code is automatically generated
-
-pragma solidity >=0.8.0 <0.9.0;
-
-// Common stubs holder
-contract Dummy {
-	uint8 dummy;
-	string stub_error = "this contract is implemented in native";
-}
-
-// Inline
-contract ERC20Events {
-	event Transfer(address indexed from, address indexed to, uint256 value);
-	event Approval(
-		address indexed owner,
-		address indexed spender,
-		uint256 value
-	);
-}
-
-// Inline
-contract InlineNameSymbol is Dummy {
-	// Selector: name() 06fdde03
-	function name() public view returns (string memory) {
-		require(false, stub_error);
-		dummy;
-		return "";
-	}
-
-	// Selector: symbol() 95d89b41
-	function symbol() public view returns (string memory) {
-		require(false, stub_error);
-		dummy;
-		return "";
-	}
-}
-
-// Inline
-contract InlineTotalSupply is Dummy {
-	// Selector: totalSupply() 18160ddd
-	function totalSupply() public view returns (uint256) {
-		require(false, stub_error);
-		dummy;
-		return 0;
-	}
-}
-
-contract ERC165 is Dummy {
-	// Selector: supportsInterface(bytes4) 01ffc9a7
-	function supportsInterface(uint32 interfaceId) public view returns (bool) {
-		require(false, stub_error);
-		interfaceId;
-		dummy;
-		return false;
-	}
-}
-
-contract ERC20 is Dummy, InlineNameSymbol, InlineTotalSupply, ERC20Events {
-	// Selector: decimals() 313ce567
-	function decimals() public view returns (uint8) {
-		require(false, stub_error);
-		dummy;
-		return 0;
-	}
-
-	// Selector: balanceOf(address) 70a08231
-	function balanceOf(address owner) public view returns (uint256) {
-		require(false, stub_error);
-		owner;
-		dummy;
-		return 0;
-	}
-
-	// Selector: transfer(address,uint256) a9059cbb
-	function transfer(address to, uint256 amount) public returns (bool) {
-		require(false, stub_error);
-		to;
-		amount;
-		dummy = 0;
-		return false;
-	}
-
-	// Selector: transferFrom(address,address,uint256) 23b872dd
-	function transferFrom(
-		address from,
-		address to,
-		uint256 amount
-	) public returns (bool) {
-		require(false, stub_error);
-		from;
-		to;
-		amount;
-		dummy = 0;
-		return false;
-	}
-
-	// Selector: approve(address,uint256) 095ea7b3
-	function approve(address spender, uint256 amount) public returns (bool) {
-		require(false, stub_error);
-		spender;
-		amount;
-		dummy = 0;
-		return false;
-	}
-
-	// Selector: allowance(address,address) dd62ed3e
-	function allowance(address owner, address spender)
-		public
-		view
-		returns (uint256)
-	{
-		require(false, stub_error);
-		owner;
-		spender;
-		dummy;
-		return 0;
-	}
-}
-
-contract UniqueFungible is Dummy, ERC165, ERC20 {}

deletedpallets/nft/src/eth/stubs/UniqueNFT.rawdiff before after both

binary blob — no preview

deletedpallets/nft/src/eth/stubs/UniqueNFT.soldiff before after both

--- a/pallets/nft/src/eth/stubs/UniqueNFT.sol
+++ /dev/null
@@ -1,326 +0,0 @@
-// SPDX-License-Identifier: OTHER
-// This code is automatically generated
-
-pragma solidity >=0.8.0 <0.9.0;
-
-// Anonymous struct
-struct Tuple0 {
-	uint256 field_0;
-	string field_1;
-}
-
-// Common stubs holder
-contract Dummy {
-	uint8 dummy;
-	string stub_error = "this contract is implemented in native";
-}
-
-// Inline
-contract ERC721Events {
-	event Transfer(
-		address indexed from,
-		address indexed to,
-		uint256 indexed tokenId
-	);
-	event Approval(
-		address indexed owner,
-		address indexed approved,
-		uint256 indexed tokenId
-	);
-	event ApprovalForAll(
-		address indexed owner,
-		address indexed operator,
-		bool approved
-	);
-}
-
-// Inline
-contract ERC721MintableEvents {
-	event MintingFinished();
-}
-
-// Inline
-contract InlineNameSymbol is Dummy {
-	// Selector: name() 06fdde03
-	function name() public view returns (string memory) {
-		require(false, stub_error);
-		dummy;
-		return "";
-	}
-
-	// Selector: symbol() 95d89b41
-	function symbol() public view returns (string memory) {
-		require(false, stub_error);
-		dummy;
-		return "";
-	}
-}
-
-// Inline
-contract InlineTotalSupply is Dummy {
-	// Selector: totalSupply() 18160ddd
-	function totalSupply() public view returns (uint256) {
-		require(false, stub_error);
-		dummy;
-		return 0;
-	}
-}
-
-contract ERC165 is Dummy {
-	// Selector: supportsInterface(bytes4) 01ffc9a7
-	function supportsInterface(uint32 interfaceId) public view returns (bool) {
-		require(false, stub_error);
-		interfaceId;
-		dummy;
-		return false;
-	}
-}
-
-contract ERC721 is Dummy, ERC165, ERC721Events {
-	// Selector: balanceOf(address) 70a08231
-	function balanceOf(address owner) public view returns (uint256) {
-		require(false, stub_error);
-		owner;
-		dummy;
-		return 0;
-	}
-
-	// Selector: ownerOf(uint256) 6352211e
-	function ownerOf(uint256 tokenId) public view returns (address) {
-		require(false, stub_error);
-		tokenId;
-		dummy;
-		return 0x0000000000000000000000000000000000000000;
-	}
-
-	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
-	function safeTransferFromWithData(
-		address from,
-		address to,
-		uint256 tokenId,
-		bytes memory data
-	) public {
-		require(false, stub_error);
-		from;
-		to;
-		tokenId;
-		data;
-		dummy = 0;
-	}
-
-	// Selector: safeTransferFrom(address,address,uint256) 42842e0e
-	function safeTransferFrom(
-		address from,
-		address to,
-		uint256 tokenId
-	) public {
-		require(false, stub_error);
-		from;
-		to;
-		tokenId;
-		dummy = 0;
-	}
-
-	// Selector: transferFrom(address,address,uint256) 23b872dd
-	function transferFrom(
-		address from,
-		address to,
-		uint256 tokenId
-	) public {
-		require(false, stub_error);
-		from;
-		to;
-		tokenId;
-		dummy = 0;
-	}
-
-	// Selector: approve(address,uint256) 095ea7b3
-	function approve(address approved, uint256 tokenId) public {
-		require(false, stub_error);
-		approved;
-		tokenId;
-		dummy = 0;
-	}
-
-	// Selector: setApprovalForAll(address,bool) a22cb465
-	function setApprovalForAll(address operator, bool approved) public {
-		require(false, stub_error);
-		operator;
-		approved;
-		dummy = 0;
-	}
-
-	// Selector: getApproved(uint256) 081812fc
-	function getApproved(uint256 tokenId) public view returns (address) {
-		require(false, stub_error);
-		tokenId;
-		dummy;
-		return 0x0000000000000000000000000000000000000000;
-	}
-
-	// Selector: isApprovedForAll(address,address) e985e9c5
-	function isApprovedForAll(address owner, address operator)
-		public
-		view
-		returns (address)
-	{
-		require(false, stub_error);
-		owner;
-		operator;
-		dummy;
-		return 0x0000000000000000000000000000000000000000;
-	}
-}
-
-contract ERC721Burnable is Dummy {
-	// Selector: burn(uint256) 42966c68
-	function burn(uint256 tokenId) public {
-		require(false, stub_error);
-		tokenId;
-		dummy = 0;
-	}
-}
-
-contract ERC721Enumerable is Dummy, InlineTotalSupply {
-	// Selector: tokenByIndex(uint256) 4f6ccce7
-	function tokenByIndex(uint256 index) public view returns (uint256) {
-		require(false, stub_error);
-		index;
-		dummy;
-		return 0;
-	}
-
-	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
-	function tokenOfOwnerByIndex(address owner, uint256 index)
-		public
-		view
-		returns (uint256)
-	{
-		require(false, stub_error);
-		owner;
-		index;
-		dummy;
-		return 0;
-	}
-}
-
-contract ERC721Metadata is Dummy, InlineNameSymbol {
-	// Selector: tokenURI(uint256) c87b56dd
-	function tokenURI(uint256 tokenId) public view returns (string memory) {
-		require(false, stub_error);
-		tokenId;
-		dummy;
-		return "";
-	}
-}
-
-contract ERC721Mintable is Dummy, ERC721MintableEvents {
-	// Selector: mintingFinished() 05d2035b
-	function mintingFinished() public view returns (bool) {
-		require(false, stub_error);
-		dummy;
-		return false;
-	}
-
-	// Selector: mint(address,uint256) 40c10f19
-	function mint(address to, uint256 tokenId) public returns (bool) {
-		require(false, stub_error);
-		to;
-		tokenId;
-		dummy = 0;
-		return false;
-	}
-
-	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
-	function mintWithTokenURI(
-		address to,
-		uint256 tokenId,
-		string memory tokenUri
-	) public returns (bool) {
-		require(false, stub_error);
-		to;
-		tokenId;
-		tokenUri;
-		dummy = 0;
-		return false;
-	}
-
-	// Selector: finishMinting() 7d64bcb4
-	function finishMinting() public returns (bool) {
-		require(false, stub_error);
-		dummy = 0;
-		return false;
-	}
-}
-
-contract ERC721UniqueExtensions is Dummy {
-	// Selector: transfer(address,uint256) a9059cbb
-	function transfer(address to, uint256 tokenId) public {
-		require(false, stub_error);
-		to;
-		tokenId;
-		dummy = 0;
-	}
-
-	// Selector: nextTokenId() 75794a3c
-	function nextTokenId() public view returns (uint256) {
-		require(false, stub_error);
-		dummy;
-		return 0;
-	}
-
-	// Selector: setVariableMetadata(uint256,bytes) d4eac26d
-	function setVariableMetadata(uint256 tokenId, bytes memory data) public {
-		require(false, stub_error);
-		tokenId;
-		data;
-		dummy = 0;
-	}
-
-	// Selector: getVariableMetadata(uint256) e6c5ce6f
-	function getVariableMetadata(uint256 tokenId)
-		public
-		view
-		returns (bytes memory)
-	{
-		require(false, stub_error);
-		tokenId;
-		dummy;
-		return hex"";
-	}
-
-	// Selector: mintBulk(address,uint256[]) 44a9945e
-	function mintBulk(address to, uint256[] memory tokenIds)
-		public
-		returns (bool)
-	{
-		require(false, stub_error);
-		to;
-		tokenIds;
-		dummy = 0;
-		return false;
-	}
-
-	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
-	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
-		public
-		returns (bool)
-	{
-		require(false, stub_error);
-		to;
-		tokens;
-		dummy = 0;
-		return false;
-	}
-}
-
-contract UniqueNFT is
-	Dummy,
-	ERC165,
-	ERC721,
-	ERC721Metadata,
-	ERC721Enumerable,
-	ERC721UniqueExtensions,
-	ERC721Mintable,
-	ERC721Burnable
-{}

deletedpallets/nft/src/eth/stubs/UniqueRefungible.rawdiff before after both

--- a/pallets/nft/src/eth/stubs/UniqueRefungible.raw
+++ /dev/null
@@ -1 +0,0 @@
-TODO
\ No newline at end of file

modifiedpallets/nft/src/lib.rsdiff before after both

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	MetaUpdatePermission, 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 create_multiple_items(amount: u32) -> Weight {259		Self::create_multiple_items_nft(amount)260			.max(Self::create_multiple_items_fungible(amount))261			.max(Self::create_multiple_items_refungible(amount))262	}263	fn burn_item() -> Weight {264		// TODO: refungible, fungible265		Self::burn_item_nft()266	}267}268impl<T: WeightInfo> WeightInfoHelpers for T {}269270// # Used definitions271//272// ## User control levels273//274// chain-controlled - key is uncontrolled by user275//                    i.e autoincrementing index276//                    can use non-cryptographic hash277// real - key is controlled by user278//        but it is hard to generate enough colliding values, i.e owner of signed txs279//        can use non-cryptographic hash280// controlled - key is completly controlled by users281//              i.e maps with mutable keys282//              should use cryptographic hash283//284// ## User control level downgrade reasons285//286// ?1 - chain-controlled -> controlled287//      collections/tokens can be destroyed, resulting in massive holes288// ?2 - chain-controlled -> controlled289//      same as ?1, but can be only added, resulting in easier exploitation290// ?3 - real -> controlled291//      no confirmation required, so addresses can be easily generated292decl_storage! {293	trait Store for Module<T: Config> as Nft {294295		//#region Private members296		/// Id of next collection297		CreatedCollectionCount: u32;298		/// Used for migrations299		ChainVersion: u64;300		/// Id of last collection token301		/// Collection id (controlled?1)302		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;303		//#endregion304305		//#region Bound counters306		/// Amount of collections destroyed, used for total amount tracking with307		/// CreatedCollectionCount308		DestroyedCollectionCount: u32;309		//#endregion310311		//#region Basic collections312		/// Collection info313		/// Collection id (controlled?1)314		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;315		/// List of collection admins316		/// Collection id (controlled?2)317		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;318		/// Whitelisted collection users319		/// Collection id (controlled?2), user id (controlled?3)320		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;321		//#endregion322323		/// How many of collection items user have324		/// Collection id (controlled?2), account id (real)325		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;326327		/// Amount of items which spender can transfer out of owners account (via transferFrom)328		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))329		/// TODO: Off chain worker should remove from this map when token gets removed330		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;331332		//#region Item collections333		/// Collection id (controlled?2), token id (controlled?1)334		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;335		/// Collection id (controlled?2), owner (controlled?2)336		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;337		/// Collection id (controlled?2), token id (controlled?1)338		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;339		//#endregion340341		//#region Index list342		/// Collection id (controlled?2), tokens owner (controlled?2)343		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;344		//#endregion345346		//#region Tokens transfer rate limit baskets347		/// (Collection id (controlled?2), who created (real))348		/// TODO: Off chain worker should remove from this map when collection gets removed349		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;350		/// Collection id (controlled?2), token id (controlled?2)351		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352		/// Collection id (controlled?2), owning user (real)353		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;354		/// Collection id (controlled?2), token id (controlled?2)355		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;356		//#endregion357358		/// Variable metadata sponsoring359		/// Collection id (controlled?2), token id (controlled?2)360		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;361	}362	add_extra_genesis {363		build(|config: &GenesisConfig<T>| {364			// Modification of storage365			for (_num, _c) in &config.collection_id {366				<Module<T>>::init_collection(_c);367			}368369			for (_num, _c, _i) in &config.nft_item_id {370				<Module<T>>::init_nft_token(*_c, _i);371			}372373			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {374				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);375			}376377			for (_num, _c, _i) in &config.refungible_item_id {378				<Module<T>>::init_refungible_token(*_c, _i);379			}380		})381	}382}383384decl_event!(385	pub enum Event<T>386	where387		AccountId = <T as frame_system::Config>::AccountId,388		CrossAccountId = <T as Config>::CrossAccountId,389	{390		/// New collection was created391		///392		/// # Arguments393		///394		/// * collection_id: Globally unique identifier of newly created collection.395		///396		/// * mode: [CollectionMode] converted into u8.397		///398		/// * account_id: Collection owner.399		CollectionCreated(CollectionId, u8, AccountId),400401		/// New item was created.402		///403		/// # Arguments404		///405		/// * collection_id: Id of the collection where item was created.406		///407		/// * item_id: Id of an item. Unique within the collection.408		///409		/// * recipient: Owner of newly created item410		ItemCreated(CollectionId, TokenId, CrossAccountId),411412		/// Collection item was burned.413		///414		/// # Arguments415		///416		/// collection_id.417		///418		/// item_id: Identifier of burned NFT.419		ItemDestroyed(CollectionId, TokenId),420421		/// Item was transferred422		///423		/// * collection_id: Id of collection to which item is belong424		///425		/// * item_id: Id of an item426		///427		/// * sender: Original owner of item428		///429		/// * recipient: New owner of item430		///431		/// * amount: Always 1 for NFT432		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),433434		/// * collection_id435		///436		/// * item_id437		///438		/// * sender439		///440		/// * spender441		///442		/// * amount443		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),444	}445);446447decl_module! {448	pub struct Module<T: Config> for enum Call449	where450		origin: T::Origin451	{452		fn deposit_event() = default;453		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;454		type Error = Error<T>;455456		fn on_initialize(_now: T::BlockNumber) -> Weight {457			0458		}459460		/// 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.461		///462		/// # Permissions463		///464		/// * Anyone.465		///466		/// # Arguments467		///468		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.469		///470		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.471		///472		/// * token_prefix: UTF-8 string with token prefix.473		///474		/// * mode: [CollectionMode] collection type and type dependent data.475		// returns collection ID476		#[weight = <SelfWeightOf<T>>::create_collection()]477		#[transactional]478		pub fn create_collection(origin,479								 collection_name: Vec<u16>,480								 collection_description: Vec<u16>,481								 token_prefix: Vec<u8>,482								 mode: CollectionMode) -> DispatchResult {483484			// Anyone can create a collection485			let who = ensure_signed(origin)?;486487			// Take a (non-refundable) deposit of collection creation488			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();489			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(490				&T::TreasuryAccountId::get(),491				T::CollectionCreationPrice::get(),492			));493			<T as Config>::Currency::settle(494				&who,495				imbalance,496				WithdrawReasons::TRANSFER,497				ExistenceRequirement::KeepAlive,498			).map_err(|_| Error::<T>::NoPermission)?;499500			let decimal_points = match mode {501				CollectionMode::Fungible(points) => points,502				_ => 0503			};504505			let created_count = CreatedCollectionCount::get();506			let destroyed_count = DestroyedCollectionCount::get();507508			// bound Total number of collections509			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);510511			// check params512			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);513			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);514			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);515			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);516517			// Generate next collection ID518			let next_id = created_count519				.checked_add(1)520				.ok_or(Error::<T>::NumOverflow)?;521522			CreatedCollectionCount::put(next_id);523524			let limits = CollectionLimits {525				sponsored_data_size: CUSTOM_DATA_LIMIT,526				..Default::default()527			};528529			// Create new collection530			let new_collection = Collection {531				owner: who.clone(),532				name: collection_name,533				mode: mode.clone(),534				mint_mode: false,535				access: AccessMode::Normal,536				description: collection_description,537				decimal_points,538				token_prefix,539				offchain_schema: Vec::new(),540				schema_version: SchemaVersion::ImageURL,541				sponsorship: SponsorshipState::Disabled,542				variable_on_chain_schema: Vec::new(),543				const_on_chain_schema: Vec::new(),544				limits,545				meta_update_permission: MetaUpdatePermission::default(),546				transfers_enabled: true,547			};548549			// Add new collection to map550			<CollectionById<T>>::insert(next_id, new_collection);551552			// call event553			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));554555			Ok(())556		}557558		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.559		///560		/// # Permissions561		///562		/// * Collection Owner.563		///564		/// # Arguments565		///566		/// * collection_id: collection to destroy.567		#[weight = <SelfWeightOf<T>>::destroy_collection()]568		#[transactional]569		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {570571			let sender = ensure_signed(origin)?;572			let collection = Self::get_collection(collection_id)?;573			Self::check_owner_permissions(&collection, &sender)?;574			if !collection.limits.owner_can_destroy {575				fail!(Error::<T>::NoPermission);576			}577578			<AddressTokens<T>>::remove_prefix(collection_id, None);579			<Allowances<T>>::remove_prefix(collection_id, None);580			<Balance<T>>::remove_prefix(collection_id, None);581			<ItemListIndex>::remove(collection_id);582			<AdminList<T>>::remove(collection_id);583			<CollectionById<T>>::remove(collection_id);584			<WhiteList<T>>::remove_prefix(collection_id, None);585586			<NftItemList<T>>::remove_prefix(collection_id, None);587			<FungibleItemList<T>>::remove_prefix(collection_id, None);588			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);589590			<NftTransferBasket<T>>::remove_prefix(collection_id, None);591			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);592			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);593594			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);595596			DestroyedCollectionCount::put(DestroyedCollectionCount::get()597				.checked_add(1)598				.ok_or(Error::<T>::NumOverflow)?);599600			Ok(())601		}602603		/// Add an address to white list.604		///605		/// # Permissions606		///607		/// * Collection Owner608		/// * Collection Admin609		///610		/// # Arguments611		///612		/// * collection_id.613		///614		/// * address.615		#[weight = <SelfWeightOf<T>>::add_to_white_list()]616		#[transactional]617		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{618619			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);620			let collection = Self::get_collection(collection_id)?;621622			Self::toggle_white_list_internal(623				&sender,624				&collection,625				&address,626				true,627			)?;628629			Ok(())630		}631632		/// Remove an address from white list.633		///634		/// # Permissions635		///636		/// * Collection Owner637		/// * Collection Admin638		///639		/// # Arguments640		///641		/// * collection_id.642		///643		/// * address.644		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]645		#[transactional]646		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{647648			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);649			let collection = Self::get_collection(collection_id)?;650651			Self::toggle_white_list_internal(652				&sender,653				&collection,654				&address,655				false,656			)?;657658			Ok(())659		}660661		/// Toggle between normal and white list access for the methods with access for `Anyone`.662		///663		/// # Permissions664		///665		/// * Collection Owner.666		///667		/// # Arguments668		///669		/// * collection_id.670		///671		/// * mode: [AccessMode]672		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]673		#[transactional]674		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult675		{676			let sender = ensure_signed(origin)?;677678			let mut target_collection = Self::get_collection(collection_id)?;679			Self::check_owner_permissions(&target_collection, &sender)?;680			target_collection.access = mode;681			target_collection.save()682		}683684		/// Allows Anyone to create tokens if:685		/// * White List is enabled, and686		/// * Address is added to white list, and687		/// * This method was called with True parameter688		///689		/// # Permissions690		/// * Collection Owner691		///692		/// # Arguments693		///694		/// * collection_id.695		///696		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.697		#[weight = <SelfWeightOf<T>>::set_mint_permission()]698		#[transactional]699		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult700		{701			let sender = ensure_signed(origin)?;702703			let mut target_collection = Self::get_collection(collection_id)?;704			Self::check_owner_permissions(&target_collection, &sender)?;705			target_collection.mint_mode = mint_permission;706			target_collection.save()707		}708709		/// Change the owner of the collection.710		///711		/// # Permissions712		///713		/// * Collection Owner.714		///715		/// # Arguments716		///717		/// * collection_id.718		///719		/// * new_owner.720		#[weight = <SelfWeightOf<T>>::change_collection_owner()]721		#[transactional]722		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {723724			let sender = ensure_signed(origin)?;725			let mut target_collection = Self::get_collection(collection_id)?;726			Self::check_owner_permissions(&target_collection, &sender)?;727			target_collection.owner = new_owner;728			target_collection.save()729		}730731		/// Adds an admin of the Collection.732		/// 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.733		///734		/// # Permissions735		///736		/// * Collection Owner.737		/// * Collection Admin.738		///739		/// # Arguments740		///741		/// * collection_id: ID of the Collection to add admin for.742		///743		/// * new_admin_id: Address of new admin to add.744		#[weight = <SelfWeightOf<T>>::add_collection_admin()]745		#[transactional]746		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {747			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);748			let collection = Self::get_collection(collection_id)?;749			Self::check_owner_or_admin_permissions(&collection, &sender)?;750			let mut admin_arr = <AdminList<T>>::get(collection_id);751752			match admin_arr.binary_search(&new_admin_id) {753				Ok(_) => {},754				Err(idx) => {755					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);756					admin_arr.insert(idx, new_admin_id);757					<AdminList<T>>::insert(collection_id, admin_arr);758				}759			}760			Ok(())761		}762763		/// 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.764		///765		/// # Permissions766		///767		/// * Collection Owner.768		/// * Collection Admin.769		///770		/// # Arguments771		///772		/// * collection_id: ID of the Collection to remove admin for.773		///774		/// * account_id: Address of admin to remove.775		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]776		#[transactional]777		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {778			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);779			let collection = Self::get_collection(collection_id)?;780			Self::check_owner_or_admin_permissions(&collection, &sender)?;781			let mut admin_arr = <AdminList<T>>::get(collection_id);782783			if let Ok(idx) = admin_arr.binary_search(&account_id) {784				admin_arr.remove(idx);785				<AdminList<T>>::insert(collection_id, admin_arr);786			}787			Ok(())788		}789790		/// # Permissions791		///792		/// * Collection Owner793		///794		/// # Arguments795		///796		/// * collection_id.797		///798		/// * new_sponsor.799		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]800		#[transactional]801		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {802			let sender = ensure_signed(origin)?;803			let mut target_collection = Self::get_collection(collection_id)?;804			Self::check_owner_permissions(&target_collection, &sender)?;805806			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);807			target_collection.save()808		}809810		/// # Permissions811		///812		/// * Sponsor.813		///814		/// # Arguments815		///816		/// * collection_id.817		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]818		#[transactional]819		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {820			let sender = ensure_signed(origin)?;821822			let mut target_collection = Self::get_collection(collection_id)?;823			ensure!(824				target_collection.sponsorship.pending_sponsor() == Some(&sender),825				Error::<T>::ConfirmUnsetSponsorFail826			);827828			target_collection.sponsorship = SponsorshipState::Confirmed(sender);829			target_collection.save()830		}831832		/// Switch back to pay-per-own-transaction model.833		///834		/// # Permissions835		///836		/// * Collection owner.837		///838		/// # Arguments839		///840		/// * collection_id.841		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]842		#[transactional]843		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844			let sender = ensure_signed(origin)?;845846			let mut target_collection = Self::get_collection(collection_id)?;847			Self::check_owner_permissions(&target_collection, &sender)?;848849			target_collection.sponsorship = SponsorshipState::Disabled;850			target_collection.save()851		}852853		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.854		///855		/// # Permissions856		///857		/// * Collection Owner.858		/// * Collection Admin.859		/// * Anyone if860		///     * White List is enabled, and861		///     * Address is added to white list, and862		///     * MintPermission is enabled (see SetMintPermission method)863		///864		/// # Arguments865		///866		/// * collection_id: ID of the collection.867		///868		/// * owner: Address, initial owner of the NFT.869		///870		/// * data: Token data to store on chain.871		// #[weight =872		// (130_000_000 as Weight)873		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))874		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))875		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]876877		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]878		#[transactional]879		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {880			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881			let collection = Self::get_collection(collection_id)?;882883			Self::create_item_internal(&sender, &collection, &owner, data)?;884885			collection.submit_logs()886		}887888		/// This method creates multiple items in a collection created with CreateCollection method.889		///890		/// # Permissions891		///892		/// * Collection Owner.893		/// * Collection Admin.894		/// * Anyone if895		///     * White List is enabled, and896		///     * Address is added to white list, and897		///     * MintPermission is enabled (see SetMintPermission method)898		///899		/// # Arguments900		///901		/// * collection_id: ID of the collection.902		///903		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].904		///905		/// * owner: Address, initial owner of the NFT.906		#[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]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>>::set_transfers_enabled_flag()]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;971972			target_collection.save()973		}974975		/// Destroys a concrete instance of NFT.976		///977		/// # Permissions978		///979		/// * Collection Owner.980		/// * Collection Admin.981		/// * Current NFT Owner.982		///983		/// # Arguments984		///985		/// * collection_id: ID of the collection.986		///987		/// * item_id: ID of NFT to burn.988		#[weight = <SelfWeightOf<T>>::burn_item()]989		#[transactional]990		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991992			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993			let target_collection = Self::get_collection(collection_id)?;994995			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;996997			target_collection.submit_logs()998		}9991000		/// Change ownership of the token.1001		///1002		/// # Permissions1003		///1004		/// * Collection Owner1005		/// * Collection Admin1006		/// * Current NFT owner1007		///1008		/// # Arguments1009		///1010		/// * recipient: Address of token recipient.1011		///1012		/// * collection_id.1013		///1014		/// * item_id: ID of the item1015		///     * Non-Fungible Mode: Required.1016		///     * Fungible Mode: Ignored.1017		///     * Re-Fungible Mode: Required.1018		///1019		/// * value: Amount to transfer.1020		///     * Non-Fungible Mode: Ignored1021		///     * Fungible Mode: Must specify transferred amount1022		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1023		#[weight = <SelfWeightOf<T>>::transfer()]1024		#[transactional]1025		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1026			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1027			let collection = Self::get_collection(collection_id)?;10281029			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10301031			collection.submit_logs()1032		}10331034		/// Set, change, or remove approved address to transfer the ownership of the NFT.1035		///1036		/// # Permissions1037		///1038		/// * Collection Owner1039		/// * Collection Admin1040		/// * Current NFT owner1041		///1042		/// # Arguments1043		///1044		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1045		///1046		/// * collection_id.1047		///1048		/// * item_id: ID of the item.1049		#[weight = <SelfWeightOf<T>>::approve()]1050		#[transactional]1051		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1052			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1053			let collection = Self::get_collection(collection_id)?;10541055			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10561057			collection.submit_logs()1058		}10591060		/// 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.1061		///1062		/// # Permissions1063		/// * Collection Owner1064		/// * Collection Admin1065		/// * Current NFT owner1066		/// * Address approved by current NFT owner1067		///1068		/// # Arguments1069		///1070		/// * from: Address that owns token.1071		///1072		/// * recipient: Address of token recipient.1073		///1074		/// * collection_id.1075		///1076		/// * item_id: ID of the item.1077		///1078		/// * value: Amount to transfer.1079		#[weight = <SelfWeightOf<T>>::transfer_from()]1080		#[transactional]1081		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1082			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1083			let collection = Self::get_collection(collection_id)?;10841085			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10861087			collection.submit_logs()1088		}1089		// #[weight = 0]1090		//     // let no_perm_mes = "You do not have permissions to modify this collection";1091		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1092		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1093		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10941095		//     // // on_nft_received  call10961097		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;10981099		//     Ok(())1100		// }11011102		/// Set off-chain data schema.1103		///1104		/// # Permissions1105		///1106		/// * Collection Owner1107		/// * Collection Admin1108		///1109		/// # Arguments1110		///1111		/// * collection_id.1112		///1113		/// * schema: String representing the offchain data schema.1114		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1115		#[transactional]1116		pub fn set_variable_meta_data (1117			origin,1118			collection_id: CollectionId,1119			item_id: TokenId,1120			data: Vec<u8>1121		) -> DispatchResult {1122			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124			let collection = Self::get_collection(collection_id)?;1125			Self::meta_update_check(&sender, &collection, item_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		};13491350		Self::deposit_event(RawEvent::Transfer(1351			target_collection.id,1352			item_id,1353			sender.clone(),1354			recipient.clone(),1355			value,1356		));13571358		Ok(())1359	}13601361	pub fn approve_internal(1362		sender: &T::CrossAccountId,1363		spender: &T::CrossAccountId,1364		collection: &CollectionHandle<T>,1365		item_id: TokenId,1366		amount: u128,1367	) -> DispatchResult {1368		Self::token_exists(collection, item_id)?;13691370		// Transfer permissions check1371		let bypasses_limits = collection.limits.owner_can_transfer1372			&& Self::is_owner_or_admin_permissions(collection, sender)?;13731374		let allowance_limit = if bypasses_limits {1375			None1376		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1377			Some(amount)1378		} else {1379			fail!(Error::<T>::NoPermission);1380		};13811382		if collection.access == AccessMode::WhiteList {1383			Self::check_white_list(collection, sender)?;1384			Self::check_white_list(collection, spender)?;1385		}13861387		collection.consume_sload()?;1388		let allowance: u128 = amount1389			.checked_add(<Allowances<T>>::get(1390				collection.id,1391				(item_id, sender.as_sub(), spender.as_sub()),1392			))1393			.ok_or(Error::<T>::NumOverflow)?;1394		if let Some(limit) = allowance_limit {1395			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1396		}1397		collection.consume_sstore()?;1398		<Allowances<T>>::insert(1399			collection.id,1400			(item_id, sender.as_sub(), spender.as_sub()),1401			allowance,1402		);14031404		if matches!(collection.mode, CollectionMode::NFT) {1405			// TODO: NFT: only one owner may exist for token in ERC7211406			collection.log(ERC721Events::Approval {1407				owner: *sender.as_eth(),1408				approved: *spender.as_eth(),1409				token_id: item_id.into(),1410			})?;1411		}14121413		if matches!(collection.mode, CollectionMode::Fungible(_)) {1414			// TODO: NFT: only one owner may exist for token in ERC201415			collection.log(ERC20Events::Approval {1416				owner: *sender.as_eth(),1417				spender: *spender.as_eth(),1418				value: allowance.into(),1419			})?;1420		}14211422		Self::deposit_event(RawEvent::Approved(1423			collection.id,1424			item_id,1425			sender.clone(),1426			spender.clone(),1427			allowance,1428		));1429		Ok(())1430	}14311432	pub fn transfer_from_internal(1433		sender: &T::CrossAccountId,1434		from: &T::CrossAccountId,1435		recipient: &T::CrossAccountId,1436		collection: &CollectionHandle<T>,1437		item_id: TokenId,1438		amount: u128,1439	) -> DispatchResult {1440		if sender == from {1441			// Transfer by `from`, because it is either equal to sender, or derived from him1442			return Self::transfer_internal(from, recipient, collection, item_id, amount);1443		}14441445		// Check approval1446		collection.consume_sload()?;1447		let approval: u128 =1448			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14491450		// Limits check1451		Self::is_correct_transfer(collection, recipient)?;14521453		// Transfer permissions check1454		ensure!(1455			approval >= amount1456				|| (collection.limits.owner_can_transfer1457					&& Self::is_owner_or_admin_permissions(collection, sender)?),1458			Error::<T>::NoPermission1459		);14601461		if collection.access == AccessMode::WhiteList {1462			Self::check_white_list(collection, sender)?;1463			Self::check_white_list(collection, recipient)?;1464		}14651466		// Reduce approval by transferred amount or remove if remaining approval drops to 01467		let allowance = approval.saturating_sub(amount);1468		collection.consume_sstore()?;1469		if allowance > 0 {1470			<Allowances<T>>::insert(1471				collection.id,1472				(item_id, from.as_sub(), sender.as_sub()),1473				allowance,1474			);1475		} else {1476			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1477		}14781479		match collection.mode {1480			CollectionMode::NFT => {1481				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1482			}1483			CollectionMode::Fungible(_) => {1484				Self::transfer_fungible(collection, amount, from, recipient)?1485			}1486			CollectionMode::ReFungible => Self::transfer_refungible(1487				collection,1488				item_id,1489				amount,1490				from.clone(),1491				recipient.clone(),1492			)?,1493		};14941495		if matches!(collection.mode, CollectionMode::Fungible(_)) {1496			collection.log(ERC20Events::Approval {1497				owner: *from.as_eth(),1498				spender: *sender.as_eth(),1499				value: allowance.into(),1500			})?;1501		}15021503		Ok(())1504	}15051506	pub fn set_variable_meta_data_internal(1507		sender: &T::CrossAccountId,1508		collection: &CollectionHandle<T>,1509		item_id: TokenId,1510		data: Vec<u8>,1511	) -> DispatchResult {1512		Self::token_exists(collection, item_id)?;15131514		ensure!(1515			CUSTOM_DATA_LIMIT >= data.len() as u32,1516			Error::<T>::TokenVariableDataLimitExceeded1517		);15181519		ensure!(1520			(Self::is_item_owner(sender, collection, item_id)?1521				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1522				|| (Self::is_owner_or_admin_permissions(collection, sender)?1523					&& collection.meta_update_permission == MetaUpdatePermission::Admin),1524			Error::<T>::NoPermission1525		);15261527		match collection.mode {1528			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1529			CollectionMode::ReFungible => {1530				Self::set_re_fungible_variable_data(collection, item_id, data)?1531			}1532			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1533		};15341535		Ok(())1536	}15371538	pub fn meta_update_check(1539		sender: &T::CrossAccountId,1540		collection: &CollectionHandle<T>,1541		item_id: TokenId,1542	) -> DispatchResult {1543		match collection.meta_update_permission {1544			MetaUpdatePermission::ItemOwner => ensure!(1545				Self::is_item_owner(sender, collection, item_id)?,1546				Error::<T>::NoPermission1547			),1548			MetaUpdatePermission::Admin => ensure!(1549				Self::is_owner_or_admin_permissions(collection, sender)?,1550				Error::<T>::NoPermission1551			),1552			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1553		}15541555		Ok(())1556	}15571558	pub fn get_variable_metadata(1559		collection: &CollectionHandle<T>,1560		item_id: TokenId,1561	) -> Result<Vec<u8>, DispatchError> {1562		Ok(match collection.mode {1563			CollectionMode::NFT => {1564				<NftItemList<T>>::get(collection.id, item_id)1565					.ok_or(Error::<T>::TokenNotFound)?1566					.variable_data1567			}1568			CollectionMode::ReFungible => {1569				<ReFungibleItemList<T>>::get(collection.id, item_id)1570					.ok_or(Error::<T>::TokenNotFound)?1571					.variable_data1572			}1573			_ => fail!(Error::<T>::UnexpectedCollectionType),1574		})1575	}15761577	pub fn create_multiple_items_internal(1578		sender: &T::CrossAccountId,1579		collection: &CollectionHandle<T>,1580		owner: &T::CrossAccountId,1581		items_data: Vec<CreateItemData>,1582	) -> DispatchResult {1583		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15841585		for data in &items_data {1586			Self::validate_create_item_args(collection, data)?;1587		}1588		for data in &items_data {1589			Self::create_item_no_validation(collection, owner, data.clone())?;1590		}15911592		Ok(())1593	}15941595	pub fn burn_item_internal(1596		sender: &T::CrossAccountId,1597		collection: &CollectionHandle<T>,1598		item_id: TokenId,1599		value: u128,1600	) -> DispatchResult {1601		ensure!(1602			Self::is_item_owner(sender, collection, item_id)?1603				|| (collection.limits.owner_can_transfer1604					&& Self::is_owner_or_admin_permissions(collection, sender)?),1605			Error::<T>::NoPermission1606		);16071608		if collection.access == AccessMode::WhiteList {1609			Self::check_white_list(collection, sender)?;1610		}16111612		match collection.mode {1613			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1614			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1615			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1616		};16171618		Ok(())1619	}16201621	pub fn toggle_white_list_internal(1622		sender: &T::CrossAccountId,1623		collection: &CollectionHandle<T>,1624		address: &T::CrossAccountId,1625		whitelisted: bool,1626	) -> DispatchResult {1627		Self::check_owner_or_admin_permissions(collection, sender)?;16281629		if whitelisted {1630			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1631		} else {1632			<WhiteList<T>>::remove(collection.id, address.as_sub());1633		}16341635		Ok(())1636	}16371638	fn is_correct_transfer(1639		collection: &CollectionHandle<T>,1640		recipient: &T::CrossAccountId,1641	) -> DispatchResult {1642		let collection_id = collection.id;16431644		// check token limit and account token limit1645		collection.consume_sload()?;1646		let account_items: u32 =1647			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16481649		// zero limit means collection limit is disabled1650		// otherwise get lower value1651		let limit = if collection.limits.account_token_ownership_limit == 01652			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1653		{1654			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1655		} else {1656			collection.limits.account_token_ownership_limit1657		};16581659		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16601661		// preliminary transfer check1662		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16631664		Ok(())1665	}16661667	fn can_create_items_in_collection(1668		collection: &CollectionHandle<T>,1669		sender: &T::CrossAccountId,1670		owner: &T::CrossAccountId,1671		amount: u32,1672	) -> DispatchResult {1673		let collection_id = collection.id;16741675		// check token limit and account token limit1676		let total_items: u32 = ItemListIndex::get(collection_id)1677			.checked_add(amount)1678			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1679		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1680			as u32)1681			.checked_add(amount)1682			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;16831684		// zero limit means collection limit is disabled1685		// otherwise get lower value1686		let account_token_limit = if collection.limits.account_token_ownership_limit == 01687			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1688		{1689			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1690		} else {1691			collection.limits.account_token_ownership_limit1692		};16931694		ensure!(1695			collection.limits.token_limit >= total_items,1696			Error::<T>::CollectionTokenLimitExceeded1697		);1698		ensure!(1699			account_token_limit >= account_items,1700			Error::<T>::AccountTokenLimitExceeded1701		);17021703		if !Self::is_owner_or_admin_permissions(collection, sender)? {1704			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1705			Self::check_white_list(collection, owner)?;1706			Self::check_white_list(collection, sender)?;1707		}17081709		Ok(())1710	}17111712	fn validate_create_item_args(1713		target_collection: &CollectionHandle<T>,1714		data: &CreateItemData,1715	) -> DispatchResult {1716		match target_collection.mode {1717			CollectionMode::NFT => {1718				if !matches!(data, CreateItemData::NFT(_)) {1719					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1720				}1721			}1722			CollectionMode::Fungible(_) => {1723				if !matches!(data, CreateItemData::Fungible(_)) {1724					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1725				}1726			}1727			CollectionMode::ReFungible => {1728				if let CreateItemData::ReFungible(data) = data {1729					// Check refungibility limits1730					ensure!(1731						data.pieces <= MAX_REFUNGIBLE_PIECES,1732						Error::<T>::WrongRefungiblePieces1733					);1734					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1735				} else {1736					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1737				}1738			}1739		};17401741		Ok(())1742	}17431744	fn create_item_no_validation(1745		collection: &CollectionHandle<T>,1746		owner: &T::CrossAccountId,1747		data: CreateItemData,1748	) -> DispatchResult {1749		match data {1750			CreateItemData::NFT(data) => {1751				let item = NftItemType {1752					owner: owner.clone(),1753					const_data: data.const_data.into_inner(),1754					variable_data: data.variable_data.into_inner(),1755				};17561757				Self::add_nft_item(collection, item)?;1758			}1759			CreateItemData::Fungible(data) => {1760				Self::add_fungible_item(collection, owner, data.value)?;1761			}1762			CreateItemData::ReFungible(data) => {1763				let owner_list = vec![Ownership {1764					owner: owner.clone(),1765					fraction: data.pieces,1766				}];17671768				let item = ReFungibleItemType {1769					owner: owner_list,1770					const_data: data.const_data.into_inner(),1771					variable_data: data.variable_data.into_inner(),1772				};17731774				Self::add_refungible_item(collection, item)?;1775			}1776		};17771778		Ok(())1779	}17801781	fn add_fungible_item(1782		collection: &CollectionHandle<T>,1783		owner: &T::CrossAccountId,1784		value: u128,1785	) -> DispatchResult {1786		let collection_id = collection.id;17871788		// Does new owner already have an account?1789		collection.consume_sload()?;1790		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17911792		// Mint1793		let item = FungibleItemType {1794			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1795		};1796		collection.consume_sstore()?;1797		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17981799		// Update balance1800		collection.consume_sload()?;1801		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1802			.checked_add(value)1803			.ok_or(Error::<T>::NumOverflow)?;1804		collection.consume_sstore()?;1805		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18061807		collection.log(ERC20Events::Transfer {1808			from: H160::default(),1809			to: *owner.as_eth(),1810			value: value.into(),1811		})?;1812		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1813		Ok(())1814	}18151816	fn add_refungible_item(1817		collection: &CollectionHandle<T>,1818		item: ReFungibleItemType<T::CrossAccountId>,1819	) -> DispatchResult {1820		let collection_id = collection.id;18211822		let current_index = <ItemListIndex>::get(collection_id)1823			.checked_add(1)1824			.ok_or(Error::<T>::NumOverflow)?;1825		let itemcopy = item.clone();18261827		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1828		let item_owner = item.owner.first().expect("only one owner is defined");18291830		let value = item_owner.fraction;1831		let owner = item_owner.owner.clone();18321833		Self::add_token_index(collection, current_index, &owner)?;18341835		<ItemListIndex>::insert(collection_id, current_index);1836		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18371838		// Update balance1839		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1840			.checked_add(value)1841			.ok_or(Error::<T>::NumOverflow)?;1842		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18431844		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1845		Ok(())1846	}18471848	fn add_nft_item(1849		collection: &CollectionHandle<T>,1850		item: NftItemType<T::CrossAccountId>,1851	) -> DispatchResult {1852		let collection_id = collection.id;18531854		let current_index = <ItemListIndex>::get(collection_id)1855			.checked_add(1)1856			.ok_or(Error::<T>::NumOverflow)?;18571858		let item_owner = item.owner.clone();1859		Self::add_token_index(collection, current_index, &item.owner)?;18601861		<ItemListIndex>::insert(collection_id, current_index);1862		<NftItemList<T>>::insert(collection_id, current_index, item);18631864		// Update balance1865		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1866			.checked_add(1)1867			.ok_or(Error::<T>::NumOverflow)?;1868		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18691870		collection.log(ERC721Events::Transfer {1871			from: H160::default(),1872			to: *item_owner.as_eth(),1873			token_id: current_index.into(),1874		})?;1875		Self::deposit_event(RawEvent::ItemCreated(1876			collection_id,1877			current_index,1878			item_owner,1879		));1880		Ok(())1881	}18821883	fn burn_refungible_item(1884		collection: &CollectionHandle<T>,1885		item_id: TokenId,1886		owner: &T::CrossAccountId,1887	) -> DispatchResult {1888		let collection_id = collection.id;18891890		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1891			.ok_or(Error::<T>::TokenNotFound)?;1892		let rft_balance = token1893			.owner1894			.iter()1895			.find(|&i| i.owner == *owner)1896			.ok_or(Error::<T>::TokenNotFound)?;1897		Self::remove_token_index(collection, item_id, owner)?;18981899		// update balance1900		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1901			.checked_sub(rft_balance.fraction)1902			.ok_or(Error::<T>::NumOverflow)?;1903		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19041905		// Re-create owners list with sender removed1906		let index = token1907			.owner1908			.iter()1909			.position(|i| i.owner == *owner)1910			.expect("owned item is exists");1911		token.owner.remove(index);1912		let owner_count = token.owner.len();19131914		// Burn the token completely if this was the last (only) owner1915		if owner_count == 0 {1916			<ReFungibleItemList<T>>::remove(collection_id, item_id);1917			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);1918		} else {1919			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);1920		}19211922		Ok(())1923	}19241925	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1926		let collection_id = collection.id;19271928		let item =1929			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1930		Self::remove_token_index(collection, item_id, &item.owner)?;19311932		// update balance1933		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1934			.checked_sub(1)1935			.ok_or(Error::<T>::NumOverflow)?;1936		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1937		<NftItemList<T>>::remove(collection_id, item_id);1938		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);19391940		collection.log(ERC721Events::Transfer {1941			from: *item.owner.as_eth(),1942			to: H160::default(),1943			token_id: item_id.into(),1944		})?;1945		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1946		Ok(())1947	}19481949	fn burn_fungible_item(1950		owner: &T::CrossAccountId,1951		collection: &CollectionHandle<T>,1952		value: u128,1953	) -> DispatchResult {1954		let collection_id = collection.id;19551956		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1957		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19581959		// update balance1960		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1961			.checked_sub(value)1962			.ok_or(Error::<T>::NumOverflow)?;1963		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19641965		if balance.value - value > 0 {1966			balance.value -= value;1967			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1968		} else {1969			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());1970		}19711972		collection.log(ERC20Events::Transfer {1973			from: *owner.as_eth(),1974			to: H160::default(),1975			value: value.into(),1976		})?;1977		Ok(())1978	}19791980	pub fn get_collection(1981		collection_id: CollectionId,1982	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1983		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1984	}19851986	fn check_owner_permissions(1987		target_collection: &CollectionHandle<T>,1988		subject: &T::AccountId,1989	) -> DispatchResult {1990		ensure!(1991			*subject == target_collection.owner,1992			Error::<T>::NoPermission1993		);19941995		Ok(())1996	}19971998	fn is_owner_or_admin_permissions(1999		collection: &CollectionHandle<T>,2000		subject: &T::CrossAccountId,2001	) -> Result<bool, DispatchError> {2002		collection.consume_sload()?;2003		Ok(*subject.as_sub() == collection.owner2004			|| <AdminList<T>>::get(collection.id).contains(subject))2005	}20062007	fn check_owner_or_admin_permissions(2008		collection: &CollectionHandle<T>,2009		subject: &T::CrossAccountId,2010	) -> DispatchResult {2011		ensure!(2012			Self::is_owner_or_admin_permissions(collection, subject)?,2013			Error::<T>::NoPermission2014		);20152016		Ok(())2017	}20182019	fn owned_amount(2020		subject: &T::CrossAccountId,2021		collection: &CollectionHandle<T>,2022		item_id: TokenId,2023	) -> Result<Option<u128>, DispatchError> {2024		collection.consume_sload()?;2025		Ok(Self::owned_amount_unchecked(subject, collection, item_id))2026	}20272028	fn owned_amount_unchecked(2029		subject: &T::CrossAccountId,2030		target_collection: &CollectionHandle<T>,2031		item_id: TokenId,2032	) -> Option<u128> {2033		let collection_id = target_collection.id;20342035		match target_collection.mode {2036			CollectionMode::NFT => {2037				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2038			}2039			CollectionMode::Fungible(_) => {2040				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2041			}2042			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2043				.owner2044				.iter()2045				.find(|i| i.owner == *subject)2046				.map(|i| i.fraction),2047		}2048	}20492050	fn is_item_owner(2051		subject: &T::CrossAccountId,2052		target_collection: &CollectionHandle<T>,2053		item_id: TokenId,2054	) -> Result<bool, DispatchError> {2055		Ok(match target_collection.mode {2056			CollectionMode::Fungible(_) => true,2057			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2058		})2059	}20602061	fn check_white_list(2062		collection: &CollectionHandle<T>,2063		address: &T::CrossAccountId,2064	) -> DispatchResult {2065		collection.consume_sload()?;2066		ensure!(2067			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),2068			Error::<T>::AddresNotInWhiteList,2069		);2070		Ok(())2071	}20722073	/// Check if token exists. In case of Fungible, check if there is an entry for2074	/// the owner in fungible balances double map2075	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2076		let collection_id = target_collection.id;2077		let exists = match target_collection.mode {2078			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2079			CollectionMode::Fungible(_) => true,2080			CollectionMode::ReFungible => {2081				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)2082			}2083		};20842085		ensure!(exists, Error::<T>::TokenNotFound);2086		Ok(())2087	}20882089	fn transfer_fungible(2090		collection: &CollectionHandle<T>,2091		value: u128,2092		owner: &T::CrossAccountId,2093		recipient: &T::CrossAccountId,2094	) -> DispatchResult {2095		let collection_id = collection.id;20962097		collection.consume_sload()?;2098		collection.consume_sload()?;2099		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2100		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21012102		recipient_balance.value = recipient_balance2103			.value2104			.checked_add(value)2105			.ok_or(Error::<T>::NumOverflow)?;2106		balance.value = balance2107			.value2108			.checked_sub(value)2109			.ok_or(Error::<T>::TokenValueTooLow)?;21102111		// update balanceOf2112		collection.consume_sstore()?;2113		collection.consume_sstore()?;2114		if balance.value != 0 {2115			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2116		} else {2117			<Balance<T>>::remove(collection_id, owner.as_sub());2118		}2119		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21202121		// Reduce or remove sender2122		collection.consume_sstore()?;2123		collection.consume_sstore()?;2124		if balance.value != 0 {2125			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2126		} else {2127			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2128		}2129		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21302131		collection.log(ERC20Events::Transfer {2132			from: *owner.as_eth(),2133			to: *recipient.as_eth(),2134			value: value.into(),2135		})?;2136		Self::deposit_event(RawEvent::Transfer(2137			collection.id,2138			1,2139			owner.clone(),2140			recipient.clone(),2141			value,2142		));21432144		Ok(())2145	}21462147	fn transfer_refungible(2148		collection: &CollectionHandle<T>,2149		item_id: TokenId,2150		value: u128,2151		owner: T::CrossAccountId,2152		new_owner: T::CrossAccountId,2153	) -> DispatchResult {2154		let collection_id = collection.id;2155		collection.consume_sload()?;2156		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2157			.ok_or(Error::<T>::TokenNotFound)?;21582159		let item = full_item2160			.owner2161			.iter()2162			.find(|i| i.owner == owner)2163			.ok_or(Error::<T>::TokenNotFound)?;2164		let amount = item.fraction;21652166		ensure!(amount >= value, Error::<T>::TokenValueTooLow);21672168		collection.consume_sload()?;2169		// update balance2170		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2171			.checked_sub(value)2172			.ok_or(Error::<T>::NumOverflow)?;2173		collection.consume_sstore()?;2174		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21752176		collection.consume_sload()?;2177		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2178			.checked_add(value)2179			.ok_or(Error::<T>::NumOverflow)?;2180		collection.consume_sstore()?;2181		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21822183		let old_owner = item.owner.clone();2184		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21852186		let mut new_full_item = full_item.clone();2187		// transfer2188		if amount == value && !new_owner_has_account {2189			// change owner2190			// new owner do not have account2191			new_full_item2192				.owner2193				.iter_mut()2194				.find(|i| i.owner == owner)2195				.expect("old owner does present in refungible")2196				.owner = new_owner.clone();2197			collection.consume_sstore()?;2198			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21992200			// update index collection2201			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2202		} else {2203			new_full_item2204				.owner2205				.iter_mut()2206				.find(|i| i.owner == owner)2207				.expect("old owner does present in refungible")2208				.fraction -= value;22092210			// separate amount2211			if new_owner_has_account {2212				// new owner has account2213				new_full_item2214					.owner2215					.iter_mut()2216					.find(|i| i.owner == new_owner)2217					.expect("new owner has account")2218					.fraction += value;2219			} else {2220				// new owner do not have account2221				new_full_item.owner.push(Ownership {2222					owner: new_owner.clone(),2223					fraction: value,2224				});2225				Self::add_token_index(collection, item_id, &new_owner)?;2226			}22272228			collection.consume_sstore()?;2229			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2230		}22312232		Self::deposit_event(RawEvent::Transfer(2233			collection.id,2234			item_id,2235			owner,2236			new_owner,2237			amount,2238		));22392240		Ok(())2241	}22422243	fn transfer_nft(2244		collection: &CollectionHandle<T>,2245		item_id: TokenId,2246		sender: T::CrossAccountId,2247		new_owner: T::CrossAccountId,2248	) -> DispatchResult {2249		let collection_id = collection.id;2250		collection.consume_sload()?;2251		let mut item =2252			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22532254		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22552256		collection.consume_sload()?;2257		// update balance2258		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2259			.checked_sub(1)2260			.ok_or(Error::<T>::NumOverflow)?;2261		collection.consume_sstore()?;2262		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22632264		collection.consume_sload()?;2265		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2266			.checked_add(1)2267			.ok_or(Error::<T>::NumOverflow)?;2268		collection.consume_sstore()?;2269		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22702271		// change owner2272		let old_owner = item.owner.clone();2273		item.owner = new_owner.clone();2274		collection.consume_sstore()?;2275		<NftItemList<T>>::insert(collection_id, item_id, item);22762277		// update index collection2278		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22792280		collection.log(ERC721Events::Transfer {2281			from: *sender.as_eth(),2282			to: *new_owner.as_eth(),2283			token_id: item_id.into(),2284		})?;2285		Self::deposit_event(RawEvent::Transfer(2286			collection.id,2287			item_id,2288			sender,2289			new_owner,2290			1,2291		));22922293		Ok(())2294	}22952296	fn set_re_fungible_variable_data(2297		collection: &CollectionHandle<T>,2298		item_id: TokenId,2299		data: Vec<u8>,2300	) -> DispatchResult {2301		let collection_id = collection.id;2302		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2303			.ok_or(Error::<T>::TokenNotFound)?;23042305		item.variable_data = data;23062307		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);23082309		Ok(())2310	}23112312	fn set_nft_variable_data(2313		collection: &CollectionHandle<T>,2314		item_id: TokenId,2315		data: Vec<u8>,2316	) -> DispatchResult {2317		let collection_id = collection.id;2318		let mut item =2319			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23202321		item.variable_data = data;23222323		<NftItemList<T>>::insert(collection_id, item_id, item);23242325		Ok(())2326	}23272328	#[allow(dead_code)]2329	fn init_collection(item: &Collection<T>) {2330		// check params2331		assert!(2332			item.decimal_points <= MAX_DECIMAL_POINTS,2333			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2334		);2335		assert!(2336			item.name.len() <= 64,2337			"Collection name can not be longer than 63 char"2338		);2339		assert!(2340			item.name.len() <= 256,2341			"Collection description can not be longer than 255 char"2342		);2343		assert!(2344			item.token_prefix.len() <= 16,2345			"Token prefix can not be longer than 15 char"2346		);23472348		// Generate next collection ID2349		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23502351		CreatedCollectionCount::put(next_id);2352	}23532354	#[allow(dead_code)]2355	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {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			&item.owner,2362		)2363		.unwrap();23642365		<ItemListIndex>::insert(collection_id, current_index);23662367		// Update balance2368		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2369			.checked_add(1)2370			.unwrap();2371		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2372	}23732374	#[allow(dead_code)]2375	fn init_fungible_token(2376		collection_id: CollectionId,2377		owner: &T::CrossAccountId,2378		item: &FungibleItemType,2379	) {2380		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23812382		Self::add_token_index(2383			&CollectionHandle::get(collection_id).unwrap(),2384			current_index,2385			owner,2386		)2387		.unwrap();23882389		<ItemListIndex>::insert(collection_id, current_index);23902391		// Update balance2392		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2393			.checked_add(item.value)2394			.unwrap();2395		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2396	}23972398	#[allow(dead_code)]2399	fn init_refungible_token(2400		collection_id: CollectionId,2401		item: &ReFungibleItemType<T::CrossAccountId>,2402	) {2403		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24042405		let value = item.owner.first().unwrap().fraction;2406		let owner = item.owner.first().unwrap().owner.clone();24072408		Self::add_token_index(2409			&CollectionHandle::get(collection_id).unwrap(),2410			current_index,2411			&owner,2412		)2413		.unwrap();24142415		<ItemListIndex>::insert(collection_id, current_index);24162417		// Update balance2418		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2419			.checked_add(value)2420			.unwrap();2421		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2422	}24232424	fn add_token_index(2425		collection: &CollectionHandle<T>,2426		item_index: TokenId,2427		owner: &T::CrossAccountId,2428	) -> DispatchResult {2429		collection.consume_sload()?;2430		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2431		if list_exists {2432			collection.consume_sload()?;2433			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24342435			// bound Owned tokens by a single address in collection2436			let account_items: u32 = list.len() as u32;2437			ensure!(2438				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2439				Error::<T>::AddressOwnershipLimitExceeded2440			);24412442			let item_contains = list.contains(&item_index.clone());24432444			if !item_contains {2445				list.push(item_index);2446			}24472448			collection.consume_sstore()?;2449			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2450		} else {2451			let itm = vec![item_index];2452			collection.consume_sstore()?;2453			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2454		}24552456		Ok(())2457	}24582459	fn remove_token_index(2460		collection: &CollectionHandle<T>,2461		item_index: TokenId,2462		owner: &T::CrossAccountId,2463	) -> DispatchResult {2464		collection.consume_sload()?;2465		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2466		if list_exists {2467			collection.consume_sload()?;2468			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2469			let item_contains = list.contains(&item_index.clone());24702471			if item_contains {2472				list.retain(|&item| item != item_index);2473				collection.consume_sstore()?;2474				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2475			}2476		}24772478		Ok(())2479	}24802481	fn move_token_index(2482		collection: &CollectionHandle<T>,2483		item_index: TokenId,2484		old_owner: &T::CrossAccountId,2485		new_owner: &T::CrossAccountId,2486	) -> DispatchResult {2487		Self::remove_token_index(collection, item_index, old_owner)?;2488		Self::add_token_index(collection, item_index, new_owner)?;24892490		Ok(())2491	}2492}24932494sp_api::decl_runtime_apis! {2495	pub trait NftApi {2496		/// Used for ethereum integration2497		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2498	}2499}

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	MetaUpdatePermission, 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		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.73		CollectionDecimalPointLimitExceeded,74		/// This address is not set as sponsor, use setCollectionSponsor first.75		ConfirmUnsetSponsorFail,76		/// Length of items properties must be greater than 0.77		EmptyArgument,78		/// Collection limit bounds per collection exceeded79		CollectionLimitBoundsExceeded,80		/// Tried to enable permissions which are only permitted to be disabled81		OwnerPermissionsCantBeReverted,82	}83}84pub trait Config:85	system::Config86	+ pallet_evm_coder_substrate::Config87	+ pallet_common::Config88	+ pallet_nonfungible::Config89	+ pallet_refungible::Config90	+ pallet_fungible::Config91	+ Sized92{93	/// Weight information for extrinsics in this pallet.94	type WeightInfo: WeightInfo;95}9697type SelfWeightOf<T> = <T as Config>::WeightInfo;9899trait WeightInfoHelpers: WeightInfo {100	fn transfer() -> Weight {101		Self::transfer_nft()102			.max(Self::transfer_fungible())103			.max(Self::transfer_refungible())104	}105	fn transfer_from() -> Weight {106		Self::transfer_from_nft()107			.max(Self::transfer_from_fungible())108			.max(Self::transfer_from_refungible())109	}110	fn approve() -> Weight {111		// TODO: refungible, fungible112		Self::approve_nft()113	}114	fn set_variable_meta_data(data: u32) -> Weight {115		// TODO: refungible116		Self::set_variable_meta_data_nft(data)117	}118	fn create_item(data: u32) -> Weight {119		Self::create_item_nft(data)120			.max(Self::create_item_fungible())121			.max(Self::create_item_refungible(data))122	}123	fn create_multiple_items(amount: u32) -> Weight {124		Self::create_multiple_items_nft(amount)125			.max(Self::create_multiple_items_fungible(amount))126			.max(Self::create_multiple_items_refungible(amount))127	}128	fn burn_item() -> Weight {129		// TODO: refungible, fungible130		Self::burn_item_nft()131	}132}133impl<T: WeightInfo> WeightInfoHelpers for T {}134135// # Used definitions136//137// ## User control levels138//139// chain-controlled - key is uncontrolled by user140//                    i.e autoincrementing index141//                    can use non-cryptographic hash142// real - key is controlled by user143//        but it is hard to generate enough colliding values, i.e owner of signed txs144//        can use non-cryptographic hash145// controlled - key is completly controlled by users146//              i.e maps with mutable keys147//              should use cryptographic hash148//149// ## User control level downgrade reasons150//151// ?1 - chain-controlled -> controlled152//      collections/tokens can be destroyed, resulting in massive holes153// ?2 - chain-controlled -> controlled154//      same as ?1, but can be only added, resulting in easier exploitation155// ?3 - real -> controlled156//      no confirmation required, so addresses can be easily generated157decl_storage! {158	trait Store for Module<T: Config> as Nft {159160		//#region Private members161		/// Used for migrations162		ChainVersion: u64;163		//#endregion164165		//#region Tokens transfer rate limit baskets166		/// (Collection id (controlled?2), who created (real))167		/// TODO: Off chain worker should remove from this map when collection gets removed168		pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;169		/// Collection id (controlled?2), token id (controlled?2)170		pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;171		/// Collection id (controlled?2), owning user (real)172		pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;173		/// Collection id (controlled?2), token id (controlled?2)174		pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;175		//#endregion176177		/// Variable metadata sponsoring178		/// Collection id (controlled?2), token id (controlled?2)179		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;180	}181}182183decl_module! {184	pub struct Module<T: Config> for enum Call185	where186		origin: T::Origin187	{188		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;189		type Error = Error<T>;190191		fn on_initialize(_now: T::BlockNumber) -> Weight {192			0193		}194195		/// 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.196		///197		/// # Permissions198		///199		/// * Anyone.200		///201		/// # Arguments202		///203		/// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.204		///205		/// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.206		///207		/// * token_prefix: UTF-8 string with token prefix.208		///209		/// * mode: [CollectionMode] collection type and type dependent data.210		// returns collection ID211		#[weight = <SelfWeightOf<T>>::create_collection()]212		#[transactional]213		pub fn create_collection(origin,214								 collection_name: Vec<u16>,215								 collection_description: Vec<u16>,216								 token_prefix: Vec<u8>,217								 mode: CollectionMode) -> DispatchResult {218219			// Anyone can create a collection220			let who = ensure_signed(origin)?;221222			// Take a (non-refundable) deposit of collection creation223			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)?;234235			let decimal_points = match mode {236				CollectionMode::Fungible(points) => points,237				_ => 0238			};239240			let created_count = CreatedCollectionCount::get();241			let destroyed_count = DestroyedCollectionCount::get();242243			// bound Total number of collections244			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);245246			// check params247			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);251252			// Generate next collection ID253			let next_id = created_count254				.checked_add(1)255				.ok_or(Error::<T>::NumOverflow)?;256257			CreatedCollectionCount::put(next_id);258259			let limits = CollectionLimits {260				sponsored_data_size: CUSTOM_DATA_LIMIT,261				..Default::default()262			};263264			// Create new collection265			let new_collection = Collection {266				owner: who.clone(),267				name: collection_name,268				mode: mode.clone(),269				mint_mode: false,270				access: AccessMode::Normal,271				description: collection_description,272				decimal_points,273				token_prefix,274				offchain_schema: Vec::new(),275				schema_version: SchemaVersion::ImageURL,276				sponsorship: SponsorshipState::Disabled,277				variable_on_chain_schema: Vec::new(),278				const_on_chain_schema: Vec::new(),279				limits,280				meta_update_permission: MetaUpdatePermission::default(),281				transfers_enabled: true,282			};283284			// Add new collection to map285			<CollectionById<T>>::insert(next_id, new_collection);286287			// call event288			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));289290			Ok(())291		}292293		/// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.294		///295		/// # Permissions296		///297		/// * Collection Owner.298		///299		/// # Arguments300		///301		/// * collection_id: collection to destroy.302		#[weight = <SelfWeightOf<T>>::destroy_collection()]303		#[transactional]304		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {305306			let sender = ensure_signed(origin)?;307			let collection = Self::get_collection(collection_id)?;308			Self::check_owner_permissions(&collection, &sender)?;309			if !collection.limits.owner_can_destroy {310				fail!(Error::<T>::NoPermission);311			}312313			<AddressTokens<T>>::remove_prefix(collection_id, None);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);320321			<NftItemList<T>>::remove_prefix(collection_id, None);322			<FungibleItemList<T>>::remove_prefix(collection_id, None);323			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);324325			<NftTransferBasket<T>>::remove_prefix(collection_id, None);326			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);327			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);328329			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);330331			DestroyedCollectionCount::put(DestroyedCollectionCount::get()332				.checked_add(1)333				.ok_or(Error::<T>::NumOverflow)?);334335			Ok(())336		}337338		/// Add an address to white list.339		///340		/// # Permissions341		///342		/// * Collection Owner343		/// * Collection Admin344		///345		/// # Arguments346		///347		/// * collection_id.348		///349		/// * address.350		#[weight = <SelfWeightOf<T>>::add_to_white_list()]351		#[transactional]352		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{353354			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);355			let collection = Self::get_collection(collection_id)?;356357			Self::toggle_white_list_internal(358				&sender,359				&collection,360				&address,361				true,362			)?;363364			Ok(())365		}366367		/// Remove an address from white list.368		///369		/// # Permissions370		///371		/// * Collection Owner372		/// * Collection Admin373		///374		/// # Arguments375		///376		/// * collection_id.377		///378		/// * address.379		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]380		#[transactional]381		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{382383			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);384			let collection = Self::get_collection(collection_id)?;385386			Self::toggle_white_list_internal(387				&sender,388				&collection,389				&address,390				false,391			)?;392393			Ok(())394		}395396		/// Toggle between normal and white list access for the methods with access for `Anyone`.397		///398		/// # Permissions399		///400		/// * Collection Owner.401		///402		/// # Arguments403		///404		/// * collection_id.405		///406		/// * mode: [AccessMode]407		#[weight = <SelfWeightOf<T>>::set_public_access_mode()]408		#[transactional]409		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult410		{411			let sender = ensure_signed(origin)?;412413			let mut target_collection = Self::get_collection(collection_id)?;414			Self::check_owner_permissions(&target_collection, &sender)?;415			target_collection.access = mode;416			target_collection.save()417		}418419		/// Allows Anyone to create tokens if:420		/// * White List is enabled, and421		/// * Address is added to white list, and422		/// * This method was called with True parameter423		///424		/// # Permissions425		/// * Collection Owner426		///427		/// # Arguments428		///429		/// * collection_id.430		///431		/// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.432		#[weight = <SelfWeightOf<T>>::set_mint_permission()]433		#[transactional]434		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult435		{436			let sender = ensure_signed(origin)?;437438			let mut target_collection = Self::get_collection(collection_id)?;439			Self::check_owner_permissions(&target_collection, &sender)?;440			target_collection.mint_mode = mint_permission;441			target_collection.save()442		}443444		/// Change the owner of the collection.445		///446		/// # Permissions447		///448		/// * Collection Owner.449		///450		/// # Arguments451		///452		/// * collection_id.453		///454		/// * new_owner.455		#[weight = <SelfWeightOf<T>>::change_collection_owner()]456		#[transactional]457		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {458459			let sender = ensure_signed(origin)?;460			let mut target_collection = Self::get_collection(collection_id)?;461			Self::check_owner_permissions(&target_collection, &sender)?;462			target_collection.owner = new_owner;463			target_collection.save()464		}465466		/// Adds an admin of the Collection.467		/// 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.468		///469		/// # Permissions470		///471		/// * Collection Owner.472		/// * Collection Admin.473		///474		/// # Arguments475		///476		/// * collection_id: ID of the Collection to add admin for.477		///478		/// * new_admin_id: Address of new admin to add.479		#[weight = <SelfWeightOf<T>>::add_collection_admin()]480		#[transactional]481		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)?);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);486487			match admin_arr.binary_search(&new_admin_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);492					<AdminList<T>>::insert(collection_id, admin_arr);493				}494			}495			Ok(())496		}497498		/// 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.499		///500		/// # Permissions501		///502		/// * Collection Owner.503		/// * Collection Admin.504		///505		/// # Arguments506		///507		/// * collection_id: ID of the Collection to remove admin for.508		///509		/// * account_id: Address of admin to remove.510		#[weight = <SelfWeightOf<T>>::remove_collection_admin()]511		#[transactional]512		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {513			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);517518			if let Ok(idx) = admin_arr.binary_search(&account_id) {519				admin_arr.remove(idx);520				<AdminList<T>>::insert(collection_id, admin_arr);521			}522			Ok(())523		}524525		/// # Permissions526		///527		/// * Collection Owner528		///529		/// # Arguments530		///531		/// * collection_id.532		///533		/// * new_sponsor.534		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]535		#[transactional]536		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {537			let sender = ensure_signed(origin)?;538			let mut target_collection = Self::get_collection(collection_id)?;539			Self::check_owner_permissions(&target_collection, &sender)?;540541			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);542			target_collection.save()543		}544545		/// # Permissions546		///547		/// * Sponsor.548		///549		/// # Arguments550		///551		/// * collection_id.552		#[weight = <SelfWeightOf<T>>::confirm_sponsorship()]553		#[transactional]554		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {555			let sender = ensure_signed(origin)?;556557			let mut target_collection = Self::get_collection(collection_id)?;558			ensure!(559				target_collection.sponsorship.pending_sponsor() == Some(&sender),560				Error::<T>::ConfirmUnsetSponsorFail561			);562563			target_collection.sponsorship = SponsorshipState::Confirmed(sender);564			target_collection.save()565		}566567		/// Switch back to pay-per-own-transaction model.568		///569		/// # Permissions570		///571		/// * Collection owner.572		///573		/// # Arguments574		///575		/// * collection_id.576		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]577		#[transactional]578		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {579			let sender = ensure_signed(origin)?;580581			let mut target_collection = Self::get_collection(collection_id)?;582			Self::check_owner_permissions(&target_collection, &sender)?;583584			target_collection.sponsorship = SponsorshipState::Disabled;585			target_collection.save()586		}587588		/// This method creates a concrete instance of NFT Collection created with CreateCollection method.589		///590		/// # Permissions591		///592		/// * Collection Owner.593		/// * Collection Admin.594		/// * Anyone if595		///     * White List is enabled, and596		///     * Address is added to white list, and597		///     * MintPermission is enabled (see SetMintPermission method)598		///599		/// # Arguments600		///601		/// * collection_id: ID of the collection.602		///603		/// * owner: Address, initial owner of the NFT.604		///605		/// * data: Token data to store on chain.606		// #[weight =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))]611612		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]613		#[transactional]614		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {615			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);616			let collection = Self::get_collection(collection_id)?;617618			Self::create_item_internal(&sender, &collection, &owner, data)?;619620			collection.submit_logs()621		}622623		/// This method creates multiple items in a collection created with CreateCollection method.624		///625		/// # Permissions626		///627		/// * Collection Owner.628		/// * Collection Admin.629		/// * Anyone if630		///     * White List is enabled, and631		///     * Address is added to white list, and632		///     * MintPermission is enabled (see SetMintPermission method)633		///634		/// # Arguments635		///636		/// * collection_id: ID of the collection.637		///638		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].639		///640		/// * owner: Address, initial owner of the NFT.641		#[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]642		#[transactional]643		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {644645			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);646			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);647			let collection = Self::get_collection(collection_id)?;648649			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;650651			collection.submit_logs()652		}653654		// TODO! transaction weight655656		/// Set transfers_enabled value for particular collection657		///658		/// # Permissions659		///660		/// * Collection Owner.661		///662		/// # Arguments663		///664		/// * collection_id: ID of the collection.665		///666		/// * value: New flag value.667		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]668		#[transactional]669		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {670671			let sender = ensure_signed(origin)?;672			let mut target_collection = Self::get_collection(collection_id)?;673674			Self::check_owner_permissions(&target_collection, &sender)?;675676			target_collection.transfers_enabled = value;677			target_collection.save()678		}679680		// TODO! transaction weight681		/// Set meta_update_permission value for particular collection682		///683		/// # Permissions684		///685		/// * Collection Owner.686		///687		/// # Arguments688		///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 {695696			let sender = ensure_signed(origin)?;697			let mut target_collection = Self::get_collection(collection_id)?;698699			ensure!(700				target_collection.meta_update_permission != MetaUpdatePermission::None,701				Error::<T>::MetadataFlagFrozen702			);703			Self::check_owner_permissions(&target_collection, &sender)?;704705			target_collection.meta_update_permission = value;706707			target_collection.save()708		}709710		/// Destroys a concrete instance of NFT.711		///712		/// # Permissions713		///714		/// * Collection Owner.715		/// * Collection Admin.716		/// * Current NFT Owner.717		///718		/// # Arguments719		///720		/// * collection_id: ID of the collection.721		///722		/// * item_id: ID of NFT to burn.723		#[weight = <SelfWeightOf<T>>::burn_item()]724		#[transactional]725		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {726727			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);728			let target_collection = Self::get_collection(collection_id)?;729730			Self::burn_item_internal(&sender, &target_collection, item_id, value)?;731732			target_collection.submit_logs()733		}734735		/// Change ownership of the token.736		///737		/// # Permissions738		///739		/// * Collection Owner740		/// * Collection Admin741		/// * Current NFT owner742		///743		/// # Arguments744		///745		/// * recipient: Address of token recipient.746		///747		/// * collection_id.748		///749		/// * item_id: ID of the item750		///     * Non-Fungible Mode: Required.751		///     * Fungible Mode: Ignored.752		///     * Re-Fungible Mode: Required.753		///754		/// * value: Amount to transfer.755		///     * Non-Fungible Mode: Ignored756		///     * Fungible Mode: Must specify transferred amount757		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)758		#[weight = <SelfWeightOf<T>>::transfer()]759		#[transactional]760		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {761			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);762			let collection = Self::get_collection(collection_id)?;763764			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;765766			collection.submit_logs()767		}768769		/// Set, change, or remove approved address to transfer the ownership of the NFT.770		///771		/// # Permissions772		///773		/// * Collection Owner774		/// * Collection Admin775		/// * Current NFT owner776		///777		/// # Arguments778		///779		/// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).780		///781		/// * collection_id.782		///783		/// * item_id: ID of the item.784		#[weight = <SelfWeightOf<T>>::approve()]785		#[transactional]786		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {787			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);788			let collection = Self::get_collection(collection_id)?;789790			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;791792			collection.submit_logs()793		}794795		/// 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.796		///797		/// # Permissions798		/// * Collection Owner799		/// * Collection Admin800		/// * Current NFT owner801		/// * Address approved by current NFT owner802		///803		/// # Arguments804		///805		/// * from: Address that owns token.806		///807		/// * recipient: Address of token recipient.808		///809		/// * collection_id.810		///811		/// * item_id: ID of the item.812		///813		/// * value: Amount to transfer.814		#[weight = <SelfWeightOf<T>>::transfer_from()]815		#[transactional]816		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {817			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);818			let collection = Self::get_collection(collection_id)?;819820			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;821822			collection.submit_logs()823		}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);829830		//     // // on_nft_received  call831832		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;833834		//     Ok(())835		// }836837		/// Set off-chain data schema.838		///839		/// # Permissions840		///841		/// * Collection Owner842		/// * Collection Admin843		///844		/// # Arguments845		///846		/// * collection_id.847		///848		/// * schema: String representing the offchain data schema.849		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]850		#[transactional]851		pub fn set_variable_meta_data (852			origin,853			collection_id: CollectionId,854			item_id: TokenId,855			data: Vec<u8>856		) -> DispatchResult {857			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);858859			let collection = Self::get_collection(collection_id)?;860			Self::meta_update_check(&sender, &collection, item_id)?;861862			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;863864			Ok(())865		}866867		/// Set schema standard868		/// ImageURL869		/// Unique870		///871		/// # Permissions872		///873		/// * Collection Owner874		/// * Collection Admin875		///876		/// # Arguments877		///878		/// * collection_id.879		///880		/// * schema: SchemaVersion: enum881		#[weight = <SelfWeightOf<T>>::set_schema_version()]882		#[transactional]883		pub fn set_schema_version(884			origin,885			collection_id: CollectionId,886			version: SchemaVersion887		) -> DispatchResult {888			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);889			let mut target_collection = Self::get_collection(collection_id)?;890			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;891			target_collection.schema_version = version;892			target_collection.save()893		}894895		/// Set off-chain data schema.896		///897		/// # Permissions898		///899		/// * Collection Owner900		/// * Collection Admin901		///902		/// # Arguments903		///904		/// * collection_id.905		///906		/// * schema: String representing the offchain data schema.907		#[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]908		#[transactional]909		pub fn set_offchain_schema(910			origin,911			collection_id: CollectionId,912			schema: Vec<u8>913		) -> DispatchResult {914			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);915			let mut target_collection = Self::get_collection(collection_id)?;916			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;917918			// check schema limit919			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");920921			target_collection.offchain_schema = schema;922			target_collection.save()923		}924925		/// Set const on-chain data schema.926		///927		/// # Permissions928		///929		/// * Collection Owner930		/// * Collection Admin931		///932		/// # Arguments933		///934		/// * collection_id.935		///936		/// * schema: String representing the const on-chain data schema.937		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]938		#[transactional]939		pub fn set_const_on_chain_schema (940			origin,941			collection_id: CollectionId,942			schema: Vec<u8>943		) -> DispatchResult {944			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);945			let mut target_collection = Self::get_collection(collection_id)?;946			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;947948			// check schema limit949			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");950951			target_collection.const_on_chain_schema = schema;952			target_collection.save()953		}954955		/// Set variable on-chain data schema.956		///957		/// # Permissions958		///959		/// * Collection Owner960		/// * Collection Admin961		///962		/// # Arguments963		///964		/// * collection_id.965		///966		/// * schema: String representing the variable on-chain data schema.967		#[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]968		#[transactional]969		pub fn set_variable_on_chain_schema (970			origin,971			collection_id: CollectionId,972			schema: Vec<u8>973		) -> DispatchResult {974			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);975			let mut target_collection = Self::get_collection(collection_id)?;976			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;977978			// check schema limit979			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");980981			target_collection.variable_on_chain_schema = schema;982			target_collection.save()983		}984985		#[weight = <SelfWeightOf<T>>::set_collection_limits()]986		#[transactional]987		pub fn set_collection_limits(988			origin,989			collection_id: u32,990			new_limits: CollectionLimits<T::BlockNumber>,991		) -> DispatchResult {992			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993			let mut target_collection = Self::get_collection(collection_id)?;994			Self::check_owner_permissions(&target_collection, sender.as_sub())?;995			let old_limits = &target_collection.limits;996997			// collection bounds998			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&999				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1000				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1001				Error::<T>::CollectionLimitBoundsExceeded);10021003			// token_limit   check  prev1004			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1005			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);10061007			ensure!(1008				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1009				(old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1010				Error::<T>::OwnerPermissionsCantBeReverted,1011			);10121013			target_collection.limits = new_limits;10141015			target_collection.save()1016		}1017	}1018}10191020impl<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>::AddressIsZero1030		);10311032		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)?;10351036		Ok(())1037	}10381039	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>::AddressIsZero1049		);10501051		// Limits check1052		Self::is_correct_transfer(target_collection, recipient)?;10531054		// Transfer permissions check1055		ensure!(1056			Self::is_item_owner(sender, target_collection, item_id)?1057				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,1058			Error::<T>::NoPermission1059		);10601061		if target_collection.access == AccessMode::WhiteList {1062			Self::check_white_list(target_collection, sender)?;1063			Self::check_white_list(target_collection, recipient)?;1064		}10651066		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		};10841085		Self::deposit_event(RawEvent::Transfer(1086			target_collection.id,1087			item_id,1088			sender.clone(),1089			recipient.clone(),1090			value,1091		));10921093		Ok(())1094	}10951096	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)?;11041105		// Transfer permissions check1106		let bypasses_limits = collection.limits.owner_can_transfer1107			&& Self::is_owner_or_admin_permissions(collection, sender)?;11081109		let allowance_limit = if bypasses_limits {1110			None1111		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1112			Some(amount)1113		} else {1114			fail!(Error::<T>::NoPermission);1115		};11161117		if collection.access == AccessMode::WhiteList {1118			Self::check_white_list(collection, sender)?;1119			Self::check_white_list(collection, spender)?;1120		}11211122		collection.consume_sload()?;1123		let allowance: u128 = amount1124			.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		);11381139		if matches!(collection.mode, CollectionMode::NFT) {1140			// TODO: NFT: only one owner may exist for token in ERC7211141			collection.log(ERC721Events::Approval {1142				owner: *sender.as_eth(),1143				approved: *spender.as_eth(),1144				token_id: item_id.into(),1145			})?;1146		}11471148		if matches!(collection.mode, CollectionMode::Fungible(_)) {1149			// TODO: NFT: only one owner may exist for token in ERC201150			collection.log(ERC20Events::Approval {1151				owner: *sender.as_eth(),1152				spender: *spender.as_eth(),1153				value: allowance.into(),1154			})?;1155		}11561157		Self::deposit_event(RawEvent::Approved(1158			collection.id,1159			item_id,1160			sender.clone(),1161			spender.clone(),1162			allowance,1163		));1164		Ok(())1165	}11661167	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 him1177			return Self::transfer_internal(from, recipient, collection, item_id, amount);1178		}11791180		// Check approval1181		collection.consume_sload()?;1182		let approval: u128 =1183			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));11841185		// Limits check1186		Self::is_correct_transfer(collection, recipient)?;11871188		// Transfer permissions check1189		ensure!(1190			approval >= amount1191				|| (collection.limits.owner_can_transfer1192					&& Self::is_owner_or_admin_permissions(collection, sender)?),1193			Error::<T>::NoPermission1194		);11951196		if collection.access == AccessMode::WhiteList {1197			Self::check_white_list(collection, sender)?;1198			Self::check_white_list(collection, recipient)?;1199		}12001201		// Reduce approval by transferred amount or remove if remaining approval drops to 01202		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		}12131214		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		};12291230		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		}12371238		Ok(())1239	}12401241	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)?;12481249		ensure!(1250			CUSTOM_DATA_LIMIT >= data.len() as u32,1251			Error::<T>::TokenVariableDataLimitExceeded1252		);12531254		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>::NoPermission1260		);12611262		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		};12691270		Ok(())1271	}12721273	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>::NoPermission1282			),1283			MetaUpdatePermission::Admin => ensure!(1284				Self::is_owner_or_admin_permissions(collection, sender)?,1285				Error::<T>::NoPermission1286			),1287			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1288		}12891290		Ok(())1291	}12921293	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_data1302			}1303			CollectionMode::ReFungible => {1304				<ReFungibleItemList<T>>::get(collection.id, item_id)1305					.ok_or(Error::<T>::TokenNotFound)?1306					.variable_data1307			}1308			_ => fail!(Error::<T>::UnexpectedCollectionType),1309		})1310	}13111312	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)?;13191320		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		}13261327		Ok(())1328	}13291330	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_transfer1339					&& Self::is_owner_or_admin_permissions(collection, sender)?),1340			Error::<T>::NoPermission1341		);13421343		if collection.access == AccessMode::WhiteList {1344			Self::check_white_list(collection, sender)?;1345		}13461347		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		};13521353		Ok(())1354	}13551356	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)?;13631364		if whitelisted {1365			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1366		} else {1367			<WhiteList<T>>::remove(collection.id, address.as_sub());1368		}13691370		Ok(())1371	}13721373	fn is_correct_transfer(1374		collection: &CollectionHandle<T>,1375		recipient: &T::CrossAccountId,1376	) -> DispatchResult {1377		let collection_id = collection.id;13781379		// check token limit and account token limit1380		collection.consume_sload()?;1381		let account_items: u32 =1382			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;13831384		// zero limit means collection limit is disabled1385		// otherwise get lower value1386		let limit = if collection.limits.account_token_ownership_limit == 01387			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1388		{1389			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1390		} else {1391			collection.limits.account_token_ownership_limit1392		};13931394		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);13951396		// preliminary transfer check1397		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);13981399		Ok(())1400	}14011402	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;14091410		// check token limit and account token limit1411		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)?;14181419		// zero limit means collection limit is disabled1420		// otherwise get lower value1421		let account_token_limit = if collection.limits.account_token_ownership_limit == 01422			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1423		{1424			ACCOUNT_TOKEN_OWNERSHIP_LIMIT1425		} else {1426			collection.limits.account_token_ownership_limit1427		};14281429		ensure!(1430			collection.limits.token_limit >= total_items,1431			Error::<T>::CollectionTokenLimitExceeded1432		);1433		ensure!(1434			account_token_limit >= account_items,1435			Error::<T>::AccountTokenLimitExceeded1436		);14371438		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		}14431444		Ok(())1445	}14461447	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 limits1465					ensure!(1466						data.pieces <= MAX_REFUNGIBLE_PIECES,1467						Error::<T>::WrongRefungiblePieces1468					);1469					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1470				} else {1471					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1472				}1473			}1474		};14751476		Ok(())1477	}14781479	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				};14911492				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				}];15021503				let item = ReFungibleItemType {1504					owner: owner_list,1505					const_data: data.const_data.into_inner(),1506					variable_data: data.variable_data.into_inner(),1507				};15081509				Self::add_refungible_item(collection, item)?;1510			}1511		};15121513		Ok(())1514	}15151516	fn add_fungible_item(1517		collection: &CollectionHandle<T>,1518		owner: &T::CrossAccountId,1519		value: u128,1520	) -> DispatchResult {1521		let collection_id = collection.id;15221523		// Does new owner already have an account?1524		collection.consume_sload()?;1525		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;15261527		// Mint1528		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);15331534		// Update balance1535		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);15411542		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	}15501551	fn add_refungible_item(1552		collection: &CollectionHandle<T>,1553		item: ReFungibleItemType<T::CrossAccountId>,1554	) -> DispatchResult {1555		let collection_id = collection.id;15561557		let current_index = <ItemListIndex>::get(collection_id)1558			.checked_add(1)1559			.ok_or(Error::<T>::NumOverflow)?;1560		let itemcopy = item.clone();15611562		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1563		let item_owner = item.owner.first().expect("only one owner is defined");15641565		let value = item_owner.fraction;1566		let owner = item_owner.owner.clone();15671568		Self::add_token_index(collection, current_index, &owner)?;15691570		<ItemListIndex>::insert(collection_id, current_index);1571		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);15721573		// Update balance1574		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);15781579		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1580		Ok(())1581	}15821583	fn add_nft_item(1584		collection: &CollectionHandle<T>,1585		item: NftItemType<T::CrossAccountId>,1586	) -> DispatchResult {1587		let collection_id = collection.id;15881589		let current_index = <ItemListIndex>::get(collection_id)1590			.checked_add(1)1591			.ok_or(Error::<T>::NumOverflow)?;15921593		let item_owner = item.owner.clone();1594		Self::add_token_index(collection, current_index, &item.owner)?;15951596		<ItemListIndex>::insert(collection_id, current_index);1597		<NftItemList<T>>::insert(collection_id, current_index, item);15981599		// Update balance1600		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);16041605		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	}16171618	fn burn_refungible_item(1619		collection: &CollectionHandle<T>,1620		item_id: TokenId,1621		owner: &T::CrossAccountId,1622	) -> DispatchResult {1623		let collection_id = collection.id;16241625		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1626			.ok_or(Error::<T>::TokenNotFound)?;1627		let rft_balance = token1628			.owner1629			.iter()1630			.find(|&i| i.owner == *owner)1631			.ok_or(Error::<T>::TokenNotFound)?;1632		Self::remove_token_index(collection, item_id, owner)?;16331634		// update balance1635		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);16391640		// Re-create owners list with sender removed1641		let index = token1642			.owner1643			.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();16481649		// Burn the token completely if this was the last (only) owner1650		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		}16561657		Ok(())1658	}16591660	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1661		let collection_id = collection.id;16621663		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)?;16661667		// update balance1668		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);16741675		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	}16831684	fn burn_fungible_item(1685		owner: &T::CrossAccountId,1686		collection: &CollectionHandle<T>,1687		value: u128,1688	) -> DispatchResult {1689		let collection_id = collection.id;16901691		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1692		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);16931694		// update balance1695		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);16991700		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		}17061707		collection.log(ERC20Events::Transfer {1708			from: *owner.as_eth(),1709			to: H160::default(),1710			value: value.into(),1711		})?;1712		Ok(())1713	}17141715	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	}17201721	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>::NoPermission1728		);17291730		Ok(())1731	}17321733	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.owner1739			|| <AdminList<T>>::get(collection.id).contains(subject))1740	}17411742	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>::NoPermission1749		);17501751		Ok(())1752	}17531754	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	}17621763	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;17691770		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				.owner1779				.iter()1780				.find(|i| i.owner == *subject)1781				.map(|i| i.fraction),1782		}1783	}17841785	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	}17951796	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	}18071808	/// Check if token exists. In case of Fungible, check if there is an entry for1809	/// the owner in fungible balances double map1810	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		};18191820		ensure!(exists, Error::<T>::TokenNotFound);1821		Ok(())1822	}18231824	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;18311832		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());18361837		recipient_balance.value = recipient_balance1838			.value1839			.checked_add(value)1840			.ok_or(Error::<T>::NumOverflow)?;1841		balance.value = balance1842			.value1843			.checked_sub(value)1844			.ok_or(Error::<T>::TokenValueTooLow)?;18451846		// update balanceOf1847		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);18551856		// Reduce or remove sender1857		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);18651866		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		));18781879		Ok(())1880	}18811882	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)?;18931894		let item = full_item1895			.owner1896			.iter()1897			.find(|i| i.owner == owner)1898			.ok_or(Error::<T>::TokenNotFound)?;1899		let amount = item.fraction;19001901		ensure!(amount >= value, Error::<T>::TokenValueTooLow);19021903		collection.consume_sload()?;1904		// update balance1905		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);19101911		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);19171918		let old_owner = item.owner.clone();1919		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);19201921		let mut new_full_item = full_item.clone();1922		// transfer1923		if amount == value && !new_owner_has_account {1924			// change owner1925			// new owner do not have account1926			new_full_item1927				.owner1928				.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);19341935			// update index collection1936			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;1937		} else {1938			new_full_item1939				.owner1940				.iter_mut()1941				.find(|i| i.owner == owner)1942				.expect("old owner does present in refungible")1943				.fraction -= value;19441945			// separate amount1946			if new_owner_has_account {1947				// new owner has account1948				new_full_item1949					.owner1950					.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 account1956				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			}19621963			collection.consume_sstore()?;1964			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1965		}19661967		Self::deposit_event(RawEvent::Transfer(1968			collection.id,1969			item_id,1970			owner,1971			new_owner,1972			amount,1973		));19741975		Ok(())1976	}19771978	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)?;19881989		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);19901991		collection.consume_sload()?;1992		// update balance1993		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);19981999		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);20052006		// change owner2007		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);20112012		// update index collection2013		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;20142015		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		));20272028		Ok(())2029	}20302031	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)?;20392040		item.variable_data = data;20412042		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);20432044		Ok(())2045	}20462047	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)?;20552056		item.variable_data = data;20572058		<NftItemList<T>>::insert(collection_id, item_id, item);20592060		Ok(())2061	}20622063	#[allow(dead_code)]2064	fn init_collection(item: &Collection<T>) {2065		// check params2066		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		);20822083		// Generate next collection ID2084		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();20852086		CreatedCollectionCount::put(next_id);2087	}20882089	#[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();20922093		Self::add_token_index(2094			&CollectionHandle::get(collection_id).unwrap(),2095			current_index,2096			&item.owner,2097		)2098		.unwrap();20992100		<ItemListIndex>::insert(collection_id, current_index);21012102		// Update balance2103		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	}21082109	#[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();21162117		Self::add_token_index(2118			&CollectionHandle::get(collection_id).unwrap(),2119			current_index,2120			owner,2121		)2122		.unwrap();21232124		<ItemListIndex>::insert(collection_id, current_index);21252126		// Update balance2127		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	}21322133	#[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();21392140		let value = item.owner.first().unwrap().fraction;2141		let owner = item.owner.first().unwrap().owner.clone();21422143		Self::add_token_index(2144			&CollectionHandle::get(collection_id).unwrap(),2145			current_index,2146			&owner,2147		)2148		.unwrap();21492150		<ItemListIndex>::insert(collection_id, current_index);21512152		// Update balance2153		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	}21582159	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());21692170			// bound Owned tokens by a single address in collection2171			let account_items: u32 = list.len() as u32;2172			ensure!(2173				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2174				Error::<T>::AddressOwnershipLimitExceeded2175			);21762177			let item_contains = list.contains(&item_index.clone());21782179			if !item_contains {2180				list.push(item_index);2181			}21822183			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		}21902191		Ok(())2192	}21932194	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());22052206			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		}22122213		Ok(())2214	}22152216	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)?;22242225		Ok(())2226	}2227}22282229sp_api::decl_runtime_apis! {2230	pub trait NftApi {2231		/// Used for ethereum integration2232		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2233	}2234}