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

--- a/.maintain/frame-weight-template.hbs
+++ b/.maintain/frame-weight-template.hbs
@@ -92,4 +92,4 @@
 			{{~/each}}
 	}
 	{{~/each}}
-}
\ No newline at end of file
+}

--- a/.maintain/scripts/compile_stub.sh
+++ b/.maintain/scripts/compile_stub.sh
@@ -6,9 +6,9 @@
 tmp=$(mktemp -d)
 cd $tmp
 cp $dir/$INPUT input.sol
-solcjs --optimize --bin input.sol
+solcjs --optimize --bin input.sol -o $PWD
 
 mv input_sol_$(basename $OUTPUT .raw).bin out.bin
 xxd -r -p out.bin out.raw
 
-mv out.raw $dir/$OUTPUT
\ No newline at end of file
+mv out.raw $dir/$OUTPUT

--- a/.maintain/scripts/generate_api.sh
+++ b/.maintain/scripts/generate_api.sh
@@ -9,4 +9,4 @@
 prettier --use-tabs $raw > $formatted
 solhint --fix $formatted
 
-mv $formatted $OUTPUT
\ No newline at end of file
+mv $formatted $OUTPUT

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,6 +3,7 @@
 members = [
     'node/*',
     'pallets/*',
+    'client/*',
     'primitives/*',
     'runtime',
     'crates/*',

--- a/Makefile
+++ b/Makefile
@@ -8,25 +8,26 @@
 
 .PHONY: regenerate_solidity
 regenerate_solidity:
-	PACKAGE=pallet-nft NAME=eth::erc::fungible_iface OUTPUT=./tests/src/eth/api/UniqueFungible.sol ./.maintain/scripts/generate_api.sh
-	PACKAGE=pallet-nft NAME=eth::erc::nft_iface OUTPUT=./tests/src/eth/api/UniqueNFT.sol ./.maintain/scripts/generate_api.sh
+	PACKAGE=pallet-fungible NAME=erc::gen_iface OUTPUT=./tests/src/eth/api/UniqueFungible.sol ./.maintain/scripts/generate_api.sh
+	PACKAGE=pallet-nonfungible NAME=erc::gen_iface OUTPUT=./tests/src/eth/api/UniqueNFT.sol ./.maintain/scripts/generate_api.sh
 	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_iface OUTPUT=./tests/src/eth/api/ContractHelpers.sol ./.maintain/scripts/generate_api.sh
 
-	PACKAGE=pallet-nft NAME=eth::erc::fungible_impl OUTPUT=./pallets/nft/src/eth/stubs/UniqueFungible.sol ./.maintain/scripts/generate_api.sh
-	PACKAGE=pallet-nft NAME=eth::erc::nft_impl OUTPUT=./pallets/nft/src/eth/stubs/UniqueNFT.sol ./.maintain/scripts/generate_api.sh
+	PACKAGE=pallet-fungible NAME=erc::gen_impl OUTPUT=./pallets/fungible/src/stubs/UniqueFungible.sol ./.maintain/scripts/generate_api.sh
+	PACKAGE=pallet-nonfungible NAME=erc::gen_impl OUTPUT=./pallets/nonfungible/src/stubs/UniqueNFT.sol ./.maintain/scripts/generate_api.sh
 	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_impl OUTPUT=./pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol ./.maintain/scripts/generate_api.sh
 
-NFT_EVM_STUBS=./pallets/nft/src/eth/stubs
+FUNGIBLE_EVM_STUBS=./pallets/fungible/src/stubs
+NONFUNGIBLE_EVM_STUBS=./pallets/nonfungible/src/stubs
 CONTRACT_HELPERS_STUBS=./pallets/evm-contract-helpers/src/stubs/
 
-$(NFT_EVM_STUBS)/UniqueFungible.raw: $(NFT_EVM_STUBS)/UniqueFungible.sol
+$(FUNGIBLE_EVM_STUBS)/UniqueFungible.raw: $(FUNGIBLE_EVM_STUBS)/UniqueFungible.sol
 	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh
-$(NFT_EVM_STUBS)/UniqueNFT.raw: $(NFT_EVM_STUBS)/UniqueNFT.sol
+$(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw: $(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.sol
 	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh
 $(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw: $(CONTRACT_HELPERS_STUBS)/ContractHelpers.sol
 	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh
 
-evm_stubs: $(NFT_EVM_STUBS)/UniqueFungible.raw $(NFT_EVM_STUBS)/UniqueNFT.raw $(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw
+evm_stubs: $(FUNGIBLE_EVM_STUBS)/UniqueFungible.raw $(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw $(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw
 
 .PHONY: _bench
 _bench:
@@ -44,5 +45,17 @@
 bench-nft:
 	make _bench PALLET=nft
 
+.PHONY: bench-fungible
+bench-fungible:
+	make _bench PALLET=fungible
+
+.PHONY: bench-refungible
+bench-refungible:
+	make _bench PALLET=refungible
+
+.PHONY: bench-nonfungible
+bench-nonfungible:
+	make _bench PALLET=nonfungible
+
 .PHONY: bench
-bench: bench-evm-migration bench-nft
+bench: bench-evm-migration bench-nft bench-fungible bench-refungible bench-nonfungible

--- a/crates/evm-coder-macros/src/solidity_interface.rs
+++ b/crates/evm-coder-macros/src/solidity_interface.rs
@@ -672,6 +672,7 @@
 		quote! {
 			#[derive(Debug)]
 			pub enum #call_name {
+				ERC165Call(::evm_coder::ERC165Call),
 				#(
 					#calls,
 				)*
@@ -691,6 +692,7 @@
 				}
 				pub fn supports_interface(interface_id: u32) -> bool {
 					interface_id != 0xffffff && (
+						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||
 						interface_id == Self::interface_id()
 						#(
 							|| #supports_interface
@@ -702,7 +704,7 @@
 					use core::fmt::Write;
 					let interface = SolidityInterface {
 						name: #solidity_name,
-						is: &["Dummy", #(
+						is: &["Dummy", "ERC165", #(
 							#solidity_is,
 						)* #(
 							#solidity_events_is,
@@ -712,9 +714,9 @@
 						)*),
 					};
 					if is_impl {
-						tc.collect("// Common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\n".into());
+						tc.collect("// Common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\ncontract ERC165 is Dummy {\n\tfunction supportsInterface(bytes4 interfaceID) external view returns (bool) {\n\t\trequire(false, stub_error);\n\t\tinterfaceID;\n\t\treturn true;\n\t}\n}\n".into());
 					} else {
-						tc.collect("// Common stubs holder\ninterface Dummy {\n}\n".into());
+						tc.collect("// Common stubs holder\ninterface Dummy {\n}\ninterface ERC165 is Dummy {\n\tfunction supportsInterface(bytes4 interfaceID) external view returns (bool);\n}\n".into());
 					}
 					#(
 						#solidity_generators
@@ -737,6 +739,7 @@
 				fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {
 					use ::evm_coder::abi::AbiRead;
 					match method_id {
+						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(::evm_coder::ERC165Call::parse(method_id, reader)?.map(Self::ERC165Call)),
 						#(
 							#parsers,
 						)*
@@ -757,6 +760,11 @@
 						#(
 							#call_variants,
 						)*
+						InternalCall::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}) => {
+							let mut writer = ::evm_coder::abi::AbiWriter::default();
+							writer.bool(&InternalCall::supports_interface(interface_id));
+							return Ok(writer);
+						}
 						_ => {},
 					}
 					let mut writer = ::evm_coder::abi::AbiWriter::default();

--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -2,7 +2,7 @@
 #[cfg(not(feature = "std"))]
 extern crate alloc;
 
-use abi::{AbiReader, AbiWriter};
+use abi::{AbiRead, AbiReader, AbiWriter};
 pub use evm_coder_macros::{event_topic, fn_selector, solidity_interface, solidity, ToLog};
 pub mod abi;
 pub mod events;
@@ -61,6 +61,29 @@
 	fn call(&mut self, call: types::Msg<C>) -> execution::Result<AbiWriter>;
 }
 
+/// Implementation is implicitly provided for all interfaces
+///
+/// Note: no Callable implementation is provided
+#[derive(Debug)]
+pub enum ERC165Call {
+	SupportsInterface { interface_id: types::bytes4 },
+}
+
+impl ERC165Call {
+	pub const INTERFACE_ID: types::bytes4 = 0x01ffc9a7;
+}
+
+impl Call for ERC165Call {
+	fn parse(selector: u32, input: &mut AbiReader) -> execution::Result<Option<Self>> {
+		if selector != Self::INTERFACE_ID {
+			return Ok(None);
+		}
+		Ok(Some(Self::SupportsInterface {
+			interface_id: input.abi_read()?,
+		}))
+	}
+}
+
 #[macro_export]
 macro_rules! generate_stubgen {
 	($name:ident, $decl:ident, $is_impl:literal) => {

--- a/node/cli/src/chain_spec.rs
+++ b/node/cli/src/chain_spec.rs
@@ -5,7 +5,6 @@
 
 use cumulus_primitives_core::ParaId;
 use nft_runtime::*;
-use nft_data_structs::*;
 use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};
 use sc_service::ChainType;
 use sp_core::{sr25519, Pair, Public};
@@ -168,34 +167,6 @@
 		treasury: Default::default(),
 		sudo: SudoConfig { key: root_key },
 		vesting: VestingConfig { vesting: vec![] },
-		nft: NftConfig {
-			collection_id: vec![(
-				1,
-				Collection {
-					owner: get_account_id_from_seed::<sr25519::Public>("Alice"),
-					mode: CollectionMode::NFT,
-					access: AccessMode::Normal,
-					decimal_points: 0,
-					name: vec![],
-					description: vec![],
-					token_prefix: vec![],
-					mint_mode: false,
-					offchain_schema: vec![],
-					schema_version: SchemaVersion::default(),
-					sponsorship: SponsorshipState::Confirmed(get_account_id_from_seed::<
-						sr25519::Public,
-					>("Alice")),
-					const_on_chain_schema: vec![],
-					variable_on_chain_schema: vec![],
-					limits: CollectionLimits::default(),
-					meta_update_permission: MetaUpdatePermission::ItemOwner,
-					transfers_enabled: true,
-				},
-			)],
-			nft_item_id: vec![],
-			fungible_item_id: vec![],
-			refungible_item_id: vec![],
-		},
 		parachain_info: nft_runtime::ParachainInfoConfig { parachain_id: id },
 		aura: nft_runtime::AuraConfig {
 			authorities: initial_authorities,

--- a/node/rpc/Cargo.toml
+++ b/node/rpc/Cargo.toml
@@ -49,6 +49,8 @@
 fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }
 
 pallet-nft = { path = "../../pallets/nft" }
+uc-rpc = { path = "../../client/rpc" }
+up-rpc = { path = "../../primitives/rpc" }
 nft-runtime = { path = "../../runtime" }
 
 [features]

--- a/node/rpc/src/lib.rs
+++ b/node/rpc/src/lib.rs
@@ -1,4 +1,4 @@
-use nft_runtime::{Hash, AccountId, Index, opaque::Block, BlockNumber, Balance};
+use nft_runtime::{Hash, AccountId, CrossAccountId, Index, opaque::Block, BlockNumber, Balance};
 use fc_rpc::{
 	EthBlockDataCache, OverrideHandle, RuntimeApiStorageOverride, SchemaV1Override, StorageOverride,
 };
@@ -9,7 +9,6 @@
 	backend::{AuxStore, StorageProvider},
 	client::BlockchainEvents,
 };
-use pallet_nft::NftApi;
 use sc_finality_grandpa::{
 	FinalityProofProvider, GrandpaJustificationStream, SharedAuthoritySet, SharedVoterState,
 };
@@ -101,9 +100,10 @@
 where
 	Block: sp_api::BlockT,
 	C: ProvideRuntimeApi<Block>,
-	C::Api: pallet_nft::NftApi<Block>,
+	C::Api: up_rpc::NftApi<Block, CrossAccountId, AccountId>,
 {
 	fn code(&self, block: &sp_api::BlockId<Block>, account: sp_core::H160) -> Option<Vec<u8>> {
+		use up_rpc::NftApi;
 		self.client
 			.runtime_api()
 			.eth_contract_code(block, account)
@@ -127,7 +127,7 @@
 	// C::Api: pallet_contracts_rpc::ContractsRuntimeApi<Block, AccountId, Balance, BlockNumber, Hash>,
 	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
 	C::Api: fp_rpc::EthereumRuntimeRPCApi<Block>,
-	C::Api: pallet_nft::NftApi<Block>,
+	C::Api: up_rpc::NftApi<Block, CrossAccountId, AccountId>,
 	B: sc_client_api::Backend<Block> + Send + Sync + 'static,
 	B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashFor<Block>>,
 	SC: SelectChain<Block> + 'static,
@@ -139,6 +139,7 @@
 		EthPubSubApiServer, EthSigner, HexEncodedIdProvider, NetApi, NetApiServer, Web3Api,
 		Web3ApiServer,
 	};
+	use uc_rpc::{NftApi, Nft};
 	// use pallet_contracts_rpc::{Contracts, ContractsApi};
 	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApi};
 	use substrate_frame_rpc_system::{FullSystem, SystemApi};
@@ -203,6 +204,7 @@
 		max_past_logs,
 		block_data_cache.clone(),
 	)));
