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

247		at: Option<BlockHash>,247		at: Option<BlockHash>,
248	) -> Result<Option<String>>;248	) -> Result<Option<String>>;
249
250	/// Get whether an operator is approved by a given owner.
251	#[method(name = "unique_isApprovedForAll")]
252	fn is_approved_for_all(
253		&self,
254		collection: CollectionId,
255		owner: CrossAccountId,
256		operator: CrossAccountId,
257		at: Option<BlockHash>,
258	) -> Result<bool>;
249}259}
250260
251mod app_promotion_unique_rpc {261mod app_promotion_unique_rpc {
569	pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>, unique_api);579	pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>, unique_api);
570	pass_method!(total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<String> => |o| o.map(|number| number.to_string()) , unique_api);580	pass_method!(total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<String> => |o| o.map(|number| number.to_string()) , unique_api);
571	pass_method!(token_owners(collection: CollectionId, token: TokenId) -> Vec<CrossAccountId>, unique_api);581	pass_method!(token_owners(collection: CollectionId, token: TokenId) -> Vec<CrossAccountId>, unique_api);
582	pass_method!(is_approved_for_all(collection: CollectionId, owner: CrossAccountId, operator: CrossAccountId) -> bool, unique_api);
572}583}
573584
574impl<C, Block, BlockNumber, CrossAccountId, AccountId>585impl<C, Block, BlockNumber, CrossAccountId, AccountId>

472			u128,472			u128,
473		),473		),
474
475		/// Amount pieces of token owned by `sender` was approved for `spender`.
476		ApprovedForAll(
477			/// Id of collection to which item is belong.
478			CollectionId,
479			/// Owner of a wallet.
480			T::CrossAccountId,
481			/// Id for which operator status was granted or rewoked.
482			T::CrossAccountId,
483			/// Is operator status was granted or rewoked.
484			bool,
485		),
474486
475		/// The colletion property has been added or edited.487		/// The colletion property has been added or edited.
476		CollectionPropertySet(488		CollectionPropertySet(
1522	/// The price of retrieving token owner1534	/// The price of retrieving token owner
1523	fn token_owner() -> Weight;1535	fn token_owner() -> Weight;
1536
1537	/// The price of setting approval for all
1538	fn set_approval_for_all() -> Weight;
1524}1539}
15251540
1526/// Weight info extension trait for refungible pallet.1541/// Weight info extension trait for refungible pallet.
1829	/// Get extension for RFT collection.1844	/// Get extension for RFT collection.
1830	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;1845	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;
1846
1847	/// An operator is allowed to transfer all tokens of the sender on their behalf.
1848	/// * `owner` - Token owner
1849	/// * `operator` - Operator
1850	/// * `approve` - Is operator enabled or disabled
1851	fn set_approval_for_all(
1852		&self,
1853		owner: T::CrossAccountId,
1854		operator: T::CrossAccountId,
1855		approve: bool,
1856	) -> DispatchResultWithPostInfo;
1857
1858	/// Tells whether an operator is approved by a given owner.
1859	fn is_approved_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool;
1831}1860}
18321861
1833/// Extension for RFT collection.1862/// Extension for RFT collection.

108		Weight::zero()108		Weight::zero()
109	}109	}
110
111	fn set_approval_for_all() -> Weight {
112		Weight::zero()
113	}
110}114}
111115
112/// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete116/// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete
425		<TotalSupply<T>>::try_get(self.id).ok()429		<TotalSupply<T>>::try_get(self.id).ok()
426	}430	}
431
432	fn set_approval_for_all(
433		&self,
434		_owner: T::CrossAccountId,
435		_operator: T::CrossAccountId,
436		_approve: bool,
437	) -> DispatchResultWithPostInfo {
438		fail!(<Error<T>>::SettingApprovalForAllNotAllowed)
439	}
440
441	fn is_approved_for_all(&self, _owner: T::CrossAccountId, _operator: T::CrossAccountId) -> bool {
442		false
443	}
427}444}
428445

