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

92			{{~/each}}92			{{~/each}}
93	}93	}
94	{{~/each}}94	{{~/each}}
95}95}
96

6tmp=$(mktemp -d)6tmp=$(mktemp -d)
7cd $tmp7cd $tmp
8cp $dir/$INPUT input.sol8cp $dir/$INPUT input.sol
9solcjs --optimize --bin input.sol9solcjs --optimize --bin input.sol -o $PWD
1010
11mv input_sol_$(basename $OUTPUT .raw).bin out.bin11mv input_sol_$(basename $OUTPUT .raw).bin out.bin
12xxd -r -p out.bin out.raw12xxd -r -p out.bin out.raw

no syntactic changes

3members = [3members = [
4    'node/*',4    'node/*',
5    'pallets/*',5    'pallets/*',
6    'client/*',
6    'primitives/*',7    'primitives/*',
7    'runtime',8    'runtime',
8    'crates/*',9    'crates/*',

88
9.PHONY: regenerate_solidity9.PHONY: regenerate_solidity
10regenerate_solidity:10regenerate_solidity:
11	PACKAGE=pallet-nft NAME=eth::erc::fungible_iface OUTPUT=./tests/src/eth/api/UniqueFungible.sol ./.maintain/scripts/generate_api.sh11	PACKAGE=pallet-fungible NAME=erc::gen_iface OUTPUT=./tests/src/eth/api/UniqueFungible.sol ./.maintain/scripts/generate_api.sh
12	PACKAGE=pallet-nft NAME=eth::erc::nft_iface OUTPUT=./tests/src/eth/api/UniqueNFT.sol ./.maintain/scripts/generate_api.sh12	PACKAGE=pallet-nonfungible NAME=erc::gen_iface OUTPUT=./tests/src/eth/api/UniqueNFT.sol ./.maintain/scripts/generate_api.sh
13	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_iface OUTPUT=./tests/src/eth/api/ContractHelpers.sol ./.maintain/scripts/generate_api.sh13	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_iface OUTPUT=./tests/src/eth/api/ContractHelpers.sol ./.maintain/scripts/generate_api.sh
1414
15	PACKAGE=pallet-nft NAME=eth::erc::fungible_impl OUTPUT=./pallets/nft/src/eth/stubs/UniqueFungible.sol ./.maintain/scripts/generate_api.sh15	PACKAGE=pallet-fungible NAME=erc::gen_impl OUTPUT=./pallets/fungible/src/stubs/UniqueFungible.sol ./.maintain/scripts/generate_api.sh
16	PACKAGE=pallet-nft NAME=eth::erc::nft_impl OUTPUT=./pallets/nft/src/eth/stubs/UniqueNFT.sol ./.maintain/scripts/generate_api.sh16	PACKAGE=pallet-nonfungible NAME=erc::gen_impl OUTPUT=./pallets/nonfungible/src/stubs/UniqueNFT.sol ./.maintain/scripts/generate_api.sh
17	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_impl OUTPUT=./pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol ./.maintain/scripts/generate_api.sh17	PACKAGE=pallet-evm-contract-helpers NAME=eth::contract_helpers_impl OUTPUT=./pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol ./.maintain/scripts/generate_api.sh
1818
19FUNGIBLE_EVM_STUBS=./pallets/fungible/src/stubs
19NFT_EVM_STUBS=./pallets/nft/src/eth/stubs20NONFUNGIBLE_EVM_STUBS=./pallets/nonfungible/src/stubs
20CONTRACT_HELPERS_STUBS=./pallets/evm-contract-helpers/src/stubs/21CONTRACT_HELPERS_STUBS=./pallets/evm-contract-helpers/src/stubs/
2122
22$(NFT_EVM_STUBS)/UniqueFungible.raw: $(NFT_EVM_STUBS)/UniqueFungible.sol23$(FUNGIBLE_EVM_STUBS)/UniqueFungible.raw: $(FUNGIBLE_EVM_STUBS)/UniqueFungible.sol
23	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh24	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh
24$(NFT_EVM_STUBS)/UniqueNFT.raw: $(NFT_EVM_STUBS)/UniqueNFT.sol25$(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw: $(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.sol
25	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh26	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh
26$(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw: $(CONTRACT_HELPERS_STUBS)/ContractHelpers.sol27$(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw: $(CONTRACT_HELPERS_STUBS)/ContractHelpers.sol
27	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh28	INPUT=$< OUTPUT=$@ ./.maintain/scripts/compile_stub.sh
2829
29evm_stubs: $(NFT_EVM_STUBS)/UniqueFungible.raw $(NFT_EVM_STUBS)/UniqueNFT.raw $(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw30evm_stubs: $(FUNGIBLE_EVM_STUBS)/UniqueFungible.raw $(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw $(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw
3031
31.PHONY: _bench32.PHONY: _bench
32_bench:33_bench:
44bench-nft:45bench-nft:
45	make _bench PALLET=nft46	make _bench PALLET=nft
47
48.PHONY: bench-fungible
49bench-fungible:
50	make _bench PALLET=fungible
51
52.PHONY: bench-refungible
53bench-refungible:
54	make _bench PALLET=refungible
55
56.PHONY: bench-nonfungible
57bench-nonfungible:
58	make _bench PALLET=nonfungible
4659
47.PHONY: bench60.PHONY: bench
48bench: bench-evm-migration bench-nft61bench: bench-evm-migration bench-nft bench-fungible bench-refungible bench-nonfungible
4962

672		quote! {672		quote! {
673			#[derive(Debug)]673			#[derive(Debug)]
674			pub enum #call_name {674			pub enum #call_name {
675				ERC165Call(::evm_coder::ERC165Call),
675				#(676				#(
676					#calls,677					#calls,
677				)*678				)*
691				}692				}
692				pub fn supports_interface(interface_id: u32) -> bool {693				pub fn supports_interface(interface_id: u32) -> bool {
693					interface_id != 0xffffff && (694					interface_id != 0xffffff && (
695						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||
694						interface_id == Self::interface_id()696						interface_id == Self::interface_id()
695						#(697						#(
696							|| #supports_interface698							|| #supports_interface
702					use core::fmt::Write;704					use core::fmt::Write;
703					let interface = SolidityInterface {705					let interface = SolidityInterface {
704						name: #solidity_name,706						name: #solidity_name,
705						is: &["Dummy", #(707						is: &["Dummy", "ERC165", #(
706							#solidity_is,708							#solidity_is,
707						)* #(709						)* #(
708							#solidity_events_is,710							#solidity_events_is,
712						)*),714						)*),
713					};715					};
714					if is_impl {716					if is_impl {
715						tc.collect("// Common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\n".into());717						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());
716					} else {718					} else {
717						tc.collect("// Common stubs holder\ninterface Dummy {\n}\n".into());719						tc.collect("// Common stubs holder\ninterface Dummy {\n}\ninterface ERC165 is Dummy {\n\tfunction supportsInterface(bytes4 interfaceID) external view returns (bool);\n}\n".into());
718					}720					}
719					#(721					#(
720						#solidity_generators722						#solidity_generators
737				fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {739				fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {
738					use ::evm_coder::abi::AbiRead;740					use ::evm_coder::abi::AbiRead;
739					match method_id {741					match method_id {
742						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(::evm_coder::ERC165Call::parse(method_id, reader)?.map(Self::ERC165Call)),
740						#(743						#(
741							#parsers,744							#parsers,
742						)*745						)*
757						#(760						#(
758							#call_variants,761							#call_variants,
759						)*762						)*
763						InternalCall::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}) => {
764							let mut writer = ::evm_coder::abi::AbiWriter::default();
765							writer.bool(&InternalCall::supports_interface(interface_id));
766							return Ok(writer);
767						}
760						_ => {},768						_ => {},
761					}769					}
762					let mut writer = ::evm_coder::abi::AbiWriter::default();770					let mut writer = ::evm_coder::abi::AbiWriter::default();

2#[cfg(not(feature = "std"))]2#[cfg(not(feature = "std"))]
3extern crate alloc;3extern crate alloc;
44
5use abi::{AbiReader, AbiWriter};5use abi::{AbiRead, AbiReader, AbiWriter};
6pub use evm_coder_macros::{event_topic, fn_selector, solidity_interface, solidity, ToLog};6pub use evm_coder_macros::{event_topic, fn_selector, solidity_interface, solidity, ToLog};
7pub mod abi;7pub mod abi;
8pub mod events;8pub mod events;
61	fn call(&mut self, call: types::Msg<C>) -> execution::Result<AbiWriter>;61	fn call(&mut self, call: types::Msg<C>) -> execution::Result<AbiWriter>;
62}62}
63
64/// Implementation is implicitly provided for all interfaces
65///
66/// Note: no Callable implementation is provided
67#[derive(Debug)]
68pub enum ERC165Call {
69	SupportsInterface { interface_id: types::bytes4 },
70}
71
72impl ERC165Call {
73	pub const INTERFACE_ID: types::bytes4 = 0x01ffc9a7;
74}
75
76impl Call for ERC165Call {
77	fn parse(selector: u32, input: &mut AbiReader) -> execution::Result<Option<Self>> {
78		if selector != Self::INTERFACE_ID {
79			return Ok(None);
80		}
81		Ok(Some(Self::SupportsInterface {
82			interface_id: input.abi_read()?,
83		}))
84	}
85}
6386
64#[macro_export]87#[macro_export]
65macro_rules! generate_stubgen {88macro_rules! generate_stubgen {

55
6use cumulus_primitives_core::ParaId;6use cumulus_primitives_core::ParaId;
7use nft_runtime::*;7use nft_runtime::*;
8use nft_data_structs::*;
9use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};8use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};
10use sc_service::ChainType;9use sc_service::ChainType;
11use sp_core::{sr25519, Pair, Public};10use sp_core::{sr25519, Pair, Public};
168		treasury: Default::default(),167		treasury: Default::default(),
169		sudo: SudoConfig { key: root_key },168		sudo: SudoConfig { key: root_key },
170		vesting: VestingConfig { vesting: vec![] },169		vesting: VestingConfig { vesting: vec![] },
171		nft: NftConfig {
172			collection_id: vec![(
173				1,
174				Collection {
175					owner: get_account_id_from_seed::<sr25519::Public>("Alice"),
176					mode: CollectionMode::NFT,
177					access: AccessMode::Normal,
178					decimal_points: 0,
179					name: vec![],
180					description: vec![],
181					token_prefix: vec![],
182					mint_mode: false,
183					offchain_schema: vec![],
184					schema_version: SchemaVersion::default(),
185					sponsorship: SponsorshipState::Confirmed(get_account_id_from_seed::<
186						sr25519::Public,
187					>("Alice")),
188					const_on_chain_schema: vec![],
189					variable_on_chain_schema: vec![],
190					limits: CollectionLimits::default(),
191					meta_update_permission: MetaUpdatePermission::ItemOwner,
192					transfers_enabled: true,
193				},
194			)],
195			nft_item_id: vec![],
196			fungible_item_id: vec![],
197			refungible_item_id: vec![],
198		},
199		parachain_info: nft_runtime::ParachainInfoConfig { parachain_id: id },170		parachain_info: nft_runtime::ParachainInfoConfig { parachain_id: id },
200		aura: nft_runtime::AuraConfig {171		aura: nft_runtime::AuraConfig {
201			authorities: initial_authorities,172			authorities: initial_authorities,

49fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }49fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }
5050
51pallet-nft = { path = "../../pallets/nft" }51pallet-nft = { path = "../../pallets/nft" }
52uc-rpc = { path = "../../client/rpc" }
53up-rpc = { path = "../../primitives/rpc" }
52nft-runtime = { path = "../../runtime" }54nft-runtime = { path = "../../runtime" }
5355
54[features]56[features]

