git.delta.rocks / unique-network / refs/commits / 20ec6e66cd9b

746		ApprovedValueTooLow,746		ApprovedValueTooLow,
747		/// Tried to approve more than owned747		/// Tried to approve more than owned
748		CantApproveMoreThanOwned,748		CantApproveMoreThanOwned,
749		/// Only spending from eth mirror could be approved
750		AddressIsNotEthMirror,
749751
750		/// Can't transfer tokens to ethereum zero address752		/// Can't transfer tokens to ethereum zero address
751		AddressIsZero,753		AddressIsZero,
1797	/// The price of setting the permission of the operation from another user.1799	/// The price of setting the permission of the operation from another user.
1798	fn approve() -> Weight;1800	fn approve() -> Weight;
1801
1802	/// The price of setting the permission of the operation from another user for eth mirror.
1803	fn approve_from() -> Weight;
17991804
1800	/// Transfer price from another user.1805	/// Transfer price from another user.
1801	fn transfer_from() -> Weight;1806	fn transfer_from() -> Weight;
2008		amount: u128,2013		amount: u128,
2009	) -> DispatchResultWithPostInfo;2014	) -> DispatchResultWithPostInfo;
2015
2016	/// Grant access to another account to transfer parts of the token owned by the calling user's eth mirror via [Self::transfer_from].
2017	///
2018	/// * `sender` - The user who grants access to the token.
2019	/// * `from` - Spender's eth mirror.
2020	/// * `to` - The user to whom the rights are granted.
2021	/// * `token` - The token to which access is granted.
2022	/// * `amount` - The amount of pieces that another user can dispose of.
2023	fn approve_from(
2024		&self,
2025		sender: T::CrossAccountId,
2026		from: T::CrossAccountId,
2027		to: T::CrossAccountId,
2028		token: TokenId,
2029		amount: u128,
2030	) -> DispatchResultWithPostInfo;
20102031
2011	/// Send parts of a token owned by another user.2032	/// Send parts of a token owned by another user.
2012	///2033	///

binary blob — no preview

283283
284/// Ethereum representation of Optional value with CrossAddress.284/// Ethereum representation of Optional value with CrossAddress.
285struct OptionCrossAddress {285struct OptionCrossAddress {
286	/// TODO: field description286	/// Whether or not this CrossAdress is valid and has meaning.
287	bool status;287	bool status;
288	/// TODO: field description288	/// The underlying CrossAddress value. If the status is false, can be set to whatever.
289	CrossAddress value;289	CrossAddress value;
290}290}
291291

82		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;82		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
83	}: {<Pallet<T>>::set_allowance(&collection, &sender, &spender, 100)?}83	}: {<Pallet<T>>::set_allowance(&collection, &sender, &spender, 100)?}
84
85	approve_from {
86		bench_init!{
87			owner: sub; collection: collection(owner);
88			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
89
90		};
91		let owner_eth = T::CrossAccountId::from_eth(*sender.as_eth());
92		<Pallet<T>>::create_item(&collection, &owner, (owner_eth.clone(), 200), &Unlimited)?;
93	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, &spender, 100)?}
8494
85	transfer_from {95	transfer_from {
86		bench_init!{96		bench_init!{

87		<SelfWeightOf<T>>::approve()87		<SelfWeightOf<T>>::approve()
88	}88	}
89
90	fn approve_from() -> Weight {
91		<SelfWeightOf<T>>::approve_from()
92	}
8993
90	fn transfer_from() -> Weight {94	fn transfer_from() -> Weight {
91		<SelfWeightOf<T>>::transfer_from()95		<SelfWeightOf<T>>::transfer_from()
254		)258		)
255	}259	}
260
261	fn approve_from(
262		&self,
263		sender: T::CrossAccountId,
264		from: T::CrossAccountId,
265		to: T::CrossAccountId,
266		token: TokenId,
267		amount: u128,
268	) -> DispatchResultWithPostInfo {
269		ensure!(
270			token == TokenId::default(),
271			<Error<T>>::FungibleItemsHaveNoId
272		);
273
274		with_weight(
275			<Pallet<T>>::set_allowance_from(self, &sender, &from, &to, amount),
276			<CommonWeights<T>>::approve_from(),
277		)
278	}
256279
257	fn transfer_from(280	fn transfer_from(
258		&self,281		&self,

613		Ok(())613		Ok(())
614	}614	}
615
616	/// Set allowance for the spender to `transfer` or `burn` owner's tokens from eth mirror.
617	///
618	/// - `collection`: Collection that contains the token
619	/// - `sender`: Owner of tokens that sets the allowance.
620	/// - `from`: Owner's eth mirror.
621	/// - `to`: Recipient of the allowance rights.
622	/// - `amount`: Amount of tokens the spender is allowed to `transfer` or `burn`.
623	pub fn set_allowance_from(
624		collection: &FungibleHandle<T>,
625		sender: &T::CrossAccountId,
626		from: &T::CrossAccountId,
627		to: &T::CrossAccountId,
628		amount: u128,
629	) -> DispatchResult {
630		if collection.permissions.access() == AccessMode::AllowList {
631			collection.check_allowlist(sender)?;
632			collection.check_allowlist(from)?;
633			collection.check_allowlist(to)?;
634		}
635
636		ensure!(
637			sender.conv_eq(from),
638			<CommonError<T>>::AddressIsNotEthMirror
639		);
640
641		if <Balance<T>>::get((collection.id, from)) < amount {
642			ensure!(
643				collection.limits.owner_can_transfer()
644					&& (collection.is_owner_or_admin(sender) || collection.is_owner_or_admin(from)),
645				<CommonError<T>>::CantApproveMoreThanOwned
646			);
647		}
648
649		// =========
650
651		Self::set_allowance_unchecked(collection, from, to, amount);
652		Ok(())
653	}
615654
616	/// Checks if a non-owner has (enough) allowance from the owner to perform operations on the tokens.655	/// Checks if a non-owner has (enough) allowance from the owner to perform operations on the tokens.
617	/// Returns the expected remaining allowance - it should be set manually if the transaction proceeds.656	/// Returns the expected remaining allowance - it should be set manually if the transaction proceeds.