+	io.extend_with(NftApi::to_delegate(Nft::new(client.clone())));
 
 	if let Some(filter_pool) = filter_pool {
 		io.extend_with(EthFilterApiServer::to_delegate(EthFilterApi::new(

--- a/pallets/evm-coder-substrate/src/lib.rs
+++ b/pallets/evm-coder-substrate/src/lib.rs
@@ -16,7 +16,7 @@
 		execution::{self, Result},
 		types::{Msg, value},
 	};
-	use frame_support::ensure;
+	use frame_support::{ensure};
 	use pallet_evm::{ExitError, ExitReason, ExitRevert, ExitSucceed, PrecompileOutput};
 	pub use frame_support::dispatch::DispatchResult;
 	use pallet_ethereum::EthereumTransactionSender;
@@ -106,6 +106,10 @@
 			self.logs.borrow_mut().push(log);
 			Ok(())
 		}
+		/// Doesn't consumes any gas, should be used after consume_log_sub
+		pub fn log_infallible(&self, log: impl ToLog) {
+			self.logs.borrow_mut().push(log.to_log(self.contract));
+		}
 		pub fn retrieve_logs(self) -> Vec<Log> {
 			self.logs.into_inner()
 		}
@@ -116,9 +120,15 @@
 		pub fn consume_sload_sub(&self) -> DispatchResult {
 			self.consume_gas_sub(G_SLOAD_WORD)
 		}
+		pub fn consume_sstores_sub(&self, amount: usize) -> DispatchResult {
+			self.consume_gas_sub(G_SSTORE_WORD.saturating_mul(amount as u64))
+		}
 		pub fn consume_sstore_sub(&self) -> DispatchResult {
 			self.consume_gas_sub(G_SSTORE_WORD)
 		}
+		pub fn consume_log_sub(&self, topics: usize, data: usize) -> DispatchResult {
+			self.consume_gas_sub(log_price(data, topics))
+		}
 		pub fn consume_gas_sub(&self, gas: u64) -> DispatchResult {
 			ensure!(gas != u64::MAX, Error::<T>::OutOfGas);
 			let mut gas_limit = self.gas_limit.borrow_mut();

binary blob — no preview

--- a/pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol
+++ b/pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol
@@ -9,7 +9,19 @@
 	string stub_error = "this contract is implemented in native";
 }
 
-contract ContractHelpers is Dummy {
+contract ERC165 is Dummy {
+	function supportsInterface(bytes4 interfaceID)
+		external
+		view
+		returns (bool)
+	{
+		require(false, stub_error);
+		interfaceID;
+		return true;
+	}
+}
+
+contract ContractHelpers is Dummy, ERC165 {
 	// Selector: contractOwner(address) 5152b14c
 	function contractOwner(address contractAddress)
 		public

--- a/pallets/inflation/src/benchmarking.rs
+++ b/pallets/inflation/src/benchmarking.rs
@@ -3,8 +3,6 @@
 use super::*;
 use crate::Module as Inflation;
 
-use sp_std::prelude::*;
-use frame_system::RawOrigin;
 use frame_benchmarking::{benchmarks};
 use frame_support::traits::OnInitialize;
 

--- a/pallets/nft/Cargo.toml
+++ b/pallets/nft/Cargo.toml
@@ -16,7 +16,7 @@
 
 [features]
 default = ['std']
-runtime-benchmarks = ['frame-benchmarking']
+runtime-benchmarks = ['frame-benchmarking', 'pallet-common/runtime-benchmarks']
 std = [
     'codec/std',
     'serde/std',
@@ -27,6 +27,10 @@
     'pallet-timestamp/std',
     'pallet-randomness-collective-flip/std',
     'pallet-transaction-payment/std',
+    'pallet-common/std',
+    'pallet-fungible/std',
+    'pallet-nonfungible/std',
+    'pallet-refungible/std',
     'fp-evm/std',
     'nft-data-structs/std',
     'up-sponsorship/std',
@@ -129,7 +133,9 @@
 
 
 [dependencies]
-scale-info = { version = "1.0.0", default-features = false, features = ["derive"] }
+scale-info = { version = "1.0.0", default-features = false, features = [
+    "derive",
+] }
 ethereum = { version = "0.9", git = "https://github.com/purestake/ethereum", branch = "joshy-scale-info", default-features = false }
 rlp = { default-features = false, version = "0.5.0" }
 sp-api = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.12" }
@@ -144,3 +150,8 @@
 pallet-ethereum = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }
 fp-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }
 hex-literal = "0.3.3"
+
+pallet-common = { default-features = false, path = "../common" }
+pallet-fungible = { default-features = false, path = "../fungible" }
+pallet-nonfungible = { default-features = false, path = "../nonfungible" }
+pallet-refungible = { default-features = false, path = "../refungible" }

--- a/pallets/nft/src/benchmarking.rs
+++ b/pallets/nft/src/benchmarking.rs
@@ -7,35 +7,10 @@
 use nft_data_structs::*;
 use core::convert::TryInto;
 use sp_runtime::DispatchError;
+use pallet_common::benchmarking::{create_data, create_u16_data};
 
 const SEED: u32 = 1;
-
-fn create_data(size: usize) -> Vec<u8> {
-	(0..size).map(|v| (v & 0xff) as u8).collect()
-}
-fn create_u16_data(size: usize) -> Vec<u16> {
-	(0..size).map(|v| (v & 0xffff) as u16).collect()
-}
-
-fn default_nft_data() -> CreateItemData {
-	CreateItemData::NFT(CreateNftData {
-		const_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
-		variable_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
-	})
-}
 
-fn default_fungible_data() -> CreateItemData {
-	CreateItemData::Fungible(CreateFungibleData { value: 1000 })
-}
-
-fn default_re_fungible_data() -> CreateItemData {
-	CreateItemData::ReFungible(CreateReFungibleData {
-		const_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
-		variable_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
-		pieces: 1000,
-	})
-}
-
 fn create_collection_helper<T: Config>(
 	owner: T::AccountId,
 	mode: CollectionMode,
@@ -55,20 +30,10 @@
 		token_prefix,
 		mode,
 	)?;
-	Ok(CreatedCollectionCount::get())
+	Ok(<pallet_common::CreatedCollectionCount<T>>::get())
 }
 fn create_nft_collection<T: Config>(owner: T::AccountId) -> Result<CollectionId, DispatchError> {
 	create_collection_helper::<T>(owner, CollectionMode::NFT)
-}
-fn create_fungible_collection<T: Config>(
-	owner: T::AccountId,
-) -> Result<CollectionId, DispatchError> {
-	create_collection_helper::<T>(owner, CollectionMode::Fungible(0))
-}
-fn create_refungible_collection<T: Config>(
-	owner: T::AccountId,
-) -> Result<CollectionId, DispatchError> {
-	create_collection_helper::<T>(owner, CollectionMode::ReFungible)
 }
 
 benchmarks! {
@@ -82,7 +47,7 @@
 		T::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
 	}: _(RawOrigin::Signed(caller.clone()), col_name.clone(), col_desc.clone(), token_prefix.clone(), mode)
 	verify {
-		assert_eq!(<Pallet<T>>::collection_id(2).unwrap().owner, caller);
+		assert_eq!(<pallet_common::CollectionById<T>>::get(CollectionId(1)).unwrap().owner, caller);
 	}
 
 	destroy_collection {
@@ -129,7 +94,7 @@
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
 		let new_admin: T::AccountId = account("admin", 0, SEED);
-		<Pallet<T>>::add_collection_admin(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(new_admin.clone()))?;
+		<Pallet<T>>::add_collection_admin(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(new_admin.clone()))?;
 	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(new_admin))
 
 	set_collection_sponsor {
@@ -140,152 +105,21 @@
 	confirm_sponsorship {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;
+		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), collection, caller.clone())?;
 	}: _(RawOrigin::Signed(caller.clone()), collection)
 
 	remove_collection_sponsor {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;
-		<Pallet<T>>::confirm_sponsorship(RawOrigin::Signed(caller.clone()).into(), 2)?;
+		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), collection, caller.clone())?;
+		<Pallet<T>>::confirm_sponsorship(RawOrigin::Signed(caller.clone()).into(), collection)?;
 	}: _(RawOrigin::Signed(caller.clone()), collection)
