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

--- /dev/null
+++ b/client/rpc/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "uc-rpc"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+pallet-common = { default-features = false, path = '../../pallets/common' }
+nft-data-structs = { default-features = false, path = '../../primitives/nft' }
+up-rpc = { path = "../../primitives/rpc" }
+codec = { package = "parity-scale-codec", version = "2.0.0" }
+jsonrpc-core = "18.0.0"
+jsonrpc-core-client = "18.0.0"
+jsonrpc-derive = "18.0.0"
+
+sp-api = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.12" }
+sp-blockchain = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.12" }
+sp-core = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.12" }
+sp-rpc = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.12" }
+sp-runtime = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.12" }

--- /dev/null
+++ b/client/rpc/src/lib.rs
@@ -0,0 +1,156 @@
+use std::sync::Arc;
+
+use codec::Decode;
+use jsonrpc_core::{Error as RpcError, ErrorCode, Result};
+use jsonrpc_derive::rpc;
+use nft_data_structs::{CollectionId, TokenId};
+use sp_api::{BlockId, BlockT, ProvideRuntimeApi};
+use sp_blockchain::HeaderBackend;
+use up_rpc::NftApi as NftRuntimeApi;
+
+#[rpc]
+pub trait NftApi<BlockHash, CrossAccountId, AccountId> {
+	#[rpc(name = "nft_accountTokens")]
+	fn account_tokens(
+		&self,
+		collection: CollectionId,
+		account: CrossAccountId,
+		at: Option<BlockHash>,
+	) -> Result<Vec<TokenId>>;
+	#[rpc(name = "nft_tokenExists")]
+	fn token_exists(
+		&self,
+		collection: CollectionId,
+		token: TokenId,
+		at: Option<BlockHash>,
+	) -> Result<bool>;
+
+	#[rpc(name = "nft_tokenOwner")]
+	fn token_owner(
+		&self,
+		collection: CollectionId,
+		token: TokenId,
+		at: Option<BlockHash>,
+	) -> Result<CrossAccountId>;
+	#[rpc(name = "nft_constMetadata")]
+	fn const_metadata(
+		&self,
+		collection: CollectionId,
+		token: TokenId,
+		at: Option<BlockHash>,
+	) -> Result<Vec<u8>>;
+	#[rpc(name = "nft_variableMetadata")]
+	fn variable_metadata(
+		&self,
+		collection: CollectionId,
+		token: TokenId,
+		at: Option<BlockHash>,
+	) -> Result<Vec<u8>>;
+
+	#[rpc(name = "nft_collectionTokens")]
+	fn collection_tokens(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<u32>;
+	#[rpc(name = "nft_accountBalance")]
+	fn account_balance(
+		&self,
+		collection: CollectionId,
+		account: CrossAccountId,
+		at: Option<BlockHash>,
+	) -> Result<u32>;
+	#[rpc(name = "nft_balance")]
+	fn balance(
+		&self,
+		collection: CollectionId,
+		account: CrossAccountId,
+		token: TokenId,
+		at: Option<BlockHash>,
+	) -> Result<String>;
+	#[rpc(name = "nft_allowance")]
+	fn allowance(
+		&self,
+		collection: CollectionId,
+		sender: CrossAccountId,
+		spender: CrossAccountId,
+		token: TokenId,
+		at: Option<BlockHash>,
+	) -> Result<String>;
+
+	#[rpc(name = "nft_adminlist")]
+	fn adminlist(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<Vec<AccountId>>;
+	#[rpc(name = "nft_allowlist")]
+	fn allowlist(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<Vec<AccountId>>;
+	#[rpc(name = "nft_lastTokenId")]
+	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;
+}
+
+pub struct Nft<C, P> {
+	client: Arc<C>,
+	_marker: std::marker::PhantomData<P>,
+}
+
+impl<C, P> Nft<C, P> {
+	pub fn new(client: Arc<C>) -> Self {
+		Self {
+			client,
+			_marker: Default::default(),
+		}
+	}
+}
+
+pub enum Error {
+	RuntimeError,
+}
+
+impl From<Error> for i64 {
+	fn from(e: Error) -> i64 {
+		match e {
+			Error::RuntimeError => 1,
+		}
+	}
+}
+
+macro_rules! pass_method {
+	($method_name:ident($($name:ident: $ty:ty),* $(,)?) -> $result:ty $(=> $mapper:expr)?) => {
+		fn $method_name(
+			&self,
+			$(
+				$name: $ty,
+			)*
+			at: Option<<Block as BlockT>::Hash>,
+		) -> Result<$result> {
+			let api = self.client.runtime_api();
+			let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash));
+
+			api.$method_name(&at, $($name),*).map_err(|e| RpcError {
+				code: ErrorCode::ServerError(Error::RuntimeError.into()),
+				message: "Unable to query".into(),
+				data: Some(format!("{:?}", e).into()),
+			}) $(
+				.map($mapper)
+			)?
+		}
+	};
+}
+
+impl<C, Block, CrossAccountId, AccountId> NftApi<<Block as BlockT>::Hash, CrossAccountId, AccountId>
+	for Nft<C, Block>
+where
+	Block: BlockT,
+	AccountId: Decode,
+	C: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
+	C::Api: NftRuntimeApi<Block, CrossAccountId, AccountId>,
+	CrossAccountId: pallet_common::account::CrossAccountId<AccountId>,
+{
+	pass_method!(account_tokens(collection: CollectionId, account: CrossAccountId) -> Vec<TokenId>);
+	pass_method!(token_exists(collection: CollectionId, token: TokenId) -> bool);
+	pass_method!(token_owner(collection: CollectionId, token: TokenId) -> CrossAccountId);
+	pass_method!(const_metadata(collection: CollectionId, token: TokenId) -> Vec<u8>);
+	pass_method!(variable_metadata(collection: CollectionId, token: TokenId) -> Vec<u8>);
+	pass_method!(collection_tokens(collection: CollectionId) -> u32);
+	pass_method!(account_balance(collection: CollectionId, account: CrossAccountId) -> u32);
+	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string());
+	pass_method!(allowance(collection: CollectionId, sender: CrossAccountId, spender: CrossAccountId, token: TokenId) -> String => |v| v.to_string());
+
+	pass_method!(adminlist(collection: CollectionId) -> Vec<AccountId>);
+	pass_method!(allowlist(collection: CollectionId) -> Vec<AccountId>);
+	pass_method!(last_token_id(collection: CollectionId) -> TokenId);
+}

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

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

