Renamed whitelist to allowlist

Author: guo-yu

README.md

@@ -42,7 +42,7 @@ This is a brief introduction to the structure of the contract, if you are intere
 
 ### Membership
 
-The Member Contract is the entry point for other subcontracts, and it is an `ERC721` contract. It includes a simple whitelist invitation function and provides the `investMint(to)` method to ensure that external investors get a corresponding membership (similar to a board of managers)
+The Member Contract is the entry point for other subcontracts, and it is an `ERC721` contract. It includes a simple allowlist invitation function and provides the `investMint(to)` method to ensure that external investors get a corresponding membership (similar to a board of managers)
 
 ### Share
 

contracts/core/Membership.sol

@@ -191,7 +191,7 @@ contract Membership is
 
         revokeRole(PAUSER_ROLE, _msgSender());
         revokeRole(DEFAULT_ADMIN_ROLE, _msgSender());
-        // reserved the INVITER_ROLE case we need it to modify the whitelist by a non-admin deployer address.
+        // reserved the INVITER_ROLE case we need it to modify the allowlist by a non-admin deployer address.
     }
 
     /**
@@ -209,7 +209,7 @@ contract Membership is
     }
 
     /**
-     * @dev Treasury could mint for a investor by pass the whitelist check
+     * @dev Treasury could mint for a investor by pass the allowlist check
      */
     function investMint(address to) external onlyRole(DEFAULT_ADMIN_ROLE) returns (uint256) {
         if (balanceOf(to) > 0) {
@@ -238,9 +238,9 @@ contract Membership is
     }
 
     /**
-     * @dev update whitelist by a back-end server bot
+     * @dev update allowlist by a back-end server bot
      */
-    function updateWhitelist(bytes32 merkleTreeRoot_) public {
+    function updateAllowlist(bytes32 merkleTreeRoot_) public {
         if (!hasRole(INVITER_ROLE, _msgSender())) revert Errors.NotInviter();
 
         _merkleTreeRoot = merkleTreeRoot_;

contracts/interfaces/IMembership.sol

@@ -19,7 +19,7 @@ interface IMembership is IERC721, IERC721Enumerable {
 
     function isInvestor(uint256 tokenId) external view returns (bool);
 
-    function updateWhitelist(bytes32 merkleTreeRoot_) external;
+    function updateAllowlist(bytes32 merkleTreeRoot_) external;
 
     function tokenURI(uint256 tokenId) external view returns (string memory);
 

tests/governor.js

@@ -26,8 +26,8 @@ describe('Governor', function () {
     await deployments.fixture(['Mocks']);
     await contractsReady(this, true)();
 
-    this.voters = this.whitelistAccounts;
-    this.votersAddresses = this.whitelistAddresses;
+    this.voters = this.allowlistAccounts;
+    this.votersAddresses = this.allowlistAddresses;
     this.receiver = await ethers.getContract('CallReceiverMock');
 
     // Proposal for testing

tests/membership.js

@@ -131,42 +131,42 @@ describe('Membership', function () {
     });
   });
 
-  describe('#updateWhitelist', function () {
+  describe('#updateAllowlist', function () {
     it('Should not updated by invalid account', async function () {
       await expect(
         this.membership
           .connect(await ethers.getSigner(this.accounts[1]))
-          .updateWhitelist(this.rootHash)
+          .updateAllowlist(this.rootHash)
       ).to.be.revertedWith('NotInviter()');
     });
   });
 
   describe('#mint', function () {
-    it('Should able to mint NFT for account in whitelist', async function () {
-      await this.membership.updateWhitelist(this.rootHash);
+    it('Should able to mint NFT for account in allowlist', async function () {
+      await this.membership.updateAllowlist(this.rootHash);
       await expect(this.membership.mint(this.proofs[0]))
         .to.changeTokenBalance(this.membership, this.ownerAddress, 1)
         .to.emit(this.membership, 'Transfer')
         .withArgs(zeroAddres, this.ownerAddress, 0);
     });
 
     it('Should not able to mint NFT for an account more than once', async function () {
-      await this.membership.updateWhitelist(this.rootHash);
+      await this.membership.updateAllowlist(this.rootHash);
       await this.membership.mint(this.proofs[0]);
 
       await expect(this.membership.mint(this.proofs[0])).to.be.revertedWith(
         'MembershipAlreadyClaimed()'
       );
     });
 
-    it('Should not able to mint NFT for account in whitelist with badProof', async function () {
-      await this.membership.updateWhitelist(this.rootHash);
+    it('Should not able to mint NFT for account in allowlist with badProof', async function () {
+      await this.membership.updateAllowlist(this.rootHash);
 
       await expect(this.membership.mint(this.badProof)).to.be.revertedWith('InvalidProof()');
     });
 
-    it('Should not able to mint NFT for account not in whitelist', async function () {
-      await this.membership.updateWhitelist(this.rootHash);
+    it('Should not able to mint NFT for account not in allowlist', async function () {
+      await this.membership.updateAllowlist(this.rootHash);
 
       await expect(
         this.membership.connect(await ethers.getSigner(this.accounts[4])).mint(this.badProof)
@@ -176,15 +176,15 @@ describe('Membership', function () {
 
   describe('#tokenURI', function () {
     it('Should return a server-side token URI by default', async function () {
-      await this.membership.updateWhitelist(this.rootHash);
+      await this.membership.updateAllowlist(this.rootHash);
       await this.membership.mint(this.proofs[0]);
 
       // Notice: hard code tokenId(0) here
       expect(await this.membership.tokenURI(0)).to.equal(`${_args[2].membership.baseTokenURI}0`);
     });
 
     it('Should return a decentralized token URI after updated', async function () {
-      await this.membership.updateWhitelist(this.rootHash);
+      await this.membership.updateAllowlist(this.rootHash);
       await this.membership.mint(this.proofs[0]);
       await this.membership.updateTokenURI(0, _testJSONString);
 
@@ -197,7 +197,7 @@ describe('Membership', function () {
 
   describe('#pause', function () {
     it('Should not able to transfer tokens after paused', async function () {
-      await this.membership.updateWhitelist(this.rootHash);
+      await this.membership.updateAllowlist(this.rootHash);
       await this.membership.mint(this.proofs[0]);
       await this.membership.pause();
 
@@ -207,14 +207,14 @@ describe('Membership', function () {
     });
 
     it('Should able to mint tokens even after paused', async function () {
-      await this.membership.updateWhitelist(this.rootHash);
+      await this.membership.updateAllowlist(this.rootHash);
       await this.membership.mint(this.proofs[0]);
       await this.membership.pause();
-      await this.membership.connect(this.whitelistAccounts[1]).mint(this.proofs[1]);
+      await this.membership.connect(this.allowlistAccounts[1]).mint(this.proofs[1]);
 
       // Notice: hard code tokenId(1) here
-      expect(await this.membership.balanceOf(this.whitelistAddresses[1])).to.equal(1);
-      expect(await this.membership.ownerOf(1)).to.equal(await this.whitelistAddresses[1]);
+      expect(await this.membership.balanceOf(this.allowlistAddresses[1])).to.equal(1);
+      expect(await this.membership.ownerOf(1)).to.equal(await this.allowlistAddresses[1]);
     });
   });
 });

tests/modules.js

@@ -73,7 +73,7 @@ describe('Modules', function () {
 
       it('Should not be able to propose by unauth account', async function () {
         await expect(
-          this.modules.payroll.connect(this.whitelistAccounts[2]).propose(...this.proposal)
+          this.modules.payroll.connect(this.allowlistAccounts[2]).propose(...this.proposal)
         ).to.be.revertedWith('NotOperator()');
       });
 
@@ -99,7 +99,7 @@ describe('Modules', function () {
           this.modules.payroll,
           'ModuleProposalConfirmed'
         );
-        await expect(this.modules.payroll.connect(this.whitelistAccounts[1]).confirm(id)).to.emit(
+        await expect(this.modules.payroll.connect(this.allowlistAccounts[1]).confirm(id)).to.emit(
           this.modules.payroll,
           'ModuleProposalConfirmed'
         );
@@ -120,7 +120,7 @@ describe('Modules', function () {
           this.modules.payroll,
           'ModuleProposalConfirmed'
         );
-        await expect(this.modules.payroll.connect(this.whitelistAccounts[1]).confirm(id)).to.emit(
+        await expect(this.modules.payroll.connect(this.allowlistAccounts[1]).confirm(id)).to.emit(
           this.modules.payroll,
           'ModuleProposalConfirmed'
         );
@@ -185,7 +185,7 @@ describe('Modules', function () {
         'ModuleProposalConfirmed'
       );
       await expect(
-        this.modules.payroll.connect(this.whitelistAccounts[1]).confirm(proposalId)
+        this.modules.payroll.connect(this.allowlistAccounts[1]).confirm(proposalId)
       ).to.emit(this.modules.payroll, 'ModuleProposalConfirmed');
 
       await expect(this.modules.payroll.schedule(proposalId)).to.emit(

utils/helpers.js

@@ -6,18 +6,18 @@ module.exports.setupProof = async function (context, _index = 4) {
   const { deployer } = await getNamedAccounts();
   const accounts = await getUnnamedAccounts();
 
-  const whitelistAddresses = [deployer].concat(accounts.filter((_, idx) => idx < _index));
-  const leafNodes = whitelistAddresses.map((adr) => keccak256(adr));
+  const allowlistAddresses = [deployer].concat(accounts.filter((_, idx) => idx < _index));
+  const leafNodes = allowlistAddresses.map((adr) => keccak256(adr));
   const merkleTree = new MerkleTree(leafNodes, keccak256, {
     sortPairs: true,
   });
 
   const deps = {
     rootHash: merkleTree.getHexRoot(),
-    proofs: whitelistAddresses.map((addr) => merkleTree.getHexProof(keccak256(addr))),
+    proofs: allowlistAddresses.map((addr) => merkleTree.getHexProof(keccak256(addr))),
     badProof: merkleTree.getHexProof(keccak256(accounts[_index])),
-    whitelistAddresses,
-    whitelistAccounts: await Promise.all(whitelistAddresses.map((v) => ethers.getSigner(v))),
+    allowlistAddresses,
+    allowlistAccounts: await Promise.all(allowlistAddresses.map((v) => ethers.getSigner(v))),
     accounts,
     owner: await ethers.getSigner(deployer),
     ownerAddress: deployer,
@@ -42,15 +42,15 @@ module.exports.contractsReady = function (context, instantMint = false) {
     const governor = Governor.attach(await membership.governor());
 
     if (instantMint) {
-      await membership.updateWhitelist(context.rootHash);
+      await membership.updateAllowlist(context.rootHash);
       await membership.setupGovernor();
 
-      // Do NOT use `context.whitelistAccounts.forEach` to avoid a block number change
+      // Do NOT use `context.allowlistAccounts.forEach` to avoid a block number change
       await Promise.all(
-        context.whitelistAccounts.map((account, idx) => {
+        context.allowlistAccounts.map((account, idx) => {
           return Promise.all([
             membership.connect(account).mint(context.proofs[idx]),
-            membership.connect(account).delegate(context.whitelistAddresses[idx]),
+            membership.connect(account).delegate(context.allowlistAddresses[idx]),
           ]);
         })
       );