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

--- 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.lock
+++ b/Cargo.lock
@@ -4925,7 +4925,7 @@
 
 [[package]]
 name = "nft"
-version = "3.0.0"
+version = "0.9.12"
 dependencies = [
  "cumulus-client-cli",
  "cumulus-client-collator",
@@ -5059,7 +5059,7 @@
 
 [[package]]
 name = "nft-runtime"
-version = "3.0.0"
+version = "0.9.12"
 dependencies = [
  "cumulus-pallet-aura-ext",
  "cumulus-pallet-dmp-queue",
@@ -5090,10 +5090,10 @@
  "pallet-evm-transaction-payment",
  "pallet-inflation",
  "pallet-nft",
- "pallet-nft-charge-transaction",
  "pallet-nft-transaction-payment",
  "pallet-randomness-collective-flip",
  "pallet-sudo",
+ "pallet-template-charge-transaction",
  "pallet-timestamp",
  "pallet-transaction-payment",
  "pallet-transaction-payment-rpc-runtime-api",
@@ -6010,25 +6010,6 @@
  "sp-runtime",
  "sp-std",
  "up-sponsorship",
-]
-
-[[package]]
-name = "pallet-nft-charge-transaction"
-version = "3.0.0"
-dependencies = [
- "frame-benchmarking",
- "frame-support",
- "frame-system",
- "pallet-balances",
- "pallet-nft-transaction-payment",
- "pallet-transaction-payment",
- "parity-scale-codec",
- "scale-info",
- "serde",
- "sp-core",
- "sp-io",
- "sp-runtime",
- "sp-std",
 ]
 
 [[package]]
@@ -6271,6 +6252,26 @@
 ]
 
 [[package]]
+name = "pallet-template-charge-transaction"
+version = "3.0.0"
+source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#e5d3354ab68face1b2ef709dc7f629803f56598d"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-transaction-payment",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "up-sponsorship",
+]
+
+[[package]]
 name = "pallet-timestamp"
 version = "4.0.0-dev"
 source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.12#d76f39995315ec36980908e4b99709bd14927044"
@@ -11597,7 +11598,7 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f559b464de2e2bdabcac6a210d12e9b5a5973c251e102c44c585c71d51bd78e"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if 0.1.10",
  "rand 0.8.4",
  "static_assertions",
 ]
@@ -11717,6 +11718,7 @@
 [[package]]
 name = "up-sponsorship"
 version = "0.1.0"
+source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#e5d3354ab68face1b2ef709dc7f629803f56598d"
 dependencies = [
  "impl-trait-for-tuples 0.2.1",
 ]

--- 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/docker-compose-tests-parachain.yml
+++ b/docker-compose-tests-parachain.yml
@@ -2,12 +2,6 @@
 
 services:
   blockchain_nodes:
-    image: blockchain_nodes
-    container_name: blockchain_nodes
-    ports:
-      - 9944:9944
-      - 9844:9844
-      - 9933:9933
     build:
       context: ./
       dockerfile: Dockerfile-parachain
@@ -17,18 +11,11 @@
         - POLKA_VERSION=${POLKA_VERSION:?err}
         - NFT_BRANCH=${NFT_BRANCH:?err}
     volumes:
-#      - ./chain-data:/chain-data
       - ./launch-config.json:/polkadot-launch/launch-config.json
     env_file:
       - ./.env
-    networks:
-      - node_test_network
-    #command: bash -c "yarn --cwd polkadot-launch start"
-    #command: bash -c 'while true; do sleep 60; df -h; done'
 
   integration_tests:
-    container_name: integration_tests
-    image: integration_tests
     build:
       context: tests/
       dockerfile: Dockerfile-tests
@@ -37,25 +24,5 @@
     volumes:
       - ./tests/src/config_docker.ts:/nft_parachain/src/config.ts
       - /home/ubuntu/mochawesome-report:/nft_parachain/mochawesome-report
-#    command: bash -c 'while true; do sleep 20; df -h; done'
-    networks:
-      - node_test_network
     depends_on:
       - blockchain_nodes
-
-#  unit_tests:
-#    container_name: unit_test
-#    image: nft_unit_test
-#    build:
-#      context: ./
-#      dockerfile: Dockerfile-unit
-#    container_name: unit_test
-#    networks:
-#      - node_test_network
-   # command: bash -c 'while true; do sleep 20; df -h; done'
-#    command: bash -c 'cargo test'
-
-networks:
-  node_test_network:
-    name: node_test_network
-    driver: bridge

--- a/node/cli/Cargo.toml
+++ b/node/cli/Cargo.toml
@@ -233,7 +233,7 @@
 
 [dependencies.nft-runtime]
 path = '../../runtime'
-version = '3.0.0'
+version = '0.9.12'
 
 [dependencies.nft-data-structs]
 path = "../../primitives/nft"
@@ -251,7 +251,7 @@
 license = 'All Rights Reserved'
 name = 'nft'
 repository = 'https://github.com/usetech-llc/nft_private/'
-version = '3.0.0'
+version = '0.9.12'
 
 [[bin]]
 name = 'nft'

--- 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/contract-helpers/Cargo.toml
+++ b/pallets/contract-helpers/Cargo.toml
@@ -9,11 +9,6 @@
 package = 'parity-scale-codec'
 version = '2.3.0'
 
-[dependencies.up-sponsorship]
-default-features = false
-path = '../../primitives/sponsorship'
-version = '0.1.0'
-
 [dependencies]
 scale-info = { version = "1.0.0", default-features = false, features = ["derive"] }
 frame-support = { default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
@@ -21,6 +16,7 @@
 pallet-contracts = { 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' }
+up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring" } 
 
 [features]
 default = ["std"]

--- 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();

--- a/pallets/evm-contract-helpers/Cargo.toml
+++ b/pallets/evm-contract-helpers/Cargo.toml
@@ -13,7 +13,7 @@
 evm-coder = { default-features = false, path = '../../crates/evm-coder' }
 pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }
 pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }
-up-sponsorship = { default-features = false, path = '../../primitives/sponsorship' }
+up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring" } 
 log = "0.4.14"
 
 [dependencies.codec]

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/evm-transaction-payment/Cargo.toml
+++ b/pallets/evm-transaction-payment/Cargo.toml
@@ -14,7 +14,7 @@
 pallet-evm = { 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" }
 pallet-ethereum = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }
-up-sponsorship = { default-features = false, path = '../../primitives/sponsorship' }
+up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring" } 
 
 [dependencies.codec]
 default-features = false