127		FungibleDisallowsNesting,127		FungibleDisallowsNesting,
128		/// Setting item properties is not allowed.128		/// Setting item properties is not allowed.
129		SettingPropertiesNotAllowed,129		SettingPropertiesNotAllowed,
130		/// Setting approval for all is not allowed.
131		SettingApprovalForAllNotAllowed,
130	}132	}
131133
132	#[pallet::config]134	#[pallet::config]

223223
224	}: {collection.token_owner(item)}224	}: {collection.token_owner(item)}
225
226	set_approval_for_all {
227		bench_init!{
228			owner: sub; collection: collection(owner);
229			operator: cross_from_sub(owner); owner: cross_sub;
230		};
231	}: {<Pallet<T>>::set_approval_for_all(&collection, &owner, &operator, true)}
232
233	is_approved_for_all {
234		bench_init!{
235			owner: sub; collection: collection(owner);
236			operator: cross_from_sub(owner); owner: cross_sub;
237		};
238	}: {<Pallet<T>>::is_approved_for_all(&collection, &owner, &operator)}
225}239}
226240

123		<SelfWeightOf<T>>::token_owner()123		<SelfWeightOf<T>>::token_owner()
124	}124	}
125
126	fn set_approval_for_all() -> Weight {
127		<SelfWeightOf<T>>::set_approval_for_all()
128	}
125}129}
126130
127fn map_create_data<T: Config>(131fn map_create_data<T: Config>(
513		}517		}
514	}518	}
519
520	fn set_approval_for_all(
521		&self,
522		owner: T::CrossAccountId,
523		operator: T::CrossAccountId,
524		approve: bool,
525	) -> DispatchResultWithPostInfo {
526		with_weight(
527			<Pallet<T>>::set_approval_for_all(self, &owner, &operator, approve),
528			<CommonWeights<T>>::set_approval_for_all(),
529		)
530	}
531
532	fn is_approved_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {
533		<Pallet<T>>::is_approved_for_all(self, &owner, &operator)
534	}
515}535}
516536

469		Ok(())469		Ok(())
470	}470	}
471471
472	/// @notice Sets or unsets the approval of a given operator.
473	///  An operator is allowed to transfer all tokens of the sender on their behalf.
472	/// @dev Not implemented474	/// @param operator Operator
475	/// @param approved Is operator enabled or disabled
476	#[weight(<SelfWeightOf<T>>::set_approval_for_all())]
473	fn set_approval_for_all(477	fn set_approval_for_all(
474		&mut self,478		&mut self,
475		_caller: caller,479		caller: caller,
476		_operator: address,480		operator: address,
477		_approved: bool,481		approved: bool,
478	) -> Result<void> {482	) -> Result<void> {
479		// TODO: Not implemetable483		let caller = T::CrossAccountId::from_eth(caller);
484		let operator = T::CrossAccountId::from_eth(operator);
485
486		<Pallet<T>>::set_approval_for_all(self, &caller, &operator, approved)
480		Err("not implemented".into())487			.map_err(dispatch_to_evm::<T>)?;
488		Ok(())
481	}489	}
482490
483	/// @dev Not implemented491	/// @dev Not implemented
486		Err("not implemented".into())494		Err("not implemented".into())
487	}495	}
488496
489	/// @dev Not implemented497	/// @notice Tells whether an operator is approved by a given owner.
498	#[weight(<SelfWeightOf<T>>::is_approved_for_all())]
490	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {499	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {
491		// TODO: Not implemetable500		let owner = T::CrossAccountId::from_eth(owner);
501		let operator = T::CrossAccountId::from_eth(operator);
502
492		Err("not implemented".into())503		Ok(<Pallet<T>>::is_approved_for_all(self, &owner, &operator))
493	}504	}
494505
495	/// @notice Returns collection helper contract address506	/// @notice Returns collection helper contract address