39	fn burn_item() -> Weight;39	fn burn_item() -> Weight;
40	fn transfer() -> Weight;40	fn transfer() -> Weight;
41	fn approve() -> Weight;41	fn approve() -> Weight;
42	fn approve_from() -> Weight;
42	fn transfer_from() -> Weight;43	fn transfer_from() -> Weight;
43	fn burn_from() -> Weight;44	fn burn_from() -> Weight;
44}45}
84			.saturating_add(T::DbWeight::get().reads(1 as u64))85			.saturating_add(T::DbWeight::get().reads(1 as u64))
85			.saturating_add(T::DbWeight::get().writes(1 as u64))86			.saturating_add(T::DbWeight::get().writes(1 as u64))
86	}87	}
88	// Storage: Fungible Balance (r:1 w:0)
89	// Storage: Fungible Allowance (r:0 w:1)
90	fn approve_from() -> Weight {
91		Weight::from_ref_time(19_817_000 as u64)
92			.saturating_add(T::DbWeight::get().reads(1 as u64))
93			.saturating_add(T::DbWeight::get().writes(1 as u64))
94	}
87	// Storage: Fungible Allowance (r:1 w:1)95	// Storage: Fungible Allowance (r:1 w:1)
88	// Storage: Fungible Balance (r:2 w:2)96	// Storage: Fungible Balance (r:2 w:2)
89	fn transfer_from() -> Weight {97	fn transfer_from() -> Weight {
141			.saturating_add(RocksDbWeight::get().reads(1 as u64))149			.saturating_add(RocksDbWeight::get().reads(1 as u64))
142			.saturating_add(RocksDbWeight::get().writes(1 as u64))150			.saturating_add(RocksDbWeight::get().writes(1 as u64))
143	}151	}
152	// Storage: Fungible Balance (r:1 w:0)
153	// Storage: Fungible Allowance (r:0 w:1)
154	fn approve_from() -> Weight {
155		Weight::from_ref_time(19_817_000 as u64)
156			.saturating_add(RocksDbWeight::get().reads(1 as u64))
157			.saturating_add(RocksDbWeight::get().writes(1 as u64))
158	}
144	// Storage: Fungible Allowance (r:1 w:1)159	// Storage: Fungible Allowance (r:1 w:1)
145	// Storage: Fungible Balance (r:2 w:2)160	// Storage: Fungible Balance (r:2 w:2)
146	fn transfer_from() -> Weight {161	fn transfer_from() -> Weight {

134		let item = create_max_item(&collection, &owner, sender.clone())?;134		let item = create_max_item(&collection, &owner, sender.clone())?;
135	}: {<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?}135	}: {<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?}
136
137	approve_from {
138		bench_init!{
139			owner: sub; collection: collection(owner);
140			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
141		};
142		let owner_eth = T::CrossAccountId::from_eth(*sender.as_eth());
143		let item = create_max_item(&collection, &owner, owner_eth.clone())?;
144	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, item, Some(&spender))?}
136145
137	transfer_from {146	transfer_from {
138		bench_init!{147		bench_init!{

102		<SelfWeightOf<T>>::approve()102		<SelfWeightOf<T>>::approve()
103	}103	}
104
105	fn approve_from() -> Weight {
106		<SelfWeightOf<T>>::approve_from()
107	}
104108
105	fn transfer_from() -> Weight {109	fn transfer_from() -> Weight {
106		<SelfWeightOf<T>>::transfer_from()110		<SelfWeightOf<T>>::transfer_from()
353		)357		)
354	}358	}
359
360	fn approve_from(
361		&self,
362		sender: T::CrossAccountId,
363		from: T::CrossAccountId,
364		to: T::CrossAccountId,
365		token: TokenId,
366		amount: u128,
367	) -> DispatchResultWithPostInfo {
368		ensure!(amount <= 1, <Error<T>>::NonfungibleItemsHaveNoAmount);
369
370		with_weight(
371			if amount == 1 {
372				<Pallet<T>>::set_allowance_from(self, &sender, &from, token, Some(&to))
373			} else {
374				<Pallet<T>>::set_allowance_from(self, &sender, &from, token, None)
375			},
376			<CommonWeights<T>>::approve_from(),
377		)
378	}
355379
356	fn transfer_from(380	fn transfer_from(
357		&self,381		&self,

1171		Ok(())1171		Ok(())
1172	}1172	}
1173
1174	/// Set allowance for the spender to `transfer` or `burn` sender's token from eth mirror.
1175	///
1176	/// - `from`: Address of sender's eth mirror.
1177	/// - `to`: Adress of spender.
1178	/// - `token`: Token the spender is allowed to `transfer` or `burn`.
1179	pub fn set_allowance_from(
1180		collection: &NonfungibleHandle<T>,
1181		sender: &T::CrossAccountId,
1182		from: &T::CrossAccountId,
1183		token: TokenId,
1184		to: Option<&T::CrossAccountId>,
1185	) -> DispatchResult {
1186		if collection.permissions.access() == AccessMode::AllowList {
1187			collection.check_allowlist(sender)?;
1188			collection.check_allowlist(from)?;
1189			if let Some(to) = to {
1190				collection.check_allowlist(to)?;
1191			}
1192		}
1193
1194		if let Some(to) = to {
1195			<PalletCommon<T>>::ensure_correct_receiver(to)?;
1196		}
1197
1198		ensure!(
1199			sender.conv_eq(from),
1200			<CommonError<T>>::AddressIsNotEthMirror
1201		);
1202
1203		let token_data =
1204			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;
1205		if token_data.owner != *from {
1206			ensure!(
1207				collection.limits.owner_can_transfer()
1208					&& (collection.is_owner_or_admin(sender) || collection.is_owner_or_admin(from)),
1209				<CommonError<T>>::CantApproveMoreThanOwned
1210			);
1211		}
1212
1213		// =========
1214
1215		Self::set_allowance_unchecked(collection, from, token, to, false);
1216		Ok(())
1217	}
11731218
1174	/// Checks allowance for the spender to use the token.1219	/// Checks allowance for the spender to use the token.
1175	fn check_allowed(1220	fn check_allowed(

42	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight;42	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight;
43	fn transfer() -> Weight;43	fn transfer() -> Weight;
44	fn approve() -> Weight;44	fn approve() -> Weight;
45	fn approve_from() -> Weight;
45	fn transfer_from() -> Weight;46	fn transfer_from() -> Weight;
46	fn burn_from() -> Weight;47	fn burn_from() -> Weight;
47	fn set_token_property_permissions(b: u32, ) -> Weight;48	fn set_token_property_permissions(b: u32, ) -> Weight;
147			.saturating_add(T::DbWeight::get().reads(2 as u64))148			.saturating_add(T::DbWeight::get().reads(2 as u64))
148			.saturating_add(T::DbWeight::get().writes(1 as u64))149			.saturating_add(T::DbWeight::get().writes(1 as u64))
149	}150	}
151	// Storage: Nonfungible TokenData (r:1 w:0)
152	// Storage: Nonfungible Allowance (r:1 w:1)
153	fn approve_from() -> Weight {
154		Weight::from_ref_time(18_965_000 as u64)
155			.saturating_add(T::DbWeight::get().reads(2 as u64))
156			.saturating_add(T::DbWeight::get().writes(1 as u64))
157	}
150	// Storage: Nonfungible Allowance (r:1 w:1)158	// Storage: Nonfungible Allowance (r:1 w:1)
151	// Storage: Nonfungible TokenData (r:1 w:1)159	// Storage: Nonfungible TokenData (r:1 w:1)
152	// Storage: Nonfungible AccountBalance (r:2 w:2)160	// Storage: Nonfungible AccountBalance (r:2 w:2)
310			.saturating_add(RocksDbWeight::get().reads(2 as u64))318			.saturating_add(RocksDbWeight::get().reads(2 as u64))
311			.saturating_add(RocksDbWeight::get().writes(1 as u64))319			.saturating_add(RocksDbWeight::get().writes(1 as u64))
312	}320	}
321	// Storage: Nonfungible TokenData (r:1 w:0)
322	// Storage: Nonfungible Allowance (r:1 w:1)
323	fn approve_from() -> Weight {
324		Weight::from_ref_time(18_965_000 as u64)
325			.saturating_add(RocksDbWeight::get().reads(2 as u64))
326			.saturating_add(RocksDbWeight::get().writes(1 as u64))
327	}
313	// Storage: Nonfungible Allowance (r:1 w:1)328	// Storage: Nonfungible Allowance (r:1 w:1)
314	// Storage: Nonfungible TokenData (r:1 w:1)329	// Storage: Nonfungible TokenData (r:1 w:1)
315	// Storage: Nonfungible AccountBalance (r:2 w:2)330	// Storage: Nonfungible AccountBalance (r:2 w:2)