-
-	// nft item
-	create_item_nft {
-		let b in 0..(CUSTOM_DATA_LIMIT * 2);
-
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_nft_collection::<T>(caller.clone())?;
-		let data = CreateItemData::NFT(CreateNftData {
-			const_data: create_data(b.min(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
-			variable_data: create_data(b.saturating_sub(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
-		});
-	}: create_item(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
-
-	create_multiple_items_nft {
-		// TODO: Take item data size into account. As create_item_nft bench shows, this parameter has no effect on execution time,
-		// but it may if we increase CUSTOM_DATA_LIMIT
-		let b in 1..1000;
-
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_nft_collection::<T>(caller.clone())?;
-		let data = (0..b).map(|_| default_nft_data()).collect();
-	}: create_multiple_items(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
 
-	// fungible item
-	create_item_fungible {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_fungible_collection::<T>(caller.clone())?;
-		let data = CreateItemData::Fungible(CreateFungibleData {
-			value: 1000,
-		});
-	}: create_item(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
-
-	create_multiple_items_fungible {
-		let b in 1..1000;
-
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_fungible_collection::<T>(caller.clone())?;
-		let data = (0..b).map(|_| default_fungible_data()).collect();
-	}: create_multiple_items(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
-
-	// refungible item
-	create_item_refungible {
-		let b in 0..(CUSTOM_DATA_LIMIT * 2);
-
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_refungible_collection::<T>(caller.clone())?;
-		let data = CreateItemData::ReFungible(CreateReFungibleData {
-			const_data: create_data(b.min(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
-			variable_data: create_data(b.saturating_sub(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
-			pieces: 1000,
-		});
-	}: create_item(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
-
-	create_multiple_items_refungible {
-		// TODO: Take item data size into account. As create_item_nft bench shows, this parameter has no effect on execution time,
-		// but it may if we increase CUSTOM_DATA_LIMIT
-		let b in 1..1000;
-
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_refungible_collection::<T>(caller.clone())?;
-		let data = (0..b).map(|_| default_re_fungible_data()).collect();
-	}: create_multiple_items(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
-
-	burn_item_nft {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_nft_collection::<T>(caller.clone())?;
-		let data = default_nft_data();
-		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
-	}: burn_item(RawOrigin::Signed(caller.clone()), collection, 1, 1)
-
-	transfer_nft {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_nft_collection::<T>(caller.clone())?;
-		let recipient: T::AccountId = account("recipient", 0, SEED);
-		let data = default_nft_data();
-		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
-	}: transfer(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
-
-	transfer_fungible {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_fungible_collection::<T>(caller.clone())?;
-		let recipient: T::AccountId = account("recipient", 0, SEED);
-		let data = default_fungible_data();
-		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
-	}: transfer(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
-
-	transfer_refungible {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_refungible_collection::<T>(caller.clone())?;
-		let recipient: T::AccountId = account("recipient", 0, SEED);
-		let data = default_re_fungible_data();
-		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
-	}: transfer(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
-
 	set_transfers_enabled_flag {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
 	}: _(RawOrigin::Signed(caller.clone()), collection, false)
-
-	approve_nft {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_nft_collection::<T>(caller.clone())?;
-		let recipient: T::AccountId = account("recipient", 0, SEED);
-		let data = default_nft_data();
-		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
-	}: approve(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
 
-	// Nft
-	transfer_from_nft {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_nft_collection::<T>(caller.clone())?;
-		let recipient: T::AccountId = account("recipient", 0, SEED);
-		let data = default_nft_data();
-		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
-		<Pallet<T>>::approve(RawOrigin::Signed(caller.clone()).into(), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)?;
-	}: transfer_from(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)
-
-	// Fungible
-	transfer_from_fungible {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_fungible_collection::<T>(caller.clone())?;
-		let recipient: T::AccountId = account("recipient", 0, SEED);
-		let data = default_fungible_data();
-		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
-		<Pallet<T>>::approve(RawOrigin::Signed(caller.clone()).into(), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)?;
-	}: transfer_from(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)
-
-	// ReFungible
-	transfer_from_refungible {
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_refungible_collection::<T>(caller.clone())?;
-		let recipient: T::AccountId = account("recipient", 0, SEED);
-		let data = default_re_fungible_data();
-		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
-		<Pallet<T>>::approve(RawOrigin::Signed(caller.clone()).into(), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)?;
-	}: transfer_from(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)
-
 	set_offchain_schema {
 		let b in 0..OFFCHAIN_SCHEMA_LIMIT;
 
@@ -308,29 +142,19 @@
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
 		let data = create_data(b as usize);
-	}: set_variable_on_chain_schema(RawOrigin::Signed(caller.clone()), 2, data)
-
-	set_variable_meta_data_nft {
-		let b in 0..CUSTOM_DATA_LIMIT;
-
-		let caller: T::AccountId = account("caller", 0, SEED);
-		let collection = create_nft_collection::<T>(caller.clone())?;
-		let data = default_nft_data();
-		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
-		let data = create_data(b as usize);
-	}: set_variable_meta_data(RawOrigin::Signed(caller.clone()), collection, 1, data)
+	}: set_variable_on_chain_schema(RawOrigin::Signed(caller.clone()), collection, data)
 
 	set_schema_version {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-	}: set_schema_version(RawOrigin::Signed(caller.clone()), 2, SchemaVersion::Unique)
+	}: set_schema_version(RawOrigin::Signed(caller.clone()), collection, SchemaVersion::Unique)
 
 	set_collection_limits{
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
 
 		let cl = CollectionLimits {
-			account_token_ownership_limit: 0,
+			account_token_ownership_limit: Some(0),
 			sponsored_data_size: 0,
 			token_limit: 1,
 			sponsor_transfer_timeout: 0,
@@ -338,5 +162,10 @@
 			owner_can_transfer: true,
 			sponsored_data_rate_limit: None,
 		};
-	}: set_collection_limits(RawOrigin::Signed(caller.clone()), 2, cl)
+	}: set_collection_limits(RawOrigin::Signed(caller.clone()), collection, cl)
+
+	set_meta_update_permission_flag {
+		let caller: T::AccountId = account("caller", 0, SEED);
+		let collection = create_nft_collection::<T>(caller.clone())?;
+	}: _(RawOrigin::Signed(caller.clone()), collection, MetaUpdatePermission::Admin)
 }

--- 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
+		}
 	}
 }

--- 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::marker::PhantomData;
+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 core::convert::TryInto;
-use core::marker::PhantomData;
-use nft_data_structs::{NFT_SPONSOR_TRANSFER_TIMEOUT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT};
 
+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> {
@@ -34,9 +35,10 @@
 				.map_err(|_| AnyError)?
 				.ok_or(AnyError)?;
 			match call {
-				UniqueNFTCall::ERC721UniqueExtensions(
-					ERC721UniqueExtensionsCall::TransferNft { token_id, .. },
-				)
+				UniqueNFTCall::ERC721UniqueExtensions(ERC721UniqueExtensionsCall::Transfer {
+					token_id,
+					..
+				})
 				| UniqueNFTCall::ERC721(ERC721Call::TransferFrom { token_id, .. }) => {
 					let token_id: u32 = token_id.try_into().map_err(|_| AnyError)?;
 					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;

--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -16,12 +16,12 @@
 pub use serde::{Serialize, Deserialize};
 
 pub use frame_support::{
-	construct_runtime, decl_event, decl_module, decl_storage, decl_error,
+	construct_runtime, decl_module, decl_storage, decl_error,
 	dispatch::DispatchResult,
 	ensure, fail, parameter_types,
 	traits::{
-		Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,
-		Randomness, IsSubType, WithdrawReasons,
+		ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced, Randomness,
+		IsSubType, WithdrawReasons,
 	},
 	weights::{
 		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},
@@ -29,22 +29,24 @@
 		WeightToFeePolynomial, DispatchClass,
 	},
 	StorageValue, transactional,
+	pallet_prelude::DispatchResultWithPostInfo,
 };
 use scale_info::TypeInfo;
 use frame_system::{self as system, ensure_signed};
-use sp_core::H160;
-use sp_std::vec;
-use sp_runtime::{DispatchError, sp_std::prelude::Vec};
-use core::ops::{Deref, DerefMut};
+use sp_runtime::{sp_std::prelude::Vec};
 use nft_data_structs::{
-	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,
-	CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
+	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, CUSTOM_DATA_LIMIT,
 	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,
-	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,
-	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,
-	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,
-	MetaUpdatePermission, FungibleItemType, ReFungibleItemType,
+	OFFCHAIN_SCHEMA_LIMIT, AccessMode, Collection, CreateItemData, CollectionLimits, CollectionId,
+	CollectionMode, TokenId, SchemaVersion, SponsorshipState, MetaUpdatePermission,
+};
+use pallet_common::{
+	account::CrossAccountId, CollectionHandle, IsAdmin, Pallet as PalletCommon,
+	Error as CommonError, CommonWeightInfo, Allowlist,
 };
+use pallet_refungible::{Pallet as PalletRefungible, RefungibleHandle};
+use pallet_fungible::{Pallet as PalletFungible, FungibleHandle};
+use pallet_nonfungible::{Pallet as PalletNonfungible, NonfungibleHandle};
 
 #[cfg(test)]
 mod mock;
@@ -58,9 +60,12 @@
 pub use eth::sponsoring::NftEthSponsorshipHandler;
 
 pub use eth::NftErcSupport;
-pub use eth::account::*;
-use eth::erc::{ERC20Events, ERC721Events};
 
+pub mod common;
+use common::CommonWeights;
+pub mod dispatch;
+use dispatch::dispatch_call;
+
 #[cfg(feature = "runtime-benchmarks")]
 mod benchmarking;
 pub mod weights;
@@ -69,204 +74,34 @@
 decl_error! {
 	/// Error for non-fungible-token module.
 	pub enum Error for Module<T: Config> {
-		/// Total collections bound exceeded.
-		TotalCollectionsLimitExceeded,
 		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.
 		CollectionDecimalPointLimitExceeded,
-		/// 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,
-		/// This collection does not exist.
-		CollectionNotFound,
-		/// Item not exists.
-		TokenNotFound,
-		/// Admin not found
-		AdminNotFound,
-		/// Arithmetic calculation overflow.
-		NumOverflow,
-		/// Account already has admin role.
-		AlreadyAdmin,
-		/// You do not own this collection.
-		NoPermission,
 		/// This address is not set as sponsor, use setCollectionSponsor first.
 		ConfirmUnsetSponsorFail,
-		/// Collection is not in mint mode.
-		PublicMintingNotAllowed,
-		/// Sender parameter and item owner must be equal.
-		MustBeTokenOwner,
-		/// Item balance not enough.
-		TokenValueTooLow,
-		/// Size of item is too large.
-		NftSizeLimitExceeded,
-		/// No approve found
-		ApproveNotFound,
-		/// Requested value more than approved.
-		TokenValueNotEnough,
-		/// Only approved addresses can call this method.
-		ApproveRequired,
-		/// Address is not in white list.
-		AddresNotInWhiteList,
-		/// Number of collection admins bound exceeded.
-		CollectionAdminsLimitExceeded,
-		/// Owned tokens by a single address bound exceeded.
-		AddressOwnershipLimitExceeded,
 		/// Length of items properties must be greater than 0.
 		EmptyArgument,
-		/// const_data exceeded data limit.
-		TokenConstDataLimitExceeded,
-		/// variable_data exceeded data limit.
-		TokenVariableDataLimitExceeded,
-		/// Not NFT item data used to mint in NFT collection.
-		NotNftDataUsedToMintNftCollectionToken,
-		/// Not Fungible item data used to mint in Fungible collection.
-		NotFungibleDataUsedToMintFungibleCollectionToken,
-		/// Not Re Fungible item data used to mint in Re Fungible collection.
-		NotReFungibleDataUsedToMintReFungibleCollectionToken,
-		/// Unexpected collection type.
-		UnexpectedCollectionType,
-		/// Can't store metadata in fungible tokens.
-		CantStoreMetadataInFungibleTokens,
-		/// Collection token limit exceeded
-		CollectionTokenLimitExceeded,
-		/// Account token limit exceeded per collection
-		AccountTokenLimitExceeded,
 		/// Collection limit bounds per collection exceeded
 		CollectionLimitBoundsExceeded,
 		/// Tried to enable permissions which are only permitted to be disabled
 		OwnerPermissionsCantBeReverted,
-		/// Schema data size limit bound exceeded
-		SchemaDataLimitExceeded,
-		/// Maximum refungibility exceeded
-		WrongRefungiblePieces,
-		/// createRefungible should be called with one owner
-		BadCreateRefungibleCall,
-		/// Gas limit exceeded
-		OutOfGas,
-		/// Metadata update denied by collection settings
-		MetadataUpdateDenied,
-		/// Metadata update flag become unmutable with None option
-		MetadataFlagFrozen,
-		/// Collection settings not allowing items transferring
-		TransferNotAllowed,
-		/// Can't transfer tokens to ethereum zero address
-		AddressIsZero,
 	}
 }
-
-#[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>,
-	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,
-}
-impl<T: Config> CollectionHandle<T> {
-	pub fn get_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 get(id: CollectionId) -> Option<Self> {
-		Self::get_with_gas_limit(id, u64::MAX)
-	}
-	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {
-		self.recorder.log_sub(log)
-	}
-	#[allow(dead_code)]
-	fn consume_gas(&self, gas: u64) -> DispatchResult {
-		self.recorder.consume_gas_sub(gas)
-	}
-	fn consume_sload(&self) -> DispatchResult {
-		self.recorder.consume_sload_sub()
-	}
-	fn consume_sstore(&self) -> DispatchResult {
-		self.recorder.consume_sstore_sub()
-	}
-	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
-	}
-}
-
-pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized + TypeInfo {
-	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;
-
+pub trait Config:
+	system::Config
+	+ pallet_evm_coder_substrate::Config
+	+ pallet_common::Config
+	+ pallet_nonfungible::Config
+	+ pallet_refungible::Config
+	+ pallet_fungible::Config
+	+ Sized
+	+ TypeInfo
+{
 	/// Weight information for extrinsics in this pallet.
 	type WeightInfo: WeightInfo;
-
-	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;
-	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;
-
-	type CrossAccountId: CrossAccountId<Self::AccountId>;
-	type Currency: Currency<Self::AccountId>;
-	type CollectionCreationPrice: Get<
-		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,
-	>;
-	type TreasuryAccountId: Get<Self::AccountId>;
 }
 
 type SelfWeightOf<T> = <T as Config>::WeightInfo;
 
-trait WeightInfoHelpers: WeightInfo {
-	fn transfer() -> Weight {
-		Self::transfer_nft()
-			.max(Self::transfer_fungible())
-			.max(Self::transfer_refungible())
-	}
-	fn transfer_from() -> Weight {
-		Self::transfer_from_nft()
-			.max(Self::transfer_from_fungible())
-			.max(Self::transfer_from_refungible())
-	}
-	fn approve() -> Weight {
-		// TODO: refungible, fungible
-		Self::approve_nft()
-	}
-	fn set_variable_meta_data(data: u32) -> Weight {
-		// TODO: refungible
-		Self::set_variable_meta_data_nft(data)
-	}
-	fn create_item(data: u32) -> Weight {
-		Self::create_item_nft(data)
-			.max(Self::create_item_fungible())
-			.max(Self::create_item_refungible(data))
-	}
-	fn create_multiple_items(amount: u32) -> Weight {
-		Self::create_multiple_items_nft(amount)
-			.max(Self::create_multiple_items_fungible(amount))
-			.max(Self::create_multiple_items_refungible(amount))
-	}
-	fn burn_item() -> Weight {
-		// TODO: refungible, fungible
-		Self::burn_item_nft()
-	}
-}
-impl<T: WeightInfo> WeightInfoHelpers for T {}
-
 // # Used definitions
 //
 // ## User control levels
@@ -293,56 +128,10 @@
 	trait Store for Module<T: Config> as Nft {
 
 		//#region Private members
-		/// Id of next collection
-		CreatedCollectionCount: u32;
 		/// Used for migrations
 		ChainVersion: u64;
-		/// Id of last collection token
-		/// Collection id (controlled?1)
-		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;
-		//#endregion
-
-		//#region Bound counters
-		/// Amount of collections destroyed, used for total amount tracking with
-		/// CreatedCollectionCount
-		DestroyedCollectionCount: u32;
 		//#endregion
 
-		//#region Basic collections
-		/// Collection info
-		/// Collection id (controlled?1)
-		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;
-		/// List of collection admins
-		/// Collection id (controlled?2)
-		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;
-		/// Whitelisted collection users
-		/// Collection id (controlled?2), user id (controlled?3)
-		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;
-		//#endregion
-
-		/// How many of collection items user have
-		/// Collection id (controlled?2), account id (real)
-		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;
-
-		/// Amount of items which spender can transfer out of owners account (via transferFrom)
-		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))
-		/// TODO: Off chain worker should remove from this map when token gets removed
-		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;
-
-		//#region Item collections
-		/// Collection id (controlled?2), token id (controlled?1)
-		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;
-		/// Collection id (controlled?2), owner (controlled?2)
-		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;
-		/// Collection id (controlled?2), token id (controlled?1)
-		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;
-		//#endregion
-
-		//#region Index list
-		/// Collection id (controlled?2), tokens owner (controlled?2)
-		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;
-		//#endregion
-
 		//#region Tokens transfer rate limit baskets
 		/// (Collection id (controlled?2), who created (real))
 		/// TODO: Off chain worker should remove from this map when collection gets removed
@@ -359,97 +148,13 @@
 		/// Collection id (controlled?2), token id (controlled?2)
 		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;
 	}
-	add_extra_genesis {
-		build(|config: &GenesisConfig<T>| {
-			// Modification of storage
-			for (_num, _c) in &config.collection_id {
-				<Module<T>>::init_collection(_c);
-			}
-
-			for (_num, _c, _i) in &config.nft_item_id {
-				<Module<T>>::init_nft_token(*_c, _i);
-			}
-
-			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {
-				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);
-			}
-
-			for (_num, _c, _i) in &config.refungible_item_id {
-				<Module<T>>::init_refungible_token(*_c, _i);
-			}
-		})
-	}
 }
 
-decl_event!(
-	pub enum Event<T>
-	where
-		AccountId = <T as frame_system::Config>::AccountId,
-		CrossAccountId = <T as Config>::CrossAccountId,
-	{
-		/// 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, 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
-		ItemCreated(CollectionId, TokenId, CrossAccountId),
-
-		/// Collection item was burned.
-		///
-		/// # Arguments
-		///
-		/// collection_id.
-		///
-		/// item_id: Identifier of burned NFT.
-		ItemDestroyed(CollectionId, TokenId),
-
-		/// 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, CrossAccountId, CrossAccountId, u128),
-
-		/// * collection_id
-		///
-		/// * item_id
-		///
-		/// * sender
-		///
-		/// * spender
-		///
-		/// * amount
-		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),
-	}
-);
-
 decl_module! {
 	pub struct Module<T: Config> for enum Call
 	where
 		origin: T::Origin
 	{
-		fn deposit_event() = default;
 		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;
 		type Error = Error<T>;
 
@@ -484,57 +189,19 @@
 			// Anyone can create a collection
 			let who = ensure_signed(origin)?;
 
-			// 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(
-				&who,
-				imbalance,
-				WithdrawReasons::TRANSFER,
-				ExistenceRequirement::KeepAlive,
-			).map_err(|_| Error::<T>::NoPermission)?;
-
-			let decimal_points = match mode {
-				CollectionMode::Fungible(points) => points,
-				_ => 0
-			};
-
-			let created_count = CreatedCollectionCount::get();
-			let destroyed_count = DestroyedCollectionCount::get();
-
-			// bound Total number of collections
-			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);
-
-			// check params
-			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
-			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);
-			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);
-			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);
-
-			// Generate next collection ID
-			let next_id = created_count
-				.checked_add(1)
-				.ok_or(Error::<T>::NumOverflow)?;
-
-			CreatedCollectionCount::put(next_id);
-
-			let limits = CollectionLimits {
+			let limits = CollectionLimits::<T::BlockNumber> {
 				sponsored_data_size: CUSTOM_DATA_LIMIT,
 				..Default::default()
 			};
 
 			// Create new collection
-			let new_collection = Collection {
+			let new_collection = Collection::<T> {
 				owner: who.clone(),
 				name: collection_name,
 				mode: mode.clone(),
 				mint_mode: false,
 				access: AccessMode::Normal,
 				description: collection_description,
-				decimal_points,
 				token_prefix,
 				offchain_schema: Vec::new(),
 				schema_version: SchemaVersion::ImageURL,
@@ -542,15 +209,21 @@
 				variable_on_chain_schema: Vec::new(),
 				const_on_chain_schema: Vec::new(),
 				limits,
-				meta_update_permission: MetaUpdatePermission::default(),
 				transfers_enabled: true,
+				meta_update_permission: Default::default(),
 			};
 
-			// Add new collection to map
-			<CollectionById<T>>::insert(next_id, new_collection);
-
-			// call event
-			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));
+			let _id = match mode {
+				CollectionMode::NFT => {PalletNonfungible::init_collection(new_collection)?},
+				CollectionMode::Fungible(decimal_points) => {
+					// check params
+					ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
+					PalletFungible::init_collection(new_collection)?
+				}
+				CollectionMode::ReFungible => {
+					PalletRefungible::init_collection(new_collection)?
+				}
+			};
 
 			Ok(())
 		}
@@ -567,35 +240,24 @@
 		#[weight = <SelfWeightOf<T>>::destroy_collection()]
 		#[transactional]
 		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {
+			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 
-			let sender = ensure_signed(origin)?;
-			let collection = Self::get_collection(collection_id)?;
-			Self::check_owner_permissions(&collection, &sender)?;
-			if !collection.limits.owner_can_destroy {
-				fail!(Error::<T>::NoPermission);
-			}
+			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			collection.check_is_owner(&sender)?;
 
-			<AddressTokens<T>>::remove_prefix(collection_id, None);
-			<Allowances<T>>::remove_prefix(collection_id, None);
-			<Balance<T>>::remove_prefix(collection_id, None);
-			<ItemListIndex>::remove(collection_id);
-			<AdminList<T>>::remove(collection_id);
-			<CollectionById<T>>::remove(collection_id);
-			<WhiteList<T>>::remove_prefix(collection_id, None);
+			// =========
 
-			<NftItemList<T>>::remove_prefix(collection_id, None);
-			<FungibleItemList<T>>::remove_prefix(collection_id, None);
-			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);
+			match collection.mode {
+				CollectionMode::ReFungible => PalletRefungible::destroy_collection(RefungibleHandle::cast(collection), &sender)?,
+				CollectionMode::Fungible(_) => PalletFungible::destroy_collection(FungibleHandle::cast(collection), &sender)?,
+				CollectionMode::NFT => PalletNonfungible::destroy_collection(NonfungibleHandle::cast(collection), &sender)?,
+			}
 
 			<NftTransferBasket<T>>::remove_prefix(collection_id, None);
 			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);
 			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);
 
 			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);