272		QueryKind = OptionQuery,272		QueryKind = OptionQuery,
273	>;273	>;
274
275	/// Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.
276	#[pallet::storage]
277	pub type WalletOperator<T: Config> = StorageNMap<
278		Key = (
279			Key<Twox64Concat, CollectionId>,
280			Key<Blake2_128Concat, T::CrossAccountId>,
281			Key<Blake2_128Concat, T::CrossAccountId>,
282		),
283		Value = bool,
284		QueryKind = OptionQuery,
285	>;
274286
275	/// Upgrade from the old schema to properties.287	/// Upgrade from the old schema to properties.
276	#[pallet::hooks]288	#[pallet::hooks]
438		<TokensBurnt<T>>::remove(id);450		<TokensBurnt<T>>::remove(id);
439		let _ = <Allowance<T>>::clear_prefix((id,), u32::MAX, None);451		let _ = <Allowance<T>>::clear_prefix((id,), u32::MAX, None);
440		let _ = <AccountBalance<T>>::clear_prefix((id,), u32::MAX, None);452		let _ = <AccountBalance<T>>::clear_prefix((id,), u32::MAX, None);
453		let _ = <WalletOperator<T>>::clear_prefix((id,), u32::MAX, None);
441		Ok(())454		Ok(())
442	}455	}
443456
1193		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {1206		if <Allowance<T>>::get((collection.id, token)).as_ref() == Some(spender) {
1194			return Ok(());1207			return Ok(());
1195		}1208		}
1209		if <WalletOperator<T>>::get((collection.id, from, spender)) == Some(true) {
1210			return Ok(());
1211		}
1196		ensure!(1212		ensure!(
1197			collection.ignores_allowance(spender),1213			collection.ignores_allowance(spender),
1198			<CommonError<T>>::ApprovedValueTooLow1214			<CommonError<T>>::ApprovedValueTooLow
1327		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)1343		Self::create_multiple_items(collection, sender, vec![data], nesting_budget)
1328	}1344	}
1345
1346	/// Sets or unsets the approval of a given operator.
1347	///
1348	/// An operator is allowed to transfer all token pieces of the sender on their behalf.
1349	/// - `owner`: Token owner
1350	/// - `operator`: Operator
1351	/// - `approve`: Is operator enabled or disabled
1352	pub fn set_approval_for_all(
1353		collection: &NonfungibleHandle<T>,
1354		owner: &T::CrossAccountId,
1355		operator: &T::CrossAccountId,
1356		approve: bool,
1357	) -> DispatchResult {
1358		if collection.permissions.access() == AccessMode::AllowList {
1359			collection.check_allowlist(owner)?;
1360			collection.check_allowlist(operator)?;
1361		}
1362
1363		<PalletCommon<T>>::ensure_correct_receiver(operator)?;
1364
1365		// =========
1366
1367		<WalletOperator<T>>::insert((collection.id, owner, operator), approve);
1368		<PalletEvm<T>>::deposit_log(
1369			ERC721Events::ApprovalForAll {
1370				owner: *owner.as_eth(),
1371				operator: *operator.as_eth(),
1372				approved: approve,
1373			}
1374			.to_log(collection_id_to_address(collection.id)),
1375		);
1376		<PalletCommon<T>>::deposit_event(CommonEvent::ApprovedForAll(
1377			collection.id,
1378			owner.clone(),
1379			operator.clone(),
1380			approve,
1381		));
1382		Ok(())
1383	}
1384
1385	/// Tells whether an operator is approved by a given owner.
1386	pub fn is_approved_for_all(
1387		collection: &NonfungibleHandle<T>,
1388		owner: &T::CrossAccountId,
1389		operator: &T::CrossAccountId,
1390	) -> bool {
1391		<WalletOperator<T>>::get((collection.id, owner, operator)).unwrap_or(false)
1392	}
1329}1393}
13301394

binary blob — no preview

