fix: prefer the term 'allowlist' for callhook senders

pcarranzav · pcarranzav · commit e78940388638 · 2022-10-28T17:36:32.000-03:00
diff --git a/cli/commands/bridge/to-l2.ts b/cli/commands/bridge/to-l2.ts
@@ -163,7 +163,7 @@ export const sendToL2Command = {
         description: 'Receiving address in L2. Same to L1 address if empty',
       })
       .positional('calldata', {
-        description: 'Calldata to pass to the recipient. Must be whitelisted in the bridge',
+        description: 'Calldata to pass to the recipient. Must be allowlisted in the bridge',
       })
       .coerce({
         maxGas: toBN,
diff --git a/contracts/gateway/L1GraphTokenGateway.sol b/contracts/gateway/L1GraphTokenGateway.sol
@@ -33,7 +33,7 @@ contract L1GraphTokenGateway is Initializable, GraphTokenGateway, L1ArbitrumMess
     /// Address of the BridgeEscrow contract that holds the GRT in the bridge
     address public escrow;
     /// Addresses for which this mapping is true are allowed to send callhooks in outbound transfers
-    mapping(address => bool) public callhookWhitelist;
+    mapping(address => bool) public callhookAllowlist;
 
     /// Emitted when an outbound transfer is initiated, i.e. tokens are deposited from L1 to L2
     event DepositInitiated(
@@ -61,10 +61,10 @@ contract L1GraphTokenGateway is Initializable, GraphTokenGateway, L1ArbitrumMess
     event L2CounterpartAddressSet(address l2Counterpart);
     /// Emitted when the escrow address has been updated
     event EscrowAddressSet(address escrow);
-    /// Emitted when an address is added to the callhook whitelist
-    event AddedToCallhookWhitelist(address newWhitelisted);
-    /// Emitted when an address is removed from the callhook whitelist
-    event RemovedFromCallhookWhitelist(address notWhitelisted);
+    /// Emitted when an address is added to the callhook allowlist
+    event AddedToCallhookAllowlist(address newAllowlisted);
+    /// Emitted when an address is removed from the callhook allowlist
+    event RemovedFromCallhookAllowlist(address notAllowlisted);
 
     /**
      * @dev Allows a function to be called only by the gateway's L2 counterpart.
@@ -94,7 +94,7 @@ contract L1GraphTokenGateway is Initializable, GraphTokenGateway, L1ArbitrumMess
      * - l2GRT using setL2TokenAddress
      * - l2Counterpart using setL2CounterpartAddress
      * - escrow using setEscrowAddress
-     * - whitelisted callhook callers using addToCallhookWhitelist
+     * - allowlisted callhook callers using addToCallhookAllowlist
      * - pauseGuardian using setPauseGuardian
      * @param _controller Address of the Controller that manages this contract
      */
@@ -150,28 +150,28 @@ contract L1GraphTokenGateway is Initializable, GraphTokenGateway, L1ArbitrumMess
     }
 
     /**
-     * @notice Adds an address to the callhook whitelist.
+     * @notice Adds an address to the callhook allowlist.
      * This address will be allowed to include callhooks when transferring tokens.
-     * @param _newWhitelisted Address to add to the whitelist
+     * @param _newAllowlisted Address to add to the allowlist
      */
-    function addToCallhookWhitelist(address _newWhitelisted) external onlyGovernor {
-        require(_newWhitelisted != address(0), "INVALID_ADDRESS");
-        require(Address.isContract(_newWhitelisted), "MUST_BE_CONTRACT");
-        require(!callhookWhitelist[_newWhitelisted], "ALREADY_WHITELISTED");
-        callhookWhitelist[_newWhitelisted] = true;
-        emit AddedToCallhookWhitelist(_newWhitelisted);
+    function addToCallhookAllowlist(address _newAllowlisted) external onlyGovernor {
+        require(_newAllowlisted != address(0), "INVALID_ADDRESS");
+        require(Address.isContract(_newAllowlisted), "MUST_BE_CONTRACT");
+        require(!callhookAllowlist[_newAllowlisted], "ALREADY_ALLOWLISTED");
+        callhookAllowlist[_newAllowlisted] = true;
+        emit AddedToCallhookAllowlist(_newAllowlisted);
     }
 
     /**
-     * @notice Removes an address from the callhook whitelist.
+     * @notice Removes an address from the callhook allowlist.
      * This address will no longer be allowed to include callhooks when transferring tokens.
-     * @param _notWhitelisted Address to remove from the whitelist
+     * @param _notAllowlisted Address to remove from the allowlist
      */
-    function removeFromCallhookWhitelist(address _notWhitelisted) external onlyGovernor {
-        require(_notWhitelisted != address(0), "INVALID_ADDRESS");
-        require(callhookWhitelist[_notWhitelisted], "NOT_WHITELISTED");
-        callhookWhitelist[_notWhitelisted] = false;
-        emit RemovedFromCallhookWhitelist(_notWhitelisted);
+    function removeFromCallhookAllowlist(address _notAllowlisted) external onlyGovernor {
+        require(_notAllowlisted != address(0), "INVALID_ADDRESS");
+        require(callhookAllowlist[_notAllowlisted], "NOT_ALLOWLISTED");
+        callhookAllowlist[_notAllowlisted] = false;
+        emit RemovedFromCallhookAllowlist(_notAllowlisted);
     }
 
     /**
@@ -180,10 +180,10 @@ contract L1GraphTokenGateway is Initializable, GraphTokenGateway, L1ArbitrumMess
      * The ticket must be redeemed on L2 to receive tokens at the specified address.
      * Note that the caller must previously allow the gateway to spend the specified amount of GRT.
      * @dev maxGas and gasPriceBid must be set using Arbitrum's NodeInterface.estimateRetryableTicket method.
-     * Also note that whitelisted senders (some protocol contracts) can include additional calldata
+     * Also note that allowlisted senders (some protocol contracts) can include additional calldata
      * for a callhook to be executed on the L2 side when the tokens are received. In this case, the L2 transaction
      * can revert if the callhook reverts, potentially locking the tokens on the bridge if the callhook
-     * never succeeds. This requires extra care when adding contracts to the whitelist, but is necessary to ensure that
+     * never succeeds. This requires extra care when adding contracts to the allowlist, but is necessary to ensure that
      * the tickets can be retried in the case of a temporary failure, and to ensure the atomicity of callhooks
      * with token transfers.
      * @param _l1Token L1 Address of the GRT contract (needed for compatibility with Arbitrum Gateway Router)
@@ -217,7 +217,7 @@ contract L1GraphTokenGateway is Initializable, GraphTokenGateway, L1ArbitrumMess
                 bytes memory extraData;
                 (from, maxSubmissionCost, extraData) = parseOutboundData(_data);
                 require(
-                    extraData.length == 0 || callhookWhitelist[msg.sender] == true,
+                    extraData.length == 0 || callhookAllowlist[msg.sender] == true,
                     "CALL_HOOK_DATA_NOT_ALLOWED"
                 );
                 require(maxSubmissionCost != 0, "NO_SUBMISSION_COST");
@@ -318,7 +318,7 @@ contract L1GraphTokenGateway is Initializable, GraphTokenGateway, L1ArbitrumMess
      * @param _from Address on L1 from which we're transferring tokens
      * @param _to Address on L2 to which we're transferring tokens
      * @param _amount Amount of GRT to transfer
-     * @param _data Additional call data for the L2 transaction, which must be empty unless the caller is whitelisted
+     * @param _data Additional call data for the L2 transaction, which must be empty unless the caller is allowlisted
      * @return Encoded calldata (including function selector) for the L2 transaction
      */
     function getOutboundCalldata(
diff --git a/contracts/l2/gateway/L2GraphTokenGateway.sol b/contracts/l2/gateway/L2GraphTokenGateway.sol
@@ -211,17 +211,17 @@ contract L2GraphTokenGateway is GraphTokenGateway, L2ArbitrumMessenger, Reentran
      * @notice Receives token amount from L1 and mints the equivalent tokens to the receiving address
      * @dev Only accepts transactions from the L1 GRT Gateway.
      * The function is payable for ITokenGateway compatibility, but msg.value must be zero.
-     * Note that whitelisted senders (some protocol contracts) can include additional calldata
+     * Note that allowlisted senders (some protocol contracts) can include additional calldata
      * for a callhook to be executed on the L2 side when the tokens are received. In this case, the L2 transaction
      * can revert if the callhook reverts, potentially locking the tokens on the bridge if the callhook
-     * never succeeds. This requires extra care when adding contracts to the whitelist, but is necessary to ensure that
+     * never succeeds. This requires extra care when adding contracts to the allowlist, but is necessary to ensure that
      * the tickets can be retried in the case of a temporary failure, and to ensure the atomicity of callhooks
      * with token transfers.
      * @param _l1Token L1 Address of GRT
      * @param _from Address of the sender on L1
      * @param _to Recipient address on L2
      * @param _amount Amount of tokens transferred
-     * @param _data Extra callhook data, only used when the sender is whitelisted
+     * @param _data Extra callhook data, only used when the sender is allowlisted
      */
     function finalizeInboundTransfer(
         address _l1Token,
diff --git a/e2e/deployment/config/l1/l1GraphTokenGateway.test.ts b/e2e/deployment/config/l1/l1GraphTokenGateway.test.ts
@@ -54,15 +54,15 @@ describe('[L1] L1GraphTokenGateway configuration', function () {
       await expect(tx).revertedWith('Only Controller governor')
     })
 
-    it('addToCallhookWhitelist should revert', async function () {
-      const tx = L1GraphTokenGateway.connect(unauthorized).addToCallhookWhitelist(
+    it('addToCallhookAllowlist should revert', async function () {
+      const tx = L1GraphTokenGateway.connect(unauthorized).addToCallhookAllowlist(
         unauthorized.address,
       )
       await expect(tx).revertedWith('Only Controller governor')
     })
 
-    it('removeFromCallhookWhitelist should revert', async function () {
-      const tx = L1GraphTokenGateway.connect(unauthorized).removeFromCallhookWhitelist(
+    it('removeFromCallhookAllowlist should revert', async function () {
+      const tx = L1GraphTokenGateway.connect(unauthorized).removeFromCallhookAllowlist(
         unauthorized.address,
       )
       await expect(tx).revertedWith('Only Controller governor')
diff --git a/test/gateway/l1GraphTokenGateway.test.ts b/test/gateway/l1GraphTokenGateway.test.ts
@@ -205,59 +205,59 @@ describe('L1GraphTokenGateway', () => {
         expect(await l1GraphTokenGateway.escrow()).eq(bridgeEscrow.address)
       })
     })
-    describe('addToCallhookWhitelist', function () {
+    describe('addToCallhookAllowlist', function () {
       it('is not callable by addreses that are not the governor', async function () {
         const tx = l1GraphTokenGateway
           .connect(tokenSender.signer)
-          .addToCallhookWhitelist(fixtureContracts.rewardsManager.address)
+          .addToCallhookAllowlist(fixtureContracts.rewardsManager.address)
         await expect(tx).revertedWith('Only Controller governor')
         expect(
-          await l1GraphTokenGateway.callhookWhitelist(fixtureContracts.rewardsManager.address),
+          await l1GraphTokenGateway.callhookAllowlist(fixtureContracts.rewardsManager.address),
         ).eq(false)
       })
-      it('rejects adding an EOA to the callhook whitelist', async function () {
+      it('rejects adding an EOA to the callhook allowlist', async function () {
         const tx = l1GraphTokenGateway
           .connect(governor.signer)
-          .addToCallhookWhitelist(tokenSender.address)
+          .addToCallhookAllowlist(tokenSender.address)
         await expect(tx).revertedWith('MUST_BE_CONTRACT')
       })
-      it('adds an address to the callhook whitelist', async function () {
+      it('adds an address to the callhook allowlist', async function () {
         const tx = l1GraphTokenGateway
           .connect(governor.signer)
-          .addToCallhookWhitelist(fixtureContracts.rewardsManager.address)
+          .addToCallhookAllowlist(fixtureContracts.rewardsManager.address)
         await expect(tx)
-          .emit(l1GraphTokenGateway, 'AddedToCallhookWhitelist')
+          .emit(l1GraphTokenGateway, 'AddedToCallhookAllowlist')
           .withArgs(fixtureContracts.rewardsManager.address)
         expect(
-          await l1GraphTokenGateway.callhookWhitelist(fixtureContracts.rewardsManager.address),
+          await l1GraphTokenGateway.callhookAllowlist(fixtureContracts.rewardsManager.address),
         ).eq(true)
       })
     })
-    describe('removeFromCallhookWhitelist', function () {
+    describe('removeFromCallhookAllowlist', function () {
       it('is not callable by addreses that are not the governor', async function () {
         await l1GraphTokenGateway
           .connect(governor.signer)
-          .addToCallhookWhitelist(fixtureContracts.rewardsManager.address)
+          .addToCallhookAllowlist(fixtureContracts.rewardsManager.address)
         const tx = l1GraphTokenGateway
           .connect(tokenSender.signer)
-          .removeFromCallhookWhitelist(fixtureContracts.rewardsManager.address)
+          .removeFromCallhookAllowlist(fixtureContracts.rewardsManager.address)
         await expect(tx).revertedWith('Only Controller governor')
         expect(
-          await l1GraphTokenGateway.callhookWhitelist(fixtureContracts.rewardsManager.address),
+          await l1GraphTokenGateway.callhookAllowlist(fixtureContracts.rewardsManager.address),
         ).eq(true)
       })
-      it('removes an address from the callhook whitelist', async function () {
+      it('removes an address from the callhook allowlist', async function () {
         await l1GraphTokenGateway
           .connect(governor.signer)
-          .addToCallhookWhitelist(fixtureContracts.rewardsManager.address)
+          .addToCallhookAllowlist(fixtureContracts.rewardsManager.address)
         const tx = l1GraphTokenGateway
           .connect(governor.signer)
-          .removeFromCallhookWhitelist(fixtureContracts.rewardsManager.address)
+          .removeFromCallhookAllowlist(fixtureContracts.rewardsManager.address)
         await expect(tx)
-          .emit(l1GraphTokenGateway, 'RemovedFromCallhookWhitelist')
+          .emit(l1GraphTokenGateway, 'RemovedFromCallhookAllowlist')
           .withArgs(fixtureContracts.rewardsManager.address)
         expect(
-          await l1GraphTokenGateway.callhookWhitelist(fixtureContracts.rewardsManager.address),
+          await l1GraphTokenGateway.callhookAllowlist(fixtureContracts.rewardsManager.address),
         ).eq(false)
       })
     })
@@ -492,7 +492,7 @@ describe('L1GraphTokenGateway', () => {
           )
         await expect(tx).revertedWith('NO_SUBMISSION_COST')
       })
-      it('reverts when called with nonempty calldata, if the sender is not whitelisted', async function () {
+      it('reverts when called with nonempty calldata, if the sender is not allowlisted', async function () {
         await grt.connect(tokenSender.signer).approve(l1GraphTokenGateway.address, toGRT('10'))
         const tx = l1GraphTokenGateway
           .connect(tokenSender.signer)
@@ -509,12 +509,12 @@ describe('L1GraphTokenGateway', () => {
           )
         await expect(tx).revertedWith('CALL_HOOK_DATA_NOT_ALLOWED')
       })
-      it('allows sending nonempty calldata, if the sender is whitelisted', async function () {
+      it('allows sending nonempty calldata, if the sender is allowlisted', async function () {
         // Make the sender a contract so that it can be allowed to send callhooks
         await provider().send('hardhat_setCode', [tokenSender.address, '0x1234'])
         await l1GraphTokenGateway
           .connect(governor.signer)
-          .addToCallhookWhitelist(tokenSender.address)
+          .addToCallhookAllowlist(tokenSender.address)
         await grt.connect(tokenSender.signer).approve(l1GraphTokenGateway.address, toGRT('10'))
         await testValidOutboundTransfer(
           tokenSender.signer,