--- /dev/null
+++ b/pallets/common/src/benchmarking.rs
@@ -0,0 +1,91 @@
+use sp_std::vec::Vec;
+use crate::{Config, CollectionHandle};
+use nft_data_structs::{
+	CollectionMode, Collection, CollectionId, MAX_COLLECTION_NAME_LENGTH,
+	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, OFFCHAIN_SCHEMA_LIMIT,
+	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT,
+};
+use frame_support::traits::{Currency, Get};
+use core::convert::TryInto;
+use sp_runtime::DispatchError;
+
+pub fn create_data(size: usize) -> Vec<u8> {
+	(0..size).map(|v| (v & 0xff) as u8).collect()
+}
+pub fn create_u16_data(size: usize) -> Vec<u16> {
+	(0..size).map(|v| (v & 0xffff) as u16).collect()
+}
+
+pub fn create_collection_raw<T: Config, R>(
+	owner: T::AccountId,
+	mode: CollectionMode,
+	handler: impl FnOnce(Collection<T>) -> Result<CollectionId, DispatchError>,
+	cast: impl FnOnce(CollectionHandle<T>) -> R,
+) -> Result<R, DispatchError> {
+	T::Currency::deposit_creating(&owner, T::CollectionCreationPrice::get());
+	let name = create_u16_data(MAX_COLLECTION_NAME_LENGTH)
+		.try_into()
+		.unwrap();
+	let description = create_u16_data(MAX_COLLECTION_DESCRIPTION_LENGTH)
+		.try_into()
+		.unwrap();
+	let token_prefix = create_data(MAX_TOKEN_PREFIX_LENGTH).try_into().unwrap();
+	let offchain_schema = create_data(OFFCHAIN_SCHEMA_LIMIT as usize)
+		.try_into()
+		.unwrap();
+	let variable_on_chain_schema = create_data(VARIABLE_ON_CHAIN_SCHEMA_LIMIT as usize)
+		.try_into()
+		.unwrap();
+	let const_on_chain_schema = create_data(CONST_ON_CHAIN_SCHEMA_LIMIT as usize)
+		.try_into()
+		.unwrap();
+	handler(Collection {
+		owner,
+		mode,
+		access: Default::default(),
+		name,
+		description,
+		token_prefix,
+		mint_mode: true,
+		offchain_schema,
+		schema_version: Default::default(),
+		sponsorship: Default::default(),
+		limits: Default::default(),
+		variable_on_chain_schema,
+		const_on_chain_schema,
+		meta_update_permission: Default::default(),
+		transfers_enabled: true,
+	})
+	.and_then(CollectionHandle::try_get)
+	.map(cast)
+}
+
+#[macro_export]
+macro_rules! bench_init {
+	($name:ident: sub $(($id:expr))?; $($rest:tt)*) => {
+		let $name: T::AccountId = account(stringify!($name), 0 $(+ $id)?, SEED);
+		bench_init!($($rest)*);
+	};
+	($name:ident: collection($owner:ident); $($rest:tt)*) => {
+		let $name = create_collection::<T>($owner.clone())?;
+		bench_init!($($rest)*);
+	};
+	($name:ident: cross; $($rest:tt)*) => {
+		let $name = T::CrossAccountId::from_sub($name);
+		bench_init!($($rest)*);
+	};
+	($name:ident: cross_sub $(($id:expr))?; $($rest:tt)*) => {
+		let account: T::AccountId = account(stringify!($name), 0 $(+ $id)?, SEED);
+		let $name = T::CrossAccountId::from_sub(account);
+		bench_init!($($rest)*);
+	};
+	($name:ident: cross_from_sub; $($rest:tt)*) => {
+		let $name = T::CrossAccountId::from_sub($name);
+		bench_init!($($rest)*);
+	};
+	($name:ident: cross_from_sub($from:ident); $($rest:tt)*) => {
+		let $name = T::CrossAccountId::from_sub($from);
+		bench_init!($($rest)*);
+	};
+	() => {}
+}

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

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

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