-
-			DestroyedCollectionCount::put(DestroyedCollectionCount::get()
-				.checked_add(1)
-				.ok_or(Error::<T>::NumOverflow)?);
 
 			Ok(())
 		}
@@ -617,11 +279,11 @@
 		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
 
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let collection = Self::get_collection(collection_id)?;
+			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
 
-			Self::toggle_white_list_internal(
+			<PalletCommon<T>>::toggle_allowlist(
+				&collection,
 				&sender,
-				&collection,
 				&address,
 				true,
 			)?;
@@ -646,11 +308,11 @@
 		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
 
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let collection = Self::get_collection(collection_id)?;
+			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
 
-			Self::toggle_white_list_internal(
-				&sender,
+			<PalletCommon<T>>::toggle_allowlist(
 				&collection,
+				&sender,
 				&address,
 				false,
 			)?;
@@ -673,10 +335,11 @@
 		#[transactional]
 		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult
 		{
-			let sender = ensure_signed(origin)?;
+			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
+
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner(&sender)?;
 
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_permissions(&target_collection, &sender)?;
 			target_collection.access = mode;
 			target_collection.save()
 		}
@@ -698,10 +361,11 @@
 		#[transactional]
 		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult
 		{
-			let sender = ensure_signed(origin)?;
+			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
+
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner(&sender)?;
 
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_permissions(&target_collection, &sender)?;
 			target_collection.mint_mode = mint_permission;
 			target_collection.save()
 		}
@@ -721,9 +385,11 @@
 		#[transactional]
 		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {
 
-			let sender = ensure_signed(origin)?;
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_permissions(&target_collection, &sender)?;
+			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
+
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner(&sender)?;
+
 			target_collection.owner = new_owner;
 			target_collection.save()
 		}
@@ -745,18 +411,11 @@
 		#[transactional]
 		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let collection = Self::get_collection(collection_id)?;
-			Self::check_owner_or_admin_permissions(&collection, &sender)?;
-			let mut admin_arr = <AdminList<T>>::get(collection_id);
 
-			match admin_arr.binary_search(&new_admin_id) {
-				Ok(_) => {},
-				Err(idx) => {
-					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);
-					admin_arr.insert(idx, new_admin_id);
-					<AdminList<T>>::insert(collection_id, admin_arr);
-				}
-			}
+			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			collection.check_is_owner_or_admin(&sender)?;
+
+			<IsAdmin<T>>::insert((collection_id, new_admin_id.as_sub()), true);
 			Ok(())
 		}
 
@@ -776,14 +435,11 @@
 		#[transactional]
 		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let collection = Self::get_collection(collection_id)?;
-			Self::check_owner_or_admin_permissions(&collection, &sender)?;
-			let mut admin_arr = <AdminList<T>>::get(collection_id);
 
-			if let Ok(idx) = admin_arr.binary_search(&account_id) {
-				admin_arr.remove(idx);
-				<AdminList<T>>::insert(collection_id, admin_arr);
-			}
+			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			collection.check_is_owner_or_admin(&sender)?;
+
+			<IsAdmin<T>>::remove((collection_id, account_id.as_sub()));
 			Ok(())
 		}
 
@@ -799,9 +455,10 @@
 		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]
 		#[transactional]
 		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_permissions(&target_collection, &sender)?;
+			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
+
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner_or_admin(&sender)?;
 
 			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);
 			target_collection.save()
@@ -819,7 +476,7 @@
 		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {
 			let sender = ensure_signed(origin)?;
 
-			let mut target_collection = Self::get_collection(collection_id)?;
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
 			ensure!(
 				target_collection.sponsorship.pending_sponsor() == Some(&sender),
 				Error::<T>::ConfirmUnsetSponsorFail
@@ -841,10 +498,10 @@
 		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]
 		#[transactional]
 		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {
-			let sender = ensure_signed(origin)?;
+			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_permissions(&target_collection, &sender)?;
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner(&sender)?;
 
 			target_collection.sponsorship = SponsorshipState::Disabled;
 			target_collection.save()
@@ -868,21 +525,12 @@
 		/// * owner: Address, initial owner of the NFT.
 		///
 		/// * data: Token data to store on chain.
-		// #[weight =
-		// (130_000_000 as Weight)
-		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))
-		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))
-		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]
-
-		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]
+		#[weight = <CommonWeights<T>>::create_item()]
 		#[transactional]
-		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {
+		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResultWithPostInfo {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let collection = Self::get_collection(collection_id)?;
-
-			Self::create_item_internal(&sender, &collection, &owner, data)?;
 
-			collection.submit_logs()
+			dispatch_call::<T, _>(collection_id, |d| d.create_item(sender, owner, data))
 		}
 
 		/// This method creates multiple items in a collection created with CreateCollection method.
@@ -903,17 +551,13 @@
 		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].
 		///
 		/// * owner: Address, initial owner of the NFT.
-		#[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]
+		#[weight = <CommonWeights<T>>::create_multiple_items(items_data.len() as u32)]
 		#[transactional]
-		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {
-
+		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResultWithPostInfo {
 			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let collection = Self::get_collection(collection_id)?;
 
-			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;
-
-			collection.submit_logs()
+			dispatch_call::<T, _>(collection_id, |d| d.create_multiple_items(sender, owner, items_data))
 		}
 
 		// TODO! transaction weight
@@ -932,46 +576,16 @@
 		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]
 		#[transactional]
 		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {
-
-			let sender = ensure_signed(origin)?;
-			let mut target_collection = Self::get_collection(collection_id)?;
+			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner(&sender)?;
 
-			Self::check_owner_permissions(&target_collection, &sender)?;
+			// =========
 
 			target_collection.transfers_enabled = value;
 			target_collection.save()
 		}
 
-		// TODO! transaction weight
-		/// Set meta_update_permission value for particular collection
-		///
-		/// # Permissions
-		///
-		/// * Collection Owner.
-		///
-		/// # Arguments
-		///
-		/// * collection_id: ID of the collection.
-		///
-		/// * value: New flag value.
-		#[weight = <T as Config>::WeightInfo::burn_item()]
-		#[transactional]
-		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {
-
-			let sender = ensure_signed(origin)?;
-			let mut target_collection = Self::get_collection(collection_id)?;
-
-			ensure!(
-				target_collection.meta_update_permission != MetaUpdatePermission::None,
-				Error::<T>::MetadataFlagFrozen
-			);
-			Self::check_owner_permissions(&target_collection, &sender)?;
-
-			target_collection.meta_update_permission = value;
-
-			target_collection.save()
-		}
-
 		/// Destroys a concrete instance of NFT.
 		///
 		/// # Permissions
@@ -985,16 +599,12 @@
 		/// * collection_id: ID of the collection.
 		///
 		/// * item_id: ID of NFT to burn.
-		#[weight = <SelfWeightOf<T>>::burn_item()]
+		#[weight = <CommonWeights<T>>::burn_item()]
 		#[transactional]
-		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {
-
+		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let target_collection = Self::get_collection(collection_id)?;
 
-			Self::burn_item_internal(&sender, &target_collection, item_id, value, true)?;
-
-			target_collection.submit_logs()
+			dispatch_call::<T, _>(collection_id, |d| d.burn_item(sender, item_id, value))
 		}
 
 		/// Destroys a concrete instance of NFT on behalf of the owner
@@ -1013,16 +623,12 @@
 		/// * item_id: ID of NFT to burn.
 		///
 		/// * from: owner of item
-		#[weight = <SelfWeightOf<T>>::burn_item()]
+		#[weight = <CommonWeights<T>>::burn_from()]
 		#[transactional]
-		pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResult {
-
+		pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let target_collection = Self::get_collection(collection_id)?;
 
-			Self::burn_from_internal(&sender, &target_collection, &from, item_id, value)?;
-
-			target_collection.submit_logs()
+			dispatch_call::<T, _>(collection_id, |d| d.burn_from(sender, from, item_id, value))
 		}
 
 		/// Change ownership of the token.
@@ -1048,15 +654,12 @@
 		///     * Non-Fungible Mode: Ignored
 		///     * Fungible Mode: Must specify transferred amount
 		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)
-		#[weight = <SelfWeightOf<T>>::transfer()]
+		#[weight = <CommonWeights<T>>::transfer()]
 		#[transactional]
-		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {
+		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let collection = Self::get_collection(collection_id)?;
 
-			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;
-
-			collection.submit_logs()
+			dispatch_call::<T, _>(collection_id, |d| d.transfer(sender, recipient, item_id, value))
 		}
 
 		/// Set, change, or remove approved address to transfer the ownership of the NFT.
@@ -1074,15 +677,12 @@
 		/// * collection_id.
 		///
 		/// * item_id: ID of the item.
-		#[weight = <SelfWeightOf<T>>::approve()]
+		#[weight = <CommonWeights<T>>::approve()]
 		#[transactional]
-		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {
+		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResultWithPostInfo {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let collection = Self::get_collection(collection_id)?;
-
-			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;
 
-			collection.submit_logs()
+			dispatch_call::<T, _>(collection_id, |d| d.approve(sender, spender, item_id, amount))
 		}
 
 		/// 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.
@@ -1104,29 +704,14 @@
 		/// * item_id: ID of the item.
 		///
 		/// * value: Amount to transfer.
-		#[weight = <SelfWeightOf<T>>::transfer_from()]
+		#[weight = <CommonWeights<T>>::transfer_from()]
 		#[transactional]
-		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {
+		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResultWithPostInfo {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let collection = Self::get_collection(collection_id)?;
 
-			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;
-
-			collection.submit_logs()
+			dispatch_call::<T, _>(collection_id, |d| d.transfer_from(sender, from, recipient, item_id, value))
 		}
-		// #[weight = 0]
-		//     // let no_perm_mes = "You do not have permissions to modify this collection";
-		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);
-		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));
-		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);
 
