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

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5114,7 +5114,7 @@
  "pallet-randomness-collective-flip",
  "pallet-refungible",
  "pallet-sudo",
- "pallet-template-charge-transaction",
+ "pallet-template-transaction-payment",
  "pallet-timestamp",
  "pallet-transaction-payment",
  "pallet-transaction-payment-rpc-runtime-api",
@@ -6350,9 +6350,9 @@
 ]
 
 [[package]]
-name = "pallet-template-charge-transaction"
+name = "pallet-template-transaction-payment"
 version = "3.0.0"
-source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#e5d3354ab68face1b2ef709dc7f629803f56598d"
+source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#ab8b91e9350a31133f3a3e4f52a84c6de4108e95"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -11696,7 +11696,7 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f559b464de2e2bdabcac6a210d12e9b5a5973c251e102c44c585c71d51bd78e"
 dependencies = [
- "cfg-if 0.1.10",
+ "cfg-if 1.0.0",
  "rand 0.8.4",
  "static_assertions",
 ]
@@ -11847,7 +11847,7 @@
 [[package]]
 name = "up-sponsorship"
 version = "0.1.0"
-source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#e5d3354ab68face1b2ef709dc7f629803f56598d"
+source = "git+https://github.com/UniqueNetwork/pallet-sponsoring#ab8b91e9350a31133f3a3e4f52a84c6de4108e95"
 dependencies = [
  "impl-trait-for-tuples 0.2.1",
 ]

--- a/README.md
+++ b/README.md
@@ -41,7 +41,7 @@
     -   Re-Fungible Token Mode
     -   Off-Chain Schema to store token image URLs
     -   Alternative economic model
-    -   White Lists and Public Mint Permission
+    -   Allow Lists and Public Mint Permission
 -   Use example: [SubstraPunks Game](https://github.com/usetech-llc/substrapunks), fully hosted on IPFS and NFT Testnet
     Blockchain.
 

--- a/doc/builders_walk_through.md
+++ b/doc/builders_walk_through.md
@@ -173,11 +173,11 @@
 6. Now select your "ZERO BALANCE" address in the drop-down list and repeat searching and adding the collection for this address.
 7. Transfer token back to your main address. Observe that despite the zero balance, the transfer is successful.
 
-### White Lists and Public Mint Permission
+### Allow Lists and Public Mint Permission
 
-We 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:
+We 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:
 
-[white_lists](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L659)
+[allow_lists](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L659)
 
 [mint_permission](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L373)
 

--- a/doc/economic_model.md
+++ b/doc/economic_model.md
@@ -40,7 +40,7 @@
 
 Set the collection sponsor address. The sponsorship needs to be confirmed by sending a ConfirmSponsorship transaction
 from that address. Also, the protection measures need to be in place so that sponsor account cannot be depleted by
-malicious users. White listing is one of the measured. It can be enabled with SetPublicAccessMode method.
+malicious users. Allow listing is one of the measured. It can be enabled with SetPublicAccessMode method.
 
 ##### List of transactions
 
@@ -67,7 +67,7 @@
     Further, the logic is similar to limiting by token as above. If only one of the limits (by token or by address)
     indicates that fee should be paid by the user, the fee is paid by the user.
 -   A pallet method (SetCollectionRateLimits) will be added to set these parameters and enable rate limiting.
--   One idea to consider is deposits that must be made by an address in order to become white listed (instead of admin
+-   One idea to consider is deposits that must be made by an address in order to become allow listed (instead of admin
     review).
 
 #### Permissions
@@ -173,12 +173,12 @@
 
 #### Description
 
-Toggle between normal and white list access for the methods with access for “Anyone”. If White List mode is enabled,
-AddToWhiteList and RemoveFromWhiteList methods can be called to add to and remove addresses from the white list.
+Toggle between normal and allow list access for the methods with access for “Anyone”. If Allow List mode is enabled,
+AddToAllowList and RemoveFromAllowList methods can be called to add to and remove addresses from the allow list.
 
-White list mode is the property of collection. If it is turned on, all public operations such as token transfers, for
-example, which normally have “Anyone” permission, become white listed, i.e. are only available to collection owner,
-admins, and addresses from the white list. White lists can be helpful for rate limiting of transfers when collection
+Allow list mode is the property of collection. If it is turned on, all public operations such as token transfers, for
+example, which normally have “Anyone” permission, become allow listed, i.e. are only available to collection owner,
+admins, and addresses from the allow list. Allow lists can be helpful for rate limiting of transfers when collection
 sponsoring is enabled.
 
 #### Permissions
@@ -190,13 +190,13 @@
 -   CollectionID: ID of the Collection to set access mode for
 -   Mode
     -   0 = Normal
-    -   1 = White list
+    -   1 = Allow list
 
-### AddToWhiteList
+### AddToAllowList
 
 #### Description
 
-Add an address to white list.
+Add an address to allow list.
 
 #### Permissions
 
@@ -208,11 +208,11 @@
 -   CollectionID: ID of the Collection
 -   Address
 
-### RemoveFromWhiteList
+### RemoveFromAllowList
 
 #### Description
 
-Remove an address from white list.
+Remove an address from allow list.
 
 #### Permissions
 

--- a/doc/hackusama_walk_through.md
+++ b/doc/hackusama_walk_through.md
@@ -187,14 +187,14 @@
    address.
 7. Transfer token back to your main address. Observe that despite the zero balance, the transfer is successful.
 
-### White Lists and Public Mint Permission
+### Allow Lists and Public Mint Permission
 
 We 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
+[feature/allow_list](https://github.com/usetech-llc/nft_parachain/tree/feature/allow_list). Here are the permalinks to
 essential functions:
 
-[white_lists](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L659)
+[allow_lists](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L659)
 
 [mint_permission](https://github.com/usetech-llc/nft_parachain/blob/b7c59f0085ed2bc1922e937adf68ef4174a8ba36/pallets/nft/src/lib.rs#L373)
 

--- a/doc/milestone_1.md
+++ b/doc/milestone_1.md
@@ -1,38 +1,38 @@
 ## Milestone 1
 
-**User Paid Fees and Sponsored. Finish/Debug white listing and spam/DOS protection**
+**User Paid Fees and Sponsored. Finish/Debug allow listing and spam/DOS protection**
 
 Implementation of two models 
 If 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.
-For 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.
+For 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.
 
 Set sponsor
 `nft`.`set_collection_sponsor`
 Confirm sponsor
 `nft`.`confirm_sponsorship`
 
-A white list mode presented by collection property `access` and can be enabled with `set_public_access_mode`. Rules provide spam/DOS protection
-While collection in the white list mode rules below are active:
-Owner can add address to white list
-Admin can add address to white list
-Non-privileged user cannot add address to white list
-Owner can remove address from white list
-Admin can remove address from white list
-Non-privileged user cannot remove address from white list
-If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom
-If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom
-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)
-If Public Access mode is set to WhiteList, token transfers can’t be Approved by a non-whitelisted address (see Approve method).
-If Public Access mode is set to WhiteList, tokens can be transferred to a whitelisted address with transfer or transferFrom
-If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom 
-If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.
-If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.
-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.
-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.
-If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.
-If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.
-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.
-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.
+A allow list mode presented by collection property `access` and can be enabled with `set_public_access_mode`. Rules provide spam/DOS protection
+While collection in the allow list mode rules below are active:
+Owner can add address to allow list
+Admin can add address to allow list
+Non-privileged user cannot add address to allow list
+Owner can remove address from allow list
+Admin can remove address from allow list
+Non-privileged user cannot remove address from allow list
+If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom
+If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom
+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)
+If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).
+If Public Access mode is set to AllowList, tokens can be transferred to a allowlisted address with transfer or transferFrom
+If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom 
+If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.
+If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.
+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.
+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.
+If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.
+If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.
+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.
+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.
 
 **Add missing custom types (CollectionMode, FungibleItemType, ReFungibleItemType)**
 

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -260,7 +260,7 @@
 		NoPermission,
 		/// Collection is not in mint mode.
 		PublicMintingNotAllowed,
-		/// Address is not in white list.
+		/// Address is not in allow list.
 		AddressNotInAllowlist,
 
 		/// Collection name can not be longer than 63 char.

--- a/pallets/fungible/src/lib.rs
+++ b/pallets/fungible/src/lib.rs
@@ -123,7 +123,7 @@
 			.checked_sub(amount)
 			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
 
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			collection.check_allowlist(owner)?;
 		}
 
@@ -161,7 +161,7 @@
 			<CommonError<T>>::TransferNotAllowed,
 		);
 
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			collection.check_allowlist(from)?;
 			collection.check_allowlist(to)?;
 		}
@@ -307,7 +307,7 @@
 		spender: &T::CrossAccountId,
 		amount: u128,
 	) -> DispatchResult {
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			collection.check_allowlist(&owner)?;
 			collection.check_allowlist(&spender)?;
 		}