1use nft_runtime::{Hash, AccountId, Index, opaque::Block, BlockNumber, Balance};1use nft_runtime::{Hash, AccountId, CrossAccountId, Index, opaque::Block, BlockNumber, Balance};
2use fc_rpc::{2use fc_rpc::{
3	EthBlockDataCache, OverrideHandle, RuntimeApiStorageOverride, SchemaV1Override, StorageOverride,3	EthBlockDataCache, OverrideHandle, RuntimeApiStorageOverride, SchemaV1Override, StorageOverride,
4};4};
9	backend::{AuxStore, StorageProvider},9	backend::{AuxStore, StorageProvider},
10	client::BlockchainEvents,10	client::BlockchainEvents,
11};11};
12use pallet_nft::NftApi;
13use sc_finality_grandpa::{12use sc_finality_grandpa::{
14	FinalityProofProvider, GrandpaJustificationStream, SharedAuthoritySet, SharedVoterState,13	FinalityProofProvider, GrandpaJustificationStream, SharedAuthoritySet, SharedVoterState,
15};14};
101where100where
102	Block: sp_api::BlockT,101	Block: sp_api::BlockT,
103	C: ProvideRuntimeApi<Block>,102	C: ProvideRuntimeApi<Block>,
104	C::Api: pallet_nft::NftApi<Block>,103	C::Api: up_rpc::NftApi<Block, CrossAccountId, AccountId>,
105{104{
106	fn code(&self, block: &sp_api::BlockId<Block>, account: sp_core::H160) -> Option<Vec<u8>> {105	fn code(&self, block: &sp_api::BlockId<Block>, account: sp_core::H160) -> Option<Vec<u8>> {
106		use up_rpc::NftApi;
107		self.client107		self.client
108			.runtime_api()108			.runtime_api()
109			.eth_contract_code(block, account)109			.eth_contract_code(block, account)
127	// C::Api: pallet_contracts_rpc::ContractsRuntimeApi<Block, AccountId, Balance, BlockNumber, Hash>,127	// C::Api: pallet_contracts_rpc::ContractsRuntimeApi<Block, AccountId, Balance, BlockNumber, Hash>,
128	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,128	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
129	C::Api: fp_rpc::EthereumRuntimeRPCApi<Block>,129	C::Api: fp_rpc::EthereumRuntimeRPCApi<Block>,
130	C::Api: pallet_nft::NftApi<Block>,130	C::Api: up_rpc::NftApi<Block, CrossAccountId, AccountId>,
131	B: sc_client_api::Backend<Block> + Send + Sync + 'static,131	B: sc_client_api::Backend<Block> + Send + Sync + 'static,
132	B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashFor<Block>>,132	B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashFor<Block>>,
133	SC: SelectChain<Block> + 'static,133	SC: SelectChain<Block> + 'static,
139		EthPubSubApiServer, EthSigner, HexEncodedIdProvider, NetApi, NetApiServer, Web3Api,139		EthPubSubApiServer, EthSigner, HexEncodedIdProvider, NetApi, NetApiServer, Web3Api,
140		Web3ApiServer,140		Web3ApiServer,
141	};141	};
142	use uc_rpc::{NftApi, Nft};
142	// use pallet_contracts_rpc::{Contracts, ContractsApi};143	// use pallet_contracts_rpc::{Contracts, ContractsApi};
143	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApi};144	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApi};
144	use substrate_frame_rpc_system::{FullSystem, SystemApi};145	use substrate_frame_rpc_system::{FullSystem, SystemApi};
203		max_past_logs,204		max_past_logs,
204		block_data_cache.clone(),205		block_data_cache.clone(),
205	)));206	)));
207	io.extend_with(NftApi::to_delegate(Nft::new(client.clone())));
206208
207	if let Some(filter_pool) = filter_pool {209	if let Some(filter_pool) = filter_pool {
208		io.extend_with(EthFilterApiServer::to_delegate(EthFilterApi::new(210		io.extend_with(EthFilterApiServer::to_delegate(EthFilterApi::new(

16		execution::{self, Result},16		execution::{self, Result},
17		types::{Msg, value},17		types::{Msg, value},
18	};18	};
19	use frame_support::ensure;19	use frame_support::{ensure};
20	use pallet_evm::{ExitError, ExitReason, ExitRevert, ExitSucceed, PrecompileOutput};20	use pallet_evm::{ExitError, ExitReason, ExitRevert, ExitSucceed, PrecompileOutput};
21	pub use frame_support::dispatch::DispatchResult;21	pub use frame_support::dispatch::DispatchResult;
22	use pallet_ethereum::EthereumTransactionSender;22	use pallet_ethereum::EthereumTransactionSender;
106			self.logs.borrow_mut().push(log);106			self.logs.borrow_mut().push(log);
107			Ok(())107			Ok(())
108		}108		}
109		/// Doesn't consumes any gas, should be used after consume_log_sub
110		pub fn log_infallible(&self, log: impl ToLog) {
111			self.logs.borrow_mut().push(log.to_log(self.contract));
112		}
109		pub fn retrieve_logs(self) -> Vec<Log> {113		pub fn retrieve_logs(self) -> Vec<Log> {
110			self.logs.into_inner()114			self.logs.into_inner()
111		}115		}
116		pub fn consume_sload_sub(&self) -> DispatchResult {120		pub fn consume_sload_sub(&self) -> DispatchResult {
117			self.consume_gas_sub(G_SLOAD_WORD)121			self.consume_gas_sub(G_SLOAD_WORD)
118		}122		}
123		pub fn consume_sstores_sub(&self, amount: usize) -> DispatchResult {
124			self.consume_gas_sub(G_SSTORE_WORD.saturating_mul(amount as u64))
125		}
119		pub fn consume_sstore_sub(&self) -> DispatchResult {126		pub fn consume_sstore_sub(&self) -> DispatchResult {
120			self.consume_gas_sub(G_SSTORE_WORD)127			self.consume_gas_sub(G_SSTORE_WORD)
121		}128		}
129		pub fn consume_log_sub(&self, topics: usize, data: usize) -> DispatchResult {
130			self.consume_gas_sub(log_price(data, topics))
131		}
122		pub fn consume_gas_sub(&self, gas: u64) -> DispatchResult {132		pub fn consume_gas_sub(&self, gas: u64) -> DispatchResult {
123			ensure!(gas != u64::MAX, Error::<T>::OutOfGas);133			ensure!(gas != u64::MAX, Error::<T>::OutOfGas);
124			let mut gas_limit = self.gas_limit.borrow_mut();134			let mut gas_limit = self.gas_limit.borrow_mut();

binary blob — no preview

9	string stub_error = "this contract is implemented in native";9	string stub_error = "this contract is implemented in native";
10}10}
11
12contract ERC165 is Dummy {
13	function supportsInterface(bytes4 interfaceID)
14		external
15		view
16		returns (bool)
17	{
18		require(false, stub_error);
19		interfaceID;
20		return true;
21	}
22}
1123
12contract ContractHelpers is Dummy {24contract ContractHelpers is Dummy, ERC165 {
13	// Selector: contractOwner(address) 5152b14c25	// Selector: contractOwner(address) 5152b14c
14	function contractOwner(address contractAddress)26	function contractOwner(address contractAddress)
15		public27		public

3use super::*;3use super::*;
4use crate::Module as Inflation;4use crate::Module as Inflation;
55
6use sp_std::prelude::*;
7use frame_system::RawOrigin;
8use frame_benchmarking::{benchmarks};6use frame_benchmarking::{benchmarks};
9use frame_support::traits::OnInitialize;7use frame_support::traits::OnInitialize;
108

1616
17[features]17[features]
18default = ['std']18default = ['std']
19runtime-benchmarks = ['frame-benchmarking']19runtime-benchmarks = ['frame-benchmarking', 'pallet-common/runtime-benchmarks']
20std = [20std = [
21    'codec/std',21    'codec/std',
22    'serde/std',22    'serde/std',
27    'pallet-timestamp/std',27    'pallet-timestamp/std',
28    'pallet-randomness-collective-flip/std',28    'pallet-randomness-collective-flip/std',
29    'pallet-transaction-payment/std',29    'pallet-transaction-payment/std',
30    'pallet-common/std',
31    'pallet-fungible/std',
32    'pallet-nonfungible/std',
33    'pallet-refungible/std',
30    'fp-evm/std',34    'fp-evm/std',
31    'nft-data-structs/std',35    'nft-data-structs/std',
32    'up-sponsorship/std',36    'up-sponsorship/std',
145fp-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }151fp-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }
146hex-literal = "0.3.3"152hex-literal = "0.3.3"
153
154pallet-common = { default-features = false, path = "../common" }
155pallet-fungible = { default-features = false, path = "../fungible" }
156pallet-nonfungible = { default-features = false, path = "../nonfungible" }
157pallet-refungible = { default-features = false, path = "../refungible" }
147158

7use nft_data_structs::*;7use nft_data_structs::*;
8use core::convert::TryInto;8use core::convert::TryInto;
9use sp_runtime::DispatchError;9use sp_runtime::DispatchError;
10use pallet_common::benchmarking::{create_data, create_u16_data};
1011
11const SEED: u32 = 1;12const SEED: u32 = 1;
12
13fn create_data(size: usize) -> Vec<u8> {
14	(0..size).map(|v| (v & 0xff) as u8).collect()
15}
16fn create_u16_data(size: usize) -> Vec<u16> {
17	(0..size).map(|v| (v & 0xffff) as u16).collect()
18}
19
20fn default_nft_data() -> CreateItemData {
21	CreateItemData::NFT(CreateNftData {
22		const_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
23		variable_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
24	})
25}
26
27fn default_fungible_data() -> CreateItemData {
28	CreateItemData::Fungible(CreateFungibleData { value: 1000 })
29}
30
31fn default_re_fungible_data() -> CreateItemData {
32	CreateItemData::ReFungible(CreateReFungibleData {
33		const_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
34		variable_data: create_data(CUSTOM_DATA_LIMIT as usize).try_into().unwrap(),
35		pieces: 1000,
36	})
37}
3813
39fn create_collection_helper<T: Config>(14fn create_collection_helper<T: Config>(
40	owner: T::AccountId,15	owner: T::AccountId,
55		token_prefix,30		token_prefix,
56		mode,31		mode,
57	)?;32	)?;
58	Ok(CreatedCollectionCount::get())33	Ok(<pallet_common::CreatedCollectionCount<T>>::get())
59}34}
60fn create_nft_collection<T: Config>(owner: T::AccountId) -> Result<CollectionId, DispatchError> {35fn create_nft_collection<T: Config>(owner: T::AccountId) -> Result<CollectionId, DispatchError> {
61	create_collection_helper::<T>(owner, CollectionMode::NFT)36	create_collection_helper::<T>(owner, CollectionMode::NFT)
62}37}
63fn create_fungible_collection<T: Config>(
64	owner: T::AccountId,
65) -> Result<CollectionId, DispatchError> {
66	create_collection_helper::<T>(owner, CollectionMode::Fungible(0))
67}
68fn create_refungible_collection<T: Config>(
69	owner: T::AccountId,
70) -> Result<CollectionId, DispatchError> {
71	create_collection_helper::<T>(owner, CollectionMode::ReFungible)
72}
7338
74benchmarks! {39benchmarks! {
7540
82		T::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());47		T::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
83	}: _(RawOrigin::Signed(caller.clone()), col_name.clone(), col_desc.clone(), token_prefix.clone(), mode)48	}: _(RawOrigin::Signed(caller.clone()), col_name.clone(), col_desc.clone(), token_prefix.clone(), mode)
84	verify {49	verify {
85		assert_eq!(<Pallet<T>>::collection_id(2).unwrap().owner, caller);50		assert_eq!(<pallet_common::CollectionById<T>>::get(CollectionId(1)).unwrap().owner, caller);
86	}51	}
8752
88	destroy_collection {53	destroy_collection {
129		let caller: T::AccountId = account("caller", 0, SEED);94		let caller: T::AccountId = account("caller", 0, SEED);
130		let collection = create_nft_collection::<T>(caller.clone())?;95		let collection = create_nft_collection::<T>(caller.clone())?;
131		let new_admin: T::AccountId = account("admin", 0, SEED);96		let new_admin: T::AccountId = account("admin", 0, SEED);
132		<Pallet<T>>::add_collection_admin(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(new_admin.clone()))?;97		<Pallet<T>>::add_collection_admin(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(new_admin.clone()))?;
133	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(new_admin))98	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(new_admin))
13499
135	set_collection_sponsor {100	set_collection_sponsor {
140	confirm_sponsorship {105	confirm_sponsorship {
141		let caller: T::AccountId = account("caller", 0, SEED);106		let caller: T::AccountId = account("caller", 0, SEED);
142		let collection = create_nft_collection::<T>(caller.clone())?;107		let collection = create_nft_collection::<T>(caller.clone())?;
143		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;108		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), collection, caller.clone())?;
144	}: _(RawOrigin::Signed(caller.clone()), collection)109	}: _(RawOrigin::Signed(caller.clone()), collection)
145110
146	remove_collection_sponsor {111	remove_collection_sponsor {
147		let caller: T::AccountId = account("caller", 0, SEED);112		let caller: T::AccountId = account("caller", 0, SEED);
148		let collection = create_nft_collection::<T>(caller.clone())?;113		let collection = create_nft_collection::<T>(caller.clone())?;
149		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), 2, caller.clone())?;114		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), collection, caller.clone())?;
150		<Pallet<T>>::confirm_sponsorship(RawOrigin::Signed(caller.clone()).into(), 2)?;115		<Pallet<T>>::confirm_sponsorship(RawOrigin::Signed(caller.clone()).into(), collection)?;
151	}: _(RawOrigin::Signed(caller.clone()), collection)116	}: _(RawOrigin::Signed(caller.clone()), collection)
152
153	// nft item
154	create_item_nft {
155		let b in 0..(CUSTOM_DATA_LIMIT * 2);
156
157		let caller: T::AccountId = account("caller", 0, SEED);
158		let collection = create_nft_collection::<T>(caller.clone())?;
159		let data = CreateItemData::NFT(CreateNftData {
160			const_data: create_data(b.min(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
161			variable_data: create_data(b.saturating_sub(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
162		});
163	}: create_item(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
164
165	create_multiple_items_nft {
166		// TODO: Take item data size into account. As create_item_nft bench shows, this parameter has no effect on execution time,
167		// but it may if we increase CUSTOM_DATA_LIMIT
168		let b in 1..1000;
169
170		let caller: T::AccountId = account("caller", 0, SEED);
171		let collection = create_nft_collection::<T>(caller.clone())?;
172		let data = (0..b).map(|_| default_nft_data()).collect();
173	}: create_multiple_items(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
174
175	// fungible item
176	create_item_fungible {
177		let caller: T::AccountId = account("caller", 0, SEED);
178		let collection = create_fungible_collection::<T>(caller.clone())?;
179		let data = CreateItemData::Fungible(CreateFungibleData {
180			value: 1000,
181		});
182	}: create_item(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
183
184	create_multiple_items_fungible {
185		let b in 1..1000;
186
187		let caller: T::AccountId = account("caller", 0, SEED);
188		let collection = create_fungible_collection::<T>(caller.clone())?;
189		let data = (0..b).map(|_| default_fungible_data()).collect();
190	}: create_multiple_items(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
191
192	// refungible item
193	create_item_refungible {
194		let b in 0..(CUSTOM_DATA_LIMIT * 2);
195
196		let caller: T::AccountId = account("caller", 0, SEED);
197		let collection = create_refungible_collection::<T>(caller.clone())?;
198		let data = CreateItemData::ReFungible(CreateReFungibleData {
199			const_data: create_data(b.min(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
200			variable_data: create_data(b.saturating_sub(CUSTOM_DATA_LIMIT) as usize).try_into().unwrap(),
201			pieces: 1000,
202		});
203	}: create_item(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
204
205	create_multiple_items_refungible {
206		// TODO: Take item data size into account. As create_item_nft bench shows, this parameter has no effect on execution time,
207		// but it may if we increase CUSTOM_DATA_LIMIT
208		let b in 1..1000;
209
210		let caller: T::AccountId = account("caller", 0, SEED);
211		let collection = create_refungible_collection::<T>(caller.clone())?;
212		let data = (0..b).map(|_| default_re_fungible_data()).collect();
213	}: create_multiple_items(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(caller.clone()), data)
214
215	burn_item_nft {
216		let caller: T::AccountId = account("caller", 0, SEED);
217		let collection = create_nft_collection::<T>(caller.clone())?;
218		let data = default_nft_data();
219		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
220	}: burn_item(RawOrigin::Signed(caller.clone()), collection, 1, 1)
221
222	transfer_nft {
223		let caller: T::AccountId = account("caller", 0, SEED);
224		let collection = create_nft_collection::<T>(caller.clone())?;
225		let recipient: T::AccountId = account("recipient", 0, SEED);
226		let data = default_nft_data();
227		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
228	}: transfer(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
229
230	transfer_fungible {
231		let caller: T::AccountId = account("caller", 0, SEED);
232		let collection = create_fungible_collection::<T>(caller.clone())?;
233		let recipient: T::AccountId = account("recipient", 0, SEED);
234		let data = default_fungible_data();
235		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
236	}: transfer(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
237
238	transfer_refungible {
239		let caller: T::AccountId = account("caller", 0, SEED);
240		let collection = create_refungible_collection::<T>(caller.clone())?;
241		let recipient: T::AccountId = account("recipient", 0, SEED);
242		let data = default_re_fungible_data();
243		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(caller.clone()), data)?;
244	}: transfer(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
245117
246	set_transfers_enabled_flag {118	set_transfers_enabled_flag {
247		let caller: T::AccountId = account("caller", 0, SEED);119		let caller: T::AccountId = account("caller", 0, SEED);
248		let collection = create_nft_collection::<T>(caller.clone())?;120		let collection = create_nft_collection::<T>(caller.clone())?;
249	}: _(RawOrigin::Signed(caller.clone()), collection, false)121	}: _(RawOrigin::Signed(caller.clone()), collection, false)
250
251	approve_nft {
252		let caller: T::AccountId = account("caller", 0, SEED);
253		let collection = create_nft_collection::<T>(caller.clone())?;
254		let recipient: T::AccountId = account("recipient", 0, SEED);
255		let data = default_nft_data();
256		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
257	}: approve(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), collection, 1, 1)
258
259	// Nft
260	transfer_from_nft {
261		let caller: T::AccountId = account("caller", 0, SEED);
262		let collection = create_nft_collection::<T>(caller.clone())?;
263		let recipient: T::AccountId = account("recipient", 0, SEED);
264		let data = default_nft_data();
265		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
266		<Pallet<T>>::approve(RawOrigin::Signed(caller.clone()).into(), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)?;
267	}: transfer_from(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)
268
269	// Fungible
270	transfer_from_fungible {
271		let caller: T::AccountId = account("caller", 0, SEED);
272		let collection = create_fungible_collection::<T>(caller.clone())?;
273		let recipient: T::AccountId = account("recipient", 0, SEED);
274		let data = default_fungible_data();
275		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
276		<Pallet<T>>::approve(RawOrigin::Signed(caller.clone()).into(), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)?;
277	}: transfer_from(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)
278
279	// ReFungible
280	transfer_from_refungible {
281		let caller: T::AccountId = account("caller", 0, SEED);
282		let collection = create_refungible_collection::<T>(caller.clone())?;
283		let recipient: T::AccountId = account("recipient", 0, SEED);
284		let data = default_re_fungible_data();
285		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
286		<Pallet<T>>::approve(RawOrigin::Signed(caller.clone()).into(), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)?;
287	}: transfer_from(RawOrigin::Signed(caller.clone()), T::CrossAccountId::from_sub(caller.clone()), T::CrossAccountId::from_sub(recipient.clone()), 2, 1, 1)
288122
289	set_offchain_schema {123	set_offchain_schema {
290		let b in 0..OFFCHAIN_SCHEMA_LIMIT;124		let b in 0..OFFCHAIN_SCHEMA_LIMIT;
308		let caller: T::AccountId = account("caller", 0, SEED);142		let caller: T::AccountId = account("caller", 0, SEED);
309		let collection = create_nft_collection::<T>(caller.clone())?;143		let collection = create_nft_collection::<T>(caller.clone())?;
310		let data = create_data(b as usize);144		let data = create_data(b as usize);
311	}: set_variable_on_chain_schema(RawOrigin::Signed(caller.clone()), 2, data)145	}: set_variable_on_chain_schema(RawOrigin::Signed(caller.clone()), collection, data)
312
313	set_variable_meta_data_nft {
314		let b in 0..CUSTOM_DATA_LIMIT;
315
316		let caller: T::AccountId = account("caller", 0, SEED);
317		let collection = create_nft_collection::<T>(caller.clone())?;
318		let data = default_nft_data();
319		<Pallet<T>>::create_item(RawOrigin::Signed(caller.clone()).into(), 2, T::CrossAccountId::from_sub(caller.clone()), data)?;
320		let data = create_data(b as usize);
321	}: set_variable_meta_data(RawOrigin::Signed(caller.clone()), collection, 1, data)
322146
323	set_schema_version {147	set_schema_version {
324		let caller: T::AccountId = account("caller", 0, SEED);148		let caller: T::AccountId = account("caller", 0, SEED);
325		let collection = create_nft_collection::<T>(caller.clone())?;149		let collection = create_nft_collection::<T>(caller.clone())?;
326	}: set_schema_version(RawOrigin::Signed(caller.clone()), 2, SchemaVersion::Unique)150	}: set_schema_version(RawOrigin::Signed(caller.clone()), collection, SchemaVersion::Unique)
327151
328	set_collection_limits{152	set_collection_limits{
329		let caller: T::AccountId = account("caller", 0, SEED);153		let caller: T::AccountId = account("caller", 0, SEED);
330		let collection = create_nft_collection::<T>(caller.clone())?;154		let collection = create_nft_collection::<T>(caller.clone())?;
331155
332		let cl = CollectionLimits {156		let cl = CollectionLimits {
333			account_token_ownership_limit: 0,157			account_token_ownership_limit: Some(0),
334			sponsored_data_size: 0,158			sponsored_data_size: 0,
335			token_limit: 1,159			token_limit: 1,
336			sponsor_transfer_timeout: 0,160			sponsor_transfer_timeout: 0,
337			owner_can_destroy: true,161			owner_can_destroy: true,
338			owner_can_transfer: true,162			owner_can_transfer: true,
339			sponsored_data_rate_limit: None,163			sponsored_data_rate_limit: None,
340		};164		};
341	}: set_collection_limits(RawOrigin::Signed(caller.clone()), 2, cl)165	}: set_collection_limits(RawOrigin::Signed(caller.clone()), collection, cl)
166
167	set_meta_update_permission_flag {
168		let caller: T::AccountId = account("caller", 0, SEED);
169		let collection = create_nft_collection::<T>(caller.clone())?;
170	}: _(RawOrigin::Signed(caller.clone()), collection, MetaUpdatePermission::Admin)
342}171}
343172