-		//     // // on_nft_received  call
-
-		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;
-
-		//     Ok(())
-		// }
-
 		/// Set off-chain data schema.
 		///
 		/// # Permissions
@@ -1139,22 +724,45 @@
 		/// * collection_id.
 		///
 		/// * schema: String representing the offchain data schema.
-		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]
+		#[weight = <CommonWeights<T>>::set_variable_metadata(data.len() as u32)]
 		#[transactional]
 		pub fn set_variable_meta_data (
 			origin,
 			collection_id: CollectionId,
 			item_id: TokenId,
 			data: Vec<u8>
-		) -> DispatchResult {
+		) -> DispatchResultWithPostInfo {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 
-			let collection = Self::get_collection(collection_id)?;
-			Self::meta_update_check(&sender, &collection, item_id)?;
+			dispatch_call::<T, _>(collection_id, |d| d.set_variable_metadata(sender, item_id, data))
+		}
 
-			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;
+		/// Set meta_update_permission value for particular collection
+		///
+		/// # Permissions
+		///
+		/// * Collection Owner.
+		///
+		/// # Arguments
+		///
+		/// * collection_id: ID of the collection.
+		///
+		/// * value: New flag value.
+		#[weight = <SelfWeightOf<T>>::set_meta_update_permission_flag()]
+		#[transactional]
+		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {
+			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
 
-			Ok(())
+			ensure!(
+				target_collection.meta_update_permission != MetaUpdatePermission::None,
+				<CommonError<T>>::MetadataFlagFrozen,
+			);
+			target_collection.check_is_owner(&sender)?;
+
+			target_collection.meta_update_permission = value;
+
+			target_collection.save()
 		}
 
 		/// Set schema standard
@@ -1179,8 +787,8 @@
 			version: SchemaVersion
 		) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner_or_admin(&sender)?;
 			target_collection.schema_version = version;
 			target_collection.save()
 		}
@@ -1205,8 +813,8 @@
 			schema: Vec<u8>
 		) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner_or_admin(&sender)?;
 
 			// check schema limit
 			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");
@@ -1235,8 +843,8 @@
 			schema: Vec<u8>
 		) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner_or_admin(&sender)?;
 
 			// check schema limit
 			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");
@@ -1265,8 +873,8 @@
 			schema: Vec<u8>
 		) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner_or_admin(&sender)?;
 
 			// check schema limit
 			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");
@@ -1279,23 +887,23 @@
 		#[transactional]
 		pub fn set_collection_limits(
 			origin,
-			collection_id: u32,
+			collection_id: CollectionId,
 			new_limits: CollectionLimits<T::BlockNumber>,
 		) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
-			let mut target_collection = Self::get_collection(collection_id)?;
-			Self::check_owner_permissions(&target_collection, sender.as_sub())?;
+			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_owner(&sender)?;
 			let old_limits = &target_collection.limits;
 
 			// collection bounds
 			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&
-				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&
+				new_limits.account_token_ownership_limit.unwrap_or(0) <= MAX_TOKEN_OWNERSHIP &&
 				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,
 				Error::<T>::CollectionLimitBoundsExceeded);
 
 			// token_limit   check  prev
-			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);
-			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);
+			ensure!(old_limits.token_limit >= new_limits.token_limit, <CommonError<T>>::CollectionTokenLimitExceeded);
+			ensure!(new_limits.token_limit > 0, <CommonError<T>>::CollectionTokenLimitExceeded);
 
 			ensure!(
 				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&
@@ -1310,1294 +918,16 @@
 	}
 }
 