@@ -335,7 +335,7 @@
 		if spender.conv_eq(from) {
 			return Self::transfer(collection, from, to, amount);
 		}
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			// `from`, `to` checked in [`transfer`]
 			collection.check_allowlist(spender)?;
 		}
@@ -366,7 +366,7 @@
 		if spender.conv_eq(from) {
 			return Self::burn(collection, from, amount);
 		}
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			// `from` checked in [`burn`]
 			collection.check_allowlist(spender)?;
 		}

--- a/pallets/nft/src/benchmarking.rs
+++ b/pallets/nft/src/benchmarking.rs
@@ -55,23 +55,23 @@
 		let collection = create_nft_collection::<T>(caller.clone())?;
 	}: _(RawOrigin::Signed(caller.clone()), collection)
 
-	add_to_white_list {
+	add_to_allow_list {
 		let caller: T::AccountId = account("caller", 0, SEED);
-		let whitelist_account: T::AccountId = account("admin", 0, SEED);
+		let allowlist_account: T::AccountId = account("admin", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(whitelist_account))
+	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(allowlist_account))
 
-	remove_from_white_list {
+	remove_from_allow_list {
 		let caller: T::AccountId = account("caller", 0, SEED);
-		let whitelist_account: T::AccountId = account("admin", 0, SEED);
+		let allowlist_account: T::AccountId = account("admin", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-		<Pallet<T>>::add_to_white_list(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(whitelist_account.clone()))?;
-	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(whitelist_account))
+		<Pallet<T>>::add_to_allow_list(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(allowlist_account.clone()))?;
+	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(allowlist_account))
 
 	set_public_access_mode {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-	}: _(RawOrigin::Signed(caller.clone()), collection, AccessMode::WhiteList)
+	}: _(RawOrigin::Signed(caller.clone()), collection, AccessMode::AllowList)
 
 	set_mint_permission {
 		let caller: T::AccountId = account("caller", 0, SEED);

--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -256,7 +256,7 @@
 			Ok(())
 		}
 
-		/// Add an address to white list.
+		/// Add an address to allow list.
 		///
 		/// # Permissions
 		///
@@ -268,9 +268,9 @@
 		/// * collection_id.
 		///
 		/// * address.
-		#[weight = <SelfWeightOf<T>>::add_to_white_list()]
+		#[weight = <SelfWeightOf<T>>::add_to_allow_list()]
 		#[transactional]
-		pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
+		pub fn add_to_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
 
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
@@ -285,7 +285,7 @@
 			Ok(())
 		}
 
-		/// Remove an address from white list.
+		/// Remove an address from allow list.
 		///
 		/// # Permissions
 		///
@@ -297,9 +297,9 @@
 		/// * collection_id.
 		///
 		/// * address.
-		#[weight = <SelfWeightOf<T>>::remove_from_white_list()]
+		#[weight = <SelfWeightOf<T>>::remove_from_allow_list()]
 		#[transactional]
-		pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
+		pub fn remove_from_allow_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{
 
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
@@ -314,7 +314,7 @@
 			Ok(())
 		}
 
-		/// Toggle between normal and white list access for the methods with access for `Anyone`.
+		/// Toggle between normal and allow list access for the methods with access for `Anyone`.
 		///
 		/// # Permissions
 		///
@@ -339,8 +339,8 @@
 		}
 
 		/// Allows Anyone to create tokens if:
-		/// * White List is enabled, and
-		/// * Address is added to white list, and
+		/// * Allow List is enabled, and
+		/// * Address is added to allow list, and
 		/// * This method was called with True parameter
 		///
 		/// # Permissions
@@ -502,8 +502,8 @@
 		/// * Collection Owner.
 		/// * Collection Admin.
 		/// * Anyone if
-		///     * White List is enabled, and
-		///     * Address is added to white list, and
+		///     * Allow List is enabled, and
+		///     * Address is added to allow list, and
 		///     * MintPermission is enabled (see SetMintPermission method)
 		///
 		/// # Arguments
@@ -528,8 +528,8 @@
 		/// * Collection Owner.
 		/// * Collection Admin.
 		/// * Anyone if
-		///     * White List is enabled, and
-		///     * Address is added to white list, and
+		///     * Allow List is enabled, and
+		///     * Address is added to allow list, and
 		///     * MintPermission is enabled (see SetMintPermission method)
 		///
 		/// # Arguments

--- a/pallets/nft/src/tests.rs
+++ b/pallets/nft/src/tests.rs
@@ -460,7 +460,7 @@
 }
 
 #[test]
-fn nft_approve_and_transfer_from_white_list() {
+fn nft_approve_and_transfer_from_allow_list() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -485,19 +485,19 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			1,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(1)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(2)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(3)
@@ -549,19 +549,19 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			1,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(1)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(2)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(3)
@@ -609,19 +609,19 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			1,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(1)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(2)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(3)
@@ -765,9 +765,9 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(1)
@@ -952,19 +952,19 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			1,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(1)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(2)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(origin1, 1, account(3)));
+		assert_ok!(TemplateModule::add_to_allow_list(origin1, 1, account(3)));
 
 		assert_ok!(TemplateModule::transfer_from(
 			origin2,
@@ -987,22 +987,22 @@
 // #region
 
 #[test]
-fn owner_can_add_address_to_white_list() {
+fn owner_can_add_address_to_allow_list() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
 		let origin1 = Origin::signed(1);
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1,
 			collection_id,
 			account(2)
 		));
-		assert!(TemplateModule::white_list(collection_id, 2));
+		assert!(TemplateModule::allow_list(collection_id, 2));
 	});
 }
 
 #[test]
-fn admin_can_add_address_to_white_list() {
+fn admin_can_add_address_to_allow_list() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 		let origin1 = Origin::signed(1);
@@ -1013,42 +1013,42 @@
 			collection_id,
 			account(2)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin2,
 			collection_id,
 			account(3)
 		));
-		assert!(TemplateModule::white_list(collection_id, 3));
+		assert!(TemplateModule::allow_list(collection_id, 3));
 	});
 }
 
 #[test]
-fn nonprivileged_user_cannot_add_address_to_white_list() {
+fn nonprivileged_user_cannot_add_address_to_allow_list() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
 		let origin2 = Origin::signed(2);
 		assert_noop!(
-			TemplateModule::add_to_white_list(origin2, collection_id, account(3)),
+			TemplateModule::add_to_allow_list(origin2, collection_id, account(3)),
 			Error::<Test>::NoPermission
 		);
 	});
 }
 
 #[test]
-fn nobody_can_add_address_to_white_list_of_nonexisting_collection() {
+fn nobody_can_add_address_to_allow_list_of_nonexisting_collection() {
 	new_test_ext().execute_with(|| {
 		let origin1 = Origin::signed(1);
 
 		assert_noop!(
-			TemplateModule::add_to_white_list(origin1, 1, account(2)),
+			TemplateModule::add_to_allow_list(origin1, 1, account(2)),
 			Error::<Test>::CollectionNotFound
 		);
 	});
 }
 
 #[test]
-fn nobody_can_add_address_to_white_list_of_deleted_collection() {
+fn nobody_can_add_address_to_allow_list_of_deleted_collection() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1058,55 +1058,55 @@
 			collection_id
 		));
 		assert_noop!(
-			TemplateModule::add_to_white_list(origin1, collection_id, account(2)),
+			TemplateModule::add_to_allow_list(origin1, collection_id, account(2)),
 			Error::<Test>::CollectionNotFound
 		);
 	});
 }
 
-// If address is already added to white list, nothing happens
+// If address is already added to allow list, nothing happens
 #[test]
-fn address_is_already_added_to_white_list() {
+fn address_is_already_added_to_allow_list() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 		let origin1 = Origin::signed(1);
 
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1,
 			collection_id,
 			account(2)
 		));
-		assert!(TemplateModule::white_list(collection_id, 2));
+		assert!(TemplateModule::allow_list(collection_id, 2));
 	});
 }
 
 #[test]
-fn owner_can_remove_address_from_white_list() {
+fn owner_can_remove_address_from_allow_list() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
 		let origin1 = Origin::signed(1);
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
 		));
-		assert_ok!(TemplateModule::remove_from_white_list(
+		assert_ok!(TemplateModule::remove_from_allow_list(
 			origin1,
 			collection_id,
 			account(2)
 		));
-		assert!(!TemplateModule::white_list(collection_id, 2));
+		assert!(!TemplateModule::allow_list(collection_id, 2));
 	});
 }
 
 #[test]
-fn admin_can_remove_address_from_white_list() {
+fn admin_can_remove_address_from_allow_list() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 		let origin1 = Origin::signed(1);
@@ -1118,102 +1118,102 @@
 			account(2)
 		));
 
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1,
 			collection_id,
 			account(3)
 		));
