git.delta.rocks / unique-network / refs/commits / 0d95470f91b8

57225722
5723[[package]]5723[[package]]
5724name = "pallet-common"5724name = "pallet-common"
5725version = "0.1.3"5725version = "0.1.4"
5726dependencies = [5726dependencies = [
5727 "ethereum",5727 "ethereum",
5728 "evm-coder",5728 "evm-coder",
58695869
5870[[package]]5870[[package]]
5871name = "pallet-evm-coder-substrate"5871name = "pallet-evm-coder-substrate"
5872version = "0.1.0"5872version = "0.1.1"
5873dependencies = [5873dependencies = [
5874 "ethereum",5874 "ethereum",
5875 "evm-coder",5875 "evm-coder",
58875887
5888[[package]]5888[[package]]
5889name = "pallet-evm-contract-helpers"5889name = "pallet-evm-contract-helpers"
5890version = "0.1.0"5890version = "0.1.1"
5891dependencies = [5891dependencies = [
5892 "evm-coder",5892 "evm-coder",
5893 "fp-evm-mapping",5893 "fp-evm-mapping",
61896189
6190[[package]]6190[[package]]
6191name = "pallet-nonfungible"6191name = "pallet-nonfungible"
6192version = "0.1.2"6192version = "0.1.3"
6193dependencies = [6193dependencies = [
6194 "ethereum",6194 "ethereum",
6195 "evm-coder",6195 "evm-coder",
63116311
6312[[package]]6312[[package]]
6313name = "pallet-refungible"6313name = "pallet-refungible"
6314version = "0.2.1"6314version = "0.2.2"
6315dependencies = [6315dependencies = [
6316 "derivative",
6316 "ethereum",6317 "ethereum",
6317 "evm-coder",6318 "evm-coder",
6318 "frame-benchmarking",6319 "frame-benchmarking",
63336334
6334[[package]]6335[[package]]
6335name = "pallet-rmrk-core"6336name = "pallet-rmrk-core"
6336version = "0.1.0"6337version = "0.1.1"
6337dependencies = [6338dependencies = [
6338 "derivative",6339 "derivative",
6339 "frame-benchmarking",6340 "frame-benchmarking",
63546355
6355[[package]]6356[[package]]
6356name = "pallet-rmrk-equip"6357name = "pallet-rmrk-equip"
6357version = "0.1.0"6358version = "0.1.1"
6358dependencies = [6359dependencies = [
6359 "frame-benchmarking",6360 "frame-benchmarking",
6360 "frame-support",6361 "frame-support",
64846485
6485[[package]]6486[[package]]
6486name = "pallet-structure"6487name = "pallet-structure"
6487version = "0.1.0"6488version = "0.1.1"
6488dependencies = [6489dependencies = [
6489 "frame-benchmarking",6490 "frame-benchmarking",
6490 "frame-support",6491 "frame-support",
66296630
6630[[package]]6631[[package]]
6631name = "pallet-unique"6632name = "pallet-unique"
6632version = "0.1.1"6633version = "0.1.2"
6633dependencies = [6634dependencies = [
6634 "ethereum",6635 "ethereum",
6635 "evm-coder",6636 "evm-coder",
1273212733
12733[[package]]12734[[package]]
12734name = "up-data-structs"12735name = "up-data-structs"
12735version = "0.2.0"12736version = "0.2.1"
12736dependencies = [12737dependencies = [
12737 "derivative",12738 "derivative",
12738 "frame-support",12739 "frame-support",
1275012751
12751[[package]]12752[[package]]
12752name = "up-rpc"12753name = "up-rpc"
12753version = "0.1.1"12754version = "0.1.2"
12754dependencies = [12755dependencies = [
12755 "pallet-common",12756 "pallet-common",
12756 "pallet-evm",12757 "pallet-evm",

1[package]1[package]
2name = "pallet-common"2name = "pallet-common"
3version = "0.1.3"3version = "0.1.4"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

1[package]1[package]
2name = "pallet-evm-coder-substrate"2name = "pallet-evm-coder-substrate"
3version = "0.1.0"3version = "0.1.1"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

1[package]1[package]
2name = "pallet-evm-contract-helpers"2name = "pallet-evm-contract-helpers"
3version = "0.1.0"3version = "0.1.1"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

9license = 'GPLv3'9license = 'GPLv3'
10name = 'pallet-inflation'10name = 'pallet-inflation'
11repository = 'https://github.com/UniqueNetwork/unique-chain'11repository = 'https://github.com/UniqueNetwork/unique-chain'
12version = '0.1.0'12version = "0.1.0"
1313
14[package.metadata.docs.rs]14[package.metadata.docs.rs]
15targets = ['x86_64-unknown-linux-gnu']15targets = ['x86_64-unknown-linux-gnu']

1[package]1[package]
2name = "pallet-nonfungible"2name = "pallet-nonfungible"
3version = "0.1.2"3version = "0.1.3"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

1[package]1[package]
2name = "pallet-rmrk-core"2name = "pallet-rmrk-core"
3version = "0.1.0"3version = "0.1.1"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

1[package]1[package]
2name = "pallet-rmrk-equip"2name = "pallet-rmrk-equip"
3version = "0.1.0"3version = "0.1.1"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

22
3All notable changes to this project will be documented in this file.3All notable changes to this project will be documented in this file.
44
5<!-- bureaucrate goes here -->
6## [v0.2.2] 2022-08-04
7
8### Product changes
9
10- Now RefungibleMultipleItems may only receive single user on type level.
11
12### Added features
13
14- Implement property RPC 7bf45b532e32daa91f03c157b58874d21b42ae1f
15
16### Other changes
17
18- refactor: Disallow invalid bulk mints 53fec71cf728dddd012257b407ea30441e699f88
19
20`create_multiple_items_ex` was allowing invalid (that will be always
21rejected at runtime level) refungible mint extrinsics, by passing
22multiple users into `RefungibleMultipleItems` call.
23
5## [v0.2.1] - 2022-07-2724## [v0.2.1] - 2022-07-27
625
7### New features26### New features

1[package]1[package]
2name = "pallet-refungible"2name = "pallet-refungible"
3version = "0.2.1"3version = "0.2.2"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66
28sp-core = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.24" }28sp-core = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.24" }
29sp-runtime = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.24" }29sp-runtime = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.24" }
30sp-std = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.24" }30sp-std = { default-features = false, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.24" }
31derivative = { version = "2.2.0", features = ["use_core"] }
3132
32[features]33[features]
33default = ["std"]34default = ["std"]

19use sp_std::collections::btree_map::BTreeMap;19use sp_std::collections::btree_map::BTreeMap;
20use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get};20use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get};
21use up_data_structs::{21use up_data_structs::{
22	CollectionId, TokenId, CreateItemExData, CreateRefungibleExData, budget::Budget, Property,22	CollectionId, TokenId, CreateItemExData, budget::Budget, Property, PropertyKey, PropertyValue,
23	PropertyKey, PropertyValue, PropertyKeyPermission, CreateItemData, CollectionPropertiesVec,23	PropertyKeyPermission, CollectionPropertiesVec, CreateRefungibleExMultipleOwners,
24	CreateRefungibleExSingleOwner,
24};25};
25use pallet_common::{26use pallet_common::{
26	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,27	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight,
3233
33use crate::{34use crate::{
34	AccountBalance, Allowance, Balance, Config, Error, Owned, Pallet, RefungibleHandle,35	AccountBalance, Allowance, Balance, Config, Error, Owned, Pallet, RefungibleHandle,
35	SelfWeightOf, TokenData, weights::WeightInfo, TokensMinted, TotalSupply,36	SelfWeightOf, weights::WeightInfo, TokensMinted, TotalSupply, CreateItemData,
36};37};
3738
38macro_rules! max_weight_of {39macro_rules! max_weight_of {
58		<SelfWeightOf<T>>::create_item()59		<SelfWeightOf<T>>::create_item()
59	}60	}
6061
61	fn create_multiple_items(data: &[CreateItemData]) -> Weight {62	fn create_multiple_items(data: &[up_data_structs::CreateItemData]) -> Weight {
62		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32).saturating_add(63		<SelfWeightOf<T>>::create_multiple_items(data.len() as u32).saturating_add(
63			data.iter()64			data.iter()
64				.map(|data| match data {65				.map(|data| match data {
65					CreateItemData::ReFungible(rft_data) => {66					up_data_structs::CreateItemData::ReFungible(rft_data) => {
66						properties_weight::<T>(&rft_data.properties)67						properties_weight::<T>(&rft_data.properties)
67					}68					}
68					_ => 0,69					_ => 0,
152fn map_create_data<T: Config>(153fn map_create_data<T: Config>(
153	data: up_data_structs::CreateItemData,154	data: up_data_structs::CreateItemData,
154	to: &T::CrossAccountId,155	to: &T::CrossAccountId,
155) -> Result<CreateRefungibleExData<T::CrossAccountId>, DispatchError> {156) -> Result<CreateItemData<T::CrossAccountId>, DispatchError> {
156	match data {157	match data {
157		up_data_structs::CreateItemData::ReFungible(data) => Ok(CreateRefungibleExData {158		up_data_structs::CreateItemData::ReFungible(data) => Ok(CreateItemData {
158			users: {159			users: {
159				let mut out = BTreeMap::new();160				let mut out = BTreeMap::new();
160				out.insert(to.clone(), data.pieces);161				out.insert(to.clone(), data.pieces);
214	) -> DispatchResultWithPostInfo {215	) -> DispatchResultWithPostInfo {
215		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);216		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);
216		let data = match data {217		let data = match data {
217			CreateItemExData::RefungibleMultipleOwners(r) => vec![r],218			CreateItemExData::RefungibleMultipleOwners(CreateRefungibleExMultipleOwners {
219				users,
220				properties,
221			}) => vec![CreateItemData { users, properties }],
218			CreateItemExData::RefungibleMultipleItems(r)222			CreateItemExData::RefungibleMultipleItems(r) => r
223				.into_inner()
224				.into_iter()
219				if r.iter().all(|i| i.users.len() == 1) =>225				.map(
220			{226					|CreateRefungibleExSingleOwner {
227					     user,
228					     pieces,
229					     properties,
230					 }| CreateItemData {
231						users: BTreeMap::from([(user, pieces)])
232							.try_into()
233							.expect("limit >= 1"),
234						properties,
235					},
236				)
221				r.into_inner()237				.collect(),
222			}
223			_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),238			_ => fail!(<Error<T>>::NotRefungibleDataUsedToMintFungibleCollectionToken),
224		};239		};
225240
442		<Pallet<T>>::token_owners(self.id, token).unwrap_or_default()457		<Pallet<T>>::token_owners(self.id, token).unwrap_or_default()
443	}458	}
444459
445	fn token_property(&self, _token_id: TokenId, _key: &PropertyKey) -> Option<PropertyValue> {460	fn token_property(&self, token_id: TokenId, key: &PropertyKey) -> Option<PropertyValue> {
446		None461		<Pallet<T>>::token_properties((self.id, token_id))
462			.get(key)
463			.cloned()
447	}464	}
448465
449	fn token_properties(466	fn token_properties(&self, token_id: TokenId, keys: Option<Vec<PropertyKey>>) -> Vec<Property> {
450		&self,
451		_token_id: TokenId,
452		_keys: Option<Vec<PropertyKey>>,
453	) -> Vec<Property> {
454		Vec::new()467		let properties = <Pallet<T>>::token_properties((self.id, token_id));
468
469		keys.map(|keys| {
470			keys.into_iter()
471				.filter_map(|key| {
472					properties.get(&key).map(|value| Property {
473						key,
474						value: value.clone(),
475					})
476				})
477				.collect()
478		})
479		.unwrap_or_else(|| {
480			properties
481				.into_iter()
482				.map(|(key, value)| Property { key, value })
483				.collect()
484		})
455	}485	}
456486
457	fn total_supply(&self) -> u32 {487	fn total_supply(&self) -> u32 {

27	convert::TryInto,27	convert::TryInto,
28};28};
29use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};29use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};
30use frame_support::{BoundedBTreeMap, BoundedVec};30use frame_support::BoundedBTreeMap;
31use pallet_common::{31use pallet_common::{
32	CollectionHandle, CollectionPropertyPermissions,32	CollectionHandle, CollectionPropertyPermissions,
33	erc::{33	erc::{
494		<Pallet<T>>::create_item(494		<Pallet<T>>::create_item(
495			self,495			self,
496			&caller,496			&caller,
497			CreateItemData::<T> {497			CreateItemData::<T::CrossAccountId> {
498				users,498				users,
499				properties: CollectionPropertiesVec::default(),499				properties: CollectionPropertiesVec::default(),
500			},500			},
560		<Pallet<T>>::create_item(560		<Pallet<T>>::create_item(
561			self,561			self,
562			&caller,562			&caller,
563			CreateItemData::<T> { users, properties },563			CreateItemData::<T::CrossAccountId> { users, properties },
564			&budget,564			&budget,
565		)565		)
566		.map_err(dispatch_to_evm::<T>)?;566		.map_err(dispatch_to_evm::<T>)?;
717			.collect::<BTreeMap<_, _>>()717			.collect::<BTreeMap<_, _>>()
718			.try_into()718			.try_into()
719			.unwrap();719			.unwrap();
720		let create_item_data = CreateItemData::<T> {720		let create_item_data = CreateItemData::<T::CrossAccountId> {
721			users,721			users,
722			properties: CollectionPropertiesVec::default(),722			properties: CollectionPropertiesVec::default(),
723		};723		};
777				})777				})
778				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;778				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;
779779
780			let create_item_data = CreateItemData::<T> {780			let create_item_data = CreateItemData::<T::CrossAccountId> {
781				users: users.clone(),781				users: users.clone(),
782				properties,782				properties,
783			};783			};

94use core::ops::Deref;94use core::ops::Deref;
95use evm_coder::ToLog;95use evm_coder::ToLog;
96use frame_support::{BoundedVec, ensure, fail, storage::with_transaction, transactional};96use frame_support::{
97	BoundedVec, ensure, fail, storage::with_transaction, transactional, pallet_prelude::ConstU32,
98};
97use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};99use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};
98use pallet_evm_coder_substrate::WithRecorder;100use pallet_evm_coder_substrate::WithRecorder;
106use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};108use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome};
107use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};109use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap};
108use up_data_structs::{110use up_data_structs::{
109	AccessMode, budget::Budget, CollectionId, CreateCollectionData, CreateRefungibleExData,111	AccessMode, budget::Budget, CollectionId, CreateCollectionData, CustomDataLimit,
110	CustomDataLimit, mapping::TokenAddressMapping, MAX_REFUNGIBLE_PIECES, TokenId, Property,112	mapping::TokenAddressMapping, MAX_REFUNGIBLE_PIECES, MAX_ITEMS_PER_BATCH, TokenId, Property,
111	PropertyKey, PropertyKeyPermission, PropertyPermission, PropertyScope, PropertyValue,113	PropertyKey, PropertyKeyPermission, PropertyPermission, PropertyScope, PropertyValue,
112	TrySetProperty,114	TrySetProperty, CollectionPropertiesVec,
113};115};
116use frame_support::BoundedBTreeMap;
117use derivative::Derivative;
114118
115pub use pallet::*;119pub use pallet::*;
116#[cfg(feature = "runtime-benchmarks")]120#[cfg(feature = "runtime-benchmarks")]
120pub mod erc_token;124pub mod erc_token;
121pub mod weights;125pub mod weights;
122126
127#[derive(Derivative, Clone)]
123pub type CreateItemData<T> =128pub struct CreateItemData<CrossAccountId> {
129	#[derivative(Debug(format_with = "bounded::map_debug"))]
124	CreateRefungibleExData<<T as pallet_evm::account::Config>::CrossAccountId>;130	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,
131	#[derivative(Debug(format_with = "bounded::vec_debug"))]
132	pub properties: CollectionPropertiesVec,
133}
125pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;134pub(crate) type SelfWeightOf<T> = <T as Config>::WeightInfo;
126135
127/// Token data, stored independently from other data used to describe it136/// Token data, stored independently from other data used to describe it
873	pub fn create_multiple_items(882	pub fn create_multiple_items(
874		collection: &RefungibleHandle<T>,883		collection: &RefungibleHandle<T>,
875		sender: &T::CrossAccountId,884		sender: &T::CrossAccountId,
876		data: Vec<CreateItemData<T>>,885		data: Vec<CreateItemData<T::CrossAccountId>>,
877		nesting_budget: &dyn Budget,886		nesting_budget: &dyn Budget,
878	) -> DispatchResult {887	) -> DispatchResult {
879		if !collection.is_owner_or_admin(sender) {888		if !collection.is_owner_or_admin(sender) {
1213	pub fn create_item(1222	pub fn create_item(
1214		collection: &RefungibleHandle<T>,1223		collection: &RefungibleHandle<T>,
1215		sender: &T::CrossAccountId,1224		sender: &T::CrossAccountId,
1216		data: CreateItemData<T>,1225		data: CreateItemData<T::CrossAccountId>,
1217		nesting_budget: &dyn Budget,1226		nesting_budget: &dyn Budget,
1218	) -> DispatchResult {1227	) -> DispatchResult {
1219		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1228		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)

1[package]1[package]
2name = "pallet-structure"2name = "pallet-structure"
3version = "0.1.0"3version = "0.1.1"
4edition = "2021"4edition = "2021"
55
6[dependencies]6[dependencies]

9license = 'GPLv3'9license = 'GPLv3'
10name = 'pallet-unique'10name = 'pallet-unique'
11repository = 'https://github.com/UniqueNetwork/unique-chain'11repository = 'https://github.com/UniqueNetwork/unique-chain'
12version = '0.1.1'12version = "0.1.2"
1313
14[package.metadata.docs.rs]14[package.metadata.docs.rs]
15targets = ['x86_64-unknown-linux-gnu']15targets = ['x86_64-unknown-linux-gnu']

22
3All notable changes to this project will be documented in this file.3All notable changes to this project will be documented in this file.
44
5<!-- bureaucrate goes here -->
6## [v0.2.1] 2022-08-04
7
8### Product changes
9
10- Now RefungibleMultipleItems may only receive single user on type level.
11
12### Other changes
13
14- refactor: Disallow invalid bulk mints 53fec71cf728dddd012257b407ea30441e699f88
15
16`create_multiple_items_ex` was allowing invalid (that will be always
17rejected at runtime level) refungible mint extrinsics, by passing
18multiple users into `RefungibleMultipleItems` call.
19
5## [v0.2.0] - 2022-08-0120## [v0.2.0] - 2022-08-01
6### Deprecated21### Deprecated
7- `CreateReFungibleData::const_data`22- `CreateReFungibleData::const_data`
11- Type aliases `CollectionName`, `CollectionDescription`, `CollectionTokenPrefix`26- Type aliases `CollectionName`, `CollectionDescription`, `CollectionTokenPrefix`
12## [v0.1.1] - 2022-07-2227## [v0.1.1] - 2022-07-22
13### Added28### Added
14- Аields with properties to `CreateReFungibleData` and `CreateRefungibleExData`.29- Аields with properties to `CreateReFungibleData` and `CreateRefungibleExData`.
30

6license = 'GPLv3'6license = 'GPLv3'
7homepage = "https://unique.network"7homepage = "https://unique.network"
8repository = 'https://github.com/UniqueNetwork/unique-chain'8repository = 'https://github.com/UniqueNetwork/unique-chain'
9version = '0.2.0'9version = "0.2.1"
1010
11[dependencies]11[dependencies]
12scale-info = { version = "2.0.1", default-features = false, features = [12scale-info = { version = "2.0.1", default-features = false, features = [

826/// Extended data for create ReFungible item.826/// Extended data for create ReFungible item.
827#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]827#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]
828#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]828#[derivative(Debug(bound = "CrossAccountId: fmt::Debug + Ord"))]
829pub struct CreateRefungibleExData<CrossAccountId> {829pub struct CreateRefungibleExMultipleOwners<CrossAccountId> {
830	#[derivative(Debug(format_with = "bounded::map_debug"))]830	#[derivative(Debug(format_with = "bounded::map_debug"))]
831	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,831	pub users: BoundedBTreeMap<CrossAccountId, u128, ConstU32<MAX_ITEMS_PER_BATCH>>,
832	#[derivative(Debug(format_with = "bounded::vec_debug"))]832	#[derivative(Debug(format_with = "bounded::vec_debug"))]
833	pub properties: CollectionPropertiesVec,833	pub properties: CollectionPropertiesVec,
834}834}
835
836/// Extended data for create ReFungible item.
837#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]
838#[derivative(Debug(bound = "CrossAccountId: fmt::Debug"))]
839pub struct CreateRefungibleExSingleOwner<CrossAccountId> {
840	pub user: CrossAccountId,
841	pub pieces: u128,
842	#[derivative(Debug(format_with = "bounded::vec_debug"))]
843	pub properties: CollectionPropertiesVec,
844}
835845
836/// Unified extended data for creating item.846/// Unified extended data for creating item.
837#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]847#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, TypeInfo, Derivative)]
853	/// many tokens, each may have only one owner863	/// many tokens, each may have only one owner
854	RefungibleMultipleItems(864	RefungibleMultipleItems(
855		#[derivative(Debug(format_with = "bounded::vec_debug"))]865		#[derivative(Debug(format_with = "bounded::vec_debug"))]
856		BoundedVec<CreateRefungibleExData<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,866		BoundedVec<CreateRefungibleExSingleOwner<CrossAccountId>, ConstU32<MAX_ITEMS_PER_BATCH>>,
857	),867	),
858868
859	/// Extended data for create ReFungible item in case of869	/// Extended data for create ReFungible item in case of
860	/// single token, which may have many owners870	/// single token, which may have many owners
861	RefungibleMultipleOwners(CreateRefungibleExData<CrossAccountId>),871	RefungibleMultipleOwners(CreateRefungibleExMultipleOwners<CrossAccountId>),
862}872}
863873
864impl From<CreateNftData> for CreateItemData {874impl From<CreateNftData> for CreateItemData {

6license = 'GPLv3'6license = 'GPLv3'
7homepage = "https://unique.network"7homepage = "https://unique.network"
8repository = 'https://github.com/UniqueNetwork/unique-chain'8repository = 'https://github.com/UniqueNetwork/unique-chain'
9version = '0.1.0'9version = "0.1.0"
1010
11[dependencies]11[dependencies]
12scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }12scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }

1[package]1[package]
2name = "up-rpc"2name = "up-rpc"
3version = "0.1.1"3version = "0.1.2"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

1616
17import {expect} from 'chai';17import {expect} from 'chai';
18import usingApi, {executeTransaction} from './substrate/substrate-api';18import usingApi, {executeTransaction} from './substrate/substrate-api';
19import {addCollectionAdminExpectSuccess, createCollectionExpectSuccess, createCollectionWithPropsExpectSuccess, getBalance, getLastTokenId} from './util/helpers';19import {addCollectionAdminExpectSuccess, createCollectionExpectSuccess, createCollectionWithPropsExpectSuccess, getBalance, getLastTokenId, getTokenProperties} from './util/helpers';
2020
21describe('Integration Test: createMultipleItemsEx', () => {21describe.only('Integration Test: createMultipleItemsEx', () => {
22  it('can initialize multiple NFT with different owners', async () => {22  it('can initialize multiple NFT with different owners', async () => {
23    const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});23    const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
24    await usingApi(async (api, privateKeyWrapper) => {24    await usingApi(async (api, privateKeyWrapper) => {
134      const alice = privateKeyWrapper('//Alice');134      const alice = privateKeyWrapper('//Alice');
135      const bob = privateKeyWrapper('//Bob');135      const bob = privateKeyWrapper('//Bob');
136
137      const users = new Map();
138      users.set(JSON.stringify({Substrate: alice.address}), 50);
139      users.set(JSON.stringify({Substrate: bob.address}), 100);
140136
141      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {137      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
142        Fungible: users,138        Fungible: new Map([
139          [JSON.stringify({Substrate: alice.address}), 50],
140          [JSON.stringify({Substrate: bob.address}), 100],
141        ]),
143      }));142      }));
144143
145      expect(await getBalance(api, collection, alice.address, 0)).to.equal(50n);144      expect(await getBalance(api, collection, alice.address, 0)).to.equal(50n);
148  });147  });
149148
150  it('can initialize an RFT with multiple owners', async () => {149  it('can initialize an RFT with multiple owners', async () => {
151    const collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
152    await usingApi(async (api, privateKeyWrapper) => {150    await usingApi(async (api, privateKeyWrapper) => {
153      const alice = privateKeyWrapper('//Alice');151      const alice = privateKeyWrapper('//Alice');
154      const bob = privateKeyWrapper('//Bob');152      const bob = privateKeyWrapper('//Bob');
155
156      const users = new Map();153      const collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
157      users.set(JSON.stringify({Substrate: alice.address}), 1);
158      users.set(JSON.stringify({Substrate: bob.address}), 2);154      await executeTransaction(
155        api,
156        alice,
157        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'data', permission: {tokenOwner: true}}]),
158      );
159159
160      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {160      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
161        RefungibleMultipleOwners: {161        RefungibleMultipleOwners: {
162          users: users,162          users: new Map([
163            [JSON.stringify({Substrate: alice.address}), 1],
164            [JSON.stringify({Substrate: bob.address}), 2],
165          ]),
166          properties: [
167            {key: 'data', value: 'testValue'},
168          ],
163        },169        },
164      }));170      }));
165      171
168174
169      expect(await getBalance(api, collection, alice.address, 1)).to.be.equal(1n);175      expect(await getBalance(api, collection, alice.address, 1)).to.be.equal(1n);
170      expect(await getBalance(api, collection, bob.address, 1)).to.be.equal(2n);176      expect(await getBalance(api, collection, bob.address, 1)).to.be.equal(2n);
177      expect((await getTokenProperties(api, collection, 1, ['data']))[0].value).to.be.equal('testValue');
171    });178    });
172  });179  });
173180
174  it('can initialize multiple RFTs with the same owner', async () => {181  it('can initialize multiple RFTs with the same owner', async () => {
175    const collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
176    await usingApi(async (api, privateKeyWrapper) => {182    await usingApi(async (api, privateKeyWrapper) => {
177      const alice = privateKeyWrapper('//Alice');183      const alice = privateKeyWrapper('//Alice');
178
179      const item1User = new Map();184      const collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
180      item1User.set(JSON.stringify({Substrate: alice.address}), 1);
181
182      const item2User = new Map();
183      item2User.set(JSON.stringify({Substrate: alice.address}), 3);185      await executeTransaction(
186        api,
187        alice,
188        api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'data', permission: {tokenOwner: true}}]),
189      );
184190
185      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {191      await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
186        RefungibleMultipleItems: [192        RefungibleMultipleItems: [
187          {users: item1User},193          {
194            user: {Substrate: alice.address}, pieces: 1,
195            properties: [
196              {key: 'data', value: 'testValue1'},
197            ],
198          },
188          {users: item2User},199          {
200            user: {Substrate: alice.address}, pieces: 3,
201            properties: [
202              {key: 'data', value: 'testValue2'},
203            ],
204          },
189        ],205        ],
190      }));206      }));
194210
195      expect(await getBalance(api, collection, alice.address, 1)).to.be.equal(1n);211      expect(await getBalance(api, collection, alice.address, 1)).to.be.equal(1n);
196      expect(await getBalance(api, collection, alice.address, 2)).to.be.equal(3n);212      expect(await getBalance(api, collection, alice.address, 2)).to.be.equal(3n);
213      expect((await getTokenProperties(api, collection, 1, ['data']))[0].value).to.be.equal('testValue1');
214      expect((await getTokenProperties(api, collection, 2, ['data']))[0].value).to.be.equal('testValue2');
197    });215    });
198  });216  });
199});217});