--- /dev/null
+++ b/pallets/fungible/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+name = "pallet-fungible"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies.codec]
+default-features = false
+features = ['derive']
+package = 'parity-scale-codec'
+version = '2.0.0'
+
+[dependencies]
+frame-support = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
+frame-system = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
+sp-runtime = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
+sp-std = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
+sp-core = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
+pallet-common = { default-features = false, path = '../common' }
+nft-data-structs = { default-features = false, path = '../../primitives/nft' }
+evm-coder = { default-features = false, path = '../../crates/evm-coder' }
+pallet-evm-coder-substrate = { default-features = false, path = '../evm-coder-substrate' }
+ethereum = { git = "https://github.com/purestake/ethereum", branch = "joshy-scale-info", default-features = false }
+frame-benchmarking = { default-features = false, optional = true, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
+scale-info = { version = "1.0.0", default-features = false, features = [
+    "derive",
+] }
+
+[features]
+default = ["std"]
+std = [
+    "frame-support/std",
+    "frame-system/std",
+    "sp-runtime/std",
+    "sp-std/std",
+    "nft-data-structs/std",
+    "pallet-common/std",
+    "evm-coder/std",
+    "ethereum/std",
+    "pallet-evm-coder-substrate/std",
+    'frame-benchmarking/std',
+]
+runtime-benchmarks = ['frame-benchmarking', 'pallet-common/runtime-benchmarks']

--- /dev/null
+++ b/pallets/fungible/src/benchmarking.rs
@@ -0,0 +1,61 @@
+use super::*;
+use crate::{Pallet, Config, FungibleHandle};
+
+use sp_std::prelude::*;
+use pallet_common::benchmarking::create_collection_raw;
+use frame_benchmarking::{benchmarks, account};
+use nft_data_structs::{CollectionMode};
+use pallet_common::bench_init;
+
+const SEED: u32 = 1;
+
+fn create_collection<T: Config>(owner: T::AccountId) -> Result<FungibleHandle<T>, DispatchError> {
+	create_collection_raw(
+		owner,
+		CollectionMode::Fungible(0),
+		<Pallet<T>>::init_collection,
+		FungibleHandle::cast,
+	)
+}
+
+benchmarks! {
+	create_item {
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			sender: cross_from_sub(owner); to: cross_sub;
+		};
+	}: {<Pallet<T>>::create_item(&collection, &sender, (to, 200))?}
+
+	burn_item {
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			owner: cross_from_sub; burner: cross_sub;
+		};
+		<Pallet<T>>::create_item(&collection, &owner, (burner.clone(), 200))?;
+	}: {<Pallet<T>>::burn(&collection, &burner, 100)?}
+
+	transfer {
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			owner: cross_from_sub; sender: cross_sub; to: cross_sub;
+		};
+		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200))?;
+	}: {<Pallet<T>>::transfer(&collection, &sender, &to, 200)?}
+
+	approve {
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
+		};
+		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200))?;
+	}: {<Pallet<T>>::set_allowance(&collection, &sender, &spender, 100)?}
+
+	transfer_from {
+		bench_init!{
+			owner: sub; collection: collection(owner);
+			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;
+		};
+		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200))?;
+		<Pallet<T>>::set_allowance(&collection, &sender, &spender, 200)?;
+	}: {<Pallet<T>>::transfer_from(&collection, &spender, &sender, &receiver, 100)?}
+}