-		assert_ok!(TemplateModule::remove_from_white_list(
+		assert_ok!(TemplateModule::remove_from_allow_list(
 			origin2,
 			collection_id,
 			account(3)
 		));
-		assert!(!TemplateModule::white_list(collection_id, 3));
+		assert!(!TemplateModule::allow_list(collection_id, 3));
 	});
 }
 
 #[test]
-fn nonprivileged_user_cannot_remove_address_from_white_list() {
+fn nonprivileged_user_cannot_remove_address_from_allow_list() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 		let origin1 = Origin::signed(1);
 		let origin2 = Origin::signed(2);
 
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1,
 			collection_id,
 			account(2)
 		));
 		assert_noop!(
-			TemplateModule::remove_from_white_list(origin2, collection_id, account(2)),
+			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),
 			Error::<Test>::NoPermission
 		);
-		assert!(TemplateModule::white_list(collection_id, 2));
+		assert!(TemplateModule::allow_list(collection_id, 2));
 	});
 }
 
 #[test]
-fn nobody_can_remove_address_from_white_list_of_nonexisting_collection() {
+fn nobody_can_remove_address_from_allow_list_of_nonexisting_collection() {
 	new_test_ext().execute_with(|| {
 		let origin1 = Origin::signed(1);
 
 		assert_noop!(
-			TemplateModule::remove_from_white_list(origin1, 1, account(2)),
+			TemplateModule::remove_from_allow_list(origin1, 1, account(2)),
 			Error::<Test>::CollectionNotFound
 		);
 	});
 }
 
 #[test]
-fn nobody_can_remove_address_from_white_list_of_deleted_collection() {
+fn nobody_can_remove_address_from_allow_list_of_deleted_collection() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 		let origin1 = Origin::signed(1);
 		let origin2 = Origin::signed(2);
 
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
 		));
 		assert_ok!(TemplateModule::destroy_collection(origin1, collection_id));
 		assert_noop!(
-			TemplateModule::remove_from_white_list(origin2, collection_id, account(2)),
+			TemplateModule::remove_from_allow_list(origin2, collection_id, account(2)),
 			Error::<Test>::CollectionNotFound
 		);
-		assert!(!TemplateModule::white_list(collection_id, 2));
+		assert!(!TemplateModule::allow_list(collection_id, 2));
 	});
 }
 
-// If address is already removed from white list, nothing happens
+// If address is already removed from allow list, nothing happens
 #[test]
-fn address_is_already_removed_from_white_list() {
+fn address_is_already_removed_from_allow_list() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 		let origin1 = Origin::signed(1);
 
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
 		));
-		assert_ok!(TemplateModule::remove_from_white_list(
+		assert_ok!(TemplateModule::remove_from_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
 		));
-		assert_ok!(TemplateModule::remove_from_white_list(
+		assert_ok!(TemplateModule::remove_from_allow_list(
 			origin1,
 			collection_id,
 			account(2)
 		));
-		assert!(!TemplateModule::white_list(collection_id, 2));
+		assert!(!TemplateModule::allow_list(collection_id, 2));
 	});
 }
 
-// If Public Access mode is set to WhiteList, tokens can’t be transferred from a non-whitelisted address with transfer or transferFrom (2 tests)
+// If Public Access mode is set to AllowList, tokens can’t be transferred from a non-allowlisted address with transfer or transferFrom (2 tests)
 #[test]
-fn white_list_test_1() {
+fn allow_list_test_1() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1225,9 +1225,9 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
@@ -1235,13 +1235,13 @@
 
 		assert_noop!(
 			TemplateModule::transfer(origin1, account(3), 1, 1, 1),
-			Error::<Test>::AddresNotInWhiteList
+			Error::<Test>::AddresNotInAllowList
 		);
 	});
 }
 
 #[test]
-fn white_list_test_2() {
+fn allow_list_test_2() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 		let origin1 = Origin::signed(1);
@@ -1252,14 +1252,14 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(1)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(2)
@@ -1275,7 +1275,7 @@
 		));
 		assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);
 
-		assert_ok!(TemplateModule::remove_from_white_list(
+		assert_ok!(TemplateModule::remove_from_allow_list(
 			origin1.clone(),
 			1,
 			account(1)
@@ -1283,14 +1283,14 @@
 
 		assert_noop!(
 			TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1),
-			Error::<Test>::AddresNotInWhiteList
+			Error::<Test>::AddresNotInAllowList
 		);
 	});
 }
 
-// If Public Access mode is set to WhiteList, tokens can’t be transferred to a non-whitelisted address with transfer or transferFrom (2 tests)
+// If Public Access mode is set to AllowList, tokens can’t be transferred to a non-allowlisted address with transfer or transferFrom (2 tests)
 #[test]
-fn white_list_test_3() {
+fn allow_list_test_3() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1302,9 +1302,9 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			1,
 			account(1)
@@ -1312,13 +1312,13 @@
 
 		assert_noop!(
 			TemplateModule::transfer(origin1, account(3), 1, 1, 1),
-			Error::<Test>::AddresNotInWhiteList
+			Error::<Test>::AddresNotInAllowList
 		);
 	});
 }
 
 #[test]
-fn white_list_test_4() {
+fn allow_list_test_4() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1330,14 +1330,14 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(1)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
@@ -1353,7 +1353,7 @@
 		));
 		assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);
 
-		assert_ok!(TemplateModule::remove_from_white_list(
+		assert_ok!(TemplateModule::remove_from_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
@@ -1361,14 +1361,14 @@
 
 		assert_noop!(
 			TemplateModule::transfer_from(origin1, account(1), account(3), 1, 1, 1),
-			Error::<Test>::AddresNotInWhiteList
+			Error::<Test>::AddresNotInAllowList
 		);
 	});
 }
 
-// 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)
+// 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)
 #[test]
-fn white_list_test_5() {
+fn allow_list_test_5() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1380,18 +1380,18 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 		assert_noop!(
 			TemplateModule::burn_item(origin1.clone(), 1, 1, 5),
-			Error::<Test>::AddresNotInWhiteList
+			Error::<Test>::AddresNotInAllowList
 		);
 	});
 }
 
-// If Public Access mode is set to WhiteList, token transfers can’t be Approved by a non-whitelisted address (see Approve method).
+// If Public Access mode is set to AllowList, token transfers can’t be Approved by a non-allowlisted address (see Approve method).
 #[test]
-fn white_list_test_6() {
+fn allow_list_test_6() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1403,21 +1403,21 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 
 		// do approve
 		assert_noop!(
 			TemplateModule::approve(origin1, account(1), 1, 1, 5),
-			Error::<Test>::AddresNotInWhiteList
+			Error::<Test>::AddresNotInAllowList
 		);
 	});
 }
 
-// If Public Access mode is set to WhiteList, tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests) and
-//          tokens can be transferred from a whitelisted address with transfer or transferFrom (2 tests)
+// If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests) and
+//          tokens can be transferred from a allowlisted address with transfer or transferFrom (2 tests)
 #[test]
-fn white_list_test_7() {
+fn allow_list_test_7() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1429,14 +1429,14 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(1)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
@@ -1447,7 +1447,7 @@
 }
 
 #[test]
-fn white_list_test_8() {
+fn allow_list_test_8() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1459,14 +1459,14 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(1)
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(2)
@@ -1493,9 +1493,9 @@
 	});
 }
 
-// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by owner.
+// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by owner.
 #[test]
-fn white_list_test_9() {
+fn allow_list_test_9() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 		let origin1 = Origin::signed(1);
@@ -1503,7 +1503,7 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 		assert_ok!(TemplateModule::set_mint_permission(
 			origin1,
@@ -1516,9 +1516,9 @@
 	});
 }
 
-// If Public Access mode is set to WhiteList, and Mint Permission is set to false, tokens can be created by admin.
+// If Public Access mode is set to AllowList, and Mint Permission is set to false, tokens can be created by admin.
 #[test]
-fn white_list_test_10() {
+fn allow_list_test_10() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1528,7 +1528,7 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 		assert_ok!(TemplateModule::set_mint_permission(
 			origin1.clone(),
@@ -1551,9 +1551,9 @@
 	});
 }
 
-// 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.
+// 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.
 #[test]
-fn white_list_test_11() {
+fn allow_list_test_11() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1563,14 +1563,14 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 		assert_ok!(TemplateModule::set_mint_permission(
 			origin1.clone(),
 			collection_id,
 			false
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1,
 			collection_id,
 			account(2)
@@ -1583,9 +1583,9 @@
 	});
 }
 
-// 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.
+// 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.
 #[test]
-fn white_list_test_12() {
+fn allow_list_test_12() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1595,7 +1595,7 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 		assert_ok!(TemplateModule::set_mint_permission(
 			origin1,
@@ -1610,9 +1610,9 @@
 	});
 }
 
-// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by owner.
+// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by owner.
 #[test]