1020		dummy = 0;1020		dummy = 0;
1021	}1021	}
10221022
1023	/// @notice Sets or unsets the approval of a given operator.
1024	///  An operator is allowed to transfer all tokens of the sender on their behalf.
1023	/// @dev Not implemented1025	/// @param operator Operator
1026	/// @param approved Is operator enabled or disabled
1024	/// @dev EVM selector for this function is: 0xa22cb465,1027	/// @dev EVM selector for this function is: 0xa22cb465,
1025	///  or in textual repr: setApprovalForAll(address,bool)1028	///  or in textual repr: setApprovalForAll(address,bool)
1026	function setApprovalForAll(address operator, bool approved) public {1029	function setApprovalForAll(address operator, bool approved) public {
1040		return 0x0000000000000000000000000000000000000000;1043		return 0x0000000000000000000000000000000000000000;
1041	}1044	}
10421045
1043	/// @dev Not implemented1046	/// @notice Tells whether an operator is approved by a given owner.
1044	/// @dev EVM selector for this function is: 0xe985e9c5,1047	/// @dev EVM selector for this function is: 0xe985e9c5,
1045	///  or in textual repr: isApprovedForAll(address,address)1048	///  or in textual repr: isApprovedForAll(address,address)
1046	function isApprovedForAll(address owner, address operator) public view returns (address) {1049	function isApprovedForAll(address owner, address operator) public view returns (bool) {
1047		require(false, stub_error);1050		require(false, stub_error);
1048		owner;1051		owner;
1049		operator;1052		operator;
1050		dummy;1053		dummy;
1051		return 0x0000000000000000000000000000000000000000;1054		return false;
1052	}1055	}
10531056
1054	/// @notice Returns collection helper contract address1057	/// @notice Returns collection helper contract address

26#![cfg_attr(rustfmt, rustfmt_skip)]26#![cfg_attr(rustfmt, rustfmt_skip)]
27#![allow(unused_parens)]27#![allow(unused_parens)]
28#![allow(unused_imports)]28#![allow(unused_imports)]
29#![allow(missing_docs)]
29#![allow(clippy::unnecessary_cast)]30#![allow(clippy::unnecessary_cast)]
3031
31use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};32use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
47	fn set_token_properties(b: u32, ) -> Weight;48	fn set_token_properties(b: u32, ) -> Weight;
48	fn delete_token_properties(b: u32, ) -> Weight;49	fn delete_token_properties(b: u32, ) -> Weight;
49	fn token_owner() -> Weight;50	fn token_owner() -> Weight;
51	fn set_approval_for_all() -> Weight;
52	fn is_approved_for_all() -> Weight;
50}53}
5154
52/// Weights for pallet_nonfungible using the Substrate node and recommended hardware.55/// Weights for pallet_nonfungible using the Substrate node and recommended hardware.
195		Weight::from_ref_time(4_366_000)198		Weight::from_ref_time(4_366_000)
196			.saturating_add(T::DbWeight::get().reads(1 as u64))199			.saturating_add(T::DbWeight::get().reads(1 as u64))
197	}200	}
201	// Storage: Nonfungible WalletOperator (r:0 w:1)
202	fn set_approval_for_all() -> Weight {
203		Weight::from_ref_time(16_231_000 as u64)
204			.saturating_add(T::DbWeight::get().writes(1 as u64))
205	}
206	// Storage: Nonfungible WalletOperator (r:1 w:0)
207	fn is_approved_for_all() -> Weight {
208		Weight::from_ref_time(6_161_000 as u64)
209			.saturating_add(T::DbWeight::get().reads(1 as u64))
210	}
198}211}
199212
200// For backwards compatibility and tests213// For backwards compatibility and tests
342		Weight::from_ref_time(4_366_000)355		Weight::from_ref_time(4_366_000)
343			.saturating_add(RocksDbWeight::get().reads(1 as u64))356			.saturating_add(RocksDbWeight::get().reads(1 as u64))
344	}357	}
358	// Storage: Nonfungible WalletOperator (r:0 w:1)
359	fn set_approval_for_all() -> Weight {
360		Weight::from_ref_time(16_231_000 as u64)
361			.saturating_add(RocksDbWeight::get().writes(1 as u64))
362	}
363	// Storage: Nonfungible WalletOperator (r:1 w:0)
364	fn is_approved_for_all() -> Weight {
365		Weight::from_ref_time(6_161_000 as u64)
366			.saturating_add(RocksDbWeight::get().reads(1 as u64))
367	}
345}368}
346369