--- /dev/null
+++ b/pallets/fungible/src/common.rs
@@ -0,0 +1,246 @@
+use core::marker::PhantomData;
+
+use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
+use nft_data_structs::TokenId;
+use pallet_common::{
+	CommonCollectionOperations, CommonWeightInfo, account::CrossAccountId, with_weight,
+};
+use sp_runtime::ArithmeticError;
+use sp_std::{vec::Vec, vec};
+
+use crate::{
+	Allowance, Balance, Config, Error, FungibleHandle, Pallet, SelfWeightOf, weights::WeightInfo,
+};
+
+pub struct CommonWeights<T: Config>(PhantomData<T>);
+impl<T: Config> CommonWeightInfo for CommonWeights<T> {
+	fn create_item() -> Weight {
+		<SelfWeightOf<T>>::create_item()
+	}
+
+	fn create_multiple_items(_amount: u32) -> Weight {
+		Self::create_item()
+	}
+
+	fn burn_item() -> Weight {
+		<SelfWeightOf<T>>::burn_item()
+	}
+
+	fn transfer() -> Weight {
+		<SelfWeightOf<T>>::transfer()
+	}
+
+	fn approve() -> Weight {
+		<SelfWeightOf<T>>::approve()
+	}
+
+	fn transfer_from() -> Weight {
+		<SelfWeightOf<T>>::transfer_from()
+	}
+
+	fn burn_from() -> Weight {
+		0
+	}
+
+	fn set_variable_metadata(_bytes: u32) -> Weight {
+		// Error
+		0
+	}
+}
+
+impl<T: Config> CommonCollectionOperations<T> for FungibleHandle<T> {
+	fn create_item(
+		&self,
+		sender: T::CrossAccountId,
+		to: T::CrossAccountId,
+		data: nft_data_structs::CreateItemData,
+	) -> DispatchResultWithPostInfo {
+		match data {
+			nft_data_structs::CreateItemData::Fungible(data) => with_weight(
+				<Pallet<T>>::create_item(self, &sender, (to, data.value)),
+				<CommonWeights<T>>::create_item(),
+			),
+			_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),
+		}
+	}
+
+	fn create_multiple_items(
+		&self,
+		sender: T::CrossAccountId,
+		to: T::CrossAccountId,
+		data: Vec<nft_data_structs::CreateItemData>,
+	) -> DispatchResultWithPostInfo {
+		let mut sum: u128 = 0;
+		for data in data {
+			match data {
+				nft_data_structs::CreateItemData::Fungible(data) => {
+					sum = sum
+						.checked_add(data.value)
+						.ok_or(ArithmeticError::Overflow)?;
+				}
+				_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),
+			}
+		}
+
+		with_weight(
+			<Pallet<T>>::create_item(self, &sender, (to, sum)),
+			<CommonWeights<T>>::create_item(),
+		)
+	}
+
+	fn burn_item(
+		&self,
+		sender: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResultWithPostInfo {
+		ensure!(
+			token == TokenId::default(),
+			<Error<T>>::FungibleItemsHaveNoId
+		);
+
+		with_weight(
+			<Pallet<T>>::burn(self, &sender, amount),
+			<CommonWeights<T>>::burn_item(),
+		)
+	}
+
+	fn transfer(
+		&self,
+		from: T::CrossAccountId,
+		to: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResultWithPostInfo {
+		ensure!(
+			token == TokenId::default(),
+			<Error<T>>::FungibleItemsHaveNoId
+		);
+
+		with_weight(
+			<Pallet<T>>::transfer(&self, &from, &to, amount),
+			<CommonWeights<T>>::transfer(),
+		)
+	}
+
+	fn approve(
+		&self,
+		sender: T::CrossAccountId,
+		spender: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResultWithPostInfo {
+		ensure!(
+			token == TokenId::default(),
+			<Error<T>>::FungibleItemsHaveNoId
+		);
+
+		with_weight(
+			<Pallet<T>>::set_allowance(&self, &sender, &spender, amount),
+			<CommonWeights<T>>::approve(),
+		)
+	}
+
+	fn transfer_from(
+		&self,
+		sender: T::CrossAccountId,
+		from: T::CrossAccountId,
+		to: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResultWithPostInfo {
+		ensure!(
+			token == TokenId::default(),
+			<Error<T>>::FungibleItemsHaveNoId
+		);
+
+		with_weight(
+			<Pallet<T>>::transfer_from(&self, &sender, &from, &to, amount),
+			<CommonWeights<T>>::transfer_from(),
+		)
+	}
+
+	fn burn_from(
+		&self,
+		sender: T::CrossAccountId,
+		from: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResultWithPostInfo {
+		ensure!(
+			token == TokenId::default(),
+			<Error<T>>::FungibleItemsHaveNoId
+		);
+
+		with_weight(
+			<Pallet<T>>::burn_from(&self, &sender, &from, amount),
+			<CommonWeights<T>>::burn_from(),
+		)
+	}
+
+	fn set_variable_metadata(
+		&self,
+		_sender: T::CrossAccountId,
+		_token: TokenId,
+		_data: Vec<u8>,
+	) -> DispatchResultWithPostInfo {
+		fail!(<Error<T>>::FungibleItemsHaveData)
+	}
+
+	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {
+		if <Balance<T>>::get((self.id, account.as_sub())) != 0 {
+			vec![TokenId::default()]
+		} else {
+			vec![]
+		}
+	}
+
+	fn token_exists(&self, token: TokenId) -> bool {
+		token == TokenId::default()
+	}
+
+	fn last_token_id(&self) -> TokenId {
+		TokenId::default()
+	}
+
+	fn token_owner(&self, _token: TokenId) -> T::CrossAccountId {
+		T::CrossAccountId::default()
+	}
+	fn const_metadata(&self, _token: TokenId) -> Vec<u8> {
+		Vec::new()
+	}
+	fn variable_metadata(&self, _token: TokenId) -> Vec<u8> {
+		Vec::new()
+	}
+
+	fn collection_tokens(&self) -> u32 {
+		1
+	}
+
+	fn account_balance(&self, account: T::CrossAccountId) -> u32 {
+		if <Balance<T>>::get((self.id, account.as_sub())) != 0 {
+			1
+		} else {
+			0
+		}
+	}
+
+	fn balance(&self, account: T::CrossAccountId, token: TokenId) -> u128 {
+		if token != TokenId::default() {
+			return 0;
+		}
+		<Balance<T>>::get((self.id, account.as_sub()))
+	}
+
+	fn allowance(
+		&self,
+		sender: T::CrossAccountId,
+		spender: T::CrossAccountId,
+		token: TokenId,
+	) -> u128 {
+		if token != TokenId::default() {
+			return 0;
+		}
+		<Allowance<T>>::get((self.id, sender.as_sub(), spender.as_sub()))
+	}
+}

--- /dev/null
+++ b/pallets/fungible/src/erc.rs
@@ -0,0 +1,124 @@
+use core::char::{REPLACEMENT_CHARACTER, decode_utf16};
+use core::convert::TryInto;
+use evm_coder::{ToLog, execution::*, generate_stubgen, solidity_interface, types::*};
+use nft_data_structs::CollectionMode;
+use pallet_common::erc::CommonEvmHandler;
+use sp_core::{H160, U256};
+use sp_std::vec::Vec;
+use pallet_common::account::CrossAccountId;
+use pallet_common::erc::PrecompileOutput;
+use pallet_evm_coder_substrate::{call_internal, dispatch_to_evm};
+
+use crate::{Allowance, Balance, Config, FungibleHandle, Pallet, TotalSupply};
+
+#[derive(ToLog)]
+pub enum ERC20Events {
+	Transfer {
+		#[indexed]
+		from: address,
+		#[indexed]
+		to: address,
+		value: uint256,
+	},
+	Approval {
+		#[indexed]
+		owner: address,
+		#[indexed]
+		spender: address,
+		value: uint256,
+	},
+}
+
+#[solidity_interface(name = "ERC20", events(ERC20Events))]
+impl<T: Config> FungibleHandle<T> {
+	fn name(&self) -> Result<string> {
+		Ok(decode_utf16(self.name.iter().copied())
+			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
+			.collect::<string>())
+	}
+	fn symbol(&self) -> Result<string> {
+		Ok(string::from_utf8_lossy(&self.token_prefix).into())
+	}
+	fn total_supply(&self) -> Result<uint256> {
+		Ok(<TotalSupply<T>>::get(self.id).into())
+	}
+
+	fn decimals(&self) -> Result<uint8> {
+		Ok(if let CollectionMode::Fungible(decimals) = &self.mode {
+			*decimals
+		} else {
+			unreachable!()
+		})
+	}
+	fn balance_of(&self, owner: address) -> Result<uint256> {
+		let owner = T::CrossAccountId::from_eth(owner);
+		let balance = <Balance<T>>::get((self.id, owner.as_sub()));
+		Ok(balance.into())
+	}
+	fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {
+		let caller = T::CrossAccountId::from_eth(caller);
+		let to = T::CrossAccountId::from_eth(to);
+		let amount = amount.try_into().map_err(|_| "amount overflow")?;
+
+		<Pallet<T>>::transfer(self, &caller, &to, amount).map_err(|_| "transfer error")?;
+		Ok(true)
+	}
+	fn transfer_from(
+		&mut self,
+		caller: caller,
+		from: address,
+		to: address,
+		amount: uint256,
+	) -> Result<bool> {
+		let caller = T::CrossAccountId::from_eth(caller);
+		let from = T::CrossAccountId::from_eth(from);
+		let to = T::CrossAccountId::from_eth(to);
+		let amount = amount.try_into().map_err(|_| "amount overflow")?;
+
+		<Pallet<T>>::transfer_from(self, &caller, &from, &to, amount)
+			.map_err(dispatch_to_evm::<T>)?;
+		Ok(true)
+	}
+	fn approve(&mut self, caller: caller, spender: address, amount: uint256) -> Result<bool> {
+		let caller = T::CrossAccountId::from_eth(caller);
+		let spender = T::CrossAccountId::from_eth(spender);
+		let amount = amount.try_into().map_err(|_| "amount overflow")?;
+
+		<Pallet<T>>::set_allowance(self, &caller, &spender, amount)
+			.map_err(dispatch_to_evm::<T>)?;
+		Ok(true)
+	}
+	fn allowance(&self, owner: address, spender: address) -> Result<uint256> {
+		let owner = T::CrossAccountId::from_eth(owner);
+		let spender = T::CrossAccountId::from_eth(spender);
+
+		Ok(<Allowance<T>>::get((self.id, owner.as_sub(), spender.as_sub())).into())
+	}
+}
+
+#[solidity_interface(name = "ERC20UniqueExtensions")]
+impl<T: Config> FungibleHandle<T> {
+	fn burn_from(&mut self, caller: caller, from: address, amount: uint256) -> Result<bool> {
+		let caller = T::CrossAccountId::from_eth(caller);
+		let from = T::CrossAccountId::from_eth(from);
+		let amount = amount.try_into().map_err(|_| "amount overflow")?;
+
+		<Pallet<T>>::burn_from(self, &caller, &from, amount).map_err(dispatch_to_evm::<T>)?;
+		Ok(true)
+	}
+}
+
+#[solidity_interface(name = "UniqueFungible", is(ERC20))]
+impl<T: Config> FungibleHandle<T> {}
+
+generate_stubgen!(gen_impl, UniqueFungibleCall, true);
+generate_stubgen!(gen_iface, UniqueFungibleCall, false);
+
+impl<T: Config> CommonEvmHandler for FungibleHandle<T> {
+	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueFungible.raw");
+
+	fn call(mut self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileOutput> {
+		let result = call_internal::<UniqueFungibleCall, _>(*source, &mut self, value, input);
+		self.0.recorder.evm_to_precompile_output(result)
+	}
+}

--- /dev/null
+++ b/pallets/fungible/src/lib.rs
@@ -0,0 +1,399 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use core::ops::Deref;
+use frame_support::{ensure};
+use nft_data_structs::{AccessMode, Collection, CollectionId, TokenId};
+use pallet_common::{
+	Error as CommonError, Event as CommonEvent, Pallet as PalletCommon, account::CrossAccountId,
+};
+use sp_core::H160;
+use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};
+use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};
+
+pub use pallet::*;
+
+use crate::erc::ERC20Events;
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking;
+pub mod common;
+pub mod erc;
+pub mod weights;
+
+pub type CreateItemData<T> = (<T as pallet_common::Config>::CrossAccountId, u128);
+pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::{Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key};
+	use nft_data_structs::CollectionId;
+	use super::weights::WeightInfo;
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Not Fungible item data used to mint in Fungible collection.
+		NotFungibleDataUsedToMintFungibleCollectionToken,
+		/// Not default id passed as TokenId argument
+		FungibleItemsHaveNoId,
+		/// Tried to set data for fungible item
+		FungibleItemsHaveData,
+	}
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config + pallet_common::Config {
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	pub(super) type TotalSupply<T: Config> =
+		StorageMap<Hasher = Twox64Concat, Key = CollectionId, Value = u128, QueryKind = ValueQuery>;
+
+	#[pallet::storage]
+	pub(super) type Balance<T: Config> = StorageNMap<
+		Key = (
+			Key<Twox64Concat, CollectionId>,
+			Key<Blake2_128Concat, T::AccountId>,
+		),
+		Value = u128,
+		QueryKind = ValueQuery,
+	>;
+
+	#[pallet::storage]
+	pub(super) type Allowance<T: Config> = StorageNMap<
+		Key = (
+			Key<Twox64Concat, CollectionId>,
+			Key<Blake2_128, T::AccountId>,
+			Key<Blake2_128Concat, T::AccountId>,
+		),
+		Value = u128,
+		QueryKind = ValueQuery,
+	>;
+}
+
+pub struct FungibleHandle<T: Config>(pallet_common::CollectionHandle<T>);
+impl<T: Config> FungibleHandle<T> {
+	pub fn cast(inner: pallet_common::CollectionHandle<T>) -> Self {
+		Self(inner)
+	}
+	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {
+		self.0
+	}
+}
+impl<T: Config> Deref for FungibleHandle<T> {
+	type Target = pallet_common::CollectionHandle<T>;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {
+		PalletCommon::init_collection(data)
+	}
+	pub fn destroy_collection(
+		collection: FungibleHandle<T>,
+		sender: &T::CrossAccountId,
+	) -> DispatchResult {
+		let id = collection.id;
+
+		// =========
+
+		PalletCommon::destroy_collection(collection.0, sender)?;
+
+		<TotalSupply<T>>::remove(id);
+		<Balance<T>>::remove_prefix((id,), None);
+		<Allowance<T>>::remove_prefix((id,), None);
+		Ok(())
+	}
+
+	pub fn burn(
+		collection: &FungibleHandle<T>,
+		owner: &T::CrossAccountId,
+		amount: u128,
+	) -> DispatchResult {
+		let total_supply = <TotalSupply<T>>::get(collection.id)
+			.checked_sub(amount)
+			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
+
+		let balance = <Balance<T>>::get((collection.id, owner.as_sub()))
+			.checked_sub(amount)
+			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
+
+		if collection.access == AccessMode::WhiteList {
+			collection.check_allowlist(owner)?;
+		}
+
+		// =========
+
+		if balance == 0 {
+			<Balance<T>>::remove((collection.id, owner.as_sub()));
+		} else {
+			<Balance<T>>::insert((collection.id, owner.as_sub()), balance);
+		}
+		<TotalSupply<T>>::insert(collection.id, total_supply);
+
+		collection.log_infallible(ERC20Events::Transfer {
+			from: *owner.as_eth(),
+			to: H160::default(),
+			value: amount.into(),
+		});
+		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(
+			collection.id,
+			TokenId::default(),
+			owner.clone(),
+			amount,
+		));
+		Ok(())
+	}
+
+	pub fn transfer(
+		collection: &FungibleHandle<T>,
+		from: &T::CrossAccountId,
+		to: &T::CrossAccountId,
+		amount: u128,
+	) -> DispatchResult {
+		ensure!(
+			collection.transfers_enabled,
+			<CommonError<T>>::TransferNotAllowed
+		);
+
+		if collection.access == AccessMode::WhiteList {
+			collection.check_allowlist(from)?;
+			collection.check_allowlist(to)?;
+		}
+		<PalletCommon<T>>::ensure_correct_receiver(to)?;
+
+		let balance_from = <Balance<T>>::get((collection.id, from.as_sub()))
+			.checked_sub(amount)
+			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
+		let balance_to = if from != to {
+			Some(
+				<Balance<T>>::get((collection.id, to.as_sub()))
+					.checked_add(amount)
+					.ok_or(ArithmeticError::Overflow)?,
+			)
+		} else {
+			None
+		};
+
+		collection.consume_sstore()?;
+		collection.consume_sstore()?;
+		collection.consume_log(2, 32)?;
+		collection.consume_sstore()?;
+
+		// =========
+
+		if let Some(balance_to) = balance_to {
+			// from != to
+			if balance_from == 0 {
+				<Balance<T>>::remove((collection.id, from.as_sub()));
+			} else {
+				<Balance<T>>::insert((collection.id, from.as_sub()), balance_from);
+			}
+			<Balance<T>>::insert((collection.id, to.as_sub()), balance_to);
+		}
+
+		collection.log_infallible(ERC20Events::Transfer {
+			from: *from.as_eth(),
+			to: *to.as_eth(),
+			value: amount.into(),
+		});
+		<PalletCommon<T>>::deposit_event(CommonEvent::Transfer(
+			collection.id,
+			TokenId::default(),
+			from.clone(),
+			to.clone(),
+			amount,
+		));
+		Ok(())
+	}
+
+	pub fn create_multiple_items(
+		collection: &FungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		data: Vec<CreateItemData<T>>,
+	) -> DispatchResult {
+		let unrestricted_minting = collection.is_owner_or_admin(sender)?;
+		if !unrestricted_minting {
+			ensure!(
+				collection.mint_mode,
+				<CommonError<T>>::PublicMintingNotAllowed
+			);
+			collection.check_allowlist(sender)?;
+
+			for (owner, _) in data.iter() {
+				collection.check_allowlist(owner)?;
+			}
+		}
+
+		let mut balances = BTreeMap::new();
+
+		let total_supply = data
+			.iter()
+			.map(|u| u.1)
+			.try_fold(0u128, |acc, v| acc.checked_add(v))
+			.ok_or(ArithmeticError::Overflow)?;
+
+		for (user, amount) in data.into_iter() {
+			collection.consume_sload()?;
+			let balance = balances
+				.entry(user.clone())
+				.or_insert_with(|| <Balance<T>>::get((collection.id, user.as_sub())));
+			*balance = (*balance)
+				.checked_add(amount)
+				.ok_or(ArithmeticError::Overflow)?;
+		}
+
+		collection.consume_sstore()?;
+		for _ in &balances {
+			collection.consume_sstore()?;
+			collection.consume_log(2, 32)?;
+			collection.consume_sstore()?;
+		}
+
+		// =========
+
+		<TotalSupply<T>>::insert(collection.id, total_supply);
+		for (user, amount) in balances {
+			<Balance<T>>::insert((collection.id, user.as_sub()), amount);
+
+			collection.log_infallible(ERC20Events::Transfer {
+				from: H160::default(),
+				to: *user.as_eth(),
+				value: amount.into(),
+			});
+			<PalletCommon<T>>::deposit_event(CommonEvent::ItemCreated(
+				collection.id,
+				TokenId::default(),
+				user.clone(),
+				amount,
+			));
+		}
+
+		Ok(())
+	}
+
+	fn set_allowance_unchecked(
+		collection: &FungibleHandle<T>,
+		owner: &T::CrossAccountId,
+		spender: &T::CrossAccountId,
+		amount: u128,
+	) {
+		<Allowance<T>>::insert((collection.id, owner.as_sub(), spender.as_sub()), amount);
+
+		collection.log_infallible(ERC20Events::Approval {
+			owner: *owner.as_eth(),
+			spender: *spender.as_eth(),
+			value: amount.into(),
+		});
+		<PalletCommon<T>>::deposit_event(CommonEvent::Approved(
+			collection.id,
+			TokenId(0),
+			owner.clone(),
+			spender.clone(),
+			amount,
+		));
+	}
+
+	pub fn set_allowance(
+		collection: &FungibleHandle<T>,
+		owner: &T::CrossAccountId,
+		spender: &T::CrossAccountId,
+		amount: u128,
+	) -> DispatchResult {
+		if collection.access == AccessMode::WhiteList {
+			collection.check_allowlist(&owner)?;
+			collection.check_allowlist(&spender)?;
+		}
+
+		if <Balance<T>>::get((collection.id, owner.as_sub())) < amount {
+			ensure!(
+				collection.ignores_owned_amount(owner)?,
+				<CommonError<T>>::CantApproveMoreThanOwned
+			);
+		}
+
+		// =========
+
+		Self::set_allowance_unchecked(collection, owner, spender, amount);
+		Ok(())
+	}
+
+	pub fn transfer_from(
+		collection: &FungibleHandle<T>,
+		spender: &T::CrossAccountId,
+		from: &T::CrossAccountId,
+		to: &T::CrossAccountId,
+		amount: u128,
+	) -> DispatchResult {
+		if spender == from {
+			return Self::transfer(collection, from, to, amount);
+		}
+		if collection.access == AccessMode::WhiteList {
+			// `from`, `to` checked in [`transfer`]
+			collection.check_allowlist(spender)?;
+		}
+
+		let allowance = <Allowance<T>>::get((collection.id, from.as_sub(), spender.as_sub()))
+			.checked_sub(amount);
+		if allowance.is_none() {
+			ensure!(
+				collection.ignores_allowance(spender)?,
+				<CommonError<T>>::TokenValueNotEnough
+			);
+		}
+
+		// =========
+
+		Self::transfer(collection, from, to, amount)?;
+		if let Some(allowance) = allowance {
+			Self::set_allowance_unchecked(collection, from, spender, allowance);
+		}
+		Ok(())
+	}
+
+	pub fn burn_from(
+		collection: &FungibleHandle<T>,
+		spender: &T::CrossAccountId,
+		from: &T::CrossAccountId,
+		amount: u128,
+	) -> DispatchResult {
+		if spender == from {
+			return Self::burn(collection, from, amount);
+		}
+		if collection.access == AccessMode::WhiteList {
+			// `from` checked in [`burn`]
+			collection.check_allowlist(spender)?;
+		}
+
+		let allowance = <Allowance<T>>::get((collection.id, from.as_sub(), spender.as_sub()))
+			.checked_sub(amount);
+		if allowance.is_none() {
+			ensure!(
+				collection.ignores_allowance(spender)?,
+				<CommonError<T>>::TokenValueNotEnough
+			);
+		}
+
+		// =========
+
+		Self::burn(collection, from, amount)?;
+		if let Some(allowance) = allowance {
+			Self::set_allowance_unchecked(collection, from, spender, allowance);
+		}
+		Ok(())
+	}
+
+	/// Delegated to `create_multiple_items`
+	pub fn create_item(
+		collection: &FungibleHandle<T>,
+		sender: &T::CrossAccountId,
+		data: CreateItemData<T>,
+	) -> DispatchResult {
+		Self::create_multiple_items(collection, sender, vec![data])
+	}
+}

binary blob — no preview

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

--- /dev/null
+++ b/pallets/fungible/src/weights.rs
@@ -0,0 +1,116 @@
+// Template adopted from https://github.com/paritytech/substrate/blob/master/.maintain/frame-weight-template.hbs
+
+//! Autogenerated weights for pallet_fungible
+//!
+//! 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:
+// target/release/nft
+// benchmark
+// --pallet
+// pallet-fungible
+// --wasm-execution
+// compiled
+// --extrinsic
+// *
+// --template
+// .maintain/frame-weight-template.hbs
+// --steps=50
+// --repeat=20
+// --output=./pallets/fungible/src/weights.rs
+
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_fungible.
+pub trait WeightInfo {
+	fn create_item() -> Weight;
+	fn burn_item() -> Weight;
+	fn transfer() -> Weight;
+	fn approve() -> Weight;
+	fn transfer_from() -> Weight;
+}
+
+/// Weights for pallet_fungible using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	// Storage: Fungible Balance (r:1 w:1)
+	// Storage: Fungible TotalSupply (r:0 w:1)
+	fn create_item() -> Weight {
+		(12_069_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Fungible TotalSupply (r:1 w:1)
+	// Storage: Fungible Balance (r:1 w:1)
+	fn burn_item() -> Weight {
+		(14_096_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Fungible Balance (r:2 w:2)
+	fn transfer() -> Weight {
+		(15_436_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Fungible Balance (r:1 w:0)
+	// Storage: Fungible Allowance (r:0 w:1)
+	fn approve() -> Weight {
+		(12_867_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Fungible Allowance (r:1 w:1)
+	// Storage: Fungible Balance (r:2 w:2)
+	fn transfer_from() -> Weight {
+		(21_462_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(3 as Weight))
+			.saturating_add(T::DbWeight::get().writes(3 as Weight))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	// Storage: Fungible Balance (r:1 w:1)
+	// Storage: Fungible TotalSupply (r:0 w:1)
+	fn create_item() -> Weight {
+		(12_069_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Fungible TotalSupply (r:1 w:1)
+	// Storage: Fungible Balance (r:1 w:1)
+	fn burn_item() -> Weight {
+		(14_096_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Fungible Balance (r:2 w:2)
+	fn transfer() -> Weight {
+		(15_436_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+	// Storage: Fungible Balance (r:1 w:0)
+	// Storage: Fungible Allowance (r:0 w:1)
+	fn approve() -> Weight {
+		(12_867_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Fungible Allowance (r:1 w:1)
+	// Storage: Fungible Balance (r:2 w:2)
+	fn transfer_from() -> Weight {
+		(21_462_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(3 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
+	}
+}

--- /dev/null
+++ b/pallets/nft/src/common.rs
@@ -0,0 +1,52 @@
+use core::marker::PhantomData;
+use frame_support::{weights::Weight};
+use pallet_common::{CommonWeightInfo};
+
+use pallet_fungible::{common::CommonWeights as FungibleWeights};
+use pallet_nonfungible::{common::CommonWeights as NonfungibleWeights};
+use pallet_refungible::{common::CommonWeights as RefungibleWeights};
+
+use crate::{Config, dispatch::dispatch_weight};
+
+macro_rules! max_weight_of {
+	($method:ident ( $($args:tt)* )) => {
+		<FungibleWeights<T>>::$method($($args)*)
+		.max(<NonfungibleWeights<T>>::$method($($args)*))
+		.max(<RefungibleWeights<T>>::$method($($args)*))
+	};
+}
+
+pub struct CommonWeights<T: Config>(PhantomData<T>);
+impl<T: Config> CommonWeightInfo for CommonWeights<T> {
+	fn create_item() -> nft_data_structs::Weight {
+		dispatch_weight::<T>() + max_weight_of!(create_item())
+	}
+
+	fn create_multiple_items(amount: u32) -> Weight {
+		dispatch_weight::<T>() + max_weight_of!(create_multiple_items(amount))
+	}
+
+	fn burn_item() -> Weight {
+		dispatch_weight::<T>() + max_weight_of!(burn_item())
+	}
+
+	fn transfer() -> nft_data_structs::Weight {
+		dispatch_weight::<T>() + max_weight_of!(transfer())
+	}
+
+	fn approve() -> nft_data_structs::Weight {
+		dispatch_weight::<T>() + max_weight_of!(approve())
+	}
+
+	fn transfer_from() -> nft_data_structs::Weight {
+		dispatch_weight::<T>() + max_weight_of!(transfer_from())
+	}
+
+	fn set_variable_metadata(bytes: u32) -> nft_data_structs::Weight {
+		dispatch_weight::<T>() + max_weight_of!(set_variable_metadata(bytes))
+	}
+
+	fn burn_from() -> Weight {
+		dispatch_weight::<T>() + max_weight_of!(burn_from())
+	}
+}

--- /dev/null
+++ b/pallets/nft/src/dispatch.rs
@@ -0,0 +1,92 @@
+use frame_support::{
+	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo},
+	traits::Get,
+	weights::Weight,
+};
+use nft_data_structs::{CollectionId, CollectionMode, Pays, PostDispatchInfo};
+use pallet_common::{CollectionHandle, CommonCollectionOperations};
+use pallet_fungible::FungibleHandle;
+use pallet_nonfungible::NonfungibleHandle;
+use pallet_refungible::RefungibleHandle;
+
+use crate::Config;
+
+// TODO: move to benchmarking
+/// Price of [`dispatch_call`] call with noop `call` argument
+pub fn dispatch_weight<T: Config>() -> Weight {
+	// Read collection
+	<T as frame_system::Config>::DbWeight::get().reads(1)
+	// Dynamic dispatch?
+	+ 6_000_000
+	// submit_logs is measured as part of collection pallets
+}
+
+pub enum Dispatched<T: Config> {
+	Fungible(FungibleHandle<T>),
+	Nonfungible(NonfungibleHandle<T>),
+	Refungible(RefungibleHandle<T>),
+}
+impl<T: Config> Dispatched<T> {
+	pub fn dispatch(handle: CollectionHandle<T>) -> Self {
+		match handle.mode {
+			CollectionMode::Fungible(_) => Self::Fungible(FungibleHandle::cast(handle)),
+			CollectionMode::NFT => Self::Nonfungible(NonfungibleHandle::cast(handle)),
+			CollectionMode::ReFungible => Self::Refungible(RefungibleHandle::cast(handle)),
+		}
+	}
+	fn into_inner(self) -> CollectionHandle<T> {
+		match self {
+			Dispatched::Fungible(f) => f.into_inner(),
+			Dispatched::Nonfungible(f) => f.into_inner(),
+			Dispatched::Refungible(f) => f.into_inner(),
+		}
+	}
+	pub fn as_dyn(&self) -> &dyn CommonCollectionOperations<T> {
+		match self {
+			Dispatched::Fungible(h) => h,
+			Dispatched::Nonfungible(h) => h,
+			Dispatched::Refungible(h) => h,
+		}
+	}
+}
+
+/// Helper function to implement substrate calls for common collection methods
+pub fn dispatch_call<
+	T: Config,
+	C: FnOnce(&dyn pallet_common::CommonCollectionOperations<T>) -> DispatchResultWithPostInfo,
+>(
+	collection: CollectionId,
+	call: C,
+) -> DispatchResultWithPostInfo {
+	let handle =
+		CollectionHandle::try_get(collection).map_err(|error| DispatchErrorWithPostInfo {
+			post_info: PostDispatchInfo {
+				actual_weight: Some(dispatch_weight::<T>()),
+				pays_fee: Pays::Yes,
+			},
+			error,
+		})?;
+	let dispatched = Dispatched::dispatch(handle);
+	let mut result = call(dispatched.as_dyn());
+	match &mut result {
+		Ok(PostDispatchInfo {
+			actual_weight: Some(weight),
+			..
+		})
+		| Err(DispatchErrorWithPostInfo {
+			post_info: PostDispatchInfo {
+				actual_weight: Some(weight),
+				..
+			},
+			..
+		}) => *weight += dispatch_weight::<T>(),
+		_ => {}
+	}
+
+	// TODO: Make submit_logs infallible, but it shouldn't fail here anyway
+	dispatched
+		.into_inner()
+		.submit_logs()
+		.expect("should succeed");
+	result
+}