-fn white_list_test_13() {
+fn allow_list_test_13() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1621,7 +1621,7 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 		assert_ok!(TemplateModule::set_mint_permission(
 			origin1,
@@ -1634,9 +1634,9 @@
 	});
 }
 
-// If Public Access mode is set to WhiteList, and Mint Permission is set to true, tokens can be created by admin.
+// If Public Access mode is set to AllowList, and Mint Permission is set to true, tokens can be created by admin.
 #[test]
-fn white_list_test_14() {
+fn allow_list_test_14() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1646,7 +1646,7 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 		assert_ok!(TemplateModule::set_mint_permission(
 			origin1.clone(),
@@ -1669,9 +1669,9 @@
 	});
 }
 
-// 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.
+// 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.
 #[test]
-fn white_list_test_15() {
+fn allow_list_test_15() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1681,7 +1681,7 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 		assert_ok!(TemplateModule::set_mint_permission(
 			origin1,
@@ -1691,14 +1691,14 @@
 
 		assert_noop!(
 			TemplateModule::create_item(origin2, 1, account(2), default_nft_data().into()),
-			Error::<Test>::AddresNotInWhiteList
+			Error::<Test>::AddresNotInAllowList
 		);
 	});
 }
 
-// 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.
+// 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.
 #[test]
-fn white_list_test_16() {
+fn allow_list_test_16() {
 	new_test_ext().execute_with(|| {
 		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
 
@@ -1708,14 +1708,14 @@
 		assert_ok!(TemplateModule::set_public_access_mode(
 			origin1.clone(),
 			collection_id,
-			AccessMode::WhiteList
+			AccessMode::AllowList
 		));
 		assert_ok!(TemplateModule::set_mint_permission(
 			origin1.clone(),
 			collection_id,
 			true
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1,
 			collection_id,
 			account(2)
@@ -2056,7 +2056,7 @@
 			collection_id,
 			true
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin1.clone(),
 			collection_id,
 			account(1)
@@ -2124,7 +2124,7 @@
 			collection_id,
 			true
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin2.clone(),
 			collection_id,
 			account(1)
@@ -2177,7 +2177,7 @@
 			collection_id,
 			true
 		));
-		assert_ok!(TemplateModule::add_to_white_list(
+		assert_ok!(TemplateModule::add_to_allow_list(
 			origin2.clone(),
 			collection_id,
 			account(1)

--- a/pallets/nft/src/weights.rs
+++ b/pallets/nft/src/weights.rs
@@ -33,8 +33,8 @@
 pub trait WeightInfo {
 	fn create_collection() -> Weight;
 	fn destroy_collection() -> Weight;
-	fn add_to_white_list() -> Weight;
-	fn remove_from_white_list() -> Weight;
+	fn add_to_allow_list() -> Weight;
+	fn remove_from_allow_list() -> Weight;
 	fn set_public_access_mode() -> Weight;
 	fn set_mint_permission() -> Weight;
 	fn change_collection_owner() -> Weight;
@@ -75,14 +75,14 @@
 	}
 	// Storage: Common CollectionById (r:1 w:0)
 	// Storage: Common Allowlist (r:0 w:1)
-	fn add_to_white_list() -> Weight {
+	fn add_to_allow_list() -> Weight {
 		(6_629_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
 	// Storage: Common CollectionById (r:1 w:0)
 	// Storage: Common Allowlist (r:0 w:1)
-	fn remove_from_white_list() -> Weight {
+	fn remove_from_allow_list() -> Weight {
 		(6_596_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
@@ -205,14 +205,14 @@
 	}
 	// Storage: Common CollectionById (r:1 w:0)
 	// Storage: Common Allowlist (r:0 w:1)
-	fn add_to_white_list() -> Weight {
+	fn add_to_allow_list() -> Weight {
 		(6_629_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
 	// Storage: Common CollectionById (r:1 w:0)
 	// Storage: Common Allowlist (r:0 w:1)
-	fn remove_from_white_list() -> Weight {
+	fn remove_from_allow_list() -> Weight {
 		(6_596_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))

--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -169,7 +169,7 @@
 			<CommonError<T>>::NoPermission
 		);
 
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			collection.check_allowlist(sender)?;
 		}
 
@@ -228,7 +228,7 @@
 			<CommonError<T>>::NoPermission
 		);
 
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			collection.check_allowlist(from)?;
 			collection.check_allowlist(to)?;
 		}
@@ -449,7 +449,7 @@
 		token: TokenId,
 		spender: Option<&T::CrossAccountId>,
 	) -> DispatchResult {
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			collection.check_allowlist(&sender)?;
 			if let Some(spender) = spender {
 				collection.check_allowlist(&spender)?;
@@ -484,7 +484,7 @@
 		if spender.conv_eq(from) {
 			return Self::transfer(collection, from, to, token);
 		}
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			// `from`, `to` checked in [`transfer`]
 			collection.check_allowlist(spender)?;
 		}
@@ -512,7 +512,7 @@
 		if spender.conv_eq(from) {
 			return Self::burn(collection, from, token);
 		}
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			// `from` checked in [`burn`]
 			collection.check_allowlist(spender)?;
 		}

--- a/pallets/refungible/src/lib.rs
+++ b/pallets/refungible/src/lib.rs
@@ -272,7 +272,7 @@
 			<CommonError<T>>::TransferNotAllowed
 		);
 
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			collection.check_allowlist(from)?;
 			collection.check_allowlist(to)?;
 		}
@@ -483,7 +483,7 @@
 		token: TokenId,
 		amount: u128,
 	) -> DispatchResult {
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			collection.check_allowlist(&sender)?;
 			collection.check_allowlist(&spender)?;
 		}
@@ -514,7 +514,7 @@
 		if spender.conv_eq(from) {
 			return Self::transfer(collection, from, to, token, amount);
 		}
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			// `from`, `to` checked in [`transfer`]
 			collection.check_allowlist(spender)?;
 		}
@@ -547,7 +547,7 @@
 		if spender.conv_eq(from) {
 			return Self::burn(collection, from, token, amount);
 		}
-		if collection.access == AccessMode::WhiteList {
+		if collection.access == AccessMode::AllowList {
 			// `from` checked in [`burn`]
 			collection.check_allowlist(spender)?;
 		}

--- a/primitives/nft/src/lib.rs
+++ b/primitives/nft/src/lib.rs
@@ -142,7 +142,7 @@
 #[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub enum AccessMode {
 	Normal,
-	WhiteList,
+	AllowList,
 }
 impl Default for AccessMode {
 	fn default() -> Self {

--- a/runtime/src/chain_extension.rs
+++ b/runtime/src/chain_extension.rs
@@ -75,10 +75,10 @@
 }
 
 #[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
-pub struct NFTExtToggleWhiteList<AccountId> {
+pub struct NFTExtToggleAllowList<AccountId> {
 	pub collection_id: u32,
 	pub address: AccountId,
-	pub whitelisted: bool,
+	pub allowlisted: bool,
 }
 
 /// The chain Extension of NFT pallet
@@ -211,18 +211,18 @@
 				Ok(RetVal::Converging(0))
 			}
 			6 => {
-				// Toggle whitelist
+				// Toggle allowlist
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtToggleWhiteList<AccountIdOf<C>> = env.read_as()?;
-				env.charge_weight(NftWeightInfoOf::<C>::add_to_white_list())?;
+				let input: NFTExtToggleAllowList<AccountIdOf<C>> = env.read_as()?;
+				env.charge_weight(NftWeightInfoOf::<C>::add_to_allow_list())?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
 
-				pallet_nft::Module::<C>::toggle_white_list_internal(
+				pallet_nft::Module::<C>::toggle_allow_list_internal(
 					&C::CrossAccountId::from_sub(env.ext().address().clone()),
 					&collection,
 					&C::CrossAccountId::from_sub(input.address),
-					input.whitelisted,
+					input.allowlisted,
 				)?;
 
 				collection.submit_logs()?;

--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -1340,7 +1340,7 @@
 		) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {
 			use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey};
 
-			let whitelist: Vec<TrackedStorageKey> = vec![
+			let allowlist: Vec<TrackedStorageKey> = vec![
 				// Block Number
 				hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),
 				// Total Issuance
@@ -1354,7 +1354,7 @@
 			];
 
 			let mut batches = Vec::<BenchmarkBatch>::new();
-			let params = (&config, &whitelist);
+			let params = (&config, &allowlist);
 
 			add_benchmark!(params, batches, pallet_evm_migration, EvmMigration);
 			add_benchmark!(params, batches, pallet_nft, Nft);

--- a/smart_contracs/transfer/lib.rs
+++ b/smart_contracs/transfer/lib.rs
@@ -75,7 +75,7 @@
     #[ink(extension = 5, returns_result = false)]
     fn set_variable_meta_data(collection_id: u32, item_id: u32, data: Vec<u8>);
     #[ink(extension = 6, returns_result = false)]
-    fn toggle_white_list(collection_id: u32, address: DefaultAccountId, whitelisted: bool);
+    fn toggle_allow_list(collection_id: u32, address: DefaultAccountId, allowlisted: bool);
 }
 
 #[ink::contract(env = crate::NftEnvironment, dynamic_storage_allocator = true)]
@@ -135,10 +135,10 @@
                 .set_variable_meta_data(collection_id, item_id, data);
         }
         #[ink(message)]
-        pub fn toggle_white_list(&mut self, collection_id: u32, address: AccountId, whitelisted: bool) {
+        pub fn toggle_allow_list(&mut self, collection_id: u32, address: AccountId, allowlisted: bool) {
             let _ = self.env()
                 .extension()
-                .toggle_white_list(collection_id, address, whitelisted);
+                .toggle_allow_list(collection_id, address, allowlisted);
         }
 
     }

--- a/tests/package.json
+++ b/tests/package.json
@@ -42,7 +42,7 @@
     "testConfirmSponsorship": "mocha --timeout 9999999 -r ts-node/register ./**/confirmSponsorship.test.ts",
     "testRemoveCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/removeCollectionAdmin.test.ts",
     "testRemoveCollectionSponsor": "mocha --timeout 9999999 -r ts-node/register ./**/removeCollectionSponsor.test.ts",
-    "testRemoveFromWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromWhiteList.test.ts",
+    "testRemoveFromAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromAllowList.test.ts",
     "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",
     "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
     "testContracts": "mocha --timeout 9999999 -r ts-node/register ./**/contracts.test.ts",
@@ -51,14 +51,14 @@
     "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts",
     "testTransferFrom": "mocha --timeout 9999999 -r ts-node/register ./**/transferFrom.test.ts",
     "testCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
-    "testToggleContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/toggleContractWhiteList.test.ts",
-    "testAddToContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/addToContractWhiteList.test.ts",
+    "testToggleContractAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/toggleContractAllowList.test.ts",
+    "testAddToContractAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/addToContractAllowList.test.ts",
     "testTransfer": "mocha --timeout 9999999 -r ts-node/register ./**/transfer.test.ts",
     "testBurnItem": "mocha --timeout 9999999 -r ts-node/register ./**/burnItem.test.ts",
     "testSetMintPermission": "mocha --timeout 9999999 -r ts-node/register ./**/setMintPermission.test.ts",
     "testCreditFeesToTreasury": "mocha --timeout 9999999 -r ts-node/register ./**/creditFeesToTreasury.test.ts",
     "testEnableContractSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/enableContractSponsoring.test.ts",
-    "testRemoveFromContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromContractWhiteList.test.ts",
+    "testRemoveFromContractAllowList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromContractAllowList.test.ts",
     "testSetContractSponsoringRateLimit": "mocha --timeout 9999999 -r ts-node/register ./**/setContractSponsoringRateLimit.test.ts",
     "testSetOffchainSchema": "mocha --timeout 9999999 -r ts-node/register ./**/setOffchainSchema.test.ts",
     "testOverflow": "mocha --timeout 9999999 -r ts-node/register ./**/overflow.test.ts",

--- a/tests/src/change-collection-owner.test.ts
+++ b/tests/src/change-collection-owner.test.ts
@@ -12,13 +12,13 @@
   setCollectionSponsorExpectSuccess,
   confirmSponsorshipExpectSuccess,
   removeCollectionSponsorExpectSuccess,
-  enableWhiteListExpectSuccess,
+  enableAllowListExpectSuccess,
   setMintPermissionExpectSuccess,
   destroyCollectionExpectSuccess,
   setCollectionSponsorExpectFailure,
   confirmSponsorshipExpectFailure,
   removeCollectionSponsorExpectFailure,
-  enableWhiteListExpectFail,
+  enableAllowListExpectFail,
   setMintPermissionExpectFailure,
   destroyCollectionExpectFailure,
   setPublicAccessModeExpectSuccess,
@@ -104,8 +104,8 @@
       );
       await submitTransactionAsync(bob, tx1);
 
-      await setPublicAccessModeExpectSuccess(bob, collectionId, 'WhiteList');
-      await enableWhiteListExpectSuccess(bob, collectionId);
+      await setPublicAccessModeExpectSuccess(bob, collectionId, 'AllowList');
+      await enableAllowListExpectSuccess(bob, collectionId);
       await setMintPermissionExpectSuccess(bob, collectionId, true);
       await destroyCollectionExpectSuccess(collectionId, '//Bob');
     });
@@ -225,7 +225,7 @@
       );
       await expect(submitTransactionExpectFailAsync(alice, tx1)).to.be.rejected;
 
-      await enableWhiteListExpectFail(alice, collectionId);
+      await enableAllowListExpectFail(alice, collectionId);
       await setMintPermissionExpectFailure(alice, collectionId, true);
       await destroyCollectionExpectFailure(collectionId, '//Alice');
     });

--- a/tests/src/collision-tests/adminDestroyCollection.test.ts
+++ b/tests/src/collision-tests/adminDestroyCollection.test.ts
@@ -27,26 +27,26 @@
   });
 });
 