-impl<T: Config> Module<T> {
-	pub fn create_item_internal(
-		sender: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		owner: &T::CrossAccountId,
-		data: CreateItemData,
-	) -> DispatchResult {
-		ensure!(
-			owner != &T::CrossAccountId::from_eth(H160([0; 20])),
-			Error::<T>::AddressIsZero
-		);
-
-		Self::can_create_items_in_collection(collection, sender, owner, 1)?;
-		Self::validate_create_item_args(collection, &data)?;
-		Self::create_item_no_validation(collection, owner, data)?;
-
-		Ok(())
+// TODO: limit returned entries?
+impl<T: Config> Pallet<T> {
+	pub fn adminlist(collection: CollectionId) -> Vec<T::AccountId> {
+		<IsAdmin<T>>::iter_prefix((collection,))
+			.map(|(a, _)| a)
+			.collect()
 	}
-
-	pub fn transfer_internal(
-		sender: &T::CrossAccountId,
-		recipient: &T::CrossAccountId,
-		target_collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		value: u128,
-	) -> DispatchResult {
-		ensure!(
-			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),
-			Error::<T>::AddressIsZero
-		);
-
-		// Limits check
-		Self::is_correct_transfer(target_collection, recipient)?;
-
-		// Transfer permissions check
-		ensure!(
-			Self::is_item_owner(sender, target_collection, item_id)?
-				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,
-			Error::<T>::NoPermission
-		);
-
-		if target_collection.access == AccessMode::WhiteList {
-			Self::check_white_list(target_collection, sender)?;
-			Self::check_white_list(target_collection, recipient)?;
-		}
-
-		match target_collection.mode {
-			CollectionMode::NFT => Self::transfer_nft(
-				target_collection,
-				item_id,
-				sender.clone(),
-				recipient.clone(),
-			)?,
-			CollectionMode::Fungible(_) => {
-				Self::transfer_fungible(target_collection, value, sender, recipient)?
-			}
-			CollectionMode::ReFungible => Self::transfer_refungible(
-				target_collection,
-				item_id,
-				value,
-				sender.clone(),
-				recipient.clone(),
-			)?,
-		};
-
-		Self::deposit_event(RawEvent::Transfer(
-			target_collection.id,
-			item_id,
-			sender.clone(),
-			recipient.clone(),
-			value,
-		));
-
-		Ok(())
-	}
-
-	pub fn approve_internal(
-		sender: &T::CrossAccountId,
-		spender: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		amount: u128,
-	) -> DispatchResult {
-		Self::token_exists(collection, item_id)?;
-
-		// Transfer permissions check
-		let bypasses_limits = collection.limits.owner_can_transfer
-			&& Self::is_owner_or_admin_permissions(collection, sender)?;
-
-		let allowance_limit = if bypasses_limits {
-			None
-		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {
-			Some(amount)
-		} else {
-			fail!(Error::<T>::NoPermission);
-		};
-
-		if collection.access == AccessMode::WhiteList {
-			Self::check_white_list(collection, sender)?;
-			Self::check_white_list(collection, spender)?;
-		}
-
-		collection.consume_sload()?;
-		let allowance: u128 = amount
-			.checked_add(<Allowances<T>>::get(
-				collection.id,
-				(item_id, sender.as_sub(), spender.as_sub()),
-			))
-			.ok_or(Error::<T>::NumOverflow)?;
-		if let Some(limit) = allowance_limit {
-			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);
-		}
-		collection.consume_sstore()?;
-		<Allowances<T>>::insert(
-			collection.id,
-			(item_id, sender.as_sub(), spender.as_sub()),
-			allowance,
-		);
-
-		if matches!(collection.mode, CollectionMode::NFT) {
-			// TODO: NFT: only one owner may exist for token in ERC721
-			collection.log(ERC721Events::Approval {
-				owner: *sender.as_eth(),
-				approved: *spender.as_eth(),
-				token_id: item_id.into(),
-			})?;
-		}
-
-		if matches!(collection.mode, CollectionMode::Fungible(_)) {
-			// TODO: NFT: only one owner may exist for token in ERC20
-			collection.log(ERC20Events::Approval {
-				owner: *sender.as_eth(),
-				spender: *spender.as_eth(),
-				value: allowance.into(),
-			})?;
-		}
-
-		Self::deposit_event(RawEvent::Approved(
-			collection.id,
-			item_id,
-			sender.clone(),
-			spender.clone(),
-			allowance,
-		));
-		Ok(())
-	}
-
-	pub fn transfer_from_internal(
-		sender: &T::CrossAccountId,
-		from: &T::CrossAccountId,
-		recipient: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		amount: u128,
-	) -> DispatchResult {
-		if sender == from {
-			// Transfer by `from`, because it is either equal to sender, or derived from him
-			return Self::transfer_internal(from, recipient, collection, item_id, amount);
-		}
-
-		// Check approval
-		collection.consume_sload()?;
-		let approval: u128 =
-			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));
-
-		// Limits check
-		Self::is_correct_transfer(collection, recipient)?;
-
-		// Transfer permissions check
-		ensure!(
-			approval >= amount
-				|| (collection.limits.owner_can_transfer
-					&& Self::is_owner_or_admin_permissions(collection, sender)?),
-			Error::<T>::NoPermission
-		);
-
-		if collection.access == AccessMode::WhiteList {
-			Self::check_white_list(collection, sender)?;
-			Self::check_white_list(collection, recipient)?;
-		}
-
-		// Reduce approval by transferred amount or remove if remaining approval drops to 0
-		let allowance = approval.saturating_sub(amount);
-		collection.consume_sstore()?;
-		if allowance > 0 {
-			<Allowances<T>>::insert(
-				collection.id,
-				(item_id, from.as_sub(), sender.as_sub()),
-				allowance,
-			);
-		} else {
-			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));
-		}
-
-		match collection.mode {
-			CollectionMode::NFT => {
-				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?
-			}
-			CollectionMode::Fungible(_) => {
-				Self::transfer_fungible(collection, amount, from, recipient)?
-			}
-			CollectionMode::ReFungible => Self::transfer_refungible(
-				collection,
-				item_id,
-				amount,
-				from.clone(),
-				recipient.clone(),
-			)?,
-		};
-
-		if matches!(collection.mode, CollectionMode::Fungible(_)) {
-			collection.log(ERC20Events::Approval {
-				owner: *from.as_eth(),
-				spender: *sender.as_eth(),
-				value: allowance.into(),
-			})?;
-		}
-
-		Ok(())
-	}
-
-	pub fn set_variable_meta_data_internal(
-		sender: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		data: Vec<u8>,
-	) -> DispatchResult {
-		Self::token_exists(collection, item_id)?;
-
-		ensure!(
-			CUSTOM_DATA_LIMIT >= data.len() as u32,
-			Error::<T>::TokenVariableDataLimitExceeded
-		);
-
-		ensure!(
-			(Self::is_item_owner(sender, collection, item_id)?
-				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)
-				|| (Self::is_owner_or_admin_permissions(collection, sender)?
-					&& collection.meta_update_permission == MetaUpdatePermission::Admin),
-			Error::<T>::NoPermission
-		);
-
-		match collection.mode {
-			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,
-			CollectionMode::ReFungible => {
-				Self::set_re_fungible_variable_data(collection, item_id, data)?
-			}
-			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),
-		};
-
-		Ok(())
-	}
-
-	pub fn meta_update_check(
-		sender: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-	) -> DispatchResult {
-		match collection.meta_update_permission {
-			MetaUpdatePermission::ItemOwner => ensure!(
-				Self::is_item_owner(sender, collection, item_id)?,
-				Error::<T>::NoPermission
-			),
-			MetaUpdatePermission::Admin => ensure!(
-				Self::is_owner_or_admin_permissions(collection, sender)?,
-				Error::<T>::NoPermission
-			),
-			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),
-		}
-
-		Ok(())
-	}
-
-	pub fn get_variable_metadata(
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-	) -> Result<Vec<u8>, DispatchError> {
-		Ok(match collection.mode {
-			CollectionMode::NFT => {
-				<NftItemList<T>>::get(collection.id, item_id)
-					.ok_or(Error::<T>::TokenNotFound)?
-					.variable_data
-			}
-			CollectionMode::ReFungible => {
-				<ReFungibleItemList<T>>::get(collection.id, item_id)
-					.ok_or(Error::<T>::TokenNotFound)?
-					.variable_data
-			}
-			_ => fail!(Error::<T>::UnexpectedCollectionType),
-		})
-	}
-
-	pub fn create_multiple_items_internal(
-		sender: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		owner: &T::CrossAccountId,
-		items_data: Vec<CreateItemData>,
-	) -> DispatchResult {
-		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;
-
-		for data in &items_data {
-			Self::validate_create_item_args(collection, data)?;
-		}
-		for data in &items_data {
-			Self::create_item_no_validation(collection, owner, data.clone())?;
-		}
-
-		Ok(())
-	}
-
-	pub fn burn_item_internal(
-		owner: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		value: u128,
-		allow_escalation: bool,
-	) -> DispatchResult {
-		ensure!(
-			Self::is_item_owner(owner, collection, item_id)?
-				|| (allow_escalation
-					&& collection.limits.owner_can_transfer
-					&& Self::is_owner_or_admin_permissions(collection, owner)?),
-			Error::<T>::NoPermission
-		);
-
-		if collection.access == AccessMode::WhiteList {
-			Self::check_white_list(collection, owner)?;
-		}
-
-		match collection.mode {
-			CollectionMode::NFT => match value {
-				1 => Self::burn_nft_item(collection, item_id)?,
-				0 => (),
-				_ => fail!(<Error<T>>::TokenValueTooLow),
-			},
-			CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, owner, value)?,
-			CollectionMode::ReFungible => {
-				Self::burn_refungible_item(collection, item_id, owner, value)?
-			}
-			_ => (),
-		};
-
-		Ok(())
-	}
-
-	pub fn burn_from_internal(
-		sender: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		from: &T::CrossAccountId,
-		item_id: TokenId,
-		amount: u128,
-	) -> DispatchResult {
-		if sender == from {
-			// Transfer by `from`, because it is either equal to sender, or derived from him
-			return Self::burn_item_internal(from, collection, item_id, amount, true);
-		}
-
-		// Check approval
-		collection.consume_sload()?;
-		let approval: u128 =
-			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));
-
-		// Transfer permissions check
-		ensure!(
-			approval >= amount
-				|| (collection.limits.owner_can_transfer
-					&& Self::is_owner_or_admin_permissions(collection, sender)?),
-			Error::<T>::NoPermission
-		);
-
-		if collection.access == AccessMode::WhiteList {
-			Self::check_white_list(collection, sender)?;
-		}
-
-		// Reduce approval by transferred amount or remove if remaining approval drops to 0
-		let allowance = approval.saturating_sub(amount);
-		collection.consume_sstore()?;
-		if allowance > 0 {
-			<Allowances<T>>::insert(
-				collection.id,
-				(item_id, from.as_sub(), sender.as_sub()),
-				allowance,
-			);
-		} else {
-			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));
-		}
-
-		// Escalation is disallowed here, because we need to be sure that passed owner is real
-		Self::burn_item_internal(from, collection, item_id, amount, false)?;
-
-		if matches!(collection.mode, CollectionMode::Fungible(_)) {
-			collection.log(ERC20Events::Approval {
-				owner: *from.as_eth(),
-				spender: *sender.as_eth(),
-				value: allowance.into(),
-			})?;
-		}
-
-		Ok(())
-	}
-
-	pub fn toggle_white_list_internal(
-		sender: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		address: &T::CrossAccountId,
-		whitelisted: bool,
-	) -> DispatchResult {
-		Self::check_owner_or_admin_permissions(collection, sender)?;
-
-		if whitelisted {
-			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);
-		} else {
-			<WhiteList<T>>::remove(collection.id, address.as_sub());
-		}
-
-		Ok(())
-	}
-
-	fn is_correct_transfer(
-		collection: &CollectionHandle<T>,
-		recipient: &T::CrossAccountId,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-
-		// check token limit and account token limit
-		collection.consume_sload()?;
-		let account_items: u32 =
-			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;
-
-		// zero limit means collection limit is disabled
-		// otherwise get lower value
-		let limit = if collection.limits.account_token_ownership_limit == 0
-			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT
-		{
-			ACCOUNT_TOKEN_OWNERSHIP_LIMIT
-		} else {
-			collection.limits.account_token_ownership_limit
-		};
-
-		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);
-
-		// preliminary transfer check
-		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);
-
-		Ok(())
-	}
-
-	fn can_create_items_in_collection(
-		collection: &CollectionHandle<T>,
-		sender: &T::CrossAccountId,
-		owner: &T::CrossAccountId,
-		amount: u32,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-
-		// check token limit and account token limit
-		let total_items: u32 = ItemListIndex::get(collection_id)
-			.checked_add(amount)
-			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;
-		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()
-			as u32)
-			.checked_add(amount)
-			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;
-
-		// zero limit means collection limit is disabled
-		// otherwise get lower value
-		let account_token_limit = if collection.limits.account_token_ownership_limit == 0
-			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT
-		{
-			ACCOUNT_TOKEN_OWNERSHIP_LIMIT
-		} else {
-			collection.limits.account_token_ownership_limit
-		};
-
-		ensure!(
-			collection.limits.token_limit >= total_items,
-			Error::<T>::CollectionTokenLimitExceeded
-		);
-		ensure!(
-			account_token_limit >= account_items,
-			Error::<T>::AccountTokenLimitExceeded
-		);
-
-		if !Self::is_owner_or_admin_permissions(collection, sender)? {
-			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);
-			Self::check_white_list(collection, owner)?;
-			Self::check_white_list(collection, sender)?;
-		}
-
-		Ok(())
-	}
-
-	fn validate_create_item_args(
-		target_collection: &CollectionHandle<T>,
-		data: &CreateItemData,
-	) -> DispatchResult {
-		match target_collection.mode {
-			CollectionMode::NFT => {
-				if !matches!(data, CreateItemData::NFT(_)) {
-					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);
-				}
-			}
-			CollectionMode::Fungible(_) => {
-				if !matches!(data, CreateItemData::Fungible(_)) {
-					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);
-				}
-			}
-			CollectionMode::ReFungible => {
-				if let CreateItemData::ReFungible(data) = data {
-					// Check refungibility limits
-					ensure!(
-						data.pieces <= MAX_REFUNGIBLE_PIECES,
-						Error::<T>::WrongRefungiblePieces
-					);
-					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);
-				} else {
-					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);
-				}
-			}
-		};
-
-		Ok(())
-	}
-
-	fn create_item_no_validation(
-		collection: &CollectionHandle<T>,
-		owner: &T::CrossAccountId,
-		data: CreateItemData,
-	) -> DispatchResult {
-		match data {
-			CreateItemData::NFT(data) => {
-				let item = NftItemType {
-					owner: owner.clone(),
-					const_data: data.const_data.into_inner(),
-					variable_data: data.variable_data.into_inner(),
-				};
-
-				Self::add_nft_item(collection, item)?;
-			}
-			CreateItemData::Fungible(data) => {
-				Self::add_fungible_item(collection, owner, data.value)?;
-			}
-			CreateItemData::ReFungible(data) => {
-				let owner_list = vec![Ownership {
-					owner: owner.clone(),
-					fraction: data.pieces,
-				}];
-
-				let item = ReFungibleItemType {
-					owner: owner_list,
-					const_data: data.const_data.into_inner(),
-					variable_data: data.variable_data.into_inner(),
-				};
-
-				Self::add_refungible_item(collection, item)?;
-			}
-		};
-
-		Ok(())
-	}
-
-	fn add_fungible_item(
-		collection: &CollectionHandle<T>,
-		owner: &T::CrossAccountId,
-		value: u128,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-
-		// Does new owner already have an account?
-		collection.consume_sload()?;
-		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;
-
-		// Mint
-		let item = FungibleItemType {
-			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,
-		};
-		collection.consume_sstore()?;
-		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);
-
-		// Update balance
-		collection.consume_sload()?;
-		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
-			.checked_add(value)
-			.ok_or(Error::<T>::NumOverflow)?;
-		collection.consume_sstore()?;
-		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
-
-		collection.log(ERC20Events::Transfer {
-			from: H160::default(),
-			to: *owner.as_eth(),
-			value: value.into(),
-		})?;
-		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));
-		Ok(())
-	}
-
-	fn add_refungible_item(
-		collection: &CollectionHandle<T>,
-		item: ReFungibleItemType<T::CrossAccountId>,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-
-		let current_index = <ItemListIndex>::get(collection_id)
-			.checked_add(1)
-			.ok_or(Error::<T>::NumOverflow)?;
-		let itemcopy = item.clone();
-
-		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);
-		let item_owner = item.owner.first().expect("only one owner is defined");
-
-		let value = item_owner.fraction;
-		let owner = item_owner.owner.clone();
-
-		Self::add_token_index(collection, current_index, &owner)?;
-
-		<ItemListIndex>::insert(collection_id, current_index);
-		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);
-
-		// Update balance
-		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
-			.checked_add(value)
-			.ok_or(Error::<T>::NumOverflow)?;
-		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
-
-		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));
-		Ok(())
-	}
-
-	fn add_nft_item(
-		collection: &CollectionHandle<T>,
-		item: NftItemType<T::CrossAccountId>,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-
-		let current_index = <ItemListIndex>::get(collection_id)
-			.checked_add(1)
-			.ok_or(Error::<T>::NumOverflow)?;
-
-		let item_owner = item.owner.clone();
-		Self::add_token_index(collection, current_index, &item.owner)?;
-
-		<ItemListIndex>::insert(collection_id, current_index);
-		<NftItemList<T>>::insert(collection_id, current_index, item);
-
-		// Update balance
-		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())
-			.checked_add(1)
-			.ok_or(Error::<T>::NumOverflow)?;
-		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);
-
-		collection.log(ERC721Events::Transfer {
-			from: H160::default(),
-			to: *item_owner.as_eth(),
-			token_id: current_index.into(),
-		})?;
-		Self::deposit_event(RawEvent::ItemCreated(
-			collection_id,
-			current_index,
-			item_owner,
-		));
-		Ok(())
-	}
-
-	fn burn_refungible_item(
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		owner: &T::CrossAccountId,
-		value: u128,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-
-		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)
-			.ok_or(Error::<T>::TokenNotFound)?;
-		let mut rft_balance = token
-			.owner
-			.iter()
-			.find(|&i| i.owner == *owner)
-			.ok_or(Error::<T>::TokenNotFound)?
-			.clone();
-		Self::remove_token_index(collection, item_id, owner)?;
-
-		// update balance
-		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())
-			.checked_sub(value)
-			.ok_or(Error::<T>::NumOverflow)?;
-		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);
-
-		rft_balance.fraction = (rft_balance.fraction)
-			.checked_sub(value)
-			.ok_or(Error::<T>::NumOverflow)?;
-
-		let index = token
-			.owner
-			.iter()
-			.position(|i| i.owner == *owner)
-			.expect("owned item is exists");
-		if rft_balance.fraction == 0 {
-			// Re-create owners list with sender removed
-			token.owner.remove(index);
-		} else {
-			token.owner[index] = rft_balance;
-		}
-
-		let owner_count = token.owner.len();
-
-		// Burn the token completely if this was the last (only) owner
-		if owner_count == 0 {
-			<ReFungibleItemList<T>>::remove(collection_id, item_id);
-			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);
-		} else {
-			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);
-		}
-
-		Ok(())
-	}
-
-	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {
-		let collection_id = collection.id;
-
-		let item =
-			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
-		Self::remove_token_index(collection, item_id, &item.owner)?;
-
-		// update balance
-		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())
-			.checked_sub(1)
-			.ok_or(Error::<T>::NumOverflow)?;
-		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);
-		<NftItemList<T>>::remove(collection_id, item_id);
-		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);
-
-		collection.log(ERC721Events::Transfer {
-			from: *item.owner.as_eth(),
-			to: H160::default(),
-			token_id: item_id.into(),
-		})?;
-		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));
-		Ok(())
-	}
-
-	fn burn_fungible_item(
-		collection: &CollectionHandle<T>,
-		owner: &T::CrossAccountId,
-		value: u128,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-
-		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());
-		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);
-
-		// update balance
-		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
-			.checked_sub(value)
-			.ok_or(Error::<T>::NumOverflow)?;
-		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
-
-		if balance.value - value > 0 {
-			balance.value -= value;
-			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);
-		} else {
-			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());
-		}
-
-		collection.log(ERC20Events::Transfer {
-			from: *owner.as_eth(),
-			to: H160::default(),
-			value: value.into(),
-		})?;
-		Ok(())
-	}
-
-	pub fn get_collection(
-		collection_id: CollectionId,
-	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {
-		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)
-	}
-
-	fn check_owner_permissions(
-		target_collection: &CollectionHandle<T>,
-		subject: &T::AccountId,
-	) -> DispatchResult {
-		ensure!(
-			*subject == target_collection.owner,
-			Error::<T>::NoPermission
-		);
-
-		Ok(())
-	}
-
-	fn is_owner_or_admin_permissions(
-		collection: &CollectionHandle<T>,
-		subject: &T::CrossAccountId,
-	) -> Result<bool, DispatchError> {
-		collection.consume_sload()?;
-		Ok(*subject.as_sub() == collection.owner
-			|| <AdminList<T>>::get(collection.id).contains(subject))
-	}
-
-	fn check_owner_or_admin_permissions(
-		collection: &CollectionHandle<T>,
-		subject: &T::CrossAccountId,
-	) -> DispatchResult {
-		ensure!(
-			Self::is_owner_or_admin_permissions(collection, subject)?,
-			Error::<T>::NoPermission
-		);
-
-		Ok(())
-	}
-
-	fn owned_amount(
-		subject: &T::CrossAccountId,
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-	) -> Result<Option<u128>, DispatchError> {
-		collection.consume_sload()?;
-		Ok(Self::owned_amount_unchecked(subject, collection, item_id))
-	}
-
-	fn owned_amount_unchecked(
-		subject: &T::CrossAccountId,
-		target_collection: &CollectionHandle<T>,
-		item_id: TokenId,
-	) -> Option<u128> {
-		let collection_id = target_collection.id;
-
-		match target_collection.mode {
-			CollectionMode::NFT => {
-				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)
-			}
-			CollectionMode::Fungible(_) => {
-				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)
-			}
-			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?
-				.owner
-				.iter()
-				.find(|i| i.owner == *subject)
-				.map(|i| i.fraction),
-		}
-	}
-
-	fn is_item_owner(
-		subject: &T::CrossAccountId,
-		target_collection: &CollectionHandle<T>,
-		item_id: TokenId,
-	) -> Result<bool, DispatchError> {
-		Ok(match target_collection.mode {
-			CollectionMode::Fungible(_) => true,
-			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),
-		})
-	}
-
-	fn check_white_list(
-		collection: &CollectionHandle<T>,
-		address: &T::CrossAccountId,
-	) -> DispatchResult {
-		collection.consume_sload()?;
-		ensure!(
-			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),
-			Error::<T>::AddresNotInWhiteList,
-		);
-		Ok(())
-	}
-
-	/// Check if token exists. In case of Fungible, check if there is an entry for
-	/// the owner in fungible balances double map
-	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {
-		let collection_id = target_collection.id;
-		let exists = match target_collection.mode {
-			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),
-			CollectionMode::Fungible(_) => true,
-			CollectionMode::ReFungible => {
-				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)
-			}
-		};
-
-		ensure!(exists, Error::<T>::TokenNotFound);
-		Ok(())
-	}
-
-	fn transfer_fungible(
-		collection: &CollectionHandle<T>,
-		value: u128,
-		owner: &T::CrossAccountId,
-		recipient: &T::CrossAccountId,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-
-		collection.consume_sload()?;
-		collection.consume_sload()?;
-		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());
-		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());
-
-		recipient_balance.value = recipient_balance
-			.value
-			.checked_add(value)
-			.ok_or(Error::<T>::NumOverflow)?;
-		balance.value = balance
-			.value
-			.checked_sub(value)
-			.ok_or(Error::<T>::TokenValueTooLow)?;
-
-		// update balanceOf
-		collection.consume_sstore()?;
-		collection.consume_sstore()?;
-		if balance.value != 0 {
-			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);
-		} else {
-			<Balance<T>>::remove(collection_id, owner.as_sub());
-		}
-		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);
-
-		// Reduce or remove sender
-		collection.consume_sstore()?;
-		collection.consume_sstore()?;
-		if balance.value != 0 {
-			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);
-		} else {
-			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());
-		}
-		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);
-
-		collection.log(ERC20Events::Transfer {
-			from: *owner.as_eth(),
-			to: *recipient.as_eth(),
-			value: value.into(),
-		})?;
-		Self::deposit_event(RawEvent::Transfer(
-			collection.id,
-			1,
-			owner.clone(),
-			recipient.clone(),
-			value,
-		));
-
-		Ok(())
-	}
-
-	fn transfer_refungible(
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		value: u128,
-		owner: T::CrossAccountId,
-		new_owner: T::CrossAccountId,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-		collection.consume_sload()?;
-		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)
-			.ok_or(Error::<T>::TokenNotFound)?;
-
-		let item = full_item
-			.owner
-			.iter()
-			.find(|i| i.owner == owner)
-			.ok_or(Error::<T>::TokenNotFound)?;
-		let amount = item.fraction;
-
-		ensure!(amount >= value, Error::<T>::TokenValueTooLow);
-
-		collection.consume_sload()?;
-		// update balance
-		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())
-			.checked_sub(value)
-			.ok_or(Error::<T>::NumOverflow)?;
-		collection.consume_sstore()?;
-		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);
-
-		collection.consume_sload()?;
-		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())
-			.checked_add(value)
-			.ok_or(Error::<T>::NumOverflow)?;
-		collection.consume_sstore()?;
-		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);
-
-		let old_owner = item.owner.clone();
-		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);
-
-		let mut new_full_item = full_item.clone();
-		// transfer
-		if amount == value && !new_owner_has_account {
-			// change owner
-			// new owner do not have account
-			new_full_item
-				.owner
-				.iter_mut()
-				.find(|i| i.owner == owner)
-				.expect("old owner does present in refungible")
-				.owner = new_owner.clone();
-			collection.consume_sstore()?;
-			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
-
-			// update index collection
-			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;
-		} else {
-			new_full_item
-				.owner
-				.iter_mut()
-				.find(|i| i.owner == owner)
-				.expect("old owner does present in refungible")
-				.fraction -= value;
-
-			// separate amount
-			if new_owner_has_account {
-				// new owner has account
-				new_full_item
-					.owner
-					.iter_mut()
-					.find(|i| i.owner == new_owner)
-					.expect("new owner has account")
-					.fraction += value;
-			} else {
-				// new owner do not have account
-				new_full_item.owner.push(Ownership {
-					owner: new_owner.clone(),
-					fraction: value,
-				});
-				Self::add_token_index(collection, item_id, &new_owner)?;
-			}
-
-			collection.consume_sstore()?;
-			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
-		}
-
-		Self::deposit_event(RawEvent::Transfer(
-			collection.id,
-			item_id,
-			owner,
-			new_owner,
-			amount,
-		));
-
-		Ok(())
-	}
-
-	fn transfer_nft(
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		sender: T::CrossAccountId,
-		new_owner: T::CrossAccountId,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-		collection.consume_sload()?;
-		let mut item =
-			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
-
-		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);
-
-		collection.consume_sload()?;
-		// update balance
-		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())
-			.checked_sub(1)
-			.ok_or(Error::<T>::NumOverflow)?;
-		collection.consume_sstore()?;
-		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);
-
-		collection.consume_sload()?;
-		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())
-			.checked_add(1)
-			.ok_or(Error::<T>::NumOverflow)?;
-		collection.consume_sstore()?;
-		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);
-
-		// change owner
-		let old_owner = item.owner.clone();
-		item.owner = new_owner.clone();
-		collection.consume_sstore()?;
-		<NftItemList<T>>::insert(collection_id, item_id, item);
-
-		// update index collection
-		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;
-
-		collection.log(ERC721Events::Transfer {
-			from: *sender.as_eth(),
-			to: *new_owner.as_eth(),
-			token_id: item_id.into(),
-		})?;
-		Self::deposit_event(RawEvent::Transfer(
-			collection.id,
-			item_id,
-			sender,
-			new_owner,
-			1,
-		));
-
-		Ok(())
-	}
-
-	fn set_re_fungible_variable_data(
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		data: Vec<u8>,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)
-			.ok_or(Error::<T>::TokenNotFound)?;
-
-		item.variable_data = data;
-
-		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);
-
-		Ok(())
-	}
-
-	fn set_nft_variable_data(
-		collection: &CollectionHandle<T>,
-		item_id: TokenId,
-		data: Vec<u8>,
-	) -> DispatchResult {
-		let collection_id = collection.id;
-		let mut item =
-			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
-
-		item.variable_data = data;
-
-		<NftItemList<T>>::insert(collection_id, item_id, item);
-
-		Ok(())
-	}
-
-	#[allow(dead_code)]
-	fn init_collection(item: &Collection<T>) {
-		// check params
-		assert!(
-			item.decimal_points <= MAX_DECIMAL_POINTS,
-			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"
-		);
-		assert!(
-			item.name.len() <= 64,
-			"Collection name can not be longer than 63 char"
-		);
-		assert!(
-			item.name.len() <= 256,
-			"Collection description can not be longer than 255 char"
-		);
-		assert!(
-			item.token_prefix.len() <= 16,
-			"Token prefix can not be longer than 15 char"
-		);
-
-		// Generate next collection ID
-		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();
-
-		CreatedCollectionCount::put(next_id);
-	}
-
-	#[allow(dead_code)]
-	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {
-		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
-
-		Self::add_token_index(
-			&CollectionHandle::get(collection_id).unwrap(),
-			current_index,
-			&item.owner,
-		)
-		.unwrap();
-
-		<ItemListIndex>::insert(collection_id, current_index);
-
-		// Update balance
-		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())
-			.checked_add(1)
-			.unwrap();
-		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);
-	}
-
-	#[allow(dead_code)]
-	fn init_fungible_token(
-		collection_id: CollectionId,
-		owner: &T::CrossAccountId,
-		item: &FungibleItemType,
-	) {
-		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
-
-		Self::add_token_index(
-			&CollectionHandle::get(collection_id).unwrap(),
-			current_index,
-			owner,
-		)
-		.unwrap();
-
-		<ItemListIndex>::insert(collection_id, current_index);
-
-		// Update balance
-		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
-			.checked_add(item.value)
-			.unwrap();
-		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
-	}
-
-	#[allow(dead_code)]
-	fn init_refungible_token(
-		collection_id: CollectionId,
-		item: &ReFungibleItemType<T::CrossAccountId>,
-	) {
-		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
-
-		let value = item.owner.first().unwrap().fraction;
-		let owner = item.owner.first().unwrap().owner.clone();
-
-		Self::add_token_index(
-			&CollectionHandle::get(collection_id).unwrap(),
-			current_index,
-			&owner,
-		)
-		.unwrap();
-
-		<ItemListIndex>::insert(collection_id, current_index);
-
-		// Update balance
-		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())
-			.checked_add(value)
-			.unwrap();
-		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
-	}
-
-	fn add_token_index(
-		collection: &CollectionHandle<T>,
-		item_index: TokenId,
-		owner: &T::CrossAccountId,
-	) -> DispatchResult {
-		collection.consume_sload()?;
-		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
-		if list_exists {
-			collection.consume_sload()?;
-			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
-
-			// bound Owned tokens by a single address in collection
-			let account_items: u32 = list.len() as u32;
-			ensure!(
-				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
-				Error::<T>::AddressOwnershipLimitExceeded
-			);
-
-			let item_contains = list.contains(&item_index.clone());
-
-			if !item_contains {
-				list.push(item_index);
-			}
-
-			collection.consume_sstore()?;
-			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);
-		} else {
-			let itm = vec![item_index];
-			collection.consume_sstore()?;
-			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);
-		}
-
-		Ok(())
-	}
-
-	fn remove_token_index(
-		collection: &CollectionHandle<T>,
-		item_index: TokenId,
-		owner: &T::CrossAccountId,
-	) -> DispatchResult {
-		collection.consume_sload()?;
-		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
-		if list_exists {
-			collection.consume_sload()?;
-			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
-			let item_contains = list.contains(&item_index.clone());
-
-			if item_contains {
-				list.retain(|&item| item != item_index);
-				collection.consume_sstore()?;
-				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);
-			}
-		}
-
-		Ok(())
-	}
-
-	fn move_token_index(
-		collection: &CollectionHandle<T>,
-		item_index: TokenId,
-		old_owner: &T::CrossAccountId,
-		new_owner: &T::CrossAccountId,
-	) -> DispatchResult {
-		Self::remove_token_index(collection, item_index, old_owner)?;
-		Self::add_token_index(collection, item_index, new_owner)?;
-
-		Ok(())
-	}
-}
-
-sp_api::decl_runtime_apis! {
-	pub trait NftApi {
-		/// Used for ethereum integration
-		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;
+	pub fn allowlist(collection: CollectionId) -> Vec<T::AccountId> {
+		<Allowlist<T>>::iter_prefix((collection,))
+			.map(|(a, _)| a)
+			.collect()
 	}
 }

--- a/pallets/nft/src/sponsorship.rs
+++ b/pallets/nft/src/sponsorship.rs
@@ -1,7 +1,6 @@
 use crate::{
-	Config, Call, CollectionById, CreateItemBasket, VariableMetaDataBasket,
-	ReFungibleTransferBasket, FungibleTransferBasket, NftTransferBasket, CreateItemData,
-	CollectionMode,
+	Config, Call, CreateItemBasket, VariableMetaDataBasket, ReFungibleTransferBasket,
+	FungibleTransferBasket, NftTransferBasket, CreateItemData, CollectionMode,
 };
 use core::marker::PhantomData;
 use up_sponsorship::SponsorshipHandler;
@@ -13,6 +12,7 @@
 	TokenId, CollectionId, NFT_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
 	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
 };