291		let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?;291		let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?;
292	}: {<Pallet<T>>::token_owner(collection.id, item)}292	}: {<Pallet<T>>::token_owner(collection.id, item)}
293
294	set_approval_for_all {
295		bench_init!{
296			owner: sub; collection: collection(owner);
297			operator: cross_from_sub(owner); owner: cross_sub;
298		};
299	}: {<Pallet<T>>::set_approval_for_all(&collection, &owner, &operator, true)}
300
301	is_approved_for_all {
302		bench_init!{
303			owner: sub; collection: collection(owner);
304			operator: cross_from_sub(owner); owner: cross_sub;
305		};
306	}: {<Pallet<T>>::is_approved_for_all(&collection, &owner, &operator)}
293}307}
294308

153		<SelfWeightOf<T>>::token_owner()153		<SelfWeightOf<T>>::token_owner()
154	}154	}
155
156	fn set_approval_for_all() -> Weight {
157		<SelfWeightOf<T>>::set_approval_for_all()
158	}
155}159}
156160
157fn map_create_data<T: Config>(161fn map_create_data<T: Config>(
517		<Pallet<T>>::total_pieces(self.id, token)521		<Pallet<T>>::total_pieces(self.id, token)
518	}522	}
523
524	fn set_approval_for_all(
525		&self,
526		owner: T::CrossAccountId,
527		operator: T::CrossAccountId,
528		approve: bool,
529	) -> DispatchResultWithPostInfo {
530		with_weight(
531			<Pallet<T>>::set_approval_for_all(self, &owner, &operator, approve),
532			<CommonWeights<T>>::set_approval_for_all(),
533		)
534	}
535
536	fn is_approved_for_all(&self, owner: T::CrossAccountId, operator: T::CrossAccountId) -> bool {
537		<Pallet<T>>::is_approved_for_all(self, &owner, &operator)
538	}
519}539}
520540
521impl<T: Config> RefungibleExtensions<T> for RefungibleHandle<T> {541impl<T: Config> RefungibleExtensions<T> for RefungibleHandle<T> {

461		Err("not implemented".into())461		Err("not implemented".into())
462	}462	}
463463
464	/// @notice Sets or unsets the approval of a given operator.
465	///  An operator is allowed to transfer all tokens of the sender on their behalf.
464	/// @dev Not implemented466	/// @param operator Operator
467	/// @param approved Is operator enabled or disabled
468	#[weight(<SelfWeightOf<T>>::set_approval_for_all())]
465	fn set_approval_for_all(469	fn set_approval_for_all(
466		&mut self,470		&mut self,
467		_caller: caller,471		caller: caller,
468		_operator: address,472		operator: address,
469		_approved: bool,473		approved: bool,
470	) -> Result<void> {474	) -> Result<void> {
471		// TODO: Not implemetable475		let caller = T::CrossAccountId::from_eth(caller);
476		let operator = T::CrossAccountId::from_eth(operator);
477
478		<Pallet<T>>::set_approval_for_all(self, &caller, &operator, approved)
472		Err("not implemented".into())479			.map_err(dispatch_to_evm::<T>)?;
480		Ok(())
473	}481	}
474482
475	/// @dev Not implemented483	/// @dev Not implemented
478		Err("not implemented".into())486		Err("not implemented".into())
479	}487	}
480488
481	/// @dev Not implemented489	/// @notice Tells whether an operator is approved by a given owner.
490	#[weight(<SelfWeightOf<T>>::is_approved_for_all())]
482	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {491	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {
483		// TODO: Not implemetable492		let owner = T::CrossAccountId::from_eth(owner);
493		let operator = T::CrossAccountId::from_eth(operator);
494
484		Err("not implemented".into())495		Ok(<Pallet<T>>::is_approved_for_all(self, &owner, &operator))
485	}496	}
486497
487	/// @notice Returns collection helper contract address498	/// @notice Returns collection helper contract address