-describe('Deleting a collection while add address to whitelist: ', () => {
+describe('Deleting a collection while add address to allowlist: ', () => {
   // tslint:disable-next-line: max-line-length
-  it('Adding an address to the collection whitelist in a block by the admin, and deleting the collection by the owner ', async () => {
+  it('Adding an address to the collection allowlist in a block by the admin, and deleting the collection by the owner ', async () => {
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(Bob.address));
       await submitTransactionAsync(Alice, changeAdminTx);
       await waitNewBlocks(1);
       //
-      const addWhitelistAdm = api.tx.nft.addToWhiteList(collectionId, normalizeAccountId(Ferdie.address));
+      const addAllowlistAdm = api.tx.nft.addToAllowList(collectionId, normalizeAccountId(Ferdie.address));
       const destroyCollection = api.tx.nft.destroyCollection(collectionId);
       await Promise.all([
-        addWhitelistAdm.signAndSend(Bob),
+        addAllowlistAdm.signAndSend(Bob),
         destroyCollection.signAndSend(Alice),
       ]);
       await waitNewBlocks(1);
-      let whiteList = false;
-      whiteList = (await api.query.nft.whiteList(collectionId, Ferdie.address)).toJSON() as boolean;
+      let allowList = false;
+      allowList = (await api.query.nft.allowList(collectionId, Ferdie.address)).toJSON() as boolean;
       // tslint:disable-next-line: no-unused-expression
-      expect(whiteList).to.be.false;
+      expect(allowList).to.be.false;
       await waitNewBlocks(2);
     });
   });

--- a/tests/src/collision-tests/tokenLimitsOff.test.ts
+++ b/tests/src/collision-tests/tokenLimitsOff.test.ts
@@ -9,7 +9,7 @@
 import privateKey from '../substrate/privateKey';
 import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
 import {
-  addToWhiteListExpectSuccess,
+  addToAllowListExpectSuccess,
   createCollectionExpectSuccess,
   getCreateItemResult,
   setMintPermissionExpectSuccess,
@@ -44,8 +44,8 @@
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       await setMintPermissionExpectSuccess(Alice, collectionId, true);
-      await addToWhiteListExpectSuccess(Alice, collectionId, Ferdie.address);
-      await addToWhiteListExpectSuccess(Alice, collectionId, Bob.address);
+      await addToAllowListExpectSuccess(Alice, collectionId, Ferdie.address);
+      await addToAllowListExpectSuccess(Alice, collectionId, Bob.address);
       const setCollectionLim = api.tx.nft.setCollectionLimits(
         collectionId,
         {

--- a/tests/src/collision-tests/turnsOffMinting.test.ts
+++ b/tests/src/collision-tests/turnsOffMinting.test.ts
@@ -8,7 +8,7 @@
 import privateKey from '../substrate/privateKey';
 import usingApi from '../substrate/substrate-api';
 import {
-  addToWhiteListExpectSuccess,
+  addToAllowListExpectSuccess,
   createCollectionExpectSuccess,
   setMintPermissionExpectSuccess,
   normalizeAccountId,
@@ -33,7 +33,7 @@
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       await setMintPermissionExpectSuccess(Alice, collectionId, true);
-      await addToWhiteListExpectSuccess(Alice, collectionId, Ferdie.address);
+      await addToAllowListExpectSuccess(Alice, collectionId, Ferdie.address);
 
       const mintItem = api.tx.nft.createItem(collectionId, normalizeAccountId(Ferdie.address), 'NFT');
       const offMinting = api.tx.nft.setMintPermission(collectionId, false);

--- a/tests/src/confirmSponsorship.test.ts
+++ b/tests/src/confirmSponsorship.test.ts
@@ -15,9 +15,9 @@
   createItemExpectSuccess,
   findUnusedAddress,
   getGenericResult,
-  enableWhiteListExpectSuccess,
+  enableAllowListExpectSuccess,
   enablePublicMintingExpectSuccess,
-  addToWhiteListExpectSuccess,
+  addToAllowListExpectSuccess,
   normalizeAccountId,
   addCollectionAdminExpectSuccess,
 } from './util/helpers';
@@ -144,8 +144,8 @@
     await setCollectionSponsorExpectSuccess(collectionId, bob.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
 
-    // Enable collection white list
-    await enableWhiteListExpectSuccess(alice, collectionId);
+    // Enable collection allow list
+    await enableAllowListExpectSuccess(alice, collectionId);
 
     // Enable public minting
     await enablePublicMintingExpectSuccess(alice, collectionId);
@@ -157,8 +157,8 @@
       // Find unused address
       const zeroBalance = await findUnusedAddress(api);
 
-      // Add zeroBalance address to white list
-      await addToWhiteListExpectSuccess(alice, collectionId, zeroBalance.address);
+      // Add zeroBalance address to allow list
+      await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);
 
       // Mint token using unused address as signer
       await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);
@@ -285,8 +285,8 @@
     await setCollectionSponsorExpectSuccess(collectionId, bob.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
 
-    // Enable collection white list
-    await enableWhiteListExpectSuccess(alice, collectionId);
+    // Enable collection allow list
+    await enableAllowListExpectSuccess(alice, collectionId);
 
     // Enable public minting
     await enablePublicMintingExpectSuccess(alice, collectionId);
@@ -295,8 +295,8 @@
       // Find unused address
       const zeroBalance = await findUnusedAddress(api);
 
-      // Add zeroBalance address to white list
-      await addToWhiteListExpectSuccess(alice, collectionId, zeroBalance.address);
+      // Add zeroBalance address to allow list
+      await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);
 
       // Mint token using unused address as signer - gets sponsored
       await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);

--- a/tests/src/contracts.test.ts
+++ b/tests/src/contracts.test.ts
@@ -16,15 +16,15 @@
 } from './util/contracthelpers';
 
 import {
-  addToWhiteListExpectSuccess,
+  addToAllowListExpectSuccess,
   approveExpectSuccess,
   createCollectionExpectSuccess,
   createItemExpectSuccess,
   enablePublicMintingExpectSuccess,
-  enableWhiteListExpectSuccess,
+  enableAllowListExpectSuccess,
   getGenericResult,
   normalizeAccountId,
-  isWhitelisted,
+  isAllowlisted,
   transferFromExpectSuccess,
   getTokenOwner,
 } from './util/helpers';
@@ -96,9 +96,9 @@
       const collectionId = await createCollectionExpectSuccess();
       const [contract] = await deployTransferContract(api);
       await enablePublicMintingExpectSuccess(alice, collectionId);
-      await enableWhiteListExpectSuccess(alice, collectionId);
-      await addToWhiteListExpectSuccess(alice, collectionId, contract.address);
-      await addToWhiteListExpectSuccess(alice, collectionId, bob.address);
+      await enableAllowListExpectSuccess(alice, collectionId);
+      await addToAllowListExpectSuccess(alice, collectionId, contract.address);
+      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
 
       const transferTx = contract.tx.createItem(value, gasLimit, bob.address, collectionId, {Nft: {const_data: '0x010203', variable_data: '0x020304'}});
       const events = await submitTransactionAsync(alice, transferTx);
@@ -124,9 +124,9 @@
       const collectionId = await createCollectionExpectSuccess();
       const [contract] = await deployTransferContract(api);
       await enablePublicMintingExpectSuccess(alice, collectionId);
-      await enableWhiteListExpectSuccess(alice, collectionId);
-      await addToWhiteListExpectSuccess(alice, collectionId, contract.address);
-      await addToWhiteListExpectSuccess(alice, collectionId, bob.address);
+      await enableAllowListExpectSuccess(alice, collectionId);
+      await addToAllowListExpectSuccess(alice, collectionId, contract.address);
+      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
 
       const transferTx = contract.tx.createMultipleItems(value, gasLimit, bob.address, collectionId, [
         {Nft: {const_data: '0x010203', variable_data: '0x020304'}},
@@ -218,7 +218,7 @@
     });
   });
 
-  it('ToggleWhiteList CE', async () => {
+  it('ToggleAllowList CE', async () => {
     await usingApi(async api => {
       const alice = privateKey('//Alice');
       const bob = privateKey('//Bob');
@@ -228,23 +228,23 @@
       const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, contract.address);
       await submitTransactionAsync(alice, changeAdminTx);
 
-      expect(await isWhitelisted(collectionId, bob.address)).to.be.false;
+      expect(await isAllowlisted(collectionId, bob.address)).to.be.false;
 
       {
-        const transferTx = contract.tx.toggleWhiteList(value, gasLimit, collectionId, bob.address, true);
+        const transferTx = contract.tx.toggleAllowList(value, gasLimit, collectionId, bob.address, true);
         const events = await submitTransactionAsync(alice, transferTx);
         const result = getGenericResult(events);
         expect(result.success).to.be.true;
 
-        expect(await isWhitelisted(collectionId, bob.address)).to.be.true;
+        expect(await isAllowlisted(collectionId, bob.address)).to.be.true;
       }
       {
-        const transferTx = contract.tx.toggleWhiteList(value, gasLimit, collectionId, bob.address, false);
+        const transferTx = contract.tx.toggleAllowList(value, gasLimit, collectionId, bob.address, false);
         const events = await submitTransactionAsync(alice, transferTx);
         const result = getGenericResult(events);
         expect(result.success).to.be.true;
 
-        expect(await isWhitelisted(collectionId, bob.address)).to.be.false;
+        expect(await isAllowlisted(collectionId, bob.address)).to.be.false;
       }
     });
   });

--- a/tests/src/eth/allowlist.test.ts
+++ b/tests/src/eth/allowlist.test.ts
@@ -24,7 +24,7 @@
     expect(await helpers.methods.allowed(flipper.options.address, randomUser).call()).to.be.true;
   });
 
