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

5114 "pallet-randomness-collective-flip",5114 "pallet-randomness-collective-flip",
5115 "pallet-refungible",5115 "pallet-refungible",
5116 "pallet-sudo",5116 "pallet-sudo",
5117 "pallet-template-charge-transaction",5117 "pallet-template-transaction-payment",
5118 "pallet-timestamp",5118 "pallet-timestamp",
5119 "pallet-transaction-payment",5119 "pallet-transaction-payment",
5120 "pallet-transaction-payment-rpc-runtime-api",5120 "pallet-transaction-payment-rpc-runtime-api",
6350]6350]
63516351
6352[[package]]6352[[package]]
6353name = "pallet-template-charge-transaction"6353name = "pallet-template-transaction-payment"
6354version = "3.0.0"6354version = "3.0.0"
6355source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#e5d3354ab68face1b2ef709dc7f629803f56598d"6355source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#ab8b91e9350a31133f3a3e4f52a84c6de4108e95"
6356dependencies = [6356dependencies = [
6357 "frame-benchmarking",6357 "frame-benchmarking",
6358 "frame-support",6358 "frame-support",
11696source = "registry+https://github.com/rust-lang/crates.io-index"11696source = "registry+https://github.com/rust-lang/crates.io-index"
11697checksum = "1f559b464de2e2bdabcac6a210d12e9b5a5973c251e102c44c585c71d51bd78e"11697checksum = "1f559b464de2e2bdabcac6a210d12e9b5a5973c251e102c44c585c71d51bd78e"
11698dependencies = [11698dependencies = [
11699 "cfg-if 0.1.10",11699 "cfg-if 1.0.0",
11700 "rand 0.8.4",11700 "rand 0.8.4",
11701 "static_assertions",11701 "static_assertions",
11702]11702]
11847[[package]]11847[[package]]
11848name = "up-sponsorship"11848name = "up-sponsorship"
11849version = "0.1.0"11849version = "0.1.0"
11850source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#e5d3354ab68face1b2ef709dc7f629803f56598d"11850source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#ab8b91e9350a31133f3a3e4f52a84c6de4108e95"
11851dependencies = [11851dependencies = [
11852 "impl-trait-for-tuples 0.2.1",11852 "impl-trait-for-tuples 0.2.1",
11853]11853]

41    -   Re-Fungible Token Mode41    -   Re-Fungible Token Mode
42    -   Off-Chain Schema to store token image URLs42    -   Off-Chain Schema to store token image URLs
43    -   Alternative economic model43    -   Alternative economic model
44    -   White Lists and Public Mint Permission44    -   Allow Lists and Public Mint Permission
45-   Use example: [SubstraPunks Game](https://github.com/usetech-llc/substrapunks), fully hosted on IPFS and NFT Testnet45-   Use example: [SubstraPunks Game](https://github.com/usetech-llc/substrapunks), fully hosted on IPFS and NFT Testnet
46    Blockchain.46    Blockchain.
4747

1736. Now select your "ZERO BALANCE" address in the drop-down list and repeat searching and adding the collection for this address.1736. Now select your "ZERO BALANCE" address in the drop-down list and repeat searching and adding the collection for this address.
1747. Transfer token back to your main address. Observe that despite the zero balance, the transfer is successful.1747. Transfer token back to your main address. Observe that despite the zero balance, the transfer is successful.
175175
176### White Lists and Public Mint Permission176### Allow Lists and Public Mint Permission
177177
178We did not complete these features in time by Hackusama deadline, but because they are important for security of the network, we completed them after the deadline anyway. They can be seen in branch [feature/white_list](https://github.com/usetech-llc/nft_parachain/tree/feature/white_list). Here are the permalinks to essential functions:178We did not complete these features in time by Hackusama deadline, but because they are important for security of the network, we completed them after the deadline anyway. They can be seen in branch [feature/allow_list](https://github.com/usetech-llc/nft_parachain/tree/feature/allow_list). Here are the permalinks to essential functions:
179179
180[white_lists](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L659)180[allow_lists](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L659)
181181
182[mint_permission](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L373)182[mint_permission](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L373)
183183

4040
41Set the collection sponsor address. The sponsorship needs to be confirmed by sending a ConfirmSponsorship transaction41Set the collection sponsor address. The sponsorship needs to be confirmed by sending a ConfirmSponsorship transaction
42from that address. Also, the protection measures need to be in place so that sponsor account cannot be depleted by42from that address. Also, the protection measures need to be in place so that sponsor account cannot be depleted by
43malicious users. White listing is one of the measured. It can be enabled with SetPublicAccessMode method.43malicious users. Allow listing is one of the measured. It can be enabled with SetPublicAccessMode method.
4444
45##### List of transactions45##### List of transactions
4646
67    Further, the logic is similar to limiting by token as above. If only one of the limits (by token or by address)67    Further, the logic is similar to limiting by token as above. If only one of the limits (by token or by address)
68    indicates that fee should be paid by the user, the fee is paid by the user.68    indicates that fee should be paid by the user, the fee is paid by the user.
69-   A pallet method (SetCollectionRateLimits) will be added to set these parameters and enable rate limiting.69-   A pallet method (SetCollectionRateLimits) will be added to set these parameters and enable rate limiting.
70-   One idea to consider is deposits that must be made by an address in order to become white listed (instead of admin70-   One idea to consider is deposits that must be made by an address in order to become allow listed (instead of admin
71    review).71    review).
7272
73#### Permissions73#### Permissions
173173
174#### Description174#### Description
175175
176Toggle between normal and white list access for the methods with access for “Anyone”. If White List mode is enabled,176Toggle between normal and allow list access for the methods with access for “Anyone”. If Allow List mode is enabled,
177AddToWhiteList and RemoveFromWhiteList methods can be called to add to and remove addresses from the white list.177AddToAllowList and RemoveFromAllowList methods can be called to add to and remove addresses from the allow list.
178178
179White list mode is the property of collection. If it is turned on, all public operations such as token transfers, for179Allow list mode is the property of collection. If it is turned on, all public operations such as token transfers, for
180example, which normally have “Anyone” permission, become white listed, i.e. are only available to collection owner,180example, which normally have “Anyone” permission, become allow listed, i.e. are only available to collection owner,
181admins, and addresses from the white list. White lists can be helpful for rate limiting of transfers when collection181admins, and addresses from the allow list. Allow lists can be helpful for rate limiting of transfers when collection
182sponsoring is enabled.182sponsoring is enabled.
183183
184#### Permissions184#### Permissions
190-   CollectionID: ID of the Collection to set access mode for190-   CollectionID: ID of the Collection to set access mode for
191-   Mode191-   Mode
192    -   0 = Normal192    -   0 = Normal
193    -   1 = White list193    -   1 = Allow list
194194
195### AddToWhiteList195### AddToAllowList
196196
197#### Description197#### Description
198198
199Add an address to white list.199Add an address to allow list.
200200
201#### Permissions201#### Permissions
202202
208-   CollectionID: ID of the Collection208-   CollectionID: ID of the Collection
209-   Address209-   Address
210210
211### RemoveFromWhiteList211### RemoveFromAllowList
212212
213#### Description213#### Description
214214
215Remove an address from white list.215Remove an address from allow list.
216216
217#### Permissions217#### Permissions
218218

187   address.187   address.
1887. Transfer token back to your main address. Observe that despite the zero balance, the transfer is successful.1887. Transfer token back to your main address. Observe that despite the zero balance, the transfer is successful.
189189
190### White Lists and Public Mint Permission190### Allow Lists and Public Mint Permission
191191
192We did not complete these features in time by Hackusama deadline, but because they are important for security of the192We did not complete these features in time by Hackusama deadline, but because they are important for security of the
193network, we completed them after the deadline anyway. They can be seen in branch193network, we completed them after the deadline anyway. They can be seen in branch
194[feature/white_list](https://github.com/usetech-llc/nft_parachain/tree/feature/white_list). Here are the permalinks to194[feature/allow_list](https://github.com/usetech-llc/nft_parachain/tree/feature/allow_list). Here are the permalinks to
195essential functions:195essential functions:
196196
197[white_lists](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L659)197[allow_lists](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L659)
198198
199[mint_permission](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L373)199[mint_permission](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L373)
200200

1## Milestone 11## Milestone 1
22
3**User Paid Fees and Sponsored. Finish/Debug white listing and spam/DOS protection**3**User Paid Fees and Sponsored. Finish/Debug allow listing and spam/DOS protection**
44
5Implementation of two models 5Implementation of two models 
6If collection sponsor is set and confirmed for collection instance that means Sponsored Economic Model has chosen. Otherwise default economic model User Paid Fees is set.6If collection sponsor is set and confirmed for collection instance that means Sponsored Economic Model has chosen. Otherwise default economic model User Paid Fees is set.
7For Sponsored Economic Model exists timeouts for token transactions. For every NFT type timeouts defined separately. Timeouts and white list limits together prevented spam and malicious actions.7For Sponsored Economic Model exists timeouts for token transactions. For every NFT type timeouts defined separately. Timeouts and allow list limits together prevented spam and malicious actions.
88
9Set sponsor9Set sponsor
10`nft`.`set_collection_sponsor`10`nft`.`set_collection_sponsor`
11Confirm sponsor11Confirm sponsor
12`nft`.`confirm_sponsorship`12`nft`.`confirm_sponsorship`
1313
14A white list mode presented by collection property `access` and can be enabled with `set_public_access_mode`. Rules provide spam/DOS protection14A allow list mode presented by collection property `access` and can be enabled with `set_public_access_mode`. Rules provide spam/DOS protection
15While collection in the white list mode rules below are active:15While collection in the allow list mode rules below are active:
16Owner can add address to white list16Owner can add address to allow list
17Admin can add address to white list17Admin can add address to allow list
18Non-privileged user cannot add address to white list18Non-privileged user cannot add address to allow list
19Owner can remove address from white list19Owner can remove address from allow list
20Admin can remove address from white list20Admin can remove address from allow list
21Non-privileged user cannot remove address from white list21Non-privileged user cannot remove address from allow list
22If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom22If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom
23If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom23If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom
24If Public Access mode is set to WhiteList, tokens can’t be destroyed by a non-whitelisted address (even if it owned them before enabling WhiteList mode)24If Public Access mode is set to AllowList, tokens can’t be destroyed by a non-allowlisted address (even if it owned them before enabling AllowList mode)
25If Public Access mode is set to WhiteList, token transfers can’t be Approved by a non-whitelisted address (see Approve method).25If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).
26If Public Access mode is set to WhiteList, tokens can be transferred to a whitelisted address with transfer or transferFrom26If Public Access mode is set to AllowList, tokens can be transferred to a allowlisted address with transfer or transferFrom
27If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom 27If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom 
28If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.28If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.
29If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.29If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.
30If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and white listed address.30If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens cannot be created by non-privileged and allow listed address.
31If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-white listed address.31If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-allow listed address.
32If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.32If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.
33If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.33If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.
34If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens cannot be created by non-privileged and non-white listed address.34If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens cannot be created by non-privileged and non-allow listed address.
35If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by non-privileged and white listed address.35If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by non-privileged and allow listed address.
3636
37**Add missing custom types (CollectionMode, FungibleItemType, ReFungibleItemType)**37**Add missing custom types (CollectionMode, FungibleItemType, ReFungibleItemType)**
3838

260		NoPermission,260		NoPermission,
261		/// Collection is not in mint mode.261		/// Collection is not in mint mode.
262		PublicMintingNotAllowed,262		PublicMintingNotAllowed,
263		/// Address is not in white list.263		/// Address is not in allow list.
264		AddressNotInAllowlist,264		AddressNotInAllowlist,
265265
266		/// Collection name can not be longer than 63 char.266		/// Collection name can not be longer than 63 char.

123			.checked_sub(amount)123			.checked_sub(amount)
124			.ok_or(<CommonError<T>>::TokenValueTooLow)?;124			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
125125
126		if collection.access == AccessMode::WhiteList {126		if collection.access == AccessMode::AllowList {
127			collection.check_allowlist(owner)?;127			collection.check_allowlist(owner)?;
128		}128		}
129129
161			<CommonError<T>>::TransferNotAllowed,161			<CommonError<T>>::TransferNotAllowed,
162		);162		);
163163
164		if collection.access == AccessMode::WhiteList {164		if collection.access == AccessMode::AllowList {
165			collection.check_allowlist(from)?;165			collection.check_allowlist(from)?;
166			collection.check_allowlist(to)?;166			collection.check_allowlist(to)?;
167		}167		}
307		spender: &T::CrossAccountId,307		spender: &T::CrossAccountId,
308		amount: u128,308		amount: u128,
309	) -> DispatchResult {309	) -> DispatchResult {
310		if collection.access == AccessMode::WhiteList {310		if collection.access == AccessMode::AllowList {
311			collection.check_allowlist(&owner)?;311			collection.check_allowlist(&owner)?;
312			collection.check_allowlist(&spender)?;312			collection.check_allowlist(&spender)?;
313		}313		}
335		if spender.conv_eq(from) {335		if spender.conv_eq(from) {
336			return Self::transfer(collection, from, to, amount);336			return Self::transfer(collection, from, to, amount);
337		}337		}
338		if collection.access == AccessMode::WhiteList {338		if collection.access == AccessMode::AllowList {
339			// `from`, `to` checked in [`transfer`]339			// `from`, `to` checked in [`transfer`]
340			collection.check_allowlist(spender)?;340			collection.check_allowlist(spender)?;
341		}341		}
366		if spender.conv_eq(from) {366		if spender.conv_eq(from) {
367			return Self::burn(collection, from, amount);367			return Self::burn(collection, from, amount);
368		}368		}
369		if collection.access == AccessMode::WhiteList {369		if collection.access == AccessMode::AllowList {
370			// `from` checked in [`burn`]370			// `from` checked in [`burn`]
371			collection.check_allowlist(spender)?;371			collection.check_allowlist(spender)?;
372		}372		}

55		let collection = create_nft_collection::<T>(caller.clone())?;55		let collection = create_nft_collection::<T>(caller.clone())?;
56	}: _(RawOrigin::Signed(caller.clone()), collection)56	}: _(RawOrigin::Signed(caller.clone()), collection)
5757
58	add_to_white_list {58	add_to_allow_list {
59		let caller: T::AccountId = account("caller", 0, SEED);59		let caller: T::AccountId = account("caller", 0, SEED);
60		let whitelist_account: T::AccountId = account("admin", 0, SEED);60		let allowlist_account: T::AccountId = account("admin", 0, SEED);
61		let collection = create_nft_collection::<T>(caller.clone())?;61		let collection = create_nft_collection::<T>(caller.clone())?;
62	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(whitelist_account))62	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(allowlist_account))
6363
64	remove_from_white_list {64	remove_from_allow_list {
65		let caller: T::AccountId = account("caller", 0, SEED);65		let caller: T::AccountId = account("caller", 0, SEED);
66		let whitelist_account: T::AccountId = account("admin", 0, SEED);66		let allowlist_account: T::AccountId = account("admin", 0, SEED);
67		let collection = create_nft_collection::<T>(caller.clone())?;67		let collection = create_nft_collection::<T>(caller.clone())?;
68		<Pallet<T>>::add_to_white_list(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(whitelist_account.clone()))?;68		<Pallet<T>>::add_to_allow_list(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(allowlist_account.clone()))?;
69	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(whitelist_account))69	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(allowlist_account))
7070
71	set_public_access_mode {71	set_public_access_mode {
72		let caller: T::AccountId = account("caller", 0, SEED);72		let caller: T::AccountId = account("caller", 0, SEED);
73		let collection = create_nft_collection::<T>(caller.clone())?;73		let collection = create_nft_collection::<T>(caller.clone())?;
74	}: _(RawOrigin::Signed(caller.clone()), collection, AccessMode::WhiteList)74	}: _(RawOrigin::Signed(caller.clone()), collection, AccessMode::AllowList)
7575
76	set_mint_permission {76	set_mint_permission {
77		let caller: T::AccountId = account("caller", 0, SEED);77		let caller: T::AccountId = account("caller", 0, SEED);

256			Ok(())256			Ok(())
257		}257		}
258258
259		/// Add an address to white list.259		/// Add an address to allow list.
260		///260		///
261		/// # Permissions261		/// # Permissions
262		///262		///
268		/// * collection_id.268		/// * collection_id.
269		///269		///
270		/// * address.270		/// * address.
271		#[weight = <SelfWeightOf<T>>::add_to_white_list()]271		#[weight = <SelfWeightOf<T>>::add_to_allow_list()]
272		#[transactional]272		#[transactional]
273		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{273		pub fn add_to_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
274274
275			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);275			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
276			let collection = <CollectionHandle<T>>::try_get(collection_id)?;276			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
285			Ok(())285			Ok(())
286		}286		}
287287
288		/// Remove an address from white list.288		/// Remove an address from allow list.
289		///289		///
290		/// # Permissions290		/// # Permissions
291		///291		///
297		/// * collection_id.297		/// * collection_id.
298		///298		///
299		/// * address.299		/// * address.
300		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]300		#[weight = <SelfWeightOf<T>>::remove_from_allow_list()]
301		#[transactional]301		#[transactional]
302		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{302		pub fn remove_from_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
303303
304			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);304			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
305			let collection = <CollectionHandle<T>>::try_get(collection_id)?;305			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
314			Ok(())314			Ok(())
315		}315		}
316316
317		/// Toggle between normal and white list access for the methods with access for `Anyone`.317		/// Toggle between normal and allow list access for the methods with access for `Anyone`.
318		///318		///
319		/// # Permissions319		/// # Permissions
320		///320		///
339		}339		}
340340
341		/// Allows Anyone to create tokens if:341		/// Allows Anyone to create tokens if:
342		/// * White List is enabled, and342		/// * Allow List is enabled, and
343		/// * Address is added to white list, and343		/// * Address is added to allow list, and
344		/// * This method was called with True parameter344		/// * This method was called with True parameter
345		///345		///
346		/// # Permissions346		/// # Permissions
502		/// * Collection Owner.502		/// * Collection Owner.
503		/// * Collection Admin.503		/// * Collection Admin.
504		/// * Anyone if504		/// * Anyone if
505		///     * White List is enabled, and505		///     * Allow List is enabled, and
506		///     * Address is added to white list, and506		///     * Address is added to allow list, and
507		///     * MintPermission is enabled (see SetMintPermission method)507		///     * MintPermission is enabled (see SetMintPermission method)
508		///508		///
509		/// # Arguments509		/// # Arguments
528		/// * Collection Owner.528		/// * Collection Owner.
529		/// * Collection Admin.529		/// * Collection Admin.
530		/// * Anyone if530		/// * Anyone if
531		///     * White List is enabled, and531		///     * Allow List is enabled, and
532		///     * Address is added to white list, and532		///     * Address is added to allow list, and
533		///     * MintPermission is enabled (see SetMintPermission method)533		///     * MintPermission is enabled (see SetMintPermission method)
534		///534		///
535		/// # Arguments535		/// # Arguments