+use pallet_common::{CollectionById};
 
 pub struct NftSponsorshipHandler<T>(PhantomData<T>);
 impl<T: Config> NftSponsorshipHandler<T> {
@@ -61,15 +61,10 @@
 			sponsor_transfer = match collection_mode {
 				CollectionMode::NFT => {
 					// get correct limit
-					let limit: u32 = if collection_limits.sponsor_transfer_timeout != 0 {
-						if collection_limits.sponsor_transfer_timeout > NFT_SPONSOR_TRANSFER_TIMEOUT
-						{
-							collection_limits.sponsor_transfer_timeout
-						} else {
-							NFT_SPONSOR_TRANSFER_TIMEOUT
-						}
+					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
+						collection_limits.sponsor_transfer_timeout
 					} else {
-						0
+						NFT_SPONSOR_TRANSFER_TIMEOUT
 					};
 
 					let mut sponsored = true;
@@ -88,18 +83,13 @@
 				}
 				CollectionMode::Fungible(_) => {
 					// get correct limit
-					let limit: u32 = if collection_limits.sponsor_transfer_timeout != 0 {
-						if collection_limits.sponsor_transfer_timeout
-							> FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
-						{
-							collection_limits.sponsor_transfer_timeout
-						} else {
-							FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
-						}
+					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
+						collection_limits.sponsor_transfer_timeout
 					} else {
-						0
+						FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
 					};
 
+					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;
 					let mut sponsored = true;
 					if FungibleTransferBasket::<T>::contains_key(collection_id, who) {
 						let last_tx_block = FungibleTransferBasket::<T>::get(collection_id, who);
@@ -116,16 +106,10 @@
 				}
 				CollectionMode::ReFungible => {
 					// get correct limit
-					let limit: u32 = if collection_limits.sponsor_transfer_timeout != 0 {
-						if collection_limits.sponsor_transfer_timeout
-							> REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
-						{
-							collection_limits.sponsor_transfer_timeout
-						} else {
-							REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
-						}
+					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {
+						collection_limits.sponsor_transfer_timeout
 					} else {
-						0
+						REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
 					};
 
 					let mut sponsored = true;

--- a/pallets/nft/src/weights.rs
+++ b/pallets/nft/src/weights.rs
@@ -2,8 +2,8 @@
 
 //! Autogenerated weights for pallet_nft
 //!
-//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 3.0.0
-//! DATE: 2021-08-31, STEPS: `[50, ]`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2021-10-21, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 128
 
 // Executed Command:
@@ -43,202 +43,141 @@
 	fn set_collection_sponsor() -> Weight;
 	fn confirm_sponsorship() -> Weight;
 	fn remove_collection_sponsor() -> Weight;
-	fn create_item_nft(b: u32, ) -> Weight;
-	fn create_multiple_items_nft(b: u32, ) -> Weight;
-	fn create_item_fungible() -> Weight;
-	fn create_multiple_items_fungible(b: u32, ) -> Weight;
-	fn create_item_refungible(b: u32, ) -> Weight;
-	fn create_multiple_items_refungible(b: u32, ) -> Weight;
-	fn burn_item_nft() -> Weight;
-	fn transfer_nft() -> Weight;
-	fn transfer_fungible() -> Weight;
-	fn transfer_refungible() -> Weight;
 	fn set_transfers_enabled_flag() -> Weight;
-	fn approve_nft() -> Weight;
-	fn transfer_from_nft() -> Weight;
-	fn transfer_from_fungible() -> Weight;
-	fn transfer_from_refungible() -> Weight;
 	fn set_offchain_schema(b: u32, ) -> Weight;
 	fn set_const_on_chain_schema(b: u32, ) -> Weight;
 	fn set_variable_on_chain_schema(b: u32, ) -> Weight;
-	fn set_variable_meta_data_nft(b: u32, ) -> Weight;
 	fn set_schema_version() -> Weight;
 	fn set_collection_limits() -> Weight;
+	fn set_meta_update_permission_flag() -> Weight;
 }
 
 /// Weights for pallet_nft using the Substrate node and recommended hardware.
 pub struct SubstrateWeight<T>(PhantomData<T>);
 impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	// Storage: Common CreatedCollectionCount (r:1 w:1)
+	// Storage: Common DestroyedCollectionCount (r:1 w:0)
+	// Storage: System Account (r:2 w:2)
+	// Storage: Common CollectionById (r:0 w:1)
 	fn create_collection() -> Weight {
-		(25_851_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(8 as Weight))
-			.saturating_add(T::DbWeight::get().writes(6 as Weight))
+		(23_803_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(4 as Weight))
+			.saturating_add(T::DbWeight::get().writes(4 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
+	// Storage: Common DestroyedCollectionCount (r:1 w:1)
+	// Storage: Nonfungible TokensMinted (r:0 w:1)
+	// Storage: Nonfungible TokensBurnt (r:0 w:1)
 	fn destroy_collection() -> Weight {
-		(28_737_000 as Weight)
+		(27_831_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes(4 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:0)
+	// Storage: Common Allowlist (r:0 w:1)
 	fn add_to_white_list() -> Weight {
-		(6_237_000 as Weight)
+		(6_629_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:0)
+	// Storage: Common Allowlist (r:0 w:1)
 	fn remove_from_white_list() -> Weight {
-		(6_252_000 as Weight)
+		(6_596_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_public_access_mode() -> Weight {
-		(6_691_000 as Weight)
+		(6_338_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_mint_permission() -> Weight {
-		(6_630_000 as Weight)
+		(6_383_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn change_collection_owner() -> Weight {
-		(6_521_000 as Weight)
+		(6_493_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:0)
+	// Storage: Common IsAdmin (r:0 w:1)
 	fn add_collection_admin() -> Weight {
-		(8_057_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+		(6_850_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:0)
+	// Storage: Common IsAdmin (r:0 w:1)
 	fn remove_collection_admin() -> Weight {
-		(8_307_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+		(6_615_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_collection_sponsor() -> Weight {
-		(6_484_000 as Weight)
+		(6_430_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn confirm_sponsorship() -> Weight {
-		(6_530_000 as Weight)
+		(6_125_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn remove_collection_sponsor() -> Weight {
-		(6_733_000 as Weight)
+		(6_236_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
-	fn create_item_nft(_b: u32, ) -> Weight {
-		(167_909_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(11 as Weight))
-			.saturating_add(T::DbWeight::get().writes(8 as Weight))
-	}
-	fn create_multiple_items_nft(b: u32, ) -> Weight {
-		(336_830_000 as Weight)
-			// Standard Error: 42_000
-			.saturating_add((11_627_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(T::DbWeight::get().reads(11 as Weight))
-			.saturating_add(T::DbWeight::get().writes(7 as Weight))
-			.saturating_add(T::DbWeight::get().writes((1 as Weight).saturating_mul(b as Weight)))
-	}
-	fn create_item_fungible() -> Weight {
-		(24_123_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(9 as Weight))
-			.saturating_add(T::DbWeight::get().writes(4 as Weight))
-	}
-	fn create_multiple_items_fungible(b: u32, ) -> Weight {
-		(48_227_000 as Weight)
-			// Standard Error: 13_000
-			.saturating_add((2_918_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(T::DbWeight::get().reads(9 as Weight))
-			.saturating_add(T::DbWeight::get().writes(4 as Weight))
-	}
-	fn create_item_refungible(_b: u32, ) -> Weight {
-		(26_293_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(9 as Weight))
-			.saturating_add(T::DbWeight::get().writes(7 as Weight))
-	}
-	fn create_multiple_items_refungible(b: u32, ) -> Weight {
-		(0 as Weight)
-			// Standard Error: 16_000
-			.saturating_add((8_374_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(T::DbWeight::get().reads(9 as Weight))
-			.saturating_add(T::DbWeight::get().writes(6 as Weight))
-			.saturating_add(T::DbWeight::get().writes((1 as Weight).saturating_mul(b as Weight)))
-	}
-	fn burn_item_nft() -> Weight {
-		(32_237_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(9 as Weight))
-			.saturating_add(T::DbWeight::get().writes(7 as Weight))
-	}
-	fn transfer_nft() -> Weight {
-		(192_578_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(14 as Weight))
-			.saturating_add(T::DbWeight::get().writes(10 as Weight))
-	}
-	fn transfer_fungible() -> Weight {
-		(170_749_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(11 as Weight))
-			.saturating_add(T::DbWeight::get().writes(7 as Weight))
-	}
-	fn transfer_refungible() -> Weight {
-		(35_949_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(10 as Weight))
-			.saturating_add(T::DbWeight::get().writes(7 as Weight))
-	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_transfers_enabled_flag() -> Weight {
-		(6_376_000 as Weight)
+		(6_500_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
-	fn approve_nft() -> Weight {
-		(169_825_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(9 as Weight))
-			.saturating_add(T::DbWeight::get().writes(4 as Weight))
-	}
-	fn transfer_from_nft() -> Weight {
-		(197_912_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(15 as Weight))
-			.saturating_add(T::DbWeight::get().writes(11 as Weight))
-	}
-	fn transfer_from_fungible() -> Weight {
-		(183_789_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(12 as Weight))
-			.saturating_add(T::DbWeight::get().writes(8 as Weight))
-	}
-	fn transfer_from_refungible() -> Weight {
-		(37_149_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(11 as Weight))
-			.saturating_add(T::DbWeight::get().writes(8 as Weight))
-	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_offchain_schema(_b: u32, ) -> Weight {
-		(6_435_000 as Weight)
+		(6_538_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_const_on_chain_schema(_b: u32, ) -> Weight {
-		(6_646_000 as Weight)
+		(6_542_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
-	fn set_variable_on_chain_schema(_b: u32, ) -> Weight {
-		(6_542_000 as Weight)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn set_variable_on_chain_schema(b: u32, ) -> Weight {
+		(6_092_000 as Weight)
+			// Standard Error: 0
+			.saturating_add((2_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
-	fn set_variable_meta_data_nft(_b: u32, ) -> Weight {
-		(14_697_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+	// Storage: Common CollectionById (r:1 w:1)
+	fn set_schema_version() -> Weight {
+		(6_470_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
-	fn set_schema_version() -> Weight {
-		(6_566_000 as Weight)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn set_collection_limits() -> Weight {
+		(6_841_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
-	fn set_collection_limits() -> Weight {
-		(6_349_000 as Weight)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn set_meta_update_permission_flag() -> Weight {
+		(6_278_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
@@ -246,178 +185,129 @@
 
 // For backwards compatibility and tests
 impl WeightInfo for () {
+	// Storage: Common CreatedCollectionCount (r:1 w:1)
+	// Storage: Common DestroyedCollectionCount (r:1 w:0)
+	// Storage: System Account (r:2 w:2)
+	// Storage: Common CollectionById (r:0 w:1)
 	fn create_collection() -> Weight {
-		(25_851_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(8 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
+		(23_803_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
+	// Storage: Common DestroyedCollectionCount (r:1 w:1)
+	// Storage: Nonfungible TokensMinted (r:0 w:1)
+	// Storage: Nonfungible TokensBurnt (r:0 w:1)
 	fn destroy_collection() -> Weight {
-		(28_737_000 as Weight)
+		(27_831_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:0)
+	// Storage: Common Allowlist (r:0 w:1)
 	fn add_to_white_list() -> Weight {
-		(6_237_000 as Weight)
+		(6_629_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:0)
+	// Storage: Common Allowlist (r:0 w:1)
 	fn remove_from_white_list() -> Weight {
-		(6_252_000 as Weight)
+		(6_596_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_public_access_mode() -> Weight {
-		(6_691_000 as Weight)
+		(6_338_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_mint_permission() -> Weight {
-		(6_630_000 as Weight)
+		(6_383_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn change_collection_owner() -> Weight {
-		(6_521_000 as Weight)
+		(6_493_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:0)
+	// Storage: Common IsAdmin (r:0 w:1)
 	fn add_collection_admin() -> Weight {
-		(8_057_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+		(6_850_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:0)
+	// Storage: Common IsAdmin (r:0 w:1)
 	fn remove_collection_admin() -> Weight {
-		(8_307_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+		(6_615_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_collection_sponsor() -> Weight {
-		(6_484_000 as Weight)
+		(6_430_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn confirm_sponsorship() -> Weight {
-		(6_530_000 as Weight)
+		(6_125_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn remove_collection_sponsor() -> Weight {
-		(6_733_000 as Weight)
+		(6_236_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
-	fn create_item_nft(b: u32, ) -> Weight {
-		(167_180_000 as Weight)
-			// Standard Error: 1_000
-			.saturating_add((10_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(RocksDbWeight::get().reads(11 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(8 as Weight))
-	}
-	fn create_multiple_items_nft(b: u32, ) -> Weight {
-		(336_830_000 as Weight)
-			// Standard Error: 42_000
-			.saturating_add((11_627_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(RocksDbWeight::get().reads(11 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
-			.saturating_add(RocksDbWeight::get().writes((1 as Weight).saturating_mul(b as Weight)))
-	}
-	fn create_item_fungible() -> Weight {
-		(24_123_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(9 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
-	}
-	fn create_multiple_items_fungible(b: u32, ) -> Weight {
-		(13_217_000 as Weight)
-			// Standard Error: 4_000
-			.saturating_add((2_971_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(RocksDbWeight::get().reads(9 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
-	}
-	fn create_item_refungible(_b: u32, ) -> Weight {
-		(26_293_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(9 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
-	}
-	fn create_multiple_items_refungible(b: u32, ) -> Weight {
-		(0 as Weight)
-			// Standard Error: 16_000
-			.saturating_add((8_374_000 as Weight).saturating_mul(b as Weight))
-			.saturating_add(RocksDbWeight::get().reads(9 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(6 as Weight))
-			.saturating_add(RocksDbWeight::get().writes((1 as Weight).saturating_mul(b as Weight)))
-	}
-	fn burn_item_nft() -> Weight {
-		(32_237_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(9 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
-	}
-	fn transfer_nft() -> Weight {
-		(192_578_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(14 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(10 as Weight))
-	}
-	fn transfer_fungible() -> Weight {
-		(170_749_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(11 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
-	}
-	fn transfer_refungible() -> Weight {
-		(35_949_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(10 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(7 as Weight))
-	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_transfers_enabled_flag() -> Weight {
-		(6_376_000 as Weight)
+		(6_500_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
-	fn approve_nft() -> Weight {
-		(169_825_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(9 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
-	}
-	fn transfer_from_nft() -> Weight {
-		(197_912_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(15 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(11 as Weight))
-	}
-	fn transfer_from_fungible() -> Weight {
-		(183_789_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(12 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(8 as Weight))
-	}
-	fn transfer_from_refungible() -> Weight {
-		(37_149_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(11 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(8 as Weight))
-	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_offchain_schema(_b: u32, ) -> Weight {
-		(6_435_000 as Weight)
+		(6_538_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Common CollectionById (r:1 w:1)
 	fn set_const_on_chain_schema(_b: u32, ) -> Weight {
-		(6_646_000 as Weight)
+		(6_542_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
-	fn set_variable_on_chain_schema(_b: u32, ) -> Weight {
-		(6_542_000 as Weight)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn set_variable_on_chain_schema(b: u32, ) -> Weight {
+		(6_092_000 as Weight)
+			// Standard Error: 0
+			.saturating_add((2_000 as Weight).saturating_mul(b as Weight))
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
-	fn set_variable_meta_data_nft(_b: u32, ) -> Weight {
-		(14_697_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+	// Storage: Common CollectionById (r:1 w:1)
+	fn set_schema_version() -> Weight {
+		(6_470_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
-	fn set_schema_version() -> Weight {
-		(6_566_000 as Weight)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn set_collection_limits() -> Weight {
+		(6_841_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
-	fn set_collection_limits() -> Weight {
-		(6_349_000 as Weight)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn set_meta_update_permission_flag() -> Weight {
+		(6_278_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}