-  itWeb3('Non-whitelisted user can\'t call contract with allowlist enabled', async ({api, web3}) => {
+  itWeb3('Non-allowlisted user can\'t call contract with allowlist enabled', async ({api, web3}) => {
     const owner = await createEthAccountWithBalance(api, web3);
     const flipper = await deployFlipper(web3, owner);
     const caller = await createEthAccountWithBalance(api, web3);
@@ -35,7 +35,7 @@
     await flipper.methods.flip().send({from: caller});
     expect(await flipper.methods.getValue().call()).to.be.true;
 
-    // Tx will be reverted if user is not in whitelist
+    // Tx will be reverted if user is not in allowlist
     await helpers.methods.toggleAllowlist(flipper.options.address, true).send({from: owner});
     await expect(flipper.methods.flip().send({from: caller})).to.rejected;
     expect(await flipper.methods.getValue().call()).to.be.true;

--- a/tests/src/eth/contractSponsoring.test.ts
+++ b/tests/src/eth/contractSponsoring.test.ts
@@ -32,7 +32,7 @@
     expect(await helpers.methods.sponsoringEnabled(flipper.options.address).call()).to.be.false;
   });
 
-  itWeb3('Sponsoring is set, an address that has no UNQ can send a transaction and it works. Sponsor balance should decrease (whitelisted)', async ({api, web3}) => {
+  itWeb3('Sponsoring is set, an address that has no UNQ can send a transaction and it works. Sponsor balance should decrease (allowlisted)', async ({api, web3}) => {
     const alice = privateKey('//Alice');
 
     const owner = await createEthAccountWithBalance(api, web3);
@@ -62,7 +62,7 @@
     expect(+balanceAfter).to.be.lessThan(+originalFlipperBalance);
   });
 
-  itWeb3('Sponsoring is set, an address that has no UNQ can send a transaction and it works. Sponsor balance should not decrease (non-whitelisted)', async ({api, web3}) => {
+  itWeb3('Sponsoring is set, an address that has no UNQ can send a transaction and it works. Sponsor balance should not decrease (non-allowlisted)', async ({api, web3}) => {
     const alice = privateKey('//Alice');
 
     const owner = await createEthAccountWithBalance(api, web3);
@@ -158,7 +158,7 @@
     expect(await helpers.methods.getSponsoringRateLimit(flipper.options.address).call()).to.be.equals('7200');
   });
 
-  itWeb3('If whitelist mode is off and sponsorship is on, sponsorship does not work', async ({api, web3}) => {
+  itWeb3('If allowlist mode is off and sponsorship is on, sponsorship does not work', async ({api, web3}) => {
     const alice = privateKey('//Alice');
 
     const owner = await createEthAccountWithBalance(api, web3);

--- a/tests/src/interfaces/augment-api-errors.ts
+++ b/tests/src/interfaces/augment-api-errors.ts
@@ -53,7 +53,7 @@
        **/
       AddressIsZero: AugmentedError<ApiType>;
       /**
-       * Address is not in white list.
+       * Address is not in allow list.
        **/
       AddressNotInAllowlist: AugmentedError<ApiType>;
       /**

--- a/tests/src/interfaces/augment-api-tx.ts
+++ b/tests/src/interfaces/augment-api-tx.ts
@@ -219,7 +219,7 @@
        **/
       addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
       /**
-       * Add an address to white list.
+       * Add an address to allow list.
        * 
        * # Permissions
        * 
@@ -232,7 +232,7 @@
        * 
        * * address.
        **/
-      addToWhiteList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
       /**
        * Set, change, or remove approved address to transfer the ownership of the NFT.
        * 
@@ -336,8 +336,8 @@
        * * Collection Owner.
        * * Collection Admin.
        * * Anyone if
-       * * White List is enabled, and
-       * * Address is added to white list, and
+       * * Allow List is enabled, and
+       * * Address is added to allow list, and
        * * MintPermission is enabled (see SetMintPermission method)
        * 
        * # Arguments
@@ -357,8 +357,8 @@
        * * Collection Owner.
        * * Collection Admin.
        * * Anyone if
-       * * White List is enabled, and
-       * * Address is added to white list, and
+       * * Allow List is enabled, and
+       * * Address is added to allow list, and
        * * MintPermission is enabled (see SetMintPermission method)
        * 
        * # Arguments
@@ -410,7 +410,7 @@
        **/
       removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
       /**
-       * Remove an address from white list.
+       * Remove an address from allow list.
        * 
        * # Permissions
        * 
@@ -423,7 +423,7 @@
        * 
        * * address.
        **/
-      removeFromWhiteList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
       setCollectionLimits: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newLimit: NftDataStructsCollectionLimits | { accountTokenOwnershipLimit?: any; sponsoredDataSize?: any; sponsoredDataRateLimit?: any; tokenLimit?: any; sponsorTransferTimeout?: any; ownerCanTransfer?: any; ownerCanDestroy?: any; transfersEnabled?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, NftDataStructsCollectionLimits]>;
       /**
        * # Permissions
@@ -468,8 +468,8 @@
       setMetaUpdatePermissionFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: NftDataStructsMetaUpdatePermission | 'ItemOwner' | 'Admin' | 'None' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, NftDataStructsMetaUpdatePermission]>;
       /**
        * Allows Anyone to create tokens if:
-       * * White List is enabled, and
-       * * Address is added to white list, and
+       * * Allow List is enabled, and
+       * * Address is added to allow list, and
        * * This method was called with True parameter
        * 
        * # Permissions
@@ -498,7 +498,7 @@
        **/
       setOffchainSchema: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, schema: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Bytes]>;
       /**
-       * Toggle between normal and white list access for the methods with access for `Anyone`.
+       * Toggle between normal and allow list access for the methods with access for `Anyone`.
        * 
        * # Permissions
        * 
@@ -510,7 +510,7 @@
        * 
        * * mode: [AccessMode]
        **/
-      setPublicAccessMode: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, mode: NftDataStructsAccessMode | 'Normal' | 'WhiteList' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, NftDataStructsAccessMode]>;
+      setPublicAccessMode: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, mode: NftDataStructsAccessMode | 'Normal' | 'AllowList' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, NftDataStructsAccessMode]>;
       /**
        * Set schema standard
        * ImageURL

--- a/tests/src/interfaces/nft/definitions.ts
+++ b/tests/src/interfaces/nft/definitions.ts
@@ -91,7 +91,7 @@
       },
     },
     NftDataStructsAccessMode: {
-      _enum: ['Normal', 'WhiteList'],
+      _enum: ['Normal', 'AllowList'],
     },
     NftDataStructsSchemaVersion: mkDummy('SchemaVersion'),
 

--- a/tests/src/interfaces/nft/types.ts
+++ b/tests/src/interfaces/nft/types.ts
@@ -7,7 +7,7 @@
 /** @name NftDataStructsAccessMode */
 export interface NftDataStructsAccessMode extends Enum {
   readonly isNormal: boolean;
-  readonly isWhiteList: boolean;
+  readonly isAllowList: boolean;
 }
 
 /** @name NftDataStructsCollection */

--- a/tests/src/metadataUpdate.test.ts
+++ b/tests/src/metadataUpdate.test.ts
@@ -12,11 +12,11 @@
   createItemExpectSuccess,
   createCollectionExpectSuccess,
   enablePublicMintingExpectSuccess,
-  enableWhiteListExpectSuccess,
+  enableAllowListExpectSuccess,
   setMetadataUpdatePermissionFlagExpectSuccess,
   setVariableMetaDataExpectSuccess,
   setMintPermissionExpectSuccess,
-  addToWhiteListExpectSuccess,
+  addToAllowListExpectSuccess,
   addCollectionAdminExpectSuccess,
   setVariableMetaDataExpectFailure,
   setMetadataUpdatePermissionFlagExpectFailure,
@@ -53,7 +53,7 @@
       await setMetadataUpdatePermissionFlagExpectSuccess(alice, nftCollectionId, 'ItemOwner');
 
       await setMintPermissionExpectSuccess(alice, nftCollectionId, true);
-      await addToWhiteListExpectSuccess(alice, nftCollectionId, bob.address);
+      await addToAllowListExpectSuccess(alice, nftCollectionId, bob.address);
       await addCollectionAdminExpectSuccess(alice, nftCollectionId, bob.address);
 
       await setVariableMetaDataExpectFailure(bob, nftCollectionId, newNftTokenId, data);
@@ -92,7 +92,7 @@
       await setMetadataUpdatePermissionFlagExpectSuccess(alice, nftCollectionId, 'Admin');
 
       await setMintPermissionExpectSuccess(alice, nftCollectionId, true);
-      await addToWhiteListExpectSuccess(alice, nftCollectionId, bob.address);
+      await addToAllowListExpectSuccess(alice, nftCollectionId, bob.address);
       await addCollectionAdminExpectSuccess(alice, nftCollectionId, bob.address);
 
       await setVariableMetaDataExpectSuccess(bob, nftCollectionId, newNftTokenId, data);
@@ -112,7 +112,7 @@
       await setMetadataUpdatePermissionFlagExpectSuccess(alice, nftCollectionId, 'Admin');
 
       await setMintPermissionExpectSuccess(alice, nftCollectionId, true);
-      await addToWhiteListExpectSuccess(alice, nftCollectionId, bob.address);
+      await addToAllowListExpectSuccess(alice, nftCollectionId, bob.address);
       await addCollectionAdminExpectSuccess(alice, nftCollectionId, bob.address);
 
       await setVariableMetaDataExpectSuccess(bob, nftCollectionId, newNftTokenId, data);
@@ -129,8 +129,8 @@
       // nft
       const nftCollectionId = await createCollectionExpectSuccess();
       await enablePublicMintingExpectSuccess(alice, nftCollectionId);
-      await addToWhiteListExpectSuccess(alice, nftCollectionId, bob.address);
-      await enableWhiteListExpectSuccess(alice, nftCollectionId);
+      await addToAllowListExpectSuccess(alice, nftCollectionId, bob.address);
+      await enableAllowListExpectSuccess(alice, nftCollectionId);
       const newNftTokenId = await createItemExpectSuccess(bob, nftCollectionId, 'NFT');
       await setMetadataUpdatePermissionFlagExpectSuccess(alice, nftCollectionId, 'Admin');
 
@@ -169,7 +169,7 @@
       await setMetadataUpdatePermissionFlagExpectSuccess(alice, nftCollectionId, 'None');
 
       await setMintPermissionExpectSuccess(alice, nftCollectionId, true);
-      await addToWhiteListExpectSuccess(alice, nftCollectionId, bob.address);
+      await addToAllowListExpectSuccess(alice, nftCollectionId, bob.address);
       await addCollectionAdminExpectSuccess(alice, nftCollectionId, bob.address);
 
       await setVariableMetaDataExpectFailure(bob, nftCollectionId, newNftTokenId, data);

--- a/tests/src/mintModes.test.ts
+++ b/tests/src/mintModes.test.ts
@@ -7,14 +7,14 @@
 import privateKey from './substrate/privateKey';
 import usingApi from './substrate/substrate-api';
 import {
-  addToWhiteListExpectSuccess,
+  addToAllowListExpectSuccess,
   createCollectionExpectSuccess,
   createItemExpectFailure,
   createItemExpectSuccess,
-  enableWhiteListExpectSuccess,
+  enableAllowListExpectSuccess,
   setMintPermissionExpectSuccess,
   addCollectionAdminExpectSuccess,
-  disableWhiteListExpectSuccess,
+  disableAllowListExpectSuccess,
 } from './util/helpers';
 
 describe('Integration Test public minting', () => {
@@ -28,40 +28,40 @@
     });
   });
 
-  it('If the AllowList mode is enabled, then the address added to the whitelist and not the owner or administrator can create tokens', async () => {
+  it('If the AllowList mode is enabled, then the address added to the allowlist and not the owner or administrator can create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, true);
-      await addToWhiteListExpectSuccess(alice, collectionId, bob.address);
+      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
 
       await createItemExpectSuccess(bob, collectionId, 'NFT');
     });
   });
 
-  it('If the AllowList mode is enabled, address not included in whitelist that is regular user cannot create tokens', async () => {
+  it('If the AllowList mode is enabled, address not included in allowlist that is regular user cannot create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, true);
       await createItemExpectFailure(bob, collectionId, 'NFT');
     });
   });
 
-  it('If the AllowList mode is enabled, address not included in whitelist that is admin can create tokens', async () => {
+  it('If the AllowList mode is enabled, address not included in allowlist that is admin can create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, true);
       await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
       await createItemExpectSuccess(bob, collectionId, 'NFT');
     });
   });
 
-  it('If the AllowList mode is enabled, address not included in whitelist that is owner can create tokens', async () => {
+  it('If the AllowList mode is enabled, address not included in allowlist that is owner can create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, true);
       await createItemExpectSuccess(alice, collectionId, 'NFT');
     });
@@ -70,7 +70,7 @@
   it('If the AllowList mode is disabled, owner can create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await disableWhiteListExpectSuccess(alice, collectionId);
+      await disableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, true);
       await createItemExpectSuccess(alice, collectionId, 'NFT');
     });
@@ -79,7 +79,7 @@
   it('If the AllowList mode is disabled, collection admin can create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await disableWhiteListExpectSuccess(alice, collectionId);
+      await disableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, true);
       await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
       await createItemExpectSuccess(bob, collectionId, 'NFT');
@@ -89,7 +89,7 @@
   it('If the AllowList mode is disabled, regular user can`t create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await disableWhiteListExpectSuccess(alice, collectionId);
+      await disableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, true);
       await createItemExpectFailure(bob, collectionId, 'NFT');
     });