--- 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-transaction-payment/Cargo.toml
+++ b/pallets/nft-transaction-payment/Cargo.toml
@@ -30,7 +30,7 @@
 sp-io = { 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' }
 
-up-sponsorship = { default-features = false, path = "../../primitives/sponsorship", version = "0.1.0" }
+up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring" } 
 
 [features]
 default = ['std']

--- 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',
@@ -121,19 +125,17 @@
 default-features = false
 path = '../../primitives/nft'
 version = '0.9.0'
-
-[dependencies.up-sponsorship]
-default-features = false
-path = '../../primitives/sponsorship'
-version = '0.1.0'
-
 
 [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" }
 
+up-sponsorship = { version = "0.1.0", default-features = false, git = "https://github.com/UniqueNetwork/pallet-sponsoring" } 
+
 evm-coder = { default-features = false, path = "../../crates/evm-coder" }
 pallet-evm-coder-substrate = { default-features = false, path = "../../pallets/evm-coder-substrate" }
 primitive-types = { version = "0.10.1", default-features = false, features = [
@@ -144,3 +146,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;

16pub use serde::{Serialize, Deserialize};16pub use serde::{Serialize, Deserialize};
1717
18pub use frame_support::{18pub use frame_support::{
19	construct_runtime, decl_event, decl_module, decl_storage, decl_error,19	construct_runtime, decl_module, decl_storage, decl_error,
20	dispatch::DispatchResult,20	dispatch::DispatchResult,
21	ensure, fail, parameter_types,21	ensure, fail, parameter_types,
22	traits::{22	traits::{
23		Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23		ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced, Randomness,
24		Randomness, IsSubType, WithdrawReasons,24		IsSubType, WithdrawReasons,
25	},25	},
26	weights::{26	weights::{
27		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},
28		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,
29		WeightToFeePolynomial, DispatchClass,29		WeightToFeePolynomial, DispatchClass,
30	},30	},
31	StorageValue, transactional,31	StorageValue, transactional,
32	pallet_prelude::DispatchResultWithPostInfo,
32};33};
33use scale_info::TypeInfo;34use scale_info::TypeInfo;
34use frame_system::{self as system, ensure_signed};35use frame_system::{self as system, ensure_signed};
35use sp_core::H160;36use sp_runtime::{sp_std::prelude::Vec};
36use sp_std::vec;
37use sp_runtime::{DispatchError, sp_std::prelude::Vec};
38use core::ops::{Deref, DerefMut};
39use nft_data_structs::{37use nft_data_structs::{
40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,38	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, CUSTOM_DATA_LIMIT,
41	CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
42	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,39	VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,
43	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,40	OFFCHAIN_SCHEMA_LIMIT, AccessMode, Collection, CreateItemData, CollectionLimits, CollectionId,
44	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,
45	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,41	CollectionMode, TokenId, SchemaVersion, SponsorshipState, MetaUpdatePermission,
46	MetaUpdatePermission, FungibleItemType, ReFungibleItemType,
47};42};
43use pallet_common::{
44	account::CrossAccountId, CollectionHandle, IsAdmin, Pallet as PalletCommon,
45	Error as CommonError, CommonWeightInfo, Allowlist,
46};
47use pallet_refungible::{Pallet as PalletRefungible, RefungibleHandle};
48use pallet_fungible::{Pallet as PalletFungible, FungibleHandle};
49use pallet_nonfungible::{Pallet as PalletNonfungible, NonfungibleHandle};
4850
49#[cfg(test)]51#[cfg(test)]
50mod mock;52mod mock;
58pub use eth::sponsoring::NftEthSponsorshipHandler;60pub use eth::sponsoring::NftEthSponsorshipHandler;
5961
60pub use eth::NftErcSupport;62pub use eth::NftErcSupport;
61pub use eth::account::*;
62use eth::erc::{ERC20Events, ERC721Events};
6363
64pub mod common;
65use common::CommonWeights;
66pub mod dispatch;
67use dispatch::dispatch_call;
68
64#[cfg(feature = "runtime-benchmarks")]69#[cfg(feature = "runtime-benchmarks")]
65mod benchmarking;70mod benchmarking;
66pub mod weights;71pub mod weights;
69decl_error! {74decl_error! {
70	/// Error for non-fungible-token module.75	/// Error for non-fungible-token module.
71	pub enum Error for Module<T: Config> {76	pub enum Error for Module<T: Config> {
72		/// Total collections bound exceeded.
73		TotalCollectionsLimitExceeded,
74		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.77		/// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.
75		CollectionDecimalPointLimitExceeded,78		CollectionDecimalPointLimitExceeded,
76		/// Collection name can not be longer than 63 char.
77		CollectionNameLimitExceeded,
78		/// Collection description can not be longer than 255 char.
79		CollectionDescriptionLimitExceeded,
80		/// Token prefix can not be longer than 15 char.
81		CollectionTokenPrefixLimitExceeded,
82		/// This collection does not exist.
83		CollectionNotFound,
84		/// Item not exists.
85		TokenNotFound,
86		/// Admin not found
87		AdminNotFound,
88		/// Arithmetic calculation overflow.
89		NumOverflow,
90		/// Account already has admin role.
91		AlreadyAdmin,
92		/// You do not own this collection.
93		NoPermission,
94		/// This address is not set as sponsor, use setCollectionSponsor first.79		/// This address is not set as sponsor, use setCollectionSponsor first.
95		ConfirmUnsetSponsorFail,80		ConfirmUnsetSponsorFail,
96		/// Collection is not in mint mode.
97		PublicMintingNotAllowed,
98		/// Sender parameter and item owner must be equal.
99		MustBeTokenOwner,
100		/// Item balance not enough.
101		TokenValueTooLow,
102		/// Size of item is too large.
103		NftSizeLimitExceeded,
104		/// No approve found
105		ApproveNotFound,
106		/// Requested value more than approved.
107		TokenValueNotEnough,
108		/// Only approved addresses can call this method.
109		ApproveRequired,
110		/// Address is not in white list.
111		AddresNotInWhiteList,
112		/// Number of collection admins bound exceeded.
113		CollectionAdminsLimitExceeded,
114		/// Owned tokens by a single address bound exceeded.
115		AddressOwnershipLimitExceeded,
116		/// Length of items properties must be greater than 0.81		/// Length of items properties must be greater than 0.
117		EmptyArgument,82		EmptyArgument,
118		/// const_data exceeded data limit.
119		TokenConstDataLimitExceeded,
120		/// variable_data exceeded data limit.
121		TokenVariableDataLimitExceeded,
122		/// Not NFT item data used to mint in NFT collection.
123		NotNftDataUsedToMintNftCollectionToken,
124		/// Not Fungible item data used to mint in Fungible collection.
125		NotFungibleDataUsedToMintFungibleCollectionToken,
126		/// Not Re Fungible item data used to mint in Re Fungible collection.
127		NotReFungibleDataUsedToMintReFungibleCollectionToken,
128		/// Unexpected collection type.
129		UnexpectedCollectionType,
130		/// Can't store metadata in fungible tokens.
131		CantStoreMetadataInFungibleTokens,
132		/// Collection token limit exceeded
133		CollectionTokenLimitExceeded,
134		/// Account token limit exceeded per collection
135		AccountTokenLimitExceeded,
136		/// Collection limit bounds per collection exceeded83		/// Collection limit bounds per collection exceeded
137		CollectionLimitBoundsExceeded,84		CollectionLimitBoundsExceeded,
138		/// Tried to enable permissions which are only permitted to be disabled85		/// Tried to enable permissions which are only permitted to be disabled
139		OwnerPermissionsCantBeReverted,86		OwnerPermissionsCantBeReverted,
140		/// Schema data size limit bound exceeded
141		SchemaDataLimitExceeded,
142		/// Maximum refungibility exceeded
143		WrongRefungiblePieces,
144		/// createRefungible should be called with one owner
145		BadCreateRefungibleCall,
146		/// Gas limit exceeded
147		OutOfGas,
148		/// Metadata update denied by collection settings
149		MetadataUpdateDenied,
150		/// Metadata update flag become unmutable with None option
151		MetadataFlagFrozen,
152		/// Collection settings not allowing items transferring
153		TransferNotAllowed,
154		/// Can't transfer tokens to ethereum zero address
155		AddressIsZero,
156	}87	}
157}88}
158
159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]
160pub struct CollectionHandle<T: Config> {89pub trait Config:
161	pub id: CollectionId,
162	collection: Collection<T>,90	system::Config
163	recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,
164}
165impl<T: Config> CollectionHandle<T> {
166	pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {91	+ pallet_evm_coder_substrate::Config
167		<CollectionById<T>>::get(id).map(|collection| Self {
168			id,
169			collection,
170			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(
171				eth::collection_id_to_address(id),92	+ pallet_common::Config
172				gas_limit,
173			),
174		})
175	}
176	pub fn get(id: CollectionId) -> Option<Self> {
177		Self::get_with_gas_limit(id, u64::MAX)
178	}93	+ pallet_nonfungible::Config
179	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {
180		self.recorder.log_sub(log)94	+ pallet_refungible::Config
181	}
182	#[allow(dead_code)]
183	fn consume_gas(&self, gas: u64) -> DispatchResult {
184		self.recorder.consume_gas_sub(gas)
185	}
186	fn consume_sload(&self) -> DispatchResult {
187		self.recorder.consume_sload_sub()
188	}
189	fn consume_sstore(&self) -> DispatchResult {
190		self.recorder.consume_sstore_sub()
191	}
192	pub fn submit_logs(self) -> DispatchResult {
193		self.recorder.submit_logs()
194	}
195	pub fn save(self) -> DispatchResult {
196		self.recorder.submit_logs()?;
197		<CollectionById<T>>::insert(self.id, self.collection);
198		Ok(())
199	}
200}
201impl<T: Config> Deref for CollectionHandle<T> {
202	type Target = Collection<T>;95	+ pallet_fungible::Config
203
204	fn deref(&self) -> &Self::Target {
205		&self.collection
206	}
207}
208
209impl<T: Config> DerefMut for CollectionHandle<T> {
210	fn deref_mut(&mut self) -> &mut Self::Target {96	+ Sized
211		&mut self.collection
212	}
213}
214
215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized + TypeInfo {
216	type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;97	+ TypeInfo
21798{
218	/// Weight information for extrinsics in this pallet.99	/// Weight information for extrinsics in this pallet.
219	type WeightInfo: WeightInfo;100	type WeightInfo: WeightInfo;
220
221	type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;
222	type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;
223
224	type CrossAccountId: CrossAccountId<Self::AccountId>;
225	type Currency: Currency<Self::AccountId>;
226	type CollectionCreationPrice: Get<
227		<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,
228	>;
229	type TreasuryAccountId: Get<Self::AccountId>;
230}101}
231102
232type SelfWeightOf<T> = <T as Config>::WeightInfo;103type SelfWeightOf<T> = <T as Config>::WeightInfo;
233104
234trait WeightInfoHelpers: WeightInfo {
235	fn transfer() -> Weight {
236		Self::transfer_nft()
237			.max(Self::transfer_fungible())
238			.max(Self::transfer_refungible())
239	}
240	fn transfer_from() -> Weight {
241		Self::transfer_from_nft()
242			.max(Self::transfer_from_fungible())
243			.max(Self::transfer_from_refungible())
244	}
245	fn approve() -> Weight {
246		// TODO: refungible, fungible
247		Self::approve_nft()
248	}
249	fn set_variable_meta_data(data: u32) -> Weight {
250		// TODO: refungible
251		Self::set_variable_meta_data_nft(data)
252	}
253	fn create_item(data: u32) -> Weight {
254		Self::create_item_nft(data)
255			.max(Self::create_item_fungible())
256			.max(Self::create_item_refungible(data))
257	}
258	fn create_multiple_items(amount: u32) -> Weight {
259		Self::create_multiple_items_nft(amount)
260			.max(Self::create_multiple_items_fungible(amount))
261			.max(Self::create_multiple_items_refungible(amount))
262	}
263	fn burn_item() -> Weight {
264		// TODO: refungible, fungible
265		Self::burn_item_nft()
266	}
267}
268impl<T: WeightInfo> WeightInfoHelpers for T {}
269
270// # Used definitions105// # Used definitions
271//106//
272// ## User control levels107// ## User control levels
293	trait Store for Module<T: Config> as Nft {128	trait Store for Module<T: Config> as Nft {
294129
295		//#region Private members130		//#region Private members
296		/// Id of next collection
297		CreatedCollectionCount: u32;
298		/// Used for migrations131		/// Used for migrations
299		ChainVersion: u64;132		ChainVersion: u64;
300		/// Id of last collection token
301		/// Collection id (controlled?1)
302		ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;
303		//#endregion133		//#endregion
304134
305		//#region Bound counters
306		/// Amount of collections destroyed, used for total amount tracking with
307		/// CreatedCollectionCount
308		DestroyedCollectionCount: u32;
309		//#endregion
310
311		//#region Basic collections
312		/// Collection info
313		/// Collection id (controlled?1)
314		pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;
315		/// List of collection admins
316		/// Collection id (controlled?2)
317		pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;
318		/// Whitelisted collection users
319		/// Collection id (controlled?2), user id (controlled?3)
320		pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;
321		//#endregion
322
323		/// How many of collection items user have
324		/// Collection id (controlled?2), account id (real)
325		pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;
326
327		/// Amount of items which spender can transfer out of owners account (via transferFrom)
328		/// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))
329		/// TODO: Off chain worker should remove from this map when token gets removed
330		pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;
331
332		//#region Item collections
333		/// Collection id (controlled?2), token id (controlled?1)
334		pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;
335		/// Collection id (controlled?2), owner (controlled?2)
336		pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;
337		/// Collection id (controlled?2), token id (controlled?1)
338		pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;
339		//#endregion
340
341		//#region Index list
342		/// Collection id (controlled?2), tokens owner (controlled?2)
343		pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;
344		//#endregion
345
346		//#region Tokens transfer rate limit baskets135		//#region Tokens transfer rate limit baskets
347		/// (Collection id (controlled?2), who created (real))136		/// (Collection id (controlled?2), who created (real))
348		/// TODO: Off chain worker should remove from this map when collection gets removed137		/// TODO: Off chain worker should remove from this map when collection gets removed
359		/// Collection id (controlled?2), token id (controlled?2)148		/// Collection id (controlled?2), token id (controlled?2)
360		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;149		pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;
361	}150	}
362	add_extra_genesis {
363		build(|config: &GenesisConfig<T>| {
364			// Modification of storage
365			for (_num, _c) in &config.collection_id {
366				<Module<T>>::init_collection(_c);
367			}
368
369			for (_num, _c, _i) in &config.nft_item_id {
370				<Module<T>>::init_nft_token(*_c, _i);
371			}
372
373			for (collection_id, account_id, fungible_item) in &config.fungible_item_id {
374				<Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);
375			}
376
377			for (_num, _c, _i) in &config.refungible_item_id {
378				<Module<T>>::init_refungible_token(*_c, _i);
379			}
380		})
381	}
382}151}
383152
384decl_event!(
385	pub enum Event<T>
386	where
387		AccountId = <T as frame_system::Config>::AccountId,
388		CrossAccountId = <T as Config>::CrossAccountId,
389	{
390		/// New collection was created
391		///
392		/// # Arguments
393		///
394		/// * collection_id: Globally unique identifier of newly created collection.
395		///
396		/// * mode: [CollectionMode] converted into u8.
397		///
398		/// * account_id: Collection owner.
399		CollectionCreated(CollectionId, u8, AccountId),
400
401		/// New item was created.
402		///
403		/// # Arguments
404		///
405		/// * collection_id: Id of the collection where item was created.
406		///
407		/// * item_id: Id of an item. Unique within the collection.
408		///
409		/// * recipient: Owner of newly created item
410		ItemCreated(CollectionId, TokenId, CrossAccountId),
411
412		/// Collection item was burned.
413		///
414		/// # Arguments
415		///
416		/// collection_id.
417		///
418		/// item_id: Identifier of burned NFT.
419		ItemDestroyed(CollectionId, TokenId),
420
421		/// Item was transferred
422		///
423		/// * collection_id: Id of collection to which item is belong
424		///
425		/// * item_id: Id of an item
426		///
427		/// * sender: Original owner of item
428		///
429		/// * recipient: New owner of item
430		///
431		/// * amount: Always 1 for NFT
432		Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),
433
434		/// * collection_id
435		///
436		/// * item_id
437		///
438		/// * sender
439		///
440		/// * spender
441		///
442		/// * amount
443		Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),
444	}
445);
446
447decl_module! {153decl_module! {
448	pub struct Module<T: Config> for enum Call154	pub struct Module<T: Config> for enum Call
449	where155	where
450		origin: T::Origin156		origin: T::Origin
451	{157	{
452		fn deposit_event() = default;
453		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;158		const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;
454		type Error = Error<T>;159		type Error = Error<T>;
455160
484			// Anyone can create a collection189			// Anyone can create a collection
485			let who = ensure_signed(origin)?;190			let who = ensure_signed(origin)?;
486191
487			// Take a (non-refundable) deposit of collection creation192			let limits = CollectionLimits::<T::BlockNumber> {
488			let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();
489			imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(
490				&T::TreasuryAccountId::get(),
491				T::CollectionCreationPrice::get(),
492			));
493			<T as Config>::Currency::settle(
494				&who,
495				imbalance,
496				WithdrawReasons::TRANSFER,
497				ExistenceRequirement::KeepAlive,
498			).map_err(|_| Error::<T>::NoPermission)?;
499
500			let decimal_points = match mode {
501				CollectionMode::Fungible(points) => points,
502				_ => 0
503			};
504
505			let created_count = CreatedCollectionCount::get();
506			let destroyed_count = DestroyedCollectionCount::get();
507
508			// bound Total number of collections
509			ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);
510
511			// check params
512			ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
513			ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);
514			ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);
515			ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);
516
517			// Generate next collection ID
518			let next_id = created_count
519				.checked_add(1)
520				.ok_or(Error::<T>::NumOverflow)?;
521
522			CreatedCollectionCount::put(next_id);
523
524			let limits = CollectionLimits {
525				sponsored_data_size: CUSTOM_DATA_LIMIT,193				sponsored_data_size: CUSTOM_DATA_LIMIT,
526				..Default::default()194				..Default::default()
527			};195			};
528196
529			// Create new collection197			// Create new collection
530			let new_collection = Collection {198			let new_collection = Collection::<T> {
531				owner: who.clone(),199				owner: who.clone(),
532				name: collection_name,200				name: collection_name,
533				mode: mode.clone(),201				mode: mode.clone(),
534				mint_mode: false,202				mint_mode: false,
535				access: AccessMode::Normal,203				access: AccessMode::Normal,
536				description: collection_description,204				description: collection_description,
537				decimal_points,
538				token_prefix,205				token_prefix,
539				offchain_schema: Vec::new(),206				offchain_schema: Vec::new(),
540				schema_version: SchemaVersion::ImageURL,207				schema_version: SchemaVersion::ImageURL,
541				sponsorship: SponsorshipState::Disabled,208				sponsorship: SponsorshipState::Disabled,
542				variable_on_chain_schema: Vec::new(),209				variable_on_chain_schema: Vec::new(),
543				const_on_chain_schema: Vec::new(),210				const_on_chain_schema: Vec::new(),
544				limits,211				limits,
545				meta_update_permission: MetaUpdatePermission::default(),
546				transfers_enabled: true,212				transfers_enabled: true,
213				meta_update_permission: Default::default(),
547			};214			};
548215
549			// Add new collection to map216			let _id = match mode {
550			<CollectionById<T>>::insert(next_id, new_collection);217				CollectionMode::NFT => {PalletNonfungible::init_collection(new_collection)?},
218				CollectionMode::Fungible(decimal_points) => {
219					// check params
220					ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
221					PalletFungible::init_collection(new_collection)?
222				}
223				CollectionMode::ReFungible => {
224					PalletRefungible::init_collection(new_collection)?
225				}
226			};
551227
552			// call event
553			Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));
554
555			Ok(())228			Ok(())
556		}229		}
557230
567		#[weight = <SelfWeightOf<T>>::destroy_collection()]240		#[weight = <SelfWeightOf<T>>::destroy_collection()]
568		#[transactional]241		#[transactional]
569		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {242		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {
243			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
570244
571			let sender = ensure_signed(origin)?;245			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
572			let collection = Self::get_collection(collection_id)?;
573			Self::check_owner_permissions(&collection, &sender)?;246			collection.check_is_owner(&sender)?;
574			if !collection.limits.owner_can_destroy {
575				fail!(Error::<T>::NoPermission);
576			}
577247
578			<AddressTokens<T>>::remove_prefix(collection_id, None);248			// =========
579			<Allowances<T>>::remove_prefix(collection_id, None);
580			<Balance<T>>::remove_prefix(collection_id, None);
581			<ItemListIndex>::remove(collection_id);
582			<AdminList<T>>::remove(collection_id);
583			<CollectionById<T>>::remove(collection_id);
584			<WhiteList<T>>::remove_prefix(collection_id, None);
585249
586			<NftItemList<T>>::remove_prefix(collection_id, None);250			match collection.mode {
251				CollectionMode::ReFungible => PalletRefungible::destroy_collection(RefungibleHandle::cast(collection), &sender)?,
587			<FungibleItemList<T>>::remove_prefix(collection_id, None);252				CollectionMode::Fungible(_) => PalletFungible::destroy_collection(FungibleHandle::cast(collection), &sender)?,
588			<ReFungibleItemList<T>>::remove_prefix(collection_id, None);253				CollectionMode::NFT => PalletNonfungible::destroy_collection(NonfungibleHandle::cast(collection), &sender)?,
254			}
589255
590			<NftTransferBasket<T>>::remove_prefix(collection_id, None);256			<NftTransferBasket<T>>::remove_prefix(collection_id, None);
591			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);257			<FungibleTransferBasket<T>>::remove_prefix(collection_id, None);
592			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);258			<ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);
593259
594			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);260			<VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);
595261
596			DestroyedCollectionCount::put(DestroyedCollectionCount::get()
597				.checked_add(1)
598				.ok_or(Error::<T>::NumOverflow)?);
599
600			Ok(())262			Ok(())
601		}263		}
602264
617		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{279		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
618280
619			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);281			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
620			let collection = Self::get_collection(collection_id)?;282			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
621283
622			Self::toggle_white_list_internal(284			<PalletCommon<T>>::toggle_allowlist(
623				&sender,
624				&collection,285				&collection,
286				&sender,
625				&address,287				&address,
626				true,288				true,
627			)?;289			)?;
646		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{308		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
647309
648			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);310			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
649			let collection = Self::get_collection(collection_id)?;311			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
650312
651			Self::toggle_white_list_internal(313			<PalletCommon<T>>::toggle_allowlist(
652				&sender,
653				&collection,314				&collection,
315				&sender,
654				&address,316				&address,
655				false,317				false,
656			)?;318			)?;
673		#[transactional]335		#[transactional]
674		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult336		pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult
675		{337		{
676			let sender = ensure_signed(origin)?;338			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
677339
678			let mut target_collection = Self::get_collection(collection_id)?;340			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
679			Self::check_owner_permissions(&target_collection, &sender)?;341			target_collection.check_is_owner(&sender)?;
342
680			target_collection.access = mode;343			target_collection.access = mode;
681			target_collection.save()344			target_collection.save()
698		#[transactional]361		#[transactional]
699		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult362		pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult
700		{363		{
701			let sender = ensure_signed(origin)?;364			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
702365
703			let mut target_collection = Self::get_collection(collection_id)?;366			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
704			Self::check_owner_permissions(&target_collection, &sender)?;367			target_collection.check_is_owner(&sender)?;
368
705			target_collection.mint_mode = mint_permission;369			target_collection.mint_mode = mint_permission;
706			target_collection.save()370			target_collection.save()
721		#[transactional]385		#[transactional]
722		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {386		pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {
723387
724			let sender = ensure_signed(origin)?;388			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
389
725			let mut target_collection = Self::get_collection(collection_id)?;390			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
726			Self::check_owner_permissions(&target_collection, &sender)?;391			target_collection.check_is_owner(&sender)?;
392
727			target_collection.owner = new_owner;393			target_collection.owner = new_owner;
728			target_collection.save()394			target_collection.save()
745		#[transactional]411		#[transactional]
746		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {412		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {
747			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);413			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
748			let collection = Self::get_collection(collection_id)?;
749			Self::check_owner_or_admin_permissions(&collection, &sender)?;
750			let mut admin_arr = <AdminList<T>>::get(collection_id);
751414
752			match admin_arr.binary_search(&new_admin_id) {415			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
753				Ok(_) => {},
754				Err(idx) => {
755					ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);
756					admin_arr.insert(idx, new_admin_id);416			collection.check_is_owner_or_admin(&sender)?;
417
757					<AdminList<T>>::insert(collection_id, admin_arr);418			<IsAdmin<T>>::insert((collection_id, new_admin_id.as_sub()), true);
758				}
759			}
760			Ok(())419			Ok(())
761		}420		}
762421
776		#[transactional]435		#[transactional]
777		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {436		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {
778			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);437			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
779			let collection = Self::get_collection(collection_id)?;
780			Self::check_owner_or_admin_permissions(&collection, &sender)?;
781			let mut admin_arr = <AdminList<T>>::get(collection_id);
782438
783			if let Ok(idx) = admin_arr.binary_search(&account_id) {439			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
784				admin_arr.remove(idx);440			collection.check_is_owner_or_admin(&sender)?;
441
785				<AdminList<T>>::insert(collection_id, admin_arr);442			<IsAdmin<T>>::remove((collection_id, account_id.as_sub()));
786			}
787			Ok(())443			Ok(())
788		}444		}
789445
799		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]455		#[weight = <SelfWeightOf<T>>::set_collection_sponsor()]
800		#[transactional]456		#[transactional]
801		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {457		pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {
802			let sender = ensure_signed(origin)?;458			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
803			let mut target_collection = Self::get_collection(collection_id)?;
804			Self::check_owner_permissions(&target_collection, &sender)?;
805459
460			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
461			target_collection.check_is_owner_or_admin(&sender)?;
462
806			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);463			target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);
807			target_collection.save()464			target_collection.save()
808		}465		}
819		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {476		pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {
820			let sender = ensure_signed(origin)?;477			let sender = ensure_signed(origin)?;
821478
822			let mut target_collection = Self::get_collection(collection_id)?;479			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
823			ensure!(480			ensure!(
824				target_collection.sponsorship.pending_sponsor() == Some(&sender),481				target_collection.sponsorship.pending_sponsor() == Some(&sender),
825				Error::<T>::ConfirmUnsetSponsorFail482				Error::<T>::ConfirmUnsetSponsorFail
841		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]498		#[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]
842		#[transactional]499		#[transactional]
843		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {500		pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {
844			let sender = ensure_signed(origin)?;501			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
845502
846			let mut target_collection = Self::get_collection(collection_id)?;503			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
847			Self::check_owner_permissions(&target_collection, &sender)?;504			target_collection.check_is_owner(&sender)?;
848505
849			target_collection.sponsorship = SponsorshipState::Disabled;506			target_collection.sponsorship = SponsorshipState::Disabled;
850			target_collection.save()507			target_collection.save()
868		/// * owner: Address, initial owner of the NFT.525		/// * owner: Address, initial owner of the NFT.
869		///526		///
870		/// * data: Token data to store on chain.527		/// * data: Token data to store on chain.
871		// #[weight =528		#[weight = <CommonWeights<T>>::create_item()]
872		// (130_000_000 as Weight)
873		// .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))
874		// .saturating_add(RocksDbWeight::get().reads(10 as Weight))
875		// .saturating_add(RocksDbWeight::get().writes(8 as Weight))]
876
877		#[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]
878		#[transactional]529		#[transactional]
879		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {530		pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResultWithPostInfo {
880			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);531			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
881			let collection = Self::get_collection(collection_id)?;
882532
883			Self::create_item_internal(&sender, &collection, &owner, data)?;533			dispatch_call::<T, _>(collection_id, |d| d.create_item(sender, owner, data))
884
885			collection.submit_logs()
886		}534		}
887535
888		/// This method creates multiple items in a collection created with CreateCollection method.536		/// This method creates multiple items in a collection created with CreateCollection method.
903		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].551		/// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].
904		///552		///
905		/// * owner: Address, initial owner of the NFT.553		/// * owner: Address, initial owner of the NFT.
906		#[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]554		#[weight = <CommonWeights<T>>::create_multiple_items(items_data.len() as u32)]
907		#[transactional]555		#[transactional]
908		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {556		pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResultWithPostInfo {
909
910			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);557			ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);
911			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);558			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
912			let collection = Self::get_collection(collection_id)?;
913559
914			Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;560			dispatch_call::<T, _>(collection_id, |d| d.create_multiple_items(sender, owner, items_data))
915
916			collection.submit_logs()
917		}561		}
918562
919		// TODO! transaction weight563		// TODO! transaction weight
932		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]576		#[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]
933		#[transactional]577		#[transactional]
934		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {578		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {
579			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
580			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
581			target_collection.check_is_owner(&sender)?;
935582
936			let sender = ensure_signed(origin)?;583			// =========
937			let mut target_collection = Self::get_collection(collection_id)?;
938584
939			Self::check_owner_permissions(&target_collection, &sender)?;
940
941			target_collection.transfers_enabled = value;585			target_collection.transfers_enabled = value;
942			target_collection.save()586			target_collection.save()
943		}587		}
944588
945		// TODO! transaction weight
946		/// Set meta_update_permission value for particular collection
947		///
948		/// # Permissions
949		///
950		/// * Collection Owner.
951		///
952		/// # Arguments
953		///
954		/// * collection_id: ID of the collection.
955		///
956		/// * value: New flag value.
957		#[weight = <T as Config>::WeightInfo::burn_item()]
958		#[transactional]
959		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {
960
961			let sender = ensure_signed(origin)?;
962			let mut target_collection = Self::get_collection(collection_id)?;
963
964			ensure!(
965				target_collection.meta_update_permission != MetaUpdatePermission::None,
966				Error::<T>::MetadataFlagFrozen
967			);
968			Self::check_owner_permissions(&target_collection, &sender)?;
969
970			target_collection.meta_update_permission = value;
971
972			target_collection.save()
973		}
974
975		/// Destroys a concrete instance of NFT.589		/// Destroys a concrete instance of NFT.
976		///590		///
977		/// # Permissions591		/// # Permissions
985		/// * collection_id: ID of the collection.599		/// * collection_id: ID of the collection.
986		///600		///
987		/// * item_id: ID of NFT to burn.601		/// * item_id: ID of NFT to burn.
988		#[weight = <SelfWeightOf<T>>::burn_item()]602		#[weight = <CommonWeights<T>>::burn_item()]
989		#[transactional]603		#[transactional]
990		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {604		pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {
991
992			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);605			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
993			let target_collection = Self::get_collection(collection_id)?;
994606
995			Self::burn_item_internal(&sender, &target_collection, item_id, value, true)?;607			dispatch_call::<T, _>(collection_id, |d| d.burn_item(sender, item_id, value))
996
997			target_collection.submit_logs()
998		}608		}
999609
1000		/// Destroys a concrete instance of NFT on behalf of the owner610		/// Destroys a concrete instance of NFT on behalf of the owner
1013		/// * item_id: ID of NFT to burn.623		/// * item_id: ID of NFT to burn.
1014		///624		///
1015		/// * from: owner of item625		/// * from: owner of item
1016		#[weight = <SelfWeightOf<T>>::burn_item()]626		#[weight = <CommonWeights<T>>::burn_from()]
1017		#[transactional]627		#[transactional]
1018		pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResult {628		pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {
1019
1020			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);629			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1021			let target_collection = Self::get_collection(collection_id)?;
1022630
1023			Self::burn_from_internal(&sender, &target_collection, &from, item_id, value)?;631			dispatch_call::<T, _>(collection_id, |d| d.burn_from(sender, from, item_id, value))
1024
1025			target_collection.submit_logs()
1026		}632		}
1027633
1028		/// Change ownership of the token.634		/// Change ownership of the token.
1048		///     * Non-Fungible Mode: Ignored654		///     * Non-Fungible Mode: Ignored
1049		///     * Fungible Mode: Must specify transferred amount655		///     * Fungible Mode: Must specify transferred amount
1050		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)656		///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)
1051		#[weight = <SelfWeightOf<T>>::transfer()]657		#[weight = <CommonWeights<T>>::transfer()]
1052		#[transactional]658		#[transactional]
1053		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {659		pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResultWithPostInfo {
1054			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);660			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1055			let collection = Self::get_collection(collection_id)?;
1056661
1057			Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;662			dispatch_call::<T, _>(collection_id, |d| d.transfer(sender, recipient, item_id, value))
1058
1059			collection.submit_logs()
1060		}663		}
1061664
1062		/// Set, change, or remove approved address to transfer the ownership of the NFT.665		/// Set, change, or remove approved address to transfer the ownership of the NFT.
1074		/// * collection_id.677		/// * collection_id.
1075		///678		///
1076		/// * item_id: ID of the item.679		/// * item_id: ID of the item.
1077		#[weight = <SelfWeightOf<T>>::approve()]680		#[weight = <CommonWeights<T>>::approve()]
1078		#[transactional]681		#[transactional]
1079		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {682		pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResultWithPostInfo {
1080			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);683			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1081			let collection = Self::get_collection(collection_id)?;
1082684
1083			Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;685			dispatch_call::<T, _>(collection_id, |d| d.approve(sender, spender, item_id, amount))
1084
1085			collection.submit_logs()
1086		}686		}
1087687
1088		/// 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.688		/// 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		/// * item_id: ID of the item.704		/// * item_id: ID of the item.
1105		///705		///
1106		/// * value: Amount to transfer.706		/// * value: Amount to transfer.
1107		#[weight = <SelfWeightOf<T>>::transfer_from()]707		#[weight = <CommonWeights<T>>::transfer_from()]
1108		#[transactional]708		#[transactional]
1109		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {709		pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResultWithPostInfo {
1110			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);710			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1111			let collection = Self::get_collection(collection_id)?;
1112711
1113			Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;712			dispatch_call::<T, _>(collection_id, |d| d.transfer_from(sender, from, recipient, item_id, value))
1114
1115			collection.submit_logs()
1116		}713		}
1117		// #[weight = 0]
1118		//     // let no_perm_mes = "You do not have permissions to modify this collection";
1119		//     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);
1120		//     // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));
1121		//     // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);
1122714
1123		//     // // on_nft_received  call
1124
1125		//     // Self::transfer(origin, collection_id, item_id, new_owner)?;
1126
1127		//     Ok(())
1128		// }
1129
1130		/// Set off-chain data schema.715		/// Set off-chain data schema.
1131		///716		///
1132		/// # Permissions717		/// # Permissions
1139		/// * collection_id.724		/// * collection_id.
1140		///725		///
1141		/// * schema: String representing the offchain data schema.726		/// * schema: String representing the offchain data schema.
1142		#[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]727		#[weight = <CommonWeights<T>>::set_variable_metadata(data.len() as u32)]
1143		#[transactional]728		#[transactional]
1144		pub fn set_variable_meta_data (729		pub fn set_variable_meta_data (
1145			origin,730			origin,
1146			collection_id: CollectionId,731			collection_id: CollectionId,
1147			item_id: TokenId,732			item_id: TokenId,
1148			data: Vec<u8>733			data: Vec<u8>
1149		) -> DispatchResult {734		) -> DispatchResultWithPostInfo {
1150			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);735			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1151736
1152			let collection = Self::get_collection(collection_id)?;737			dispatch_call::<T, _>(collection_id, |d| d.set_variable_metadata(sender, item_id, data))
1153			Self::meta_update_check(&sender, &collection, item_id)?;738		}
1154739
1155			Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;740		/// Set meta_update_permission value for particular collection
741		///
742		/// # Permissions
743		///
744		/// * Collection Owner.
745		///
746		/// # Arguments
747		///
748		/// * collection_id: ID of the collection.
749		///
750		/// * value: New flag value.
751		#[weight = <SelfWeightOf<T>>::set_meta_update_permission_flag()]
752		#[transactional]
753		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {
754			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
755			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
1156756
1157			Ok(())757			ensure!(
758				target_collection.meta_update_permission != MetaUpdatePermission::None,
759				<CommonError<T>>::MetadataFlagFrozen,
760			);
761			target_collection.check_is_owner(&sender)?;
762
763			target_collection.meta_update_permission = value;
764
765			target_collection.save()
1158		}766		}
1159767
1160		/// Set schema standard768		/// Set schema standard
1179			version: SchemaVersion787			version: SchemaVersion
1180		) -> DispatchResult {788		) -> DispatchResult {
1181			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);789			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1182			let mut target_collection = Self::get_collection(collection_id)?;790			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
1183			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;791			target_collection.check_is_owner_or_admin(&sender)?;
1184			target_collection.schema_version = version;792			target_collection.schema_version = version;
1185			target_collection.save()793			target_collection.save()
1186		}794		}
1205			schema: Vec<u8>813			schema: Vec<u8>
1206		) -> DispatchResult {814		) -> DispatchResult {
1207			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);815			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1208			let mut target_collection = Self::get_collection(collection_id)?;816			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
1209			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;817			target_collection.check_is_owner_or_admin(&sender)?;
1210818
1211			// check schema limit819			// check schema limit
1212			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");820			ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");
1235			schema: Vec<u8>843			schema: Vec<u8>
1236		) -> DispatchResult {844		) -> DispatchResult {
1237			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);845			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1238			let mut target_collection = Self::get_collection(collection_id)?;846			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
1239			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;847			target_collection.check_is_owner_or_admin(&sender)?;
1240848
1241			// check schema limit849			// check schema limit
1242			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");850			ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");
1265			schema: Vec<u8>873			schema: Vec<u8>
1266		) -> DispatchResult {874		) -> DispatchResult {
1267			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);875			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1268			let mut target_collection = Self::get_collection(collection_id)?;876			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
1269			Self::check_owner_or_admin_permissions(&target_collection, &sender)?;877			target_collection.check_is_owner_or_admin(&sender)?;
1270878
1271			// check schema limit879			// check schema limit
1272			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");880			ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");
1279		#[transactional]887		#[transactional]
1280		pub fn set_collection_limits(888		pub fn set_collection_limits(
1281			origin,889			origin,
1282			collection_id: u32,890			collection_id: CollectionId,
1283			new_limits: CollectionLimits<T::BlockNumber>,891			new_limits: CollectionLimits<T::BlockNumber>,
1284		) -> DispatchResult {892		) -> DispatchResult {
1285			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);893			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1286			let mut target_collection = Self::get_collection(collection_id)?;894			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
1287			Self::check_owner_permissions(&target_collection, sender.as_sub())?;895			target_collection.check_is_owner(&sender)?;
1288			let old_limits = &target_collection.limits;896			let old_limits = &target_collection.limits;
1289897
1290			// collection bounds898			// collection bounds
1291			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&899			ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&
1292				new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&900				new_limits.account_token_ownership_limit.unwrap_or(0) <= MAX_TOKEN_OWNERSHIP &&
1293				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,901				new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,
1294				Error::<T>::CollectionLimitBoundsExceeded);902				Error::<T>::CollectionLimitBoundsExceeded);
1295903
1296			// token_limit   check  prev904			// token_limit   check  prev
1297			ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);905			ensure!(old_limits.token_limit >= new_limits.token_limit, <CommonError<T>>::CollectionTokenLimitExceeded);
1298			ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);906			ensure!(new_limits.token_limit > 0, <CommonError<T>>::CollectionTokenLimitExceeded);
1299907
1300			ensure!(908			ensure!(
1301				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&909				(old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&
1310	}918	}
1311}919}
1312920
921// TODO: limit returned entries?
1313impl<T: Config> Module<T> {922impl<T: Config> Pallet<T> {
1314	pub fn create_item_internal(923	pub fn adminlist(collection: CollectionId) -> Vec<T::AccountId> {
1315		sender: &T::CrossAccountId,
1316		collection: &CollectionHandle<T>,
1317		owner: &T::CrossAccountId,
1318		data: CreateItemData,
1319	) -> DispatchResult {
1320		ensure!(
1321			owner != &T::CrossAccountId::from_eth(H160([0; 20])),
1322			Error::<T>::AddressIsZero924		<IsAdmin<T>>::iter_prefix((collection,))
1323		);
1324
1325		Self::can_create_items_in_collection(collection, sender, owner, 1)?;
1326		Self::validate_create_item_args(collection, &data)?;925			.map(|(a, _)| a)
1327		Self::create_item_no_validation(collection, owner, data)?;
1328
1329		Ok(())926			.collect()
1330	}927	}
1331928	pub fn allowlist(collection: CollectionId) -> Vec<T::AccountId> {
1332	pub fn transfer_internal(929		<Allowlist<T>>::iter_prefix((collection,))
1333		sender: &T::CrossAccountId,930			.map(|(a, _)| a)
1334		recipient: &T::CrossAccountId,931			.collect()
1335		target_collection: &CollectionHandle<T>,
1336		item_id: TokenId,
1337		value: u128,
1338	) -> DispatchResult {
1339		ensure!(
1340			recipient != &T::CrossAccountId::from_eth(H160([0; 20])),
1341			Error::<T>::AddressIsZero
1342		);
1343
1344		// Limits check
1345		Self::is_correct_transfer(target_collection, recipient)?;
1346
1347		// Transfer permissions check
1348		ensure!(
1349			Self::is_item_owner(sender, target_collection, item_id)?
1350				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,
1351			Error::<T>::NoPermission
1352		);
1353
1354		if target_collection.access == AccessMode::WhiteList {
1355			Self::check_white_list(target_collection, sender)?;
1356			Self::check_white_list(target_collection, recipient)?;
1357		}
1358
1359		match target_collection.mode {
1360			CollectionMode::NFT => Self::transfer_nft(
1361				target_collection,
1362				item_id,
1363				sender.clone(),
1364				recipient.clone(),
1365			)?,
1366			CollectionMode::Fungible(_) => {
1367				Self::transfer_fungible(target_collection, value, sender, recipient)?
1368			}
1369			CollectionMode::ReFungible => Self::transfer_refungible(
1370				target_collection,
1371				item_id,
1372				value,
1373				sender.clone(),
1374				recipient.clone(),
1375			)?,
1376		};
1377
1378		Self::deposit_event(RawEvent::Transfer(
1379			target_collection.id,
1380			item_id,
1381			sender.clone(),
1382			recipient.clone(),
1383			value,
1384		));
1385
1386		Ok(())
1387	}
1388
1389	pub fn approve_internal(
1390		sender: &T::CrossAccountId,
1391		spender: &T::CrossAccountId,
1392		collection: &CollectionHandle<T>,
1393		item_id: TokenId,
1394		amount: u128,
1395	) -> DispatchResult {
1396		Self::token_exists(collection, item_id)?;
1397
1398		// Transfer permissions check
1399		let bypasses_limits = collection.limits.owner_can_transfer
1400			&& Self::is_owner_or_admin_permissions(collection, sender)?;
1401
1402		let allowance_limit = if bypasses_limits {
1403			None
1404		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {
1405			Some(amount)
1406		} else {
1407			fail!(Error::<T>::NoPermission);
1408		};
1409
1410		if collection.access == AccessMode::WhiteList {
1411			Self::check_white_list(collection, sender)?;
1412			Self::check_white_list(collection, spender)?;
1413		}
1414
1415		collection.consume_sload()?;
1416		let allowance: u128 = amount
1417			.checked_add(<Allowances<T>>::get(
1418				collection.id,
1419				(item_id, sender.as_sub(), spender.as_sub()),
1420			))
1421			.ok_or(Error::<T>::NumOverflow)?;
1422		if let Some(limit) = allowance_limit {
1423			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);
1424		}
1425		collection.consume_sstore()?;
1426		<Allowances<T>>::insert(
1427			collection.id,
1428			(item_id, sender.as_sub(), spender.as_sub()),
1429			allowance,
1430		);
1431
1432		if matches!(collection.mode, CollectionMode::NFT) {
1433			// TODO: NFT: only one owner may exist for token in ERC721
1434			collection.log(ERC721Events::Approval {
1435				owner: *sender.as_eth(),
1436				approved: *spender.as_eth(),
1437				token_id: item_id.into(),
1438			})?;
1439		}
1440
1441		if matches!(collection.mode, CollectionMode::Fungible(_)) {
1442			// TODO: NFT: only one owner may exist for token in ERC20
1443			collection.log(ERC20Events::Approval {
1444				owner: *sender.as_eth(),
1445				spender: *spender.as_eth(),
1446				value: allowance.into(),
1447			})?;
1448		}
1449
1450		Self::deposit_event(RawEvent::Approved(
1451			collection.id,
1452			item_id,
1453			sender.clone(),
1454			spender.clone(),
1455			allowance,
1456		));
1457		Ok(())
1458	}
1459
1460	pub fn transfer_from_internal(
1461		sender: &T::CrossAccountId,
1462		from: &T::CrossAccountId,
1463		recipient: &T::CrossAccountId,
1464		collection: &CollectionHandle<T>,
1465		item_id: TokenId,
1466		amount: u128,
1467	) -> DispatchResult {
1468		if sender == from {
1469			// Transfer by `from`, because it is either equal to sender, or derived from him
1470			return Self::transfer_internal(from, recipient, collection, item_id, amount);
1471		}
1472
1473		// Check approval
1474		collection.consume_sload()?;
1475		let approval: u128 =
1476			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));
1477
1478		// Limits check
1479		Self::is_correct_transfer(collection, recipient)?;
1480
1481		// Transfer permissions check
1482		ensure!(
1483			approval >= amount
1484				|| (collection.limits.owner_can_transfer
1485					&& Self::is_owner_or_admin_permissions(collection, sender)?),
1486			Error::<T>::NoPermission
1487		);
1488
1489		if collection.access == AccessMode::WhiteList {
1490			Self::check_white_list(collection, sender)?;
1491			Self::check_white_list(collection, recipient)?;
1492		}
1493
1494		// Reduce approval by transferred amount or remove if remaining approval drops to 0
1495		let allowance = approval.saturating_sub(amount);
1496		collection.consume_sstore()?;
1497		if allowance > 0 {
1498			<Allowances<T>>::insert(
1499				collection.id,
1500				(item_id, from.as_sub(), sender.as_sub()),
1501				allowance,
1502			);
1503		} else {
1504			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));
1505		}
1506
1507		match collection.mode {
1508			CollectionMode::NFT => {
1509				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?
1510			}
1511			CollectionMode::Fungible(_) => {
1512				Self::transfer_fungible(collection, amount, from, recipient)?
1513			}
1514			CollectionMode::ReFungible => Self::transfer_refungible(
1515				collection,
1516				item_id,
1517				amount,
1518				from.clone(),
1519				recipient.clone(),
1520			)?,
1521		};
1522
1523		if matches!(collection.mode, CollectionMode::Fungible(_)) {
1524			collection.log(ERC20Events::Approval {
1525				owner: *from.as_eth(),
1526				spender: *sender.as_eth(),
1527				value: allowance.into(),
1528			})?;
1529		}
1530
1531		Ok(())
1532	}
1533
1534	pub fn set_variable_meta_data_internal(
1535		sender: &T::CrossAccountId,
1536		collection: &CollectionHandle<T>,
1537		item_id: TokenId,
1538		data: Vec<u8>,
1539	) -> DispatchResult {
1540		Self::token_exists(collection, item_id)?;
1541
1542		ensure!(
1543			CUSTOM_DATA_LIMIT >= data.len() as u32,
1544			Error::<T>::TokenVariableDataLimitExceeded
1545		);
1546
1547		ensure!(
1548			(Self::is_item_owner(sender, collection, item_id)?
1549				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)
1550				|| (Self::is_owner_or_admin_permissions(collection, sender)?
1551					&& collection.meta_update_permission == MetaUpdatePermission::Admin),
1552			Error::<T>::NoPermission
1553		);
1554
1555		match collection.mode {
1556			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,
1557			CollectionMode::ReFungible => {
1558				Self::set_re_fungible_variable_data(collection, item_id, data)?
1559			}
1560			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),
1561		};
1562
1563		Ok(())
1564	}
1565
1566	pub fn meta_update_check(
1567		sender: &T::CrossAccountId,
1568		collection: &CollectionHandle<T>,
1569		item_id: TokenId,
1570	) -> DispatchResult {
1571		match collection.meta_update_permission {
1572			MetaUpdatePermission::ItemOwner => ensure!(
1573				Self::is_item_owner(sender, collection, item_id)?,
1574				Error::<T>::NoPermission
1575			),
1576			MetaUpdatePermission::Admin => ensure!(
1577				Self::is_owner_or_admin_permissions(collection, sender)?,
1578				Error::<T>::NoPermission
1579			),
1580			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),
1581		}
1582
1583		Ok(())
1584	}
1585
1586	pub fn get_variable_metadata(
1587		collection: &CollectionHandle<T>,
1588		item_id: TokenId,
1589	) -> Result<Vec<u8>, DispatchError> {
1590		Ok(match collection.mode {
1591			CollectionMode::NFT => {
1592				<NftItemList<T>>::get(collection.id, item_id)
1593					.ok_or(Error::<T>::TokenNotFound)?
1594					.variable_data
1595			}
1596			CollectionMode::ReFungible => {
1597				<ReFungibleItemList<T>>::get(collection.id, item_id)
1598					.ok_or(Error::<T>::TokenNotFound)?
1599					.variable_data
1600			}
1601			_ => fail!(Error::<T>::UnexpectedCollectionType),
1602		})
1603	}
1604
1605	pub fn create_multiple_items_internal(
1606		sender: &T::CrossAccountId,
1607		collection: &CollectionHandle<T>,
1608		owner: &T::CrossAccountId,
1609		items_data: Vec<CreateItemData>,
1610	) -> DispatchResult {
1611		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;
1612
1613		for data in &items_data {
1614			Self::validate_create_item_args(collection, data)?;
1615		}
1616		for data in &items_data {
1617			Self::create_item_no_validation(collection, owner, data.clone())?;
1618		}
1619
1620		Ok(())
1621	}
1622
1623	pub fn burn_item_internal(
1624		owner: &T::CrossAccountId,
1625		collection: &CollectionHandle<T>,
1626		item_id: TokenId,
1627		value: u128,
1628		allow_escalation: bool,
1629	) -> DispatchResult {
1630		ensure!(
1631			Self::is_item_owner(owner, collection, item_id)?
1632				|| (allow_escalation
1633					&& collection.limits.owner_can_transfer
1634					&& Self::is_owner_or_admin_permissions(collection, owner)?),
1635			Error::<T>::NoPermission
1636		);
1637
1638		if collection.access == AccessMode::WhiteList {
1639			Self::check_white_list(collection, owner)?;
1640		}
1641
1642		match collection.mode {
1643			CollectionMode::NFT => match value {
1644				1 => Self::burn_nft_item(collection, item_id)?,
1645				0 => (),
1646				_ => fail!(<Error<T>>::TokenValueTooLow),
1647			},
1648			CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, owner, value)?,
1649			CollectionMode::ReFungible => {
1650				Self::burn_refungible_item(collection, item_id, owner, value)?
1651			}
1652			_ => (),
1653		};
1654
1655		Ok(())
1656	}
1657
1658	pub fn burn_from_internal(
1659		sender: &T::CrossAccountId,
1660		collection: &CollectionHandle<T>,
1661		from: &T::CrossAccountId,
1662		item_id: TokenId,
1663		amount: u128,
1664	) -> DispatchResult {
1665		if sender == from {
1666			// Transfer by `from`, because it is either equal to sender, or derived from him
1667			return Self::burn_item_internal(from, collection, item_id, amount, true);
1668		}
1669
1670		// Check approval
1671		collection.consume_sload()?;
1672		let approval: u128 =
1673			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));
1674
1675		// Transfer permissions check
1676		ensure!(
1677			approval >= amount
1678				|| (collection.limits.owner_can_transfer
1679					&& Self::is_owner_or_admin_permissions(collection, sender)?),
1680			Error::<T>::NoPermission
1681		);
1682
1683		if collection.access == AccessMode::WhiteList {
1684			Self::check_white_list(collection, sender)?;
1685		}
1686
1687		// Reduce approval by transferred amount or remove if remaining approval drops to 0
1688		let allowance = approval.saturating_sub(amount);
1689		collection.consume_sstore()?;
1690		if allowance > 0 {
1691			<Allowances<T>>::insert(
1692				collection.id,
1693				(item_id, from.as_sub(), sender.as_sub()),
1694				allowance,
1695			);
1696		} else {
1697			<Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));
1698		}
1699
1700		// Escalation is disallowed here, because we need to be sure that passed owner is real
1701		Self::burn_item_internal(from, collection, item_id, amount, false)?;
1702
1703		if matches!(collection.mode, CollectionMode::Fungible(_)) {
1704			collection.log(ERC20Events::Approval {
1705				owner: *from.as_eth(),
1706				spender: *sender.as_eth(),
1707				value: allowance.into(),
1708			})?;
1709		}
1710
1711		Ok(())
1712	}
1713
1714	pub fn toggle_white_list_internal(
1715		sender: &T::CrossAccountId,
1716		collection: &CollectionHandle<T>,
1717		address: &T::CrossAccountId,
1718		whitelisted: bool,
1719	) -> DispatchResult {
1720		Self::check_owner_or_admin_permissions(collection, sender)?;
1721
1722		if whitelisted {
1723			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);
1724		} else {
1725			<WhiteList<T>>::remove(collection.id, address.as_sub());
1726		}
1727
1728		Ok(())
1729	}
1730
1731	fn is_correct_transfer(
1732		collection: &CollectionHandle<T>,
1733		recipient: &T::CrossAccountId,
1734	) -> DispatchResult {
1735		let collection_id = collection.id;
1736
1737		// check token limit and account token limit
1738		collection.consume_sload()?;
1739		let account_items: u32 =
1740			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;
1741
1742		// zero limit means collection limit is disabled
1743		// otherwise get lower value
1744		let limit = if collection.limits.account_token_ownership_limit == 0
1745			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT
1746		{
1747			ACCOUNT_TOKEN_OWNERSHIP_LIMIT
1748		} else {
1749			collection.limits.account_token_ownership_limit
1750		};
1751
1752		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);
1753
1754		// preliminary transfer check
1755		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);
1756
1757		Ok(())
1758	}
1759
1760	fn can_create_items_in_collection(
1761		collection: &CollectionHandle<T>,
1762		sender: &T::CrossAccountId,
1763		owner: &T::CrossAccountId,
1764		amount: u32,
1765	) -> DispatchResult {
1766		let collection_id = collection.id;
1767
1768		// check token limit and account token limit
1769		let total_items: u32 = ItemListIndex::get(collection_id)
1770			.checked_add(amount)
1771			.ok_or(Error::<T>::CollectionTokenLimitExceeded)?;
1772		let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()
1773			as u32)
1774			.checked_add(amount)
1775			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;
1776
1777		// zero limit means collection limit is disabled
1778		// otherwise get lower value
1779		let account_token_limit = if collection.limits.account_token_ownership_limit == 0
1780			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT
1781		{
1782			ACCOUNT_TOKEN_OWNERSHIP_LIMIT
1783		} else {
1784			collection.limits.account_token_ownership_limit
1785		};
1786
1787		ensure!(
1788			collection.limits.token_limit >= total_items,
1789			Error::<T>::CollectionTokenLimitExceeded
1790		);
1791		ensure!(
1792			account_token_limit >= account_items,
1793			Error::<T>::AccountTokenLimitExceeded
1794		);
1795
1796		if !Self::is_owner_or_admin_permissions(collection, sender)? {
1797			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);
1798			Self::check_white_list(collection, owner)?;
1799			Self::check_white_list(collection, sender)?;
1800		}
1801
1802		Ok(())
1803	}
1804
1805	fn validate_create_item_args(
1806		target_collection: &CollectionHandle<T>,
1807		data: &CreateItemData,
1808	) -> DispatchResult {
1809		match target_collection.mode {
1810			CollectionMode::NFT => {
1811				if !matches!(data, CreateItemData::NFT(_)) {
1812					fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);
1813				}
1814			}
1815			CollectionMode::Fungible(_) => {
1816				if !matches!(data, CreateItemData::Fungible(_)) {
1817					fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);
1818				}
1819			}
1820			CollectionMode::ReFungible => {
1821				if let CreateItemData::ReFungible(data) = data {
1822					// Check refungibility limits
1823					ensure!(
1824						data.pieces <= MAX_REFUNGIBLE_PIECES,
1825						Error::<T>::WrongRefungiblePieces
1826					);
1827					ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);
1828				} else {
1829					fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);
1830				}
1831			}
1832		};
1833
1834		Ok(())
1835	}
1836
1837	fn create_item_no_validation(
1838		collection: &CollectionHandle<T>,
1839		owner: &T::CrossAccountId,
1840		data: CreateItemData,
1841	) -> DispatchResult {
1842		match data {
1843			CreateItemData::NFT(data) => {
1844				let item = NftItemType {
1845					owner: owner.clone(),
1846					const_data: data.const_data.into_inner(),
1847					variable_data: data.variable_data.into_inner(),
1848				};
1849
1850				Self::add_nft_item(collection, item)?;
1851			}
1852			CreateItemData::Fungible(data) => {
1853				Self::add_fungible_item(collection, owner, data.value)?;
1854			}
1855			CreateItemData::ReFungible(data) => {
1856				let owner_list = vec![Ownership {
1857					owner: owner.clone(),
1858					fraction: data.pieces,
1859				}];
1860
1861				let item = ReFungibleItemType {
1862					owner: owner_list,
1863					const_data: data.const_data.into_inner(),
1864					variable_data: data.variable_data.into_inner(),
1865				};
1866
1867				Self::add_refungible_item(collection, item)?;
1868			}
1869		};
1870
1871		Ok(())
1872	}
1873
1874	fn add_fungible_item(
1875		collection: &CollectionHandle<T>,
1876		owner: &T::CrossAccountId,
1877		value: u128,
1878	) -> DispatchResult {
1879		let collection_id = collection.id;
1880
1881		// Does new owner already have an account?
1882		collection.consume_sload()?;
1883		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;
1884
1885		// Mint
1886		let item = FungibleItemType {
1887			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,
1888		};
1889		collection.consume_sstore()?;
1890		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);
1891
1892		// Update balance
1893		collection.consume_sload()?;
1894		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
1895			.checked_add(value)
1896			.ok_or(Error::<T>::NumOverflow)?;
1897		collection.consume_sstore()?;
1898		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
1899
1900		collection.log(ERC20Events::Transfer {
1901			from: H160::default(),
1902			to: *owner.as_eth(),
1903			value: value.into(),
1904		})?;
1905		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));
1906		Ok(())
1907	}
1908
1909	fn add_refungible_item(
1910		collection: &CollectionHandle<T>,
1911		item: ReFungibleItemType<T::CrossAccountId>,
1912	) -> DispatchResult {
1913		let collection_id = collection.id;
1914
1915		let current_index = <ItemListIndex>::get(collection_id)
1916			.checked_add(1)
1917			.ok_or(Error::<T>::NumOverflow)?;
1918		let itemcopy = item.clone();
1919
1920		ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);
1921		let item_owner = item.owner.first().expect("only one owner is defined");
1922
1923		let value = item_owner.fraction;
1924		let owner = item_owner.owner.clone();
1925
1926		Self::add_token_index(collection, current_index, &owner)?;
1927
1928		<ItemListIndex>::insert(collection_id, current_index);
1929		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);
1930
1931		// Update balance
1932		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
1933			.checked_add(value)
1934			.ok_or(Error::<T>::NumOverflow)?;
1935		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
1936
1937		Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));
1938		Ok(())
1939	}
1940
1941	fn add_nft_item(
1942		collection: &CollectionHandle<T>,
1943		item: NftItemType<T::CrossAccountId>,
1944	) -> DispatchResult {
1945		let collection_id = collection.id;
1946
1947		let current_index = <ItemListIndex>::get(collection_id)
1948			.checked_add(1)
1949			.ok_or(Error::<T>::NumOverflow)?;
1950
1951		let item_owner = item.owner.clone();
1952		Self::add_token_index(collection, current_index, &item.owner)?;
1953
1954		<ItemListIndex>::insert(collection_id, current_index);
1955		<NftItemList<T>>::insert(collection_id, current_index, item);
1956
1957		// Update balance
1958		let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())
1959			.checked_add(1)
1960			.ok_or(Error::<T>::NumOverflow)?;
1961		<Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);
1962
1963		collection.log(ERC721Events::Transfer {
1964			from: H160::default(),
1965			to: *item_owner.as_eth(),
1966			token_id: current_index.into(),
1967		})?;
1968		Self::deposit_event(RawEvent::ItemCreated(
1969			collection_id,
1970			current_index,
1971			item_owner,
1972		));
1973		Ok(())
1974	}
1975
1976	fn burn_refungible_item(
1977		collection: &CollectionHandle<T>,
1978		item_id: TokenId,
1979		owner: &T::CrossAccountId,
1980		value: u128,
1981	) -> DispatchResult {
1982		let collection_id = collection.id;
1983
1984		let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)
1985			.ok_or(Error::<T>::TokenNotFound)?;
1986		let mut rft_balance = token
1987			.owner
1988			.iter()
1989			.find(|&i| i.owner == *owner)
1990			.ok_or(Error::<T>::TokenNotFound)?
1991			.clone();
1992		Self::remove_token_index(collection, item_id, owner)?;
1993
1994		// update balance
1995		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())
1996			.checked_sub(value)
1997			.ok_or(Error::<T>::NumOverflow)?;
1998		<Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);
1999
2000		rft_balance.fraction = (rft_balance.fraction)
2001			.checked_sub(value)
2002			.ok_or(Error::<T>::NumOverflow)?;
2003
2004		let index = token
2005			.owner
2006			.iter()
2007			.position(|i| i.owner == *owner)
2008			.expect("owned item is exists");
2009		if rft_balance.fraction == 0 {
2010			// Re-create owners list with sender removed
2011			token.owner.remove(index);
2012		} else {
2013			token.owner[index] = rft_balance;
2014		}
2015
2016		let owner_count = token.owner.len();
2017
2018		// Burn the token completely if this was the last (only) owner
2019		if owner_count == 0 {
2020			<ReFungibleItemList<T>>::remove(collection_id, item_id);
2021			<VariableMetaDataBasket<T>>::remove(collection_id, item_id);
2022		} else {
2023			<ReFungibleItemList<T>>::insert(collection_id, item_id, token);
2024		}
2025
2026		Ok(())
2027	}
2028
2029	fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {
2030		let collection_id = collection.id;
2031
2032		let item =
2033			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
2034		Self::remove_token_index(collection, item_id, &item.owner)?;
2035
2036		// update balance
2037		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())
2038			.checked_sub(1)
2039			.ok_or(Error::<T>::NumOverflow)?;
2040		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);
2041		<NftItemList<T>>::remove(collection_id, item_id);
2042		<VariableMetaDataBasket<T>>::remove(collection_id, item_id);
2043
2044		collection.log(ERC721Events::Transfer {
2045			from: *item.owner.as_eth(),
2046			to: H160::default(),
2047			token_id: item_id.into(),
2048		})?;
2049		Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));
2050		Ok(())
2051	}
2052
2053	fn burn_fungible_item(
2054		collection: &CollectionHandle<T>,
2055		owner: &T::CrossAccountId,
2056		value: u128,
2057	) -> DispatchResult {
2058		let collection_id = collection.id;
2059
2060		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());
2061		ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);
2062
2063		// update balance
2064		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
2065			.checked_sub(value)
2066			.ok_or(Error::<T>::NumOverflow)?;
2067		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
2068
2069		if balance.value - value > 0 {
2070			balance.value -= value;
2071			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);
2072		} else {
2073			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());
2074		}
2075
2076		collection.log(ERC20Events::Transfer {
2077			from: *owner.as_eth(),
2078			to: H160::default(),
2079			value: value.into(),
2080		})?;
2081		Ok(())
2082	}
2083
2084	pub fn get_collection(
2085		collection_id: CollectionId,
2086	) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {
2087		Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)
2088	}
2089
2090	fn check_owner_permissions(
2091		target_collection: &CollectionHandle<T>,
2092		subject: &T::AccountId,
2093	) -> DispatchResult {
2094		ensure!(
2095			*subject == target_collection.owner,
2096			Error::<T>::NoPermission
2097		);
2098
2099		Ok(())
2100	}
2101
2102	fn is_owner_or_admin_permissions(
2103		collection: &CollectionHandle<T>,
2104		subject: &T::CrossAccountId,
2105	) -> Result<bool, DispatchError> {
2106		collection.consume_sload()?;
2107		Ok(*subject.as_sub() == collection.owner
2108			|| <AdminList<T>>::get(collection.id).contains(subject))
2109	}
2110
2111	fn check_owner_or_admin_permissions(
2112		collection: &CollectionHandle<T>,
2113		subject: &T::CrossAccountId,
2114	) -> DispatchResult {
2115		ensure!(
2116			Self::is_owner_or_admin_permissions(collection, subject)?,
2117			Error::<T>::NoPermission
2118		);
2119
2120		Ok(())
2121	}
2122
2123	fn owned_amount(
2124		subject: &T::CrossAccountId,
2125		collection: &CollectionHandle<T>,
2126		item_id: TokenId,
2127	) -> Result<Option<u128>, DispatchError> {
2128		collection.consume_sload()?;
2129		Ok(Self::owned_amount_unchecked(subject, collection, item_id))
2130	}
2131
2132	fn owned_amount_unchecked(
2133		subject: &T::CrossAccountId,
2134		target_collection: &CollectionHandle<T>,
2135		item_id: TokenId,
2136	) -> Option<u128> {
2137		let collection_id = target_collection.id;
2138
2139		match target_collection.mode {
2140			CollectionMode::NFT => {
2141				(<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)
2142			}
2143			CollectionMode::Fungible(_) => {
2144				Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)
2145			}
2146			CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?
2147				.owner
2148				.iter()
2149				.find(|i| i.owner == *subject)
2150				.map(|i| i.fraction),
2151		}
2152	}
2153
2154	fn is_item_owner(
2155		subject: &T::CrossAccountId,
2156		target_collection: &CollectionHandle<T>,
2157		item_id: TokenId,
2158	) -> Result<bool, DispatchError> {
2159		Ok(match target_collection.mode {
2160			CollectionMode::Fungible(_) => true,
2161			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),
2162		})
2163	}
2164
2165	fn check_white_list(
2166		collection: &CollectionHandle<T>,
2167		address: &T::CrossAccountId,
2168	) -> DispatchResult {
2169		collection.consume_sload()?;
2170		ensure!(
2171			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),
2172			Error::<T>::AddresNotInWhiteList,
2173		);
2174		Ok(())
2175	}
2176
2177	/// Check if token exists. In case of Fungible, check if there is an entry for
2178	/// the owner in fungible balances double map
2179	fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {
2180		let collection_id = target_collection.id;
2181		let exists = match target_collection.mode {
2182			CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),
2183			CollectionMode::Fungible(_) => true,
2184			CollectionMode::ReFungible => {
2185				<ReFungibleItemList<T>>::contains_key(collection_id, item_id)
2186			}
2187		};
2188
2189		ensure!(exists, Error::<T>::TokenNotFound);
2190		Ok(())
2191	}
2192
2193	fn transfer_fungible(
2194		collection: &CollectionHandle<T>,
2195		value: u128,
2196		owner: &T::CrossAccountId,
2197		recipient: &T::CrossAccountId,
2198	) -> DispatchResult {
2199		let collection_id = collection.id;
2200
2201		collection.consume_sload()?;
2202		collection.consume_sload()?;
2203		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());
2204		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());
2205
2206		recipient_balance.value = recipient_balance
2207			.value
2208			.checked_add(value)
2209			.ok_or(Error::<T>::NumOverflow)?;
2210		balance.value = balance
2211			.value
2212			.checked_sub(value)
2213			.ok_or(Error::<T>::TokenValueTooLow)?;
2214
2215		// update balanceOf
2216		collection.consume_sstore()?;
2217		collection.consume_sstore()?;
2218		if balance.value != 0 {
2219			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);
2220		} else {
2221			<Balance<T>>::remove(collection_id, owner.as_sub());
2222		}
2223		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);
2224
2225		// Reduce or remove sender
2226		collection.consume_sstore()?;
2227		collection.consume_sstore()?;
2228		if balance.value != 0 {
2229			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);
2230		} else {
2231			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());
2232		}
2233		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);
2234
2235		collection.log(ERC20Events::Transfer {
2236			from: *owner.as_eth(),
2237			to: *recipient.as_eth(),
2238			value: value.into(),
2239		})?;
2240		Self::deposit_event(RawEvent::Transfer(
2241			collection.id,
2242			1,
2243			owner.clone(),
2244			recipient.clone(),
2245			value,
2246		));
2247
2248		Ok(())
2249	}
2250
2251	fn transfer_refungible(
2252		collection: &CollectionHandle<T>,
2253		item_id: TokenId,
2254		value: u128,
2255		owner: T::CrossAccountId,
2256		new_owner: T::CrossAccountId,
2257	) -> DispatchResult {
2258		let collection_id = collection.id;
2259		collection.consume_sload()?;
2260		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)
2261			.ok_or(Error::<T>::TokenNotFound)?;
2262
2263		let item = full_item
2264			.owner
2265			.iter()
2266			.find(|i| i.owner == owner)
2267			.ok_or(Error::<T>::TokenNotFound)?;
2268		let amount = item.fraction;
2269
2270		ensure!(amount >= value, Error::<T>::TokenValueTooLow);
2271
2272		collection.consume_sload()?;
2273		// update balance
2274		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())
2275			.checked_sub(value)
2276			.ok_or(Error::<T>::NumOverflow)?;
2277		collection.consume_sstore()?;
2278		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);
2279
2280		collection.consume_sload()?;
2281		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())
2282			.checked_add(value)
2283			.ok_or(Error::<T>::NumOverflow)?;
2284		collection.consume_sstore()?;
2285		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);
2286
2287		let old_owner = item.owner.clone();
2288		let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);
2289
2290		let mut new_full_item = full_item.clone();
2291		// transfer
2292		if amount == value && !new_owner_has_account {
2293			// change owner
2294			// new owner do not have account
2295			new_full_item
2296				.owner
2297				.iter_mut()
2298				.find(|i| i.owner == owner)
2299				.expect("old owner does present in refungible")
2300				.owner = new_owner.clone();
2301			collection.consume_sstore()?;
2302			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
2303
2304			// update index collection
2305			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;
2306		} else {
2307			new_full_item
2308				.owner
2309				.iter_mut()
2310				.find(|i| i.owner == owner)
2311				.expect("old owner does present in refungible")
2312				.fraction -= value;
2313
2314			// separate amount
2315			if new_owner_has_account {
2316				// new owner has account
2317				new_full_item
2318					.owner
2319					.iter_mut()
2320					.find(|i| i.owner == new_owner)
2321					.expect("new owner has account")
2322					.fraction += value;
2323			} else {
2324				// new owner do not have account
2325				new_full_item.owner.push(Ownership {
2326					owner: new_owner.clone(),
2327					fraction: value,
2328				});
2329				Self::add_token_index(collection, item_id, &new_owner)?;
2330			}
2331
2332			collection.consume_sstore()?;
2333			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
2334		}
2335
2336		Self::deposit_event(RawEvent::Transfer(
2337			collection.id,
2338			item_id,
2339			owner,
2340			new_owner,
2341			amount,
2342		));
2343
2344		Ok(())
2345	}
2346
2347	fn transfer_nft(
2348		collection: &CollectionHandle<T>,
2349		item_id: TokenId,
2350		sender: T::CrossAccountId,
2351		new_owner: T::CrossAccountId,
2352	) -> DispatchResult {
2353		let collection_id = collection.id;
2354		collection.consume_sload()?;
2355		let mut item =
2356			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
2357
2358		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);
2359
2360		collection.consume_sload()?;
2361		// update balance
2362		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())
2363			.checked_sub(1)
2364			.ok_or(Error::<T>::NumOverflow)?;
2365		collection.consume_sstore()?;
2366		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);
2367
2368		collection.consume_sload()?;
2369		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())
2370			.checked_add(1)
2371			.ok_or(Error::<T>::NumOverflow)?;
2372		collection.consume_sstore()?;
2373		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);
2374
2375		// change owner
2376		let old_owner = item.owner.clone();
2377		item.owner = new_owner.clone();
2378		collection.consume_sstore()?;
2379		<NftItemList<T>>::insert(collection_id, item_id, item);
2380
2381		// update index collection
2382		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;
2383
2384		collection.log(ERC721Events::Transfer {
2385			from: *sender.as_eth(),
2386			to: *new_owner.as_eth(),
2387			token_id: item_id.into(),
2388		})?;
2389		Self::deposit_event(RawEvent::Transfer(
2390			collection.id,
2391			item_id,
2392			sender,
2393			new_owner,
2394			1,
2395		));
2396
2397		Ok(())
2398	}
2399
2400	fn set_re_fungible_variable_data(
2401		collection: &CollectionHandle<T>,
2402		item_id: TokenId,
2403		data: Vec<u8>,
2404	) -> DispatchResult {
2405		let collection_id = collection.id;
2406		let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)
2407			.ok_or(Error::<T>::TokenNotFound)?;
2408
2409		item.variable_data = data;
2410
2411		<ReFungibleItemList<T>>::insert(collection_id, item_id, item);
2412
2413		Ok(())
2414	}
2415
2416	fn set_nft_variable_data(
2417		collection: &CollectionHandle<T>,
2418		item_id: TokenId,
2419		data: Vec<u8>,
2420	) -> DispatchResult {
2421		let collection_id = collection.id;
2422		let mut item =
2423			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
2424
2425		item.variable_data = data;
2426
2427		<NftItemList<T>>::insert(collection_id, item_id, item);
2428
2429		Ok(())
2430	}
2431
2432	#[allow(dead_code)]
2433	fn init_collection(item: &Collection<T>) {
2434		// check params
2435		assert!(
2436			item.decimal_points <= MAX_DECIMAL_POINTS,
2437			"decimal_points parameter must be lower than MAX_DECIMAL_POINTS"
2438		);
2439		assert!(
2440			item.name.len() <= 64,
2441			"Collection name can not be longer than 63 char"
2442		);
2443		assert!(
2444			item.name.len() <= 256,
2445			"Collection description can not be longer than 255 char"
2446		);
2447		assert!(
2448			item.token_prefix.len() <= 16,
2449			"Token prefix can not be longer than 15 char"
2450		);
2451
2452		// Generate next collection ID
2453		let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();
2454
2455		CreatedCollectionCount::put(next_id);
2456	}
2457
2458	#[allow(dead_code)]
2459	fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {
2460		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
2461
2462		Self::add_token_index(
2463			&CollectionHandle::get(collection_id).unwrap(),
2464			current_index,
2465			&item.owner,
2466		)
2467		.unwrap();
2468
2469		<ItemListIndex>::insert(collection_id, current_index);
2470
2471		// Update balance
2472		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())
2473			.checked_add(1)
2474			.unwrap();
2475		<Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);
2476	}
2477
2478	#[allow(dead_code)]
2479	fn init_fungible_token(
2480		collection_id: CollectionId,
2481		owner: &T::CrossAccountId,
2482		item: &FungibleItemType,
2483	) {
2484		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
2485
2486		Self::add_token_index(
2487			&CollectionHandle::get(collection_id).unwrap(),
2488			current_index,
2489			owner,
2490		)
2491		.unwrap();
2492
2493		<ItemListIndex>::insert(collection_id, current_index);
2494
2495		// Update balance
2496		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
2497			.checked_add(item.value)
2498			.unwrap();
2499		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
2500	}
2501
2502	#[allow(dead_code)]
2503	fn init_refungible_token(
2504		collection_id: CollectionId,
2505		item: &ReFungibleItemType<T::CrossAccountId>,
2506	) {
2507		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
2508
2509		let value = item.owner.first().unwrap().fraction;
2510		let owner = item.owner.first().unwrap().owner.clone();
2511
2512		Self::add_token_index(
2513			&CollectionHandle::get(collection_id).unwrap(),
2514			current_index,
2515			&owner,
2516		)
2517		.unwrap();
2518
2519		<ItemListIndex>::insert(collection_id, current_index);
2520
2521		// Update balance
2522		let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())
2523			.checked_add(value)
2524			.unwrap();
2525		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
2526	}
2527
2528	fn add_token_index(
2529		collection: &CollectionHandle<T>,
2530		item_index: TokenId,
2531		owner: &T::CrossAccountId,
2532	) -> DispatchResult {
2533		collection.consume_sload()?;
2534		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
2535		if list_exists {
2536			collection.consume_sload()?;
2537			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
2538
2539			// bound Owned tokens by a single address in collection
2540			let account_items: u32 = list.len() as u32;
2541			ensure!(
2542				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
2543				Error::<T>::AddressOwnershipLimitExceeded
2544			);
2545
2546			let item_contains = list.contains(&item_index.clone());
2547
2548			if !item_contains {
2549				list.push(item_index);
2550			}
2551
2552			collection.consume_sstore()?;
2553			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);
2554		} else {
2555			let itm = vec![item_index];
2556			collection.consume_sstore()?;
2557			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);
2558		}
2559
2560		Ok(())
2561	}
2562
2563	fn remove_token_index(
2564		collection: &CollectionHandle<T>,
2565		item_index: TokenId,
2566		owner: &T::CrossAccountId,
2567	) -> DispatchResult {
2568		collection.consume_sload()?;
2569		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
2570		if list_exists {
2571			collection.consume_sload()?;
2572			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
2573			let item_contains = list.contains(&item_index.clone());
2574
2575			if item_contains {
2576				list.retain(|&item| item != item_index);
2577				collection.consume_sstore()?;
2578				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);
2579			}
2580		}
2581
2582		Ok(())
2583	}
2584
2585	fn move_token_index(
2586		collection: &CollectionHandle<T>,
2587		item_index: TokenId,
2588		old_owner: &T::CrossAccountId,
2589		new_owner: &T::CrossAccountId,
2590	) -> DispatchResult {
2591		Self::remove_token_index(collection, item_index, old_owner)?;
2592		Self::add_token_index(collection, item_index, new_owner)?;
2593
2594		Ok(())
2595	}
2596}
2597
2598sp_api::decl_runtime_apis! {
2599	pub trait NftApi {
2600		/// Used for ethereum integration
2601		fn eth_contract_code(account: H160) -> Option<Vec<u8>>;
2602	}932	}
2603}933}
2604934