273		QueryKind = ValueQuery,273		QueryKind = ValueQuery,
274	>;274	>;
275
276	/// Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.
277	#[pallet::storage]
278	pub type WalletOperator<T: Config> = StorageNMap<
279		Key = (
280			Key<Twox64Concat, CollectionId>,
281			Key<Blake2_128Concat, T::CrossAccountId>,
282			Key<Blake2_128Concat, T::CrossAccountId>,
283		),
284		Value = bool,
285		QueryKind = OptionQuery,
286	>;
275287
276	#[pallet::hooks]288	#[pallet::hooks]
277	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {289	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
1162		let allowance =1174		let allowance =
1163			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);1175			<Allowance<T>>::get((collection.id, token, from, &spender)).checked_sub(amount);
1176
1177		// Allowance if any would be reduced if spender is also wallet operator
1178		if <WalletOperator<T>>::get((collection.id, from, spender)) == Some(true) {
1179			return Ok(allowance);
1180		}
1181
1164		if allowance.is_none() {1182		if allowance.is_none() {
1165			ensure!(1183			ensure!(
1388		}1406		}
1389	}1407	}
1408
1409	/// Sets or unsets the approval of a given operator.
1410	///
1411	/// An operator is allowed to transfer all tokens of the sender on their behalf.
1412	/// - `owner`: Token owner
1413	/// - `operator`: Operator
1414	/// - `approve`: Is operator enabled or disabled
1415	pub fn set_approval_for_all(
1416		collection: &RefungibleHandle<T>,
1417		owner: &T::CrossAccountId,
1418		operator: &T::CrossAccountId,
1419		approve: bool,
1420	) -> DispatchResult {
1421		if collection.permissions.access() == AccessMode::AllowList {
1422			collection.check_allowlist(owner)?;
1423			collection.check_allowlist(operator)?;
1424		}
1425
1426		<PalletCommon<T>>::ensure_correct_receiver(operator)?;
1427
1428		// =========
1429
1430		<WalletOperator<T>>::insert((collection.id, owner, operator), approve);
1431		<PalletEvm<T>>::deposit_log(
1432			ERC721Events::ApprovalForAll {
1433				owner: *owner.as_eth(),
1434				operator: *operator.as_eth(),
1435				approved: approve,
1436			}
1437			.to_log(collection_id_to_address(collection.id)),
1438		);
1439		<PalletCommon<T>>::deposit_event(CommonEvent::ApprovedForAll(
1440			collection.id,
1441			owner.clone(),
1442			operator.clone(),
1443			approve,
1444		));
1445		Ok(())
1446	}
1447
1448	/// Tells whether an operator is approved by a given owner.
1449	pub fn is_approved_for_all(
1450		collection: &RefungibleHandle<T>,
1451		owner: &T::CrossAccountId,
1452		operator: &T::CrossAccountId,
1453	) -> bool {
1454		<WalletOperator<T>>::get((collection.id, owner, operator)).unwrap_or(false)
1455	}
1390}1456}
13911457

binary blob — no preview