@@ -110,9 +110,9 @@
   it('Address that is the not owner or not admin cannot create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, false);
-      await addToWhiteListExpectSuccess(alice, collectionId, bob.address);
+      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
       await createItemExpectFailure(bob, collectionId, 'NFT');
     });
   });
@@ -120,7 +120,7 @@
   it('Address that is collection owner can create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await disableWhiteListExpectSuccess(alice, collectionId);
+      await disableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, false);
       await createItemExpectSuccess(alice, collectionId, 'NFT');
     });
@@ -129,7 +129,7 @@
   it('Address that is admin can create tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await disableWhiteListExpectSuccess(alice, collectionId);
+      await disableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, false);
       await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
       await createItemExpectSuccess(bob, collectionId, 'NFT');

--- a/tests/src/setMintPermission.test.ts
+++ b/tests/src/setMintPermission.test.ts
@@ -7,12 +7,12 @@
 import privateKey from './substrate/privateKey';
 import usingApi from './substrate/substrate-api';
 import {
-  addToWhiteListExpectSuccess,
+  addToAllowListExpectSuccess,
   createCollectionExpectSuccess,
   createItemExpectFailure,
   createItemExpectSuccess,
   destroyCollectionExpectSuccess,
-  enableWhiteListExpectSuccess,
+  enableAllowListExpectSuccess,
   findNotExistingCollection,
   setMintPermissionExpectFailure,
   setMintPermissionExpectSuccess,
@@ -30,12 +30,12 @@
     });
   });
 