460}460}
461461
462#[test]462#[test]
463fn nft_approve_and_transfer_from_white_list() {463fn nft_approve_and_transfer_from_allow_list() {
464	new_test_ext().execute_with(|| {464	new_test_ext().execute_with(|| {
465		let collection_id = create_test_collection(&CollectionMode::NFT, 1);465		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
466466
485		assert_ok!(TemplateModule::set_public_access_mode(485		assert_ok!(TemplateModule::set_public_access_mode(
486			origin1.clone(),486			origin1.clone(),
487			1,487			1,
488			AccessMode::WhiteList488			AccessMode::AllowList
489		));489		));
490		assert_ok!(TemplateModule::add_to_white_list(490		assert_ok!(TemplateModule::add_to_allow_list(
491			origin1.clone(),491			origin1.clone(),
492			1,492			1,
493			account(1)493			account(1)
494		));494		));
495		assert_ok!(TemplateModule::add_to_white_list(495		assert_ok!(TemplateModule::add_to_allow_list(
496			origin1.clone(),496			origin1.clone(),
497			1,497			1,
498			account(2)498			account(2)
499		));499		));
500		assert_ok!(TemplateModule::add_to_white_list(500		assert_ok!(TemplateModule::add_to_allow_list(
501			origin1.clone(),501			origin1.clone(),
502			1,502			1,
503			account(3)503			account(3)
549		assert_ok!(TemplateModule::set_public_access_mode(549		assert_ok!(TemplateModule::set_public_access_mode(
550			origin1.clone(),550			origin1.clone(),
551			1,551			1,
552			AccessMode::WhiteList552			AccessMode::AllowList
553		));553		));
554		assert_ok!(TemplateModule::add_to_white_list(554		assert_ok!(TemplateModule::add_to_allow_list(
555			origin1.clone(),555			origin1.clone(),
556			1,556			1,
557			account(1)557			account(1)
558		));558		));
559		assert_ok!(TemplateModule::add_to_white_list(559		assert_ok!(TemplateModule::add_to_allow_list(
560			origin1.clone(),560			origin1.clone(),
561			1,561			1,
562			account(2)562			account(2)
563		));563		));
564		assert_ok!(TemplateModule::add_to_white_list(564		assert_ok!(TemplateModule::add_to_allow_list(
565			origin1.clone(),565			origin1.clone(),
566			1,566			1,
567			account(3)567			account(3)
609		assert_ok!(TemplateModule::set_public_access_mode(609		assert_ok!(TemplateModule::set_public_access_mode(
610			origin1.clone(),610			origin1.clone(),
611			1,611			1,
612			AccessMode::WhiteList612			AccessMode::AllowList
613		));613		));
614		assert_ok!(TemplateModule::add_to_white_list(614		assert_ok!(TemplateModule::add_to_allow_list(
615			origin1.clone(),615			origin1.clone(),
616			1,616			1,
617			account(1)617			account(1)
618		));618		));
619		assert_ok!(TemplateModule::add_to_white_list(619		assert_ok!(TemplateModule::add_to_allow_list(
620			origin1.clone(),620			origin1.clone(),
621			1,621			1,
622			account(2)622			account(2)
623		));623		));
624		assert_ok!(TemplateModule::add_to_white_list(624		assert_ok!(TemplateModule::add_to_allow_list(
625			origin1.clone(),625			origin1.clone(),
626			1,626			1,
627			account(3)627			account(3)
765		assert_ok!(TemplateModule::set_public_access_mode(765		assert_ok!(TemplateModule::set_public_access_mode(
766			origin1.clone(),766			origin1.clone(),
767			collection_id,767			collection_id,
768			AccessMode::WhiteList768			AccessMode::AllowList
769		));769		));
770		assert_ok!(TemplateModule::add_to_white_list(770		assert_ok!(TemplateModule::add_to_allow_list(
771			origin1.clone(),771			origin1.clone(),
772			1,772			1,
773			account(1)773			account(1)
952		assert_ok!(TemplateModule::set_public_access_mode(952		assert_ok!(TemplateModule::set_public_access_mode(
953			origin1.clone(),953			origin1.clone(),
954			1,954			1,
955			AccessMode::WhiteList955			AccessMode::AllowList
956		));956		));
957		assert_ok!(TemplateModule::add_to_white_list(957		assert_ok!(TemplateModule::add_to_allow_list(
958			origin1.clone(),958			origin1.clone(),
959			1,959			1,
960			account(1)960			account(1)
961		));961		));
962		assert_ok!(TemplateModule::add_to_white_list(962		assert_ok!(TemplateModule::add_to_allow_list(
963			origin1.clone(),963			origin1.clone(),
964			1,964			1,
965			account(2)965			account(2)
966		));966		));
967		assert_ok!(TemplateModule::add_to_white_list(origin1, 1, account(3)));967		assert_ok!(TemplateModule::add_to_allow_list(origin1, 1, account(3)));
968968
969		assert_ok!(TemplateModule::transfer_from(969		assert_ok!(TemplateModule::transfer_from(
970			origin2,970			origin2,
987// #region987// #region
988988
989#[test]989#[test]
990fn owner_can_add_address_to_white_list() {990fn owner_can_add_address_to_allow_list() {
991	new_test_ext().execute_with(|| {991	new_test_ext().execute_with(|| {
992		let collection_id = create_test_collection(&CollectionMode::NFT, 1);992		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
993993
994		let origin1 = Origin::signed(1);994		let origin1 = Origin::signed(1);
995		assert_ok!(TemplateModule::add_to_white_list(995		assert_ok!(TemplateModule::add_to_allow_list(
996			origin1,996			origin1,
997			collection_id,997			collection_id,
998			account(2)998			account(2)
999		));999		));
1000		assert!(TemplateModule::white_list(collection_id, 2));1000		assert!(TemplateModule::allow_list(collection_id, 2));
1001	});1001	});
1002}1002}
10031003
1004#[test]1004#[test]
1005fn admin_can_add_address_to_white_list() {1005fn admin_can_add_address_to_allow_list() {
1006	new_test_ext().execute_with(|| {1006	new_test_ext().execute_with(|| {
1007		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1007		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1008		let origin1 = Origin::signed(1);1008		let origin1 = Origin::signed(1);
1013			collection_id,1013			collection_id,
1014			account(2)1014			account(2)
1015		));1015		));
1016		assert_ok!(TemplateModule::add_to_white_list(1016		assert_ok!(TemplateModule::add_to_allow_list(
1017			origin2,1017			origin2,
1018			collection_id,1018			collection_id,
1019			account(3)1019			account(3)
1020		));1020		));
1021		assert!(TemplateModule::white_list(collection_id, 3));1021		assert!(TemplateModule::allow_list(collection_id, 3));
1022	});1022	});
1023}1023}
10241024
1025#[test]1025#[test]
1026fn nonprivileged_user_cannot_add_address_to_white_list() {1026fn nonprivileged_user_cannot_add_address_to_allow_list() {
1027	new_test_ext().execute_with(|| {1027	new_test_ext().execute_with(|| {
1028		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1028		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
10291029
1030		let origin2 = Origin::signed(2);1030		let origin2 = Origin::signed(2);
1031		assert_noop!(1031		assert_noop!(
1032			TemplateModule::add_to_white_list(origin2, collection_id, account(3)),1032			TemplateModule::add_to_allow_list(origin2, collection_id, account(3)),
1033			Error::<Test>::NoPermission1033			Error::<Test>::NoPermission
1034		);1034		);
1035	});1035	});
1036}1036}
10371037
1038#[test]1038#[test]
1039fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {1039fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {
1040	new_test_ext().execute_with(|| {1040	new_test_ext().execute_with(|| {
1041		let origin1 = Origin::signed(1);1041		let origin1 = Origin::signed(1);
10421042
1043		assert_noop!(1043		assert_noop!(
1044			TemplateModule::add_to_white_list(origin1, 1, account(2)),1044			TemplateModule::add_to_allow_list(origin1, 1, account(2)),
1045			Error::<Test>::CollectionNotFound1045			Error::<Test>::CollectionNotFound
1046		);1046		);
1047	});1047	});
1048}1048}
10491049
1050#[test]1050#[test]
1051fn nobody_can_add_address_to_white_list_of_deleted_collection() {1051fn nobody_can_add_address_to_allow_list_of_deleted_collection() {
1052	new_test_ext().execute_with(|| {1052	new_test_ext().execute_with(|| {
1053		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1053		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
10541054
1058			collection_id1058			collection_id
1059		));1059		));
1060		assert_noop!(1060		assert_noop!(
1061			TemplateModule::add_to_white_list(origin1, collection_id, account(2)),1061			TemplateModule::add_to_allow_list(origin1, collection_id, account(2)),
1062			Error::<Test>::CollectionNotFound1062			Error::<Test>::CollectionNotFound
1063		);1063		);
1064	});1064	});
1065}1065}
10661066
1067// If address is already added to white list, nothing happens1067// If address is already added to allow list, nothing happens
1068#[test]1068#[test]
1069fn address_is_already_added_to_white_list() {1069fn address_is_already_added_to_allow_list() {
1070	new_test_ext().execute_with(|| {1070	new_test_ext().execute_with(|| {
1071		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1071		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1072		let origin1 = Origin::signed(1);1072		let origin1 = Origin::signed(1);
10731073
1074		assert_ok!(TemplateModule::add_to_white_list(1074		assert_ok!(TemplateModule::add_to_allow_list(
1075			origin1.clone(),1075			origin1.clone(),
1076			collection_id,1076			collection_id,
1077			account(2)1077			account(2)
1078		));1078		));
1079		assert_ok!(TemplateModule::add_to_white_list(1079		assert_ok!(TemplateModule::add_to_allow_list(
1080			origin1,1080			origin1,
1081			collection_id,1081			collection_id,
1082			account(2)1082			account(2)
1083		));1083		));
1084		assert!(TemplateModule::white_list(collection_id, 2));1084		assert!(TemplateModule::allow_list(collection_id, 2));
1085	});1085	});
1086}1086}
10871087
1088#[test]1088#[test]
1089fn owner_can_remove_address_from_white_list() {1089fn owner_can_remove_address_from_allow_list() {
1090	new_test_ext().execute_with(|| {1090	new_test_ext().execute_with(|| {
1091		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1091		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
10921092
1093		let origin1 = Origin::signed(1);1093		let origin1 = Origin::signed(1);
1094		assert_ok!(TemplateModule::add_to_white_list(1094		assert_ok!(TemplateModule::add_to_allow_list(
1095			origin1.clone(),1095			origin1.clone(),
1096			collection_id,1096			collection_id,
1097			account(2)1097			account(2)
1098		));1098		));
1099		assert_ok!(TemplateModule::remove_from_white_list(1099		assert_ok!(TemplateModule::remove_from_allow_list(
1100			origin1,1100			origin1,
1101			collection_id,1101			collection_id,
1102			account(2)1102			account(2)
1103		));1103		));
1104		assert!(!TemplateModule::white_list(collection_id, 2));1104		assert!(!TemplateModule::allow_list(collection_id, 2));
1105	});1105	});
1106}1106}
11071107
1108#[test]1108#[test]
1109fn admin_can_remove_address_from_white_list() {1109fn admin_can_remove_address_from_allow_list() {
1110	new_test_ext().execute_with(|| {1110	new_test_ext().execute_with(|| {
1111		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1111		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1112		let origin1 = Origin::signed(1);1112		let origin1 = Origin::signed(1);
1118			account(2)1118			account(2)
1119		));1119		));
11201120
1121		assert_ok!(TemplateModule::add_to_white_list(1121		assert_ok!(TemplateModule::add_to_allow_list(
1122			origin1,1122			origin1,
1123			collection_id,1123			collection_id,
1124			account(3)1124			account(3)
1125		));1125		));
1126		assert_ok!(TemplateModule::remove_from_white_list(1126		assert_ok!(TemplateModule::remove_from_allow_list(
1127			origin2,1127			origin2,
1128			collection_id,1128			collection_id,
1129			account(3)1129			account(3)
1130		));1130		));
1131		assert!(!TemplateModule::white_list(collection_id, 3));1131		assert!(!TemplateModule::allow_list(collection_id, 3));
1132	});1132	});
1133}1133}
11341134
1135#[test]1135#[test]
1136fn nonprivileged_user_cannot_remove_address_from_white_list() {1136fn nonprivileged_user_cannot_remove_address_from_allow_list() {
1137	new_test_ext().execute_with(|| {1137	new_test_ext().execute_with(|| {
1138		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1138		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1139		let origin1 = Origin::signed(1);1139		let origin1 = Origin::signed(1);
1140		let origin2 = Origin::signed(2);1140		let origin2 = Origin::signed(2);
11411141
1142		assert_ok!(TemplateModule::add_to_white_list(1142		assert_ok!(TemplateModule::add_to_allow_list(
1143			origin1,1143			origin1,
1144			collection_id,1144			collection_id,
1145			account(2)1145			account(2)
1146		));1146		));
1147		assert_noop!(1147		assert_noop!(
1148			TemplateModule::remove_from_white_list(origin2, collection_id, account(2)),1148			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),
1149			Error::<Test>::NoPermission1149			Error::<Test>::NoPermission
1150		);1150		);
1151		assert!(TemplateModule::white_list(collection_id, 2));1151		assert!(TemplateModule::allow_list(collection_id, 2));
1152	});1152	});
1153}1153}
11541154
1155#[test]1155#[test]
1156fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {1156fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {
1157	new_test_ext().execute_with(|| {1157	new_test_ext().execute_with(|| {
1158		let origin1 = Origin::signed(1);1158		let origin1 = Origin::signed(1);
11591159
1160		assert_noop!(1160		assert_noop!(
1161			TemplateModule::remove_from_white_list(origin1, 1, account(2)),1161			TemplateModule::remove_from_allow_list(origin1, 1, account(2)),
1162			Error::<Test>::CollectionNotFound1162			Error::<Test>::CollectionNotFound
1163		);1163		);
1164	});1164	});
1165}1165}
11661166
1167#[test]1167#[test]
1168fn nobody_can_remove_address_from_white_list_of_deleted_collection() {1168fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {
1169	new_test_ext().execute_with(|| {1169	new_test_ext().execute_with(|| {
1170		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1170		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1171		let origin1 = Origin::signed(1);1171		let origin1 = Origin::signed(1);
1172		let origin2 = Origin::signed(2);1172		let origin2 = Origin::signed(2);
11731173
1174		assert_ok!(TemplateModule::add_to_white_list(1174		assert_ok!(TemplateModule::add_to_allow_list(
1175			origin1.clone(),1175			origin1.clone(),
1176			collection_id,1176			collection_id,
1177			account(2)1177			account(2)
1178		));1178		));
1179		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));1179		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));
1180		assert_noop!(1180		assert_noop!(
1181			TemplateModule::remove_from_white_list(origin2, collection_id, account(2)),1181			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),
1182			Error::<Test>::CollectionNotFound1182			Error::<Test>::CollectionNotFound
1183		);1183		);
1184		assert!(!TemplateModule::white_list(collection_id, 2));1184		assert!(!TemplateModule::allow_list(collection_id, 2));
1185	});1185	});
1186}1186}
11871187
1188// If address is already removed from white list, nothing happens1188// If address is already removed from allow list, nothing happens
1189#[test]1189#[test]
1190fn address_is_already_removed_from_white_list() {1190fn address_is_already_removed_from_allow_list() {
1191	new_test_ext().execute_with(|| {1191	new_test_ext().execute_with(|| {
1192		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1192		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1193		let origin1 = Origin::signed(1);1193		let origin1 = Origin::signed(1);
11941194
1195		assert_ok!(TemplateModule::add_to_white_list(1195		assert_ok!(TemplateModule::add_to_allow_list(
1196			origin1.clone(),1196			origin1.clone(),
1197			collection_id,1197			collection_id,
1198			account(2)1198			account(2)
1199		));1199		));
1200		assert_ok!(TemplateModule::remove_from_white_list(1200		assert_ok!(TemplateModule::remove_from_allow_list(
1201			origin1.clone(),1201			origin1.clone(),
1202			collection_id,1202			collection_id,
1203			account(2)1203			account(2)
1204		));1204		));
1205		assert_ok!(TemplateModule::remove_from_white_list(1205		assert_ok!(TemplateModule::remove_from_allow_list(
1206			origin1,1206			origin1,
1207			collection_id,1207			collection_id,
1208			account(2)1208			account(2)
1209		));1209		));
1210		assert!(!TemplateModule::white_list(collection_id, 2));1210		assert!(!TemplateModule::allow_list(collection_id, 2));
1211	});1211	});
1212}1212}
12131213
1214// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)1214// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)
1215#[test]1215#[test]
1216fn white_list_test_1() {1216fn allow_list_test_1() {
1217	new_test_ext().execute_with(|| {1217	new_test_ext().execute_with(|| {
1218		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1218		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
12191219
1225		assert_ok!(TemplateModule::set_public_access_mode(1225		assert_ok!(TemplateModule::set_public_access_mode(
1226			origin1.clone(),1226			origin1.clone(),
1227			collection_id,1227			collection_id,
1228			AccessMode::WhiteList1228			AccessMode::AllowList
1229		));1229		));
1230		assert_ok!(TemplateModule::add_to_white_list(1230		assert_ok!(TemplateModule::add_to_allow_list(
1231			origin1.clone(),1231			origin1.clone(),
1232			collection_id,1232			collection_id,
1233			account(2)1233			account(2)
1234		));1234		));
12351235
1236		assert_noop!(1236		assert_noop!(
1237			TemplateModule::transfer(origin1, account(3), 1, 1, 1),1237			TemplateModule::transfer(origin1, account(3), 1, 1, 1),
1238			Error::<Test>::AddresNotInWhiteList1238			Error::<Test>::AddresNotInAllowList
1239		);1239		);
1240	});1240	});
1241}1241}
12421242
1243#[test]1243#[test]
1244fn white_list_test_2() {1244fn allow_list_test_2() {
1245	new_test_ext().execute_with(|| {1245	new_test_ext().execute_with(|| {
1246		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1246		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1247		let origin1 = Origin::signed(1);1247		let origin1 = Origin::signed(1);
1252		assert_ok!(TemplateModule::set_public_access_mode(1252		assert_ok!(TemplateModule::set_public_access_mode(
1253			origin1.clone(),1253			origin1.clone(),
1254			collection_id,1254			collection_id,
1255			AccessMode::WhiteList1255			AccessMode::AllowList
1256		));1256		));
1257		assert_ok!(TemplateModule::add_to_white_list(1257		assert_ok!(TemplateModule::add_to_allow_list(
1258			origin1.clone(),1258			origin1.clone(),
1259			1,1259			1,
1260			account(1)1260			account(1)
1261		));1261		));
1262		assert_ok!(TemplateModule::add_to_white_list(1262		assert_ok!(TemplateModule::add_to_allow_list(
1263			origin1.clone(),1263			origin1.clone(),
1264			1,1264			1,
1265			account(2)1265			account(2)
1275		));1275		));
1276		assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);1276		assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);
12771277
1278		assert_ok!(TemplateModule::remove_from_white_list(1278		assert_ok!(TemplateModule::remove_from_allow_list(
1279			origin1.clone(),1279			origin1.clone(),
1280			1,1280			1,
1281			account(1)1281			account(1)
1282		));1282		));
12831283
1284		assert_noop!(1284		assert_noop!(
1285			TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1),1285			TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1),
1286			Error::<Test>::AddresNotInWhiteList1286			Error::<Test>::AddresNotInAllowList
1287		);1287		);
1288	});1288	});
1289}1289}
12901290
1291// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)1291// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)
1292#[test]1292#[test]
1293fn white_list_test_3() {1293fn allow_list_test_3() {
1294	new_test_ext().execute_with(|| {1294	new_test_ext().execute_with(|| {
1295		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1295		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
12961296
1302		assert_ok!(TemplateModule::set_public_access_mode(1302		assert_ok!(TemplateModule::set_public_access_mode(
1303			origin1.clone(),1303			origin1.clone(),
1304			collection_id,1304			collection_id,
1305			AccessMode::WhiteList1305			AccessMode::AllowList
1306		));1306		));
1307		assert_ok!(TemplateModule::add_to_white_list(1307		assert_ok!(TemplateModule::add_to_allow_list(
1308			origin1.clone(),1308			origin1.clone(),
1309			1,1309			1,
1310			account(1)1310			account(1)
1311		));1311		));
13121312
1313		assert_noop!(1313		assert_noop!(
1314			TemplateModule::transfer(origin1, account(3), 1, 1, 1),1314			TemplateModule::transfer(origin1, account(3), 1, 1, 1),
1315			Error::<Test>::AddresNotInWhiteList1315			Error::<Test>::AddresNotInAllowList
1316		);1316		);
1317	});1317	});
1318}1318}
13191319
1320#[test]1320#[test]
1321fn white_list_test_4() {1321fn allow_list_test_4() {
1322	new_test_ext().execute_with(|| {1322	new_test_ext().execute_with(|| {
1323		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1323		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
13241324
1330		assert_ok!(TemplateModule::set_public_access_mode(1330		assert_ok!(TemplateModule::set_public_access_mode(
1331			origin1.clone(),1331			origin1.clone(),
1332			collection_id,1332			collection_id,
1333			AccessMode::WhiteList1333			AccessMode::AllowList
1334		));1334		));
1335		assert_ok!(TemplateModule::add_to_white_list(1335		assert_ok!(TemplateModule::add_to_allow_list(
1336			origin1.clone(),1336			origin1.clone(),
1337			collection_id,1337			collection_id,
1338			account(1)1338			account(1)
1339		));1339		));
1340		assert_ok!(TemplateModule::add_to_white_list(1340		assert_ok!(TemplateModule::add_to_allow_list(
1341			origin1.clone(),1341			origin1.clone(),
1342			collection_id,1342			collection_id,
1343			account(2)1343			account(2)
1353		));1353		));
1354		assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);1354		assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);
13551355
1356		assert_ok!(TemplateModule::remove_from_white_list(1356		assert_ok!(TemplateModule::remove_from_allow_list(
1357			origin1.clone(),1357			origin1.clone(),
1358			collection_id,1358			collection_id,
1359			account(2)1359			account(2)
1360		));1360		));
13611361
1362		assert_noop!(1362		assert_noop!(
1363			TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1),1363			TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1),
1364			Error::<Test>::AddresNotInWhiteList1364			Error::<Test>::AddresNotInAllowList
1365		);1365		);
1366	});1366	});
1367}1367}
13681368
1369// If Public Access mode is set to WhiteList, tokens can’t be destroyed by a non-whitelisted address (even if it owned them before enabling WhiteList mode)1369// If Public Access mode is set to AllowList, tokens can’t be destroyed by a non-allowlisted address (even if it owned them before enabling AllowList mode)
1370#[test]1370#[test]
1371fn white_list_test_5() {1371fn allow_list_test_5() {
1372	new_test_ext().execute_with(|| {1372	new_test_ext().execute_with(|| {
1373		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1373		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
13741374
1380		assert_ok!(TemplateModule::set_public_access_mode(1380		assert_ok!(TemplateModule::set_public_access_mode(
1381			origin1.clone(),1381			origin1.clone(),
1382			collection_id,1382			collection_id,
1383			AccessMode::WhiteList1383			AccessMode::AllowList
1384		));1384		));
1385		assert_noop!(1385		assert_noop!(
1386			TemplateModule::burn_item(origin1.clone(), 1, 1, 5),1386			TemplateModule::burn_item(origin1.clone(), 1, 1, 5),
1387			Error::<Test>::AddresNotInWhiteList1387			Error::<Test>::AddresNotInAllowList
1388		);1388		);
1389	});1389	});
1390}1390}
13911391
1392// If Public Access mode is set to WhiteList, token transfers can’t be Approved by a non-whitelisted address (see Approve method).1392// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).
1393#[test]1393#[test]
1394fn white_list_test_6() {1394fn allow_list_test_6() {
1395	new_test_ext().execute_with(|| {1395	new_test_ext().execute_with(|| {
1396		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1396		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
13971397
1403		assert_ok!(TemplateModule::set_public_access_mode(1403		assert_ok!(TemplateModule::set_public_access_mode(
1404			origin1.clone(),1404			origin1.clone(),
1405			collection_id,1405			collection_id,
1406			AccessMode::WhiteList1406			AccessMode::AllowList
1407		));1407		));
14081408
1409		// do approve1409		// do approve
1410		assert_noop!(1410		assert_noop!(
1411			TemplateModule::approve(origin1, account(1), 1, 1, 5),1411			TemplateModule::approve(origin1, account(1), 1, 1, 5),
1412			Error::<Test>::AddresNotInWhiteList1412			Error::<Test>::AddresNotInAllowList
1413		);1413		);
1414	});1414	});
1415}1415}
14161416
1417// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and1417// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and
1418//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)1418//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)
1419#[test]1419#[test]
1420fn white_list_test_7() {1420fn allow_list_test_7() {
1421	new_test_ext().execute_with(|| {1421	new_test_ext().execute_with(|| {
1422		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1422		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
14231423
1429		assert_ok!(TemplateModule::set_public_access_mode(1429		assert_ok!(TemplateModule::set_public_access_mode(
1430			origin1.clone(),1430			origin1.clone(),
1431			collection_id,1431			collection_id,
1432			AccessMode::WhiteList1432			AccessMode::AllowList
1433		));1433		));
1434		assert_ok!(TemplateModule::add_to_white_list(1434		assert_ok!(TemplateModule::add_to_allow_list(
1435			origin1.clone(),1435			origin1.clone(),
1436			collection_id,1436			collection_id,
1437			account(1)1437			account(1)
1438		));1438		));
1439		assert_ok!(TemplateModule::add_to_white_list(1439		assert_ok!(TemplateModule::add_to_allow_list(
1440			origin1.clone(),1440			origin1.clone(),
1441			collection_id,1441			collection_id,
1442			account(2)1442			account(2)
1447}1447}
14481448
1449#[test]1449#[test]
1450fn white_list_test_8() {1450fn allow_list_test_8() {
1451	new_test_ext().execute_with(|| {1451	new_test_ext().execute_with(|| {
1452		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1452		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
14531453
1459		assert_ok!(TemplateModule::set_public_access_mode(1459		assert_ok!(TemplateModule::set_public_access_mode(
1460			origin1.clone(),1460			origin1.clone(),
1461			collection_id,1461			collection_id,
1462			AccessMode::WhiteList1462			AccessMode::AllowList
1463		));1463		));
1464		assert_ok!(TemplateModule::add_to_white_list(1464		assert_ok!(TemplateModule::add_to_allow_list(
1465			origin1.clone(),1465			origin1.clone(),
1466			collection_id,1466			collection_id,
1467			account(1)1467			account(1)
1468		));1468		));
1469		assert_ok!(TemplateModule::add_to_white_list(1469		assert_ok!(TemplateModule::add_to_allow_list(
1470			origin1.clone(),1470			origin1.clone(),
1471			collection_id,1471			collection_id,
1472			account(2)1472			account(2)
1493	});1493	});
1494}1494}
14951495
1496// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.1496// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.
1497#[test]1497#[test]
1498fn white_list_test_9() {1498fn allow_list_test_9() {
1499	new_test_ext().execute_with(|| {1499	new_test_ext().execute_with(|| {
1500		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1500		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
1501		let origin1 = Origin::signed(1);1501		let origin1 = Origin::signed(1);
15021502
1503		assert_ok!(TemplateModule::set_public_access_mode(1503		assert_ok!(TemplateModule::set_public_access_mode(
1504			origin1.clone(),1504			origin1.clone(),
1505			collection_id,1505			collection_id,
1506			AccessMode::WhiteList1506			AccessMode::AllowList
1507		));1507		));
1508		assert_ok!(TemplateModule::set_mint_permission(1508		assert_ok!(TemplateModule::set_mint_permission(
1509			origin1,1509			origin1,
1516	});1516	});
1517}1517}
15181518
1519// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.1519// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.
1520#[test]1520#[test]
1521fn white_list_test_10() {1521fn allow_list_test_10() {
1522	new_test_ext().execute_with(|| {1522	new_test_ext().execute_with(|| {
1523		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1523		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
15241524
1528		assert_ok!(TemplateModule::set_public_access_mode(1528		assert_ok!(TemplateModule::set_public_access_mode(
1529			origin1.clone(),1529			origin1.clone(),
1530			collection_id,1530			collection_id,
1531			AccessMode::WhiteList1531			AccessMode::AllowList
1532		));1532		));
1533		assert_ok!(TemplateModule::set_mint_permission(1533		assert_ok!(TemplateModule::set_mint_permission(
1534			origin1.clone(),1534			origin1.clone(),
1551	});1551	});
1552}1552}
15531553
1554// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and white listed address.1554// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens cannot be created by non-privileged and allow listed address.
1555#[test]1555#[test]
1556fn white_list_test_11() {1556fn allow_list_test_11() {
1557	new_test_ext().execute_with(|| {1557	new_test_ext().execute_with(|| {
1558		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1558		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
15591559
1563		assert_ok!(TemplateModule::set_public_access_mode(1563		assert_ok!(TemplateModule::set_public_access_mode(
1564			origin1.clone(),1564			origin1.clone(),
1565			collection_id,1565			collection_id,
1566			AccessMode::WhiteList1566			AccessMode::AllowList
1567		));1567		));
1568		assert_ok!(TemplateModule::set_mint_permission(1568		assert_ok!(TemplateModule::set_mint_permission(
1569			origin1.clone(),1569			origin1.clone(),
1570			collection_id,1570			collection_id,
1571			false1571			false
1572		));1572		));
1573		assert_ok!(TemplateModule::add_to_white_list(1573		assert_ok!(TemplateModule::add_to_allow_list(
1574			origin1,1574			origin1,
1575			collection_id,1575			collection_id,
1576			account(2)1576			account(2)
1583	});1583	});
1584}1584}
15851585
1586// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-white listed address.1586// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens cannot be created by non-privileged and non-allow listed address.
1587#[test]1587#[test]
1588fn white_list_test_12() {1588fn allow_list_test_12() {
1589	new_test_ext().execute_with(|| {1589	new_test_ext().execute_with(|| {
1590		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1590		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
15911591
1595		assert_ok!(TemplateModule::set_public_access_mode(1595		assert_ok!(TemplateModule::set_public_access_mode(
1596			origin1.clone(),1596			origin1.clone(),
1597			collection_id,1597			collection_id,
1598			AccessMode::WhiteList1598			AccessMode::AllowList
1599		));1599		));
1600		assert_ok!(TemplateModule::set_mint_permission(1600		assert_ok!(TemplateModule::set_mint_permission(
1601			origin1,1601			origin1,
1610	});1610	});
1611}1611}
16121612
1613// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.1613// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.
1614#[test]1614#[test]
1615fn white_list_test_13() {1615fn allow_list_test_13() {
1616	new_test_ext().execute_with(|| {1616	new_test_ext().execute_with(|| {
1617		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1617		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
16181618
1621		assert_ok!(TemplateModule::set_public_access_mode(1621		assert_ok!(TemplateModule::set_public_access_mode(
1622			origin1.clone(),1622			origin1.clone(),
1623			collection_id,1623			collection_id,
1624			AccessMode::WhiteList1624			AccessMode::AllowList
1625		));1625		));
1626		assert_ok!(TemplateModule::set_mint_permission(1626		assert_ok!(TemplateModule::set_mint_permission(
1627			origin1,1627			origin1,
1634	});1634	});
1635}1635}
16361636
1637// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.1637// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.
1638#[test]1638#[test]
1639fn white_list_test_14() {1639fn allow_list_test_14() {
1640	new_test_ext().execute_with(|| {1640	new_test_ext().execute_with(|| {
1641		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1641		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
16421642
1646		assert_ok!(TemplateModule::set_public_access_mode(1646		assert_ok!(TemplateModule::set_public_access_mode(
1647			origin1.clone(),1647			origin1.clone(),
1648			collection_id,1648			collection_id,
1649			AccessMode::WhiteList1649			AccessMode::AllowList
1650		));1650		));
1651		assert_ok!(TemplateModule::set_mint_permission(1651		assert_ok!(TemplateModule::set_mint_permission(
1652			origin1.clone(),1652			origin1.clone(),
1669	});1669	});
1670}1670}
16711671
1672// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens cannot be created by non-privileged and non-white listed address.1672// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens cannot be created by non-privileged and non-allow listed address.
1673#[test]1673#[test]
1674fn white_list_test_15() {1674fn allow_list_test_15() {
1675	new_test_ext().execute_with(|| {1675	new_test_ext().execute_with(|| {
1676		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1676		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
16771677
1681		assert_ok!(TemplateModule::set_public_access_mode(1681		assert_ok!(TemplateModule::set_public_access_mode(
1682			origin1.clone(),1682			origin1.clone(),
1683			collection_id,1683			collection_id,
1684			AccessMode::WhiteList1684			AccessMode::AllowList
1685		));1685		));
1686		assert_ok!(TemplateModule::set_mint_permission(1686		assert_ok!(TemplateModule::set_mint_permission(
1687			origin1,1687			origin1,
16911691
1692		assert_noop!(1692		assert_noop!(
1693			TemplateModule::create_item(origin2, 1, account(2), default_nft_data().into()),1693			TemplateModule::create_item(origin2, 1, account(2), default_nft_data().into()),
1694			Error::<Test>::AddresNotInWhiteList1694			Error::<Test>::AddresNotInAllowList
1695		);1695		);
1696	});1696	});
1697}1697}
16981698
1699// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by non-privileged and white listed address.1699// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by non-privileged and allow listed address.
1700#[test]1700#[test]
1701fn white_list_test_16() {1701fn allow_list_test_16() {
1702	new_test_ext().execute_with(|| {1702	new_test_ext().execute_with(|| {
1703		let collection_id = create_test_collection(&CollectionMode::NFT, 1);1703		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
17041704
1708		assert_ok!(TemplateModule::set_public_access_mode(1708		assert_ok!(TemplateModule::set_public_access_mode(
1709			origin1.clone(),1709			origin1.clone(),
1710			collection_id,1710			collection_id,
1711			AccessMode::WhiteList1711			AccessMode::AllowList
1712		));1712		));
1713		assert_ok!(TemplateModule::set_mint_permission(1713		assert_ok!(TemplateModule::set_mint_permission(
1714			origin1.clone(),1714			origin1.clone(),
1715			collection_id,1715			collection_id,
1716			true1716			true
1717		));1717		));
1718		assert_ok!(TemplateModule::add_to_white_list(1718		assert_ok!(TemplateModule::add_to_allow_list(
1719			origin1,1719			origin1,
1720			collection_id,1720			collection_id,
1721			account(2)1721			account(2)
2056			collection_id,2056			collection_id,
2057			true2057			true
2058		));2058		));
2059		assert_ok!(TemplateModule::add_to_white_list(2059		assert_ok!(TemplateModule::add_to_allow_list(
2060			origin1.clone(),2060			origin1.clone(),
2061			collection_id,2061			collection_id,
2062			account(1)2062			account(1)
2124			collection_id,2124			collection_id,
2125			true2125			true
2126		));2126		));
2127		assert_ok!(TemplateModule::add_to_white_list(2127		assert_ok!(TemplateModule::add_to_allow_list(
2128			origin2.clone(),2128			origin2.clone(),
2129			collection_id,2129			collection_id,
2130			account(1)2130			account(1)
2177			collection_id,2177			collection_id,
2178			true2178			true
2179		));2179		));
2180		assert_ok!(TemplateModule::add_to_white_list(2180		assert_ok!(TemplateModule::add_to_allow_list(
2181			origin2.clone(),2181			origin2.clone(),
2182			collection_id,2182			collection_id,
2183			account(1)2183			account(1)