1017		dummy = 0;1017		dummy = 0;
1018	}1018	}
10191019
1020	/// @notice Sets or unsets the approval of a given operator.
1021	///  An operator is allowed to transfer all tokens of the sender on their behalf.
1020	/// @dev Not implemented1022	/// @param operator Operator
1023	/// @param approved Is operator enabled or disabled
1021	/// @dev EVM selector for this function is: 0xa22cb465,1024	/// @dev EVM selector for this function is: 0xa22cb465,
1022	///  or in textual repr: setApprovalForAll(address,bool)1025	///  or in textual repr: setApprovalForAll(address,bool)
1023	function setApprovalForAll(address operator, bool approved) public {1026	function setApprovalForAll(address operator, bool approved) public {
1037		return 0x0000000000000000000000000000000000000000;1040		return 0x0000000000000000000000000000000000000000;
1038	}1041	}
10391042
1040	/// @dev Not implemented1043	/// @notice Tells whether an operator is approved by a given owner.
1041	/// @dev EVM selector for this function is: 0xe985e9c5,1044	/// @dev EVM selector for this function is: 0xe985e9c5,
1042	///  or in textual repr: isApprovedForAll(address,address)1045	///  or in textual repr: isApprovedForAll(address,address)
1043	function isApprovedForAll(address owner, address operator) public view returns (address) {1046	function isApprovedForAll(address owner, address operator) public view returns (bool) {
1044		require(false, stub_error);1047		require(false, stub_error);
1045		owner;1048		owner;
1046		operator;1049		operator;
1047		dummy;1050		dummy;
1048		return 0x0000000000000000000000000000000000000000;1051		return false;
1049	}1052	}
10501053
1051	/// @notice Returns collection helper contract address1054	/// @notice Returns collection helper contract address

3//! Autogenerated weights for pallet_refungible3//! Autogenerated weights for pallet_refungible
4//!4//!
5//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev5//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
6//! DATE: 2022-08-15, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`6//! DATE: 2022-11-25, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
7//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 10247//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
88
9// Executed Command:9// Executed Command:
26#![cfg_attr(rustfmt, rustfmt_skip)]26#![cfg_attr(rustfmt, rustfmt_skip)]
27#![allow(unused_parens)]27#![allow(unused_parens)]
28#![allow(unused_imports)]28#![allow(unused_imports)]
29#![allow(missing_docs)]
29#![allow(clippy::unnecessary_cast)]30#![allow(clippy::unnecessary_cast)]
3031
31use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};32use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
54	fn delete_token_properties(b: u32, ) -> Weight;55	fn delete_token_properties(b: u32, ) -> Weight;
55	fn repartition_item() -> Weight;56	fn repartition_item() -> Weight;
56	fn token_owner() -> Weight;57	fn token_owner() -> Weight;
58	fn set_approval_for_all() -> Weight;
59	fn is_approved_for_all() -> Weight;
57}60}
5861
59/// Weights for pallet_refungible using the Substrate node and recommended hardware.62/// Weights for pallet_refungible using the Substrate node and recommended hardware.
259		Weight::from_ref_time(9_431_000)262		Weight::from_ref_time(9_431_000)
260			.saturating_add(T::DbWeight::get().reads(2 as u64))263			.saturating_add(T::DbWeight::get().reads(2 as u64))
261	}264	}
265	// Storage: Refungible WalletOperator (r:0 w:1)
266	fn set_approval_for_all() -> Weight {
267		Weight::from_ref_time(16_150_000 as u64)
268			.saturating_add(T::DbWeight::get().writes(1 as u64))
269	}
270	// Storage: Refungible WalletOperator (r:1 w:0)
271	fn is_approved_for_all() -> Weight {
272		Weight::from_ref_time(5_901_000 as u64)
273			.saturating_add(T::DbWeight::get().reads(1 as u64))
274	}
262}275}
263276
264// For backwards compatibility and tests277// For backwards compatibility and tests
463		Weight::from_ref_time(9_431_000)476		Weight::from_ref_time(9_431_000)
464			.saturating_add(RocksDbWeight::get().reads(2 as u64))477			.saturating_add(RocksDbWeight::get().reads(2 as u64))
465	}478	}
479	// Storage: Refungible WalletOperator (r:0 w:1)
480	fn set_approval_for_all() -> Weight {
481		Weight::from_ref_time(16_150_000 as u64)
482			.saturating_add(RocksDbWeight::get().writes(1 as u64))
483	}
484	// Storage: Refungible WalletOperator (r:1 w:0)
485	fn is_approved_for_all() -> Weight {
486		Weight::from_ref_time(5_901_000 as u64)
487			.saturating_add(RocksDbWeight::get().reads(1 as u64))
488	}
466}489}
467490