-  it('ensure white-listed non-privileged address can mint tokens', async () => {
+  it('ensure allow-listed non-privileged address can mint tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, true);
-      await addToWhiteListExpectSuccess(alice, collectionId, bob.address);
+      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
 
       await createItemExpectSuccess(bob, collectionId, 'NFT');
     });
@@ -88,7 +88,7 @@
 
   it('fails when not collection owner tries to set mint status', async () => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-    await enableWhiteListExpectSuccess(alice, collectionId);
+    await enableAllowListExpectSuccess(alice, collectionId);
     await setMintPermissionExpectFailure(bob, collectionId, true);
   });
 
@@ -100,10 +100,10 @@
     });
   });
 
-  it('ensure non-white-listed non-privileged address can\'t mint tokens', async () => {
+  it('ensure non-allow-listed non-privileged address can\'t mint tokens', async () => {
     await usingApi(async () => {
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
       await setMintPermissionExpectSuccess(alice, collectionId, true);
 
       await createItemExpectFailure(bob, collectionId, 'NFT');

--- a/tests/src/setPublicAccessMode.test.ts
+++ b/tests/src/setPublicAccessMode.test.ts
@@ -11,12 +11,12 @@
 import privateKey from './substrate/privateKey';
 import usingApi, {submitTransactionExpectFailAsync} from './substrate/substrate-api';
 import {
-  addToWhiteListExpectSuccess,
+  addToAllowListExpectSuccess,
   createCollectionExpectSuccess,
   createItemExpectSuccess,
   destroyCollectionExpectSuccess,
   enablePublicMintingExpectSuccess,
-  enableWhiteListExpectSuccess,
+  enableAllowListExpectSuccess,
   normalizeAccountId,
   addCollectionAdminExpectSuccess,
 } from './util/helpers';
@@ -35,20 +35,20 @@
     });
   });
 
-  it('Run extrinsic with collection id parameters, set the whitelist mode for the collection', async () => {
+  it('Run extrinsic with collection id parameters, set the allowlist mode for the collection', async () => {
     await usingApi(async () => {
       const collectionId: number = await createCollectionExpectSuccess();
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
       await enablePublicMintingExpectSuccess(alice, collectionId);
-      await addToWhiteListExpectSuccess(alice, collectionId, bob.address);
+      await addToAllowListExpectSuccess(alice, collectionId, bob.address);
       await createItemExpectSuccess(bob, collectionId, 'NFT', bob.address);
     });
   });
 
-  it('Whitelisted collection limits', async () => {
+  it('Allowlisted collection limits', async () => {
     await usingApi(async (api: ApiPromise) => {
       const collectionId = await createCollectionExpectSuccess();
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
       await enablePublicMintingExpectSuccess(alice, collectionId);
       const tx = api.tx.nft.createItem(collectionId, normalizeAccountId(bob.address), 'NFT');
       await expect(submitTransactionExpectFailAsync(bob, tx)).to.be.rejected;
@@ -61,7 +61,7 @@
     await usingApi(async (api: ApiPromise) => {
       // tslint:disable-next-line: radix
       const collectionId = (await api.query.common.createdCollectionCount()).toNumber() + 1;
-      const tx = api.tx.nft.setPublicAccessMode(collectionId, 'WhiteList');
+      const tx = api.tx.nft.setPublicAccessMode(collectionId, 'AllowList');
       await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;
     });
   });
@@ -71,7 +71,7 @@
       // tslint:disable-next-line: no-bitwise
       const collectionId = await createCollectionExpectSuccess();
       await destroyCollectionExpectSuccess(collectionId);
-      const tx = api.tx.nft.setPublicAccessMode(collectionId, 'WhiteList');
+      const tx = api.tx.nft.setPublicAccessMode(collectionId, 'AllowList');
       await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;
     });
   });
@@ -79,8 +79,8 @@
   it('Re-set the list mode already set in quantity', async () => {
     await usingApi(async () => {
       const collectionId: number = await createCollectionExpectSuccess();
-      await enableWhiteListExpectSuccess(alice, collectionId);
-      await enableWhiteListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
+      await enableAllowListExpectSuccess(alice, collectionId);
     });
   });
 
@@ -88,7 +88,7 @@
     await usingApi(async (api: ApiPromise) => {
       // tslint:disable-next-line: no-bitwise
       const collectionId = await createCollectionExpectSuccess();
-      const tx = api.tx.nft.setPublicAccessMode(collectionId, 'WhiteList');
+      const tx = api.tx.nft.setPublicAccessMode(collectionId, 'AllowList');
       await expect(submitTransactionExpectFailAsync(bob, tx)).to.be.rejected;
     });
   });
@@ -106,7 +106,7 @@
       // tslint:disable-next-line: no-bitwise
       const collectionId = await createCollectionExpectSuccess();
       await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-      const tx = api.tx.nft.setPublicAccessMode(collectionId, 'WhiteList');
+      const tx = api.tx.nft.setPublicAccessMode(collectionId, 'AllowList');
       await expect(submitTransactionExpectFailAsync(bob, tx)).to.be.rejected;
     });
   });

--- a/tests/src/transfer_contract/metadata.json
+++ b/tests/src/transfer_contract/metadata.json
@@ -323,7 +323,7 @@
             }
           },
           {
-            "name": "whitelisted",
+            "name": "allowlisted",
             "type": {
               "displayName": [
                 "bool"
@@ -335,7 +335,7 @@
         "docs": [],
         "mutates": true,
         "name": [
-          "toggle_white_list"
+          "toggle_allow_list"
         ],
         "payable": false,
         "returnType": null,