163		let item = create_max_item(&collection, &owner, [(sender.clone(), 200)])?;163		let item = create_max_item(&collection, &owner, [(sender.clone(), 200)])?;
164	}: {<Pallet<T>>::set_allowance(&collection, &sender, &spender, item, 100)?}164	}: {<Pallet<T>>::set_allowance(&collection, &sender, &spender, item, 100)?}
165
166	approve_from {
167		bench_init!{
168			owner: sub; collection: collection(owner);
169			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
170		};
171		let owner_eth = T::CrossAccountId::from_eth(*sender.as_eth());
172		let item = create_max_item(&collection, &owner, [(owner_eth.clone(), 200)])?;
173	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, &spender, item, 100)?}
165174
166	transfer_from_normal {175	transfer_from_normal {
167		bench_init!{176		bench_init!{

127		<SelfWeightOf<T>>::approve()127		<SelfWeightOf<T>>::approve()
128	}128	}
129
130	fn approve_from() -> Weight {
131		<SelfWeightOf<T>>::approve_from()
132	}
129133
130	fn transfer_from() -> Weight {134	fn transfer_from() -> Weight {
131		max_weight_of!(135		max_weight_of!(
314		)318		)
315	}319	}
320
321	fn approve_from(
322		&self,
323		sender: T::CrossAccountId,
324		from: T::CrossAccountId,
325		to: T::CrossAccountId,
326		token_id: TokenId,
327		amount: u128,
328	) -> DispatchResultWithPostInfo {
329		with_weight(
330			<Pallet<T>>::set_allowance_from(self, &sender, &from, &to, token_id, amount),
331			<CommonWeights<T>>::approve_from(),
332		)
333	}
316334
317	fn transfer_from(335	fn transfer_from(
318		&self,336		&self,

1102		Ok(())1102		Ok(())
1103	}1103	}
1104
1105	/// Set allowance to spend from sender's eth mirror
1106	///
1107	/// - `from`: Address of sender's eth mirror.
1108	/// - `to`: Adress of spender.
1109	/// - `amount`: Amount of token pieces the spender is allowed to `transfer` or `burn.
1110	pub fn set_allowance_from(
1111		collection: &RefungibleHandle<T>,
1112		sender: &T::CrossAccountId,
1113		from: &T::CrossAccountId,
1114		to: &T::CrossAccountId,
1115		token_id: TokenId,
1116		amount: u128,
1117	) -> DispatchResult {
1118		if collection.permissions.access() == AccessMode::AllowList {
1119			collection.check_allowlist(sender)?;
1120			collection.check_allowlist(from)?;
1121			collection.check_allowlist(to)?;
1122		}
1123
1124		<PalletCommon<T>>::ensure_correct_receiver(to)?;
1125
1126		ensure!(
1127			sender.conv_eq(from),
1128			<CommonError<T>>::AddressIsNotEthMirror
1129		);
1130
1131		if <Balance<T>>::get((collection.id, token_id, from)) < amount {
1132			ensure!(
1133				collection.limits.owner_can_transfer()
1134					&& (collection.is_owner_or_admin(sender) || collection.is_owner_or_admin(from))
1135					&& Self::token_exists(collection, token_id),
1136				<CommonError<T>>::CantApproveMoreThanOwned
1137			);
1138		}
1139
1140		// =========
1141
1142		Self::set_allowance_unchecked(collection, from, to, token_id, amount);
1143		Ok(())
1144	}
11041145
1105	/// Returns allowance, which should be set after transaction1146	/// Returns allowance, which should be set after transaction
1106	fn check_allowed(1147	fn check_allowed(

45	fn transfer_removing() -> Weight;45	fn transfer_removing() -> Weight;
46	fn transfer_creating_removing() -> Weight;46	fn transfer_creating_removing() -> Weight;
47	fn approve() -> Weight;47	fn approve() -> Weight;
48	fn approve_from() -> Weight;
48	fn transfer_from_normal() -> Weight;49	fn transfer_from_normal() -> Weight;
49	fn transfer_from_creating() -> Weight;50	fn transfer_from_creating() -> Weight;
50	fn transfer_from_removing() -> Weight;51	fn transfer_from_removing() -> Weight;
175			.saturating_add(T::DbWeight::get().reads(1 as u64))176			.saturating_add(T::DbWeight::get().reads(1 as u64))
176			.saturating_add(T::DbWeight::get().writes(1 as u64))177			.saturating_add(T::DbWeight::get().writes(1 as u64))
177	}178	}
179	// Storage: Refungible Balance (r:1 w:0)
180	// Storage: Refungible Allowance (r:0 w:1)
181	fn approve_from() -> Weight {
182		Weight::from_ref_time(20_649_000 as u64)
183			.saturating_add(T::DbWeight::get().reads(1 as u64))
184			.saturating_add(T::DbWeight::get().writes(1 as u64))
185	}
178	// Storage: Refungible Allowance (r:1 w:1)186	// Storage: Refungible Allowance (r:1 w:1)
179	// Storage: Refungible CollectionAllowance (r:1 w:0)187	// Storage: Refungible CollectionAllowance (r:1 w:0)
180	// Storage: Refungible Balance (r:2 w:2)188	// Storage: Refungible Balance (r:2 w:2)
400			.saturating_add(RocksDbWeight::get().reads(1 as u64))408			.saturating_add(RocksDbWeight::get().reads(1 as u64))
401			.saturating_add(RocksDbWeight::get().writes(1 as u64))409			.saturating_add(RocksDbWeight::get().writes(1 as u64))
402	}410	}
411	// Storage: Refungible Balance (r:1 w:0)
412	// Storage: Refungible Allowance (r:0 w:1)
413	fn approve_from() -> Weight {
414		Weight::from_ref_time(20_649_000 as u64)
415			.saturating_add(RocksDbWeight::get().reads(1 as u64))
416			.saturating_add(RocksDbWeight::get().writes(1 as u64))
417	}
403	// Storage: Refungible Allowance (r:1 w:1)418	// Storage: Refungible Allowance (r:1 w:1)
404	// Storage: Refungible CollectionAllowance (r:1 w:0)419	// Storage: Refungible CollectionAllowance (r:1 w:0)
405	// Storage: Refungible Balance (r:2 w:2)420	// Storage: Refungible Balance (r:2 w:2)