1127			})1127			})
1128		}1128		}
1129
1130		/// Sets or unsets the approval of a given operator.
1131		///
1132		/// An operator is allowed to transfer all tokens of the sender on their behalf.
1133		///
1134		/// # Arguments
1135		///
1136		/// * `owner`: Token owner
1137		/// * `operator`: Operator
1138		/// * `approve`: Is operator enabled or disabled
1139		#[weight = T::CommonWeightInfo::set_approval_for_all()]
1140		pub fn set_approval_for_all(
1141			origin,
1142			collection_id: CollectionId,
1143			operator: T::CrossAccountId,
1144			approve: bool,
1145		) -> DispatchResultWithPostInfo {
1146			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1147			dispatch_tx::<T, _>(collection_id, |d| {
1148				d.set_approval_for_all(sender, operator, approve)
1149			})
1150		}
1129	}1151	}
1130}1152}
11311153

133133
134		fn token_owners(collection: CollectionId, token: TokenId) -> Result<Vec<CrossAccountId>>;134		fn token_owners(collection: CollectionId, token: TokenId) -> Result<Vec<CrossAccountId>>;
135
136		/// Get whether an operator is approved by a given owner.
137		fn is_approved_for_all(collection: CollectionId, owner: CrossAccountId, operator: CrossAccountId) -> Result<bool>;
135	}138	}
136}139}
137140

188                    dispatch_unique_runtime!(collection.total_pieces(token_id))188                    dispatch_unique_runtime!(collection.total_pieces(token_id))
189                }189                }
190
191		        fn is_approved_for_all(collection: CollectionId, owner: CrossAccountId, operator: CrossAccountId) -> Result<bool, DispatchError> {
192                    dispatch_unique_runtime!(collection.is_approved_for_all(owner, operator))
193                }
190            }194            }
191195
192            impl app_promotion_rpc::AppPromotionApi<Block, BlockNumber, CrossAccountId, AccountId> for Runtime {196            impl app_promotion_rpc::AppPromotionApi<Block, BlockNumber, CrossAccountId, AccountId> for Runtime {

121		max_weight_of!(token_owner())121		max_weight_of!(token_owner())
122	}122	}
123
124	fn set_approval_for_all() -> Weight {
125		max_weight_of!(set_approval_for_all())
126	}
123}127}
124128
125#[cfg(feature = "refungible")]129#[cfg(feature = "refungible")]

604  });604  });
605});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    await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
621    const checkBeforeApprovalTx = () => helper.nft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
622    expect(await checkBeforeApprovalTx()).to.be.false;
623    await helper.nft.setApprovalForAll(alice, collectionId, {Substrate: bob.address}, true);
624    const checkAfterApprovalTx = () => helper.nft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
625    expect(await checkAfterApprovalTx()).to.be.true;
626    await helper.nft.setApprovalForAll(alice, collectionId, {Substrate: bob.address}, false);
627    const checkAfterDisapprovalTx = () => helper.nft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
628    expect(await checkAfterDisapprovalTx()).to.be.false;
629  });
630
631  itSub.ifWithPallets('[rft] Enable and disable approval', [Pallets.ReFungible], async ({helper}) => {
632    const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
633    const checkBeforeApprovalTx = () => helper.rft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
634    expect(await checkBeforeApprovalTx()).to.be.false;
635    await helper.rft.setApprovalForAll(alice, collectionId, {Substrate: bob.address}, true);
636    const checkAfterApprovalTx = () => helper.rft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
637    expect(await checkAfterApprovalTx()).to.be.true;
638    await helper.rft.setApprovalForAll(alice, collectionId, {Substrate: bob.address}, false);
639    const checkAfterDisapprovalTx = () => helper.rft.isApprovedForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address});
640    expect(await checkAfterDisapprovalTx()).to.be.false;
641  });
642});
606643