851			dispatch_tx::<T, _>(collection_id, |d| d.approve(sender, spender, item_id, amount))851			dispatch_tx::<T, _>(collection_id, |d| d.approve(sender, spender, item_id, amount))
852		}852		}
853
854		/// Allow a non-permissioned address to transfer or burn an item from owner's eth mirror.
855		///
856		/// # Permissions
857		///
858		/// * Collection owner
859		/// * Collection admin
860		/// * Current item owner
861		///
862		/// # Arguments
863		///
864		/// * `from`: Owner's account eth mirror
865		/// * `to`: Account to be approved to make specific transactions on non-owned tokens.
866		/// * `collection_id`: ID of the collection the item belongs to.
867		/// * `item_id`: ID of the item transactions on which are now approved.
868		/// * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).
869		/// Set to 0 to revoke the approval.
870		#[weight = T::CommonWeightInfo::approve_from()]
871		pub fn approve_from(origin, from:T::CrossAccountId, to: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResultWithPostInfo {
872			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
873
874			dispatch_tx::<T, _>(collection_id, |d| d.approve_from(sender, from, to, item_id, amount))
875		}
853876
854		/// Change ownership of an item on behalf of the owner as a non-owner account.877		/// Change ownership of an item on behalf of the owner as a non-owner account.
855		///878		///

27#[cfg(feature = "collator-selection")]26#[cfg(feature = "collator-selection")]
28use sp_runtime::transaction_validity::InvalidTransaction;27use sp_runtime::transaction_validity::InvalidTransaction;
28
29#[cfg(feature = "collator-selection")]
30use sp_runtime::transaction_validity::InvalidTransaction;
2931
30#[derive(Debug, Encode, Decode, PartialEq, Eq, Clone, TypeInfo)]32#[derive(Debug, Encode, Decode, PartialEq, Eq, Clone, TypeInfo)]
31pub struct DisableIdentityCalls;33pub struct DisableIdentityCalls;

101		dispatch_weight::<T>() + max_weight_of!(approve())101		dispatch_weight::<T>() + max_weight_of!(approve())
102	}102	}
103
104	fn approve_from() -> Weight {
105		dispatch_weight::<T>() + max_weight_of!(approve_from())
106	}
103107
104	fn transfer_from() -> Weight {108	fn transfer_from() -> Weight {
105		dispatch_weight::<T>() + max_weight_of!(transfer_from())109		dispatch_weight::<T>() + max_weight_of!(transfer_from())

1616
17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import {expect, itSub, Pallets, usingPlaygrounds} from './util';18import {expect, itSub, Pallets, usingPlaygrounds} from './util';
19import {CrossAccountId} from './util/playgrounds/unique';
1920
2021
21describe('Integration Test approve(spender, collection_id, item_id, amount):', () => {
22  let alice: IKeyringPair;
23  let bob: IKeyringPair;
24  let charlie: IKeyringPair;
2522
23[
26  before(async () => {24  {method: 'approveToken', account: (account: IKeyringPair) => CrossAccountId.fromKeyring(account)},
25  {method: 'approveTokenFromEth', account: (account: IKeyringPair) => CrossAccountId.fromKeyring(account).toEthereum()},
26].map(testCase => {
27  describe(`Integration Test ${testCase.method}(spender, collection_id, item_id, amount):`, () => {
28    let alice: IKeyringPair;
29    let bob: IKeyringPair;
30    let charlie: IKeyringPair;
31
32    before(async () => {
27    await usingPlaygrounds(async (helper, privateKey) => {33      await usingPlaygrounds(async (helper, privateKey) => {
28      const donor = await privateKey({filename: __filename});34        const donor = await privateKey({filename: __filename});
29      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);35        [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
36      });
30    });37    });
31  });
3238
33  itSub('[nft] Execute the extrinsic and check approvedList', async ({helper}) => {39    itSub('[nft] Execute the extrinsic and check approvedList', async ({helper}) => {
34    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});40      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
35    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});41      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)});
36    await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});42      await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address});
37    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;43      expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;
38  });44    });
3945
40  itSub('[fungible] Execute the extrinsic and check approvedList', async ({helper}) => {46    itSub('[fungible] Execute the extrinsic and check approvedList', async ({helper}) => {
41    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);47      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
42    await helper.ft.mintTokens(alice, collectionId, 10n, {Substrate: alice.address});48      await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice));
43    const tokenId = await helper.ft.getLastTokenId(collectionId);49      const tokenId = await helper.ft.getLastTokenId(collectionId);
44    await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});50      await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address});
45    const amount = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});51      const amount = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
46    expect(amount).to.be.equal(BigInt(1));52      expect(amount).to.be.equal(BigInt(1));
47  });53    });
4854
49  itSub.ifWithPallets('[refungible] Execute the extrinsic and check approvedList', [Pallets.ReFungible], async ({helper}) => {55    itSub.ifWithPallets('[refungible] Execute the extrinsic and check approvedList', [Pallets.ReFungible], async ({helper}) => {
50    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});56      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
51    const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n});57      const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n});
52    await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});58      await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address});
53    const amount = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});59      const amount = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
54    expect(amount).to.be.equal(BigInt(1));60      expect(amount).to.be.equal(BigInt(1));
55  });61    });
5662
57  itSub('[nft] Remove approval by using 0 amount', async ({helper}) => {63    itSub('[nft] Remove approval by using 0 amount', async ({helper}) => {
58    const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});64      const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
59    const collectionId = collection.collectionId;65      const collectionId = collection.collectionId;
60    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});66      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)});
61    await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});67      await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address});
62    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;68      expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;
63    await helper.signTransaction(alice, helper.constructApiCall('api.tx.unique.approve', [{Substrate: bob.address}, collectionId, tokenId, 0]));69      await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n);
64    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false;70      expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false;
65  });71    });
6672
67  itSub('[fungible] Remove approval by using 0 amount', async ({helper}) => {73    itSub('[fungible] Remove approval by using 0 amount', async ({helper}) => {
68    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);74      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
69    await helper.ft.mintTokens(alice, collectionId, 10n, {Substrate: alice.address});75      await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice));
70    const tokenId = await helper.ft.getLastTokenId(collectionId);76      const tokenId = await helper.ft.getLastTokenId(collectionId);
71    await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});77      await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address});
72    const amountBefore = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});78      const amountBefore = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
73    expect(amountBefore).to.be.equal(BigInt(1));79      expect(amountBefore).to.be.equal(BigInt(1));
7480
75    await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 0n);81      await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n);
76    const amountAfter = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});82      const amountAfter = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
77    expect(amountAfter).to.be.equal(BigInt(0));83      expect(amountAfter).to.be.equal(BigInt(0));
78  });84    });
7985
80  itSub.ifWithPallets('[refungible] Remove approval by using 0 amount', [Pallets.ReFungible], async ({helper}) => {86    itSub.ifWithPallets('[refungible] Remove approval by using 0 amount', [Pallets.ReFungible], async ({helper}) => {
81    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});87      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
82    const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n});88      const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n});
83    await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});89      await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address});
84    const amountBefore = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});90      const amountBefore = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
85    expect(amountBefore).to.be.equal(BigInt(1));91      expect(amountBefore).to.be.equal(BigInt(1));
8692
87    await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 0n);93      await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n);
88    const amountAfter = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});94      const amountAfter = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
89    expect(amountAfter).to.be.equal(BigInt(0));95      expect(amountAfter).to.be.equal(BigInt(0));
90  });96    });
9197
92  itSub('can`t be called by collection owner on non-owned item when OwnerCanTransfer == false', async ({helper}) => {98    itSub('can`t be called by collection owner on non-owned item when OwnerCanTransfer == false', async ({helper}) => {
93    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});99      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
94    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});100      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)});
95    const approveTokenTx = () => helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});101      const result = (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: charlie.address});
96    await expect(approveTokenTx()).to.be.rejected;102      await expect(result).to.be.rejected;
103    });
97  });104  });
98});
99105
100describe('Normal user can approve other users to transfer:', () => {106  describe(`[${testCase.method}] Normal user can approve other users to transfer:`, () => {
101  let alice: IKeyringPair;107    let alice: IKeyringPair;
102  let bob: IKeyringPair;108    let bob: IKeyringPair;
103  let charlie: IKeyringPair;109    let charlie: IKeyringPair;
104110
105  before(async () => {111    before(async () => {
106    await usingPlaygrounds(async (helper, privateKey) => {112      await usingPlaygrounds(async (helper, privateKey) => {
107      const donor = await privateKey({filename: __filename});113        const donor = await privateKey({filename: __filename});
108      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);114        [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
115      });
109    });116    });
110  });
111117
112  itSub('NFT', async ({helper}) => {118    itSub('NFT', async ({helper}) => {
113    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});119      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
114    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});120      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)});
115    await helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});121      await (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address});
116    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.true;122      expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.true;
117  });123    });
118124
119  itSub('Fungible up to an approved amount', async ({helper}) => {125    itSub('Fungible up to an approved amount', async ({helper}) => {
120    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);126      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
121    await helper.ft.mintTokens(alice, collectionId, 10n, bob.address);127      await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(bob));
122    const tokenId = await helper.ft.getLastTokenId(collectionId);128      const tokenId = await helper.ft.getLastTokenId(collectionId);
123    await helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});129      await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address});
124    const amount = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: charlie.address}, {Substrate: bob.address});130      const amount = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: charlie.address}, testCase.account(bob));
125    expect(amount).to.be.equal(BigInt(1));131      expect(amount).to.be.equal(BigInt(1));
126  });132    });
127133
128  itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => {134    itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => {
129    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});135      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
130    const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: bob.address, pieces: 100n});136      const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob), pieces: 100n});
131    await helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}, 100n);137      await (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}, 100n);
132    const amount = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: charlie.address}, {Substrate: bob.address});138      const amount = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: charlie.address}, testCase.account(bob));
133    expect(amount).to.be.equal(BigInt(100n));139      expect(amount).to.be.equal(BigInt(100n));
140    });
134  });141  });
135});
136142
137describe('Approved users can transferFrom up to approved amount:', () => {143  describe(`[${testCase.method}] Approved users can transferFrom up to approved amount:`, () => {
138  let alice: IKeyringPair;144    let alice: IKeyringPair;
139  let bob: IKeyringPair;145    let bob: IKeyringPair;
140  let charlie: IKeyringPair;146    let charlie: IKeyringPair;
141147
142  before(async () => {148    before(async () => {
143    await usingPlaygrounds(async (helper, privateKey) => {149      await usingPlaygrounds(async (helper, privateKey) => {
144      const donor = await privateKey({filename: __filename});150        const donor = await privateKey({filename: __filename});
145      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);151        [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
152      });
146    });153    });
147  });
148154
149  itSub('NFT', async ({helper}) => {155    itSub('NFT', async ({helper}) => {
150    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});156      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
151    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});157      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)});
152    await helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});158      await (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address});
153    await helper.nft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});159      await helper.nft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address});
154    const owner = await helper.nft.getTokenOwner(collectionId, tokenId);160      const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
155    expect(owner.Substrate).to.be.equal(alice.address);161      expect(owner.Substrate).to.be.equal(alice.address);
156  });162    });
157163
158  itSub('Fungible up to an approved amount', async ({helper}) => {164    itSub('Fungible up to an approved amount', async ({helper}) => {
159    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);165      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
160    await helper.ft.mintTokens(alice, collectionId, 10n, bob.address);166      await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(bob));
161    const tokenId = await helper.ft.getLastTokenId(collectionId);167      const tokenId = await helper.ft.getLastTokenId(collectionId);
162    await helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});168      await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address});
163    const before = await helper.ft.getBalance(collectionId, {Substrate: alice.address});169      const before = await helper.ft.getBalance(collectionId, {Substrate: alice.address});
164    await helper.ft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n);170      await helper.ft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 1n);
165    const after = await helper.ft.getBalance(collectionId, {Substrate: alice.address});171      const after = await helper.ft.getBalance(collectionId, {Substrate: alice.address});
166    expect(after - before).to.be.equal(BigInt(1));172      expect(after - before).to.be.equal(BigInt(1));
167  });173    });
168174
169  itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => {175    itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => {
170    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});176      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
171    const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: bob.address, pieces: 100n});177      const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob), pieces: 100n});
172    await helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});178      await (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address});
173    const before = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address});179      const before = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address});
174    await helper.rft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n);180      await helper.rft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 1n);
175    const after = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address});181      const after = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address});
176    expect(after - before).to.be.equal(BigInt(1));182      expect(after - before).to.be.equal(BigInt(1));
183    });
177  });184  });
178});
179185
180describe('Approved users cannot use transferFrom to repeat transfers if approved amount was already transferred:', () => {186  describe(`[${testCase.method}] Approved users cannot use transferFrom to repeat transfers if approved amount was already transferred:`, () => {
181  let alice: IKeyringPair;187    let alice: IKeyringPair;
182  let bob: IKeyringPair;188    let bob: IKeyringPair;
183  let charlie: IKeyringPair;189    let charlie: IKeyringPair;
184190
185  before(async () => {191    before(async () => {
186    await usingPlaygrounds(async (helper, privateKey) => {192      await usingPlaygrounds(async (helper, privateKey) => {
187      const donor = await privateKey({filename: __filename});193        const donor = await privateKey({filename: __filename});
188      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);194        [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
195      });
189    });196    });
190  });
191197
192  itSub('NFT', async ({helper}) => {198    itSub('NFT', async ({helper}) => {
193    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});199      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
194    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});200      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)});
195    await helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});201      await (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address});
196    await helper.nft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});202      await helper.nft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address});
197    const owner = await helper.nft.getTokenOwner(collectionId, tokenId);203      const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
198    expect(owner.Substrate).to.be.equal(alice.address);204      expect(owner.Substrate).to.be.equal(alice.address);
199    const transferTokenFromTx = () => helper.nft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});205      const transferTokenFromTx = () => helper.nft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address});
200    await expect(transferTokenFromTx()).to.be.rejected;206      await expect(transferTokenFromTx()).to.be.rejected;
201  });207    });
202208
203  itSub('Fungible up to an approved amount', async ({helper}) => {209    itSub('Fungible up to an approved amount', async ({helper}) => {
204    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);210      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
205    await helper.ft.mintTokens(alice, collectionId, 10n, bob.address);211      await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(bob));
206    const tokenId = await helper.ft.getLastTokenId(collectionId);212      const tokenId = await helper.ft.getLastTokenId(collectionId);
207    await helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});213      await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address});
208    const before = await helper.ft.getBalance(collectionId, {Substrate: alice.address});214      const before = await helper.ft.getBalance(collectionId, {Substrate: alice.address});
209    await helper.ft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n);215      await helper.ft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 1n);
210    const after = await helper.ft.getBalance(collectionId, {Substrate: alice.address});216      const after = await helper.ft.getBalance(collectionId, {Substrate: alice.address});
211    expect(after - before).to.be.equal(BigInt(1));217      expect(after - before).to.be.equal(BigInt(1));
212218
213    const transferTokenFromTx = () => helper.ft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n);219      const transferTokenFromTx = () => helper.ft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 1n);
214    await expect(transferTokenFromTx()).to.be.rejected;220      await expect(transferTokenFromTx()).to.be.rejected;
215  });221    });
216222
217  itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => {223    itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => {
218    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});224      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
219    const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: bob.address, pieces: 100n});225      const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob), pieces: 100n});
220    await helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}, 100n);226      await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}, 100n);
221    const before = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address});227      const before = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address});
222    await helper.rft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 100n);228      await helper.rft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 100n);
223    const after = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address});229      const after = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address});
224    expect(after - before).to.be.equal(BigInt(100));230      expect(after - before).to.be.equal(BigInt(100));
225    const transferTokenFromTx = () => helper.rft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 100n);231      const transferTokenFromTx = () => helper.rft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 100n);
226    await expect(transferTokenFromTx()).to.be.rejected;232      await expect(transferTokenFromTx()).to.be.rejected;
233    });
227  });234  });
228});
229235
230describe('Approved amount decreases by the transferred amount:', () => {236  describe(`[${testCase.method}] Approved amount decreases by the transferred amount:`, () => {
231  let alice: IKeyringPair;237    let alice: IKeyringPair;
232  let bob: IKeyringPair;238    let bob: IKeyringPair;
233  let charlie: IKeyringPair;239    let charlie: IKeyringPair;
234  let dave: IKeyringPair;240    let dave: IKeyringPair;
235241
236  before(async () => {242    before(async () => {
237    await usingPlaygrounds(async (helper, privateKey) => {243      await usingPlaygrounds(async (helper, privateKey) => {
238      const donor = await privateKey({filename: __filename});244        const donor = await privateKey({filename: __filename});
239      [alice, bob, charlie, dave] = await helper.arrange.createAccounts([100n, 100n, 100n, 100n], donor);245        [alice, bob, charlie, dave] = await helper.arrange.createAccounts([100n, 100n, 100n, 100n], donor);
246      });
240    });247    });
241  });
242248
243  itSub('If a user B is approved to transfer 10 Fungible tokens from user A, they can transfer 2 tokens to user C, which will result in decreasing approval from 10 to 8. Then user B can transfer 8 tokens to user D.', async ({helper}) => {249    itSub('If a user B is approved to transfer 10 Fungible tokens from user A, they can transfer 2 tokens to user C, which will result in decreasing approval from 10 to 8. Then user B can transfer 8 tokens to user D.', async ({helper}) => {
244    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);250      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
245    await helper.ft.mintTokens(alice, collectionId, 10n, alice.address);251      await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice));
246    const tokenId = await helper.ft.getLastTokenId(collectionId);252      const tokenId = await helper.ft.getLastTokenId(collectionId);
247    await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 10n);253      await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 10n);
248254
249    const charlieBefore = await helper.ft.getBalance(collectionId, {Substrate: charlie.address});255      const charlieBefore = await helper.ft.getBalance(collectionId, {Substrate: charlie.address});
250    await helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: alice.address}, {Substrate: charlie.address}, 2n);256      await helper.ft.transferTokenFrom(bob, collectionId, tokenId, testCase.account(alice), {Substrate: charlie.address}, 2n);
251    const charlieAfter = await helper.ft.getBalance(collectionId, {Substrate: charlie.address});257      const charlieAfter = await helper.ft.getBalance(collectionId, {Substrate: charlie.address});
252    expect(charlieAfter - charlieBefore).to.be.equal(BigInt(2));258      expect(charlieAfter - charlieBefore).to.be.equal(BigInt(2));
253259
254    const daveBefore = await helper.ft.getBalance(collectionId, {Substrate: dave.address});260      const daveBefore = await helper.ft.getBalance(collectionId, {Substrate: dave.address});
255    await helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: alice.address}, {Substrate: dave.address}, 8n);261      await helper.ft.transferTokenFrom(bob, collectionId, tokenId, testCase.account(alice), {Substrate: dave.address}, 8n);
256    const daveAfter = await helper.ft.getBalance(collectionId, {Substrate: dave.address});262      const daveAfter = await helper.ft.getBalance(collectionId, {Substrate: dave.address});
257    expect(daveAfter - daveBefore).to.be.equal(BigInt(8));263      expect(daveAfter - daveBefore).to.be.equal(BigInt(8));
264    });
258  });265  });
259});
260266
261describe('User may clear the approvals to approving for 0 amount:', () => {267  describe(`[${testCase.method}] User may clear the approvals to approving for 0 amount:`, () => {
262  let alice: IKeyringPair;268    let alice: IKeyringPair;
263  let bob: IKeyringPair;269    let bob: IKeyringPair;
264  let charlie: IKeyringPair;270    let charlie: IKeyringPair;
265271
266  before(async () => {272    before(async () => {
267    await usingPlaygrounds(async (helper, privateKey) => {273      await usingPlaygrounds(async (helper, privateKey) => {
268      const donor = await privateKey({filename: __filename});274        const donor = await privateKey({filename: __filename});
269      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);275        [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
276      });
270    });277    });
278
279    itSub('NFT', async ({helper}) => {
280      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
281      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)});
282      await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address});
283      expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;
284      await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n);
285      expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false;
286      const transferTokenFromTx = () => helper.nft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: bob.address});
287      await expect(transferTokenFromTx()).to.be.rejected;
288    });
289
290    itSub('Fungible', async ({helper}) => {
291      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
292      await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice));
293      const tokenId = await helper.ft.getLastTokenId(collectionId);
294      await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address});
295      const amountBefore = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
296      expect(amountBefore).to.be.equal(BigInt(1));
297
298      await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n);
299      const amountAfter = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
300      expect(amountAfter).to.be.equal(BigInt(0));
301
302      const transferTokenFromTx = () => helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 1n);
303      await expect(transferTokenFromTx()).to.be.rejected;
304    });
305
306    itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => {
307      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
308      const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n});
309      await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address});
310      const amountBefore = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
311      expect(amountBefore).to.be.equal(BigInt(1));
312
313      await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n);
314      const amountAfter = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice));
315      expect(amountAfter).to.be.equal(BigInt(0));
316
317      const transferTokenFromTx = () => helper.rft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 100n);
318      await expect(transferTokenFromTx()).to.be.rejected;
319    });
271  });320  });
272321
273  itSub('NFT', async ({helper}) => {322  describe(`[${testCase.method}] User cannot approve for the amount greater than they own:`, () => {
323    let alice: IKeyringPair;
324    let bob: IKeyringPair;
325    let charlie: IKeyringPair;
326
327    before(async () => {
328      await usingPlaygrounds(async (helper, privateKey) => {
329        const donor = await privateKey({filename: __filename});
330        [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
331      });
332    });
333
334    itSub('1 for NFT', async ({helper}) => {
274    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});335      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
275    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});336      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)});
276    await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});337      const result = (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}, 2n);
277    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true;338      await expect(result).to.be.rejected;
339      expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.false;
278    await helper.signTransaction(alice, helper.constructApiCall('api.tx.unique.approve', [{Substrate: bob.address}, collectionId, tokenId, 0]));340    });
341
342    itSub('Fungible', async ({helper}) => {
343      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
344      await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice));
279    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false;345      const tokenId = await helper.ft.getLastTokenId(collectionId);
346      const result = (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 11n);
347      await expect(result).to.be.rejected;
280    const transferTokenFromTx = () => helper.nft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: bob.address});348    });
349
350    itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => {
351      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
352      const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n});
353      const result = (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 101n);
281    await expect(transferTokenFromTx()).to.be.rejected;354      await expect(result).to.be.rejected;
355    });
282  });356  });
283357
284  itSub('Fungible', async ({helper}) => {358  describe(`[${testCase.method}] Integration Test approve(spender, collection_id, item_id, amount) with collection admin permissions:`, () => {
285    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
286    await helper.ft.mintTokens(alice, collectionId, 10n, alice.address);
287    const tokenId = await helper.ft.getLastTokenId(collectionId);
288    await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});359    let alice: IKeyringPair;
289    const amountBefore = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});360    let bob: IKeyringPair;
290    expect(amountBefore).to.be.equal(BigInt(1));361    let charlie: IKeyringPair;
291362
292    await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 0n);363    before(async () => {
364      await usingPlaygrounds(async (helper, privateKey) => {
365        const donor = await privateKey({filename: __filename});
293    const amountAfter = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});366        [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
367      });
294    expect(amountAfter).to.be.equal(BigInt(0));368    });
295369
296    const transferTokenFromTx = () => helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 1n);370    itSub('can be called by collection admin on non-owned item', async ({helper}) => {
371      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
372      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)});
373      await helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address});
374      const result = (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address});
297    await expect(transferTokenFromTx()).to.be.rejected;375      await expect(result).to.be.rejected;
376    });
298  });377  });
299378
300  itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => {379  describe(`[${testCase.method}] Negative Integration Test approve(spender, collection_id, item_id, amount):`, () => {
301    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
302    const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n});
303    await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address});380    let alice: IKeyringPair;
304    const amountBefore = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});381    let bob: IKeyringPair;
305    expect(amountBefore).to.be.equal(BigInt(1));382    let charlie: IKeyringPair;
306383
307    await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 0n);384    before(async () => {
385      await usingPlaygrounds(async (helper, privateKey) => {
386        const donor = await privateKey({filename: __filename});
308    const amountAfter = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address});387        [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
388      });
309    expect(amountAfter).to.be.equal(BigInt(0));389    });
310390
311    const transferTokenFromTx = () => helper.rft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 100n);391    itSub('[nft] Approve for a collection that does not exist', async ({helper}) => {
312    await expect(transferTokenFromTx()).to.be.rejected;392      const collectionId = 1 << 32 - 1;
393      await expect((helper.nft as any)[testCase.method](bob, collectionId, 1, {Substrate: charlie.address})).to.be.rejected;
394    });
395
396    itSub('[fungible] Approve for a collection that does not exist', async ({helper}) => {
397      const collectionId = 1 << 32 - 1;
398      const approveTx = () => (helper.ft as any)[testCase.method](bob, collectionId, 1, {Substrate: charlie.address});
399      await expect(approveTx()).to.be.rejected;
400    });
401
402    itSub.ifWithPallets('[refungible] Approve for a collection that does not exist', [Pallets.ReFungible], async ({helper}) => {
403      const collectionId = 1 << 32 - 1;
404      const approveTx = () => (helper.rft as any)[testCase.method](bob, collectionId, 1, {Substrate: charlie.address});
405      await expect(approveTx()).to.be.rejected;
406    });
407
408    itSub('[nft] Approve for a collection that was destroyed', async ({helper}) => {
409      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
410      await helper.nft.burn(alice, collectionId);
411      const approveTx = () => (helper.nft as any)[testCase.method](alice, collectionId, 1, {Substrate: bob.address});
412      await expect(approveTx()).to.be.rejected;
413    });
414
415    itSub('[fungible] Approve for a collection that was destroyed', async ({helper}) => {
416      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
417      await helper.ft.burn(alice, collectionId);
418      const approveTx = () => (helper.ft as any)[testCase.method](alice, collectionId, 1, {Substrate: bob.address});
419      await expect(approveTx()).to.be.rejected;
420    });
421
422    itSub.ifWithPallets('[refungible] Approve for a collection that was destroyed', [Pallets.ReFungible], async ({helper}) => {
423      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
424      await helper.rft.burn(alice, collectionId);
425      const approveTx = () => (helper.rft as any)[testCase.method](alice, collectionId, 1, {Substrate: bob.address});
426      await expect(approveTx()).to.be.rejected;
427    });
428
429    itSub('[nft] Approve transfer of a token that does not exist', async ({helper}) => {
430      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
431      const approveTx = () => (helper.nft as any)[testCase.method](alice, collectionId, 2, {Substrate: bob.address});
432      await expect(approveTx()).to.be.rejected;
433    });
434
435    itSub.ifWithPallets('[refungible] Approve transfer of a token that does not exist', [Pallets.ReFungible], async ({helper}) => {
436      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
437      const approveTx = () => (helper.rft as any)[testCase.method](alice, collectionId, 2, {Substrate: bob.address});
438      await expect(approveTx()).to.be.rejected;
439    });
440
441    itSub('[nft] Approve using the address that does not own the approved token', async ({helper}) => {
442      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
443      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)});
444      const approveTx = () => (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address});
445      await expect(approveTx()).to.be.rejected;
446    });
447
448    itSub('[fungible] Approve using the address that does not own the approved token', async ({helper}) => {
449      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
450      await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice));
451      const tokenId = await helper.ft.getLastTokenId(collectionId);
452      const approveTx = () => (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address});
453      await expect(approveTx()).to.be.rejected;
454    });
455
456    itSub.ifWithPallets('[refungible] Approve using the address that does not own the approved token', [Pallets.ReFungible], async ({helper}) => {
457      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
458      const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n});
459      const approveTx = () => (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address});
460      await expect(approveTx()).to.be.rejected;
461    });
462
463    itSub.ifWithPallets('should fail if approved more ReFungibles than owned', [Pallets.ReFungible], async ({helper}) => {
464      const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
465      const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n});
466      await helper.rft.transferToken(alice, collectionId, tokenId, testCase.account(bob), 100n);
467      await (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}, 100n);
468
469      const approveTx = () => (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}, 101n);
470      await expect(approveTx()).to.be.rejected;
471    });
472
473    itSub('should fail if approved more Fungibles than owned', async ({helper}) => {
474      const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
475      await helper.ft.mintTokens(alice, collectionId, 10n, alice.address);
476      const tokenId = await helper.ft.getLastTokenId(collectionId);
477
478      await helper.ft.transferToken(alice, collectionId, tokenId, testCase.account(bob), 10n);
479      await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}, 10n);
480      const approveTx = () => (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}, 11n);
481      await expect(approveTx()).to.be.rejected;
482    });
483
484    itSub('fails when called by collection owner on non-owned item when OwnerCanTransfer == false', async ({helper}) => {
485      const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
486      const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)});
487      await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: false});
488
489      const approveTx = () => (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: charlie.address});
490      await expect(approveTx()).to.be.rejected;
491    });
313  });492  });
314});493});
315494
316describe('User cannot approve for the amount greater than they own:', () => {495describe('Normal user can approve other users to be wallet operator:', () => {
317  let alice: IKeyringPair;496  let alice: IKeyringPair;
318  let bob: IKeyringPair;497  let bob: IKeyringPair;
319  let charlie: IKeyringPair;
320498
321  before(async () => {499  before(async () => {
322    await usingPlaygrounds(async (helper, privateKey) => {500    await usingPlaygrounds(async (helper, privateKey) => {
323      const donor = await privateKey({filename: __filename});501      const donor = await privateKey({filename: __filename});
324      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);502      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
325    });503    });
326  });504  });
327505
328  itSub('1 for NFT', async ({helper}) => {506  itSub('[nft] Enable and disable approval', async ({helper}) => {
329    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});507    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
330    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
331    const approveTx = () => helper.signTransaction(bob, helper.constructApiCall('api.tx.unique.approve', [{Substrate: charlie.address}, collectionId, tokenId, 2]));
332    await expect(approveTx()).to.be.rejected;
333    expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.false;
334  });
335508
336  itSub('Fungible', async ({helper}) => {509    const checkBeforeApproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
337    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);510    expect(checkBeforeApproval).to.be.false;
511
338    await helper.ft.mintTokens(alice, collectionId, 10n, alice.address);512    await helper.nft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, true);
339    const tokenId = await helper.ft.getLastTokenId(collectionId);513    const checkAfterApproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
340    const approveTx = () => helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 11n);514    expect(checkAfterApproval).to.be.true;
515
516    await helper.nft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, false);
341    await expect(approveTx()).to.be.rejected;517    const checkAfterDisapproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
518    expect(checkAfterDisapproval).to.be.false;
342  });519  });
343520
344  itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => {521  itSub.ifWithPallets('[rft] Enable and disable approval', [Pallets.ReFungible], async ({helper}) => {
345    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});522    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
523
346    const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n});524    const checkBeforeApproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
525    expect(checkBeforeApproval).to.be.false;
526
527    await helper.rft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, true);
347    const approveTx = () => helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 101n);528    const checkAfterApproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
529    expect(checkAfterApproval).to.be.true;
530
531    await helper.rft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, false);
348    await expect(approveTx()).to.be.rejected;532    const checkAfterDisapproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
533    expect(checkAfterDisapproval).to.be.false;
349  });534  });
350});535});
351536
464    await token.approve(dave, {Substrate: bob.address}, 50n);649    await token.approve(dave, {Substrate: bob.address}, 50n);
465    await expect(token.approve(dave, {Substrate: charlie.address}, 51n))650    await expect(token.approve(dave, {Substrate: charlie.address}, 51n))
466      .to.be.rejectedWith('this test would fail (since it is skipped), replace this expecting message with what would have been received');651      .to.be.rejectedWith('this test would fail (since it is skipped), replace this expecting message with what would have been received');
467  });
468});
469
470describe('Integration Test approve(spender, collection_id, item_id, amount) with collection admin permissions:', () => {
471  let alice: IKeyringPair;
472  let bob: IKeyringPair;
473  let charlie: IKeyringPair;
474
475  before(async () => {
476    await usingPlaygrounds(async (helper, privateKey) => {
477      const donor = await privateKey({filename: __filename});
478      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
479    });
480  });
481
482  itSub('can be called by collection admin on non-owned item', async ({helper}) => {
483    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
484    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
485    await helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address});
486    const approveTx = () => helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address});
487    await expect(approveTx()).to.be.rejected;
488  });
489});
490
491describe('Negative Integration Test approve(spender, collection_id, item_id, amount):', () => {
492  let alice: IKeyringPair;
493  let bob: IKeyringPair;
494  let charlie: IKeyringPair;
495
496  before(async () => {
497    await usingPlaygrounds(async (helper, privateKey) => {
498      const donor = await privateKey({filename: __filename});
499      [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
500    });
501  });
502
503  itSub('[nft] Approve for a collection that does not exist', async ({helper}) => {
504    const collectionId = 1 << 32 - 1;
505    const approveTx = () => helper.nft.approveToken(bob, collectionId, 1, {Substrate: charlie.address});
506    await expect(approveTx()).to.be.rejected;
507  });
508
509  itSub('[fungible] Approve for a collection that does not exist', async ({helper}) => {
510    const collectionId = 1 << 32 - 1;
511    const approveTx = () => helper.ft.approveToken(bob, collectionId, 1, {Substrate: charlie.address});
512    await expect(approveTx()).to.be.rejected;
513  });
514
515  itSub.ifWithPallets('[refungible] Approve for a collection that does not exist', [Pallets.ReFungible], async ({helper}) => {
516    const collectionId = 1 << 32 - 1;
517    const approveTx = () => helper.rft.approveToken(bob, collectionId, 1, {Substrate: charlie.address});
518    await expect(approveTx()).to.be.rejected;
519  });
520
521  itSub('[nft] Approve for a collection that was destroyed', async ({helper}) => {
522    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
523    await helper.nft.burn(alice, collectionId);
524    const approveTx = () => helper.nft.approveToken(alice, collectionId, 1, {Substrate: bob.address});
525    await expect(approveTx()).to.be.rejected;
526  });
527
528  itSub('[fungible] Approve for a collection that was destroyed', async ({helper}) => {
529    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
530    await helper.ft.burn(alice, collectionId);
531    const approveTx = () => helper.ft.approveToken(alice, collectionId, 1, {Substrate: bob.address});
532    await expect(approveTx()).to.be.rejected;
533  });
534
535  itSub.ifWithPallets('[refungible] Approve for a collection that was destroyed', [Pallets.ReFungible], async ({helper}) => {
536    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
537    await helper.rft.burn(alice, collectionId);
538    const approveTx = () => helper.rft.approveToken(alice, collectionId, 1, {Substrate: bob.address});
539    await expect(approveTx()).to.be.rejected;
540  });
541
542  itSub('[nft] Approve transfer of a token that does not exist', async ({helper}) => {
543    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
544    const approveTx = () => helper.nft.approveToken(alice, collectionId, 2, {Substrate: bob.address});
545    await expect(approveTx()).to.be.rejected;
546  });
547
548  itSub.ifWithPallets('[refungible] Approve transfer of a token that does not exist', [Pallets.ReFungible], async ({helper}) => {
549    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
550    const approveTx = () => helper.rft.approveToken(alice, collectionId, 2, {Substrate: bob.address});
551    await expect(approveTx()).to.be.rejected;
552  });
553
554  itSub('[nft] Approve using the address that does not own the approved token', async ({helper}) => {
555    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
556    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
557    const approveTx = () => helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address});
558    await expect(approveTx()).to.be.rejected;
559  });
560
561  itSub('[fungible] Approve using the address that does not own the approved token', async ({helper}) => {
562    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
563    await helper.ft.mintTokens(alice, collectionId, 10n, alice.address);
564    const tokenId = await helper.ft.getLastTokenId(collectionId);
565    const approveTx = () => helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address});
566    await expect(approveTx()).to.be.rejected;
567  });
568
569  itSub.ifWithPallets('[refungible] Approve using the address that does not own the approved token', [Pallets.ReFungible], async ({helper}) => {
570    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
571    const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n});
572    const approveTx = () => helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address});
573    await expect(approveTx()).to.be.rejected;
574  });
575
576  itSub.ifWithPallets('should fail if approved more ReFungibles than owned', [Pallets.ReFungible], async ({helper}) => {
577    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
578    const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n});
579    await helper.rft.transferToken(alice, collectionId, tokenId, {Substrate: bob.address}, 100n);
580    await helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 100n);
581
582    const approveTx = () => helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 101n);
583    await expect(approveTx()).to.be.rejected;
584  });
585
586  itSub('should fail if approved more Fungibles than owned', async ({helper}) => {
587    const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
588    await helper.ft.mintTokens(alice, collectionId, 10n, alice.address);
589    const tokenId = await helper.ft.getLastTokenId(collectionId);
590
591    await helper.ft.transferToken(alice, collectionId, tokenId, {Substrate: bob.address}, 10n);
592    await helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 10n);
593    const approveTx = () => helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 11n);
594    await expect(approveTx()).to.be.rejected;
595  });
596
597  itSub('fails when called by collection owner on non-owned item when OwnerCanTransfer == false', async ({helper}) => {
598    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
599    const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
600    await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: false});
601
602    const approveTx = () => helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
603    await expect(approveTx()).to.be.rejected;
604  });
605});
606
607describe('Normal user can approve other users to be wallet operator:', () => {
608  let alice: IKeyringPair;
609  let bob: IKeyringPair;
610
611  before(async () => {
612    await usingPlaygrounds(async (helper, privateKey) => {
613      const donor = await privateKey({filename: __filename});
614      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
615    });
616  });
617
618  itSub('[nft] Enable and disable approval', async ({helper}) => {
619    const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
620
621    const checkBeforeApproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
622    expect(checkBeforeApproval).to.be.false;
623
624    await helper.nft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, true);
625    const checkAfterApproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
626    expect(checkAfterApproval).to.be.true;
627
628    await helper.nft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, false);
629    const checkAfterDisapproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
630    expect(checkAfterDisapproval).to.be.false;
631  });
632
633  itSub.ifWithPallets('[rft] Enable and disable approval', [Pallets.ReFungible], async ({helper}) => {
634    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
635
636    const checkBeforeApproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
637    expect(checkBeforeApproval).to.be.false;
638
639    await helper.rft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, true);
640    const checkAfterApproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
641    expect(checkAfterApproval).to.be.true;
642
643    await helper.rft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, false);
644    const checkAfterDisapproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
645    expect(checkAfterDisapproval).to.be.false;
646  });652  });
647});653});
648654