Merge pull request #269 from hopperlabsxyz/feat/blacklist

Feat/blacklist

Author: GuiDupont

.github/workflows/run-tests.yml

@@ -462,4 +462,4 @@ jobs:
           path: .
       - run: forge test -vvv
         env:
-          PROXY: false
+          PROXY: false

script/safe_scripts/updateDefaultLogic.s.sol

@@ -6,22 +6,11 @@ import {
     ProxyAdmin
 } from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
-import {BeaconProxyFactory} from "@src/protocol-v1/BeaconProxyFactory.sol";
-import {OptinProxyFactory} from "@src/protocol-v2/OptinProxyFactory.sol";
-import {LogicRegistry, ProtocolRegistry} from "@src/protocol-v2/ProtocolRegistry.sol";
-import {Script, console} from "forge-std/Script.sol";
+import {LogicRegistry} from "@src/protocol-v2/ProtocolRegistry.sol";
 
 // import {Vault} from "../src/v0.5.0/Vault.sol";
 
 import {BatchScript} from "../tools/BatchScript.sol";
-import {Options, Upgrades} from "openzeppelin-foundry-upgrades/Upgrades.sol";
-
-/*
- This script will deploy the OptinProxyFactory, propose safe txs to:
- - update the fee registry with the logicRegistry
- - update the default implementation in the logic registry
- - upgrade the set of signers of the DAO multisig
-*/
 
 contract UpgradeProtocolRegistry is BatchScript {
     address registry;

src/v0.6.0/Whitelistable.sol

@@ -2,46 +2,50 @@
 pragma solidity 0.8.26;
 
 import {Roles} from "./Roles.sol";
+import {SanctionsList} from "./interfaces/SanctionsList.sol";
 import {RolesLib} from "./libraries/RolesLib.sol";
 import {WhitelistableLib} from "./libraries/WhitelistableLib.sol";
+import {AccessMode} from "./primitives/Enums.sol";
 
 abstract contract Whitelistable is Roles {
     /// @custom:storage-definition erc7201:hopper.storage.Whitelistable
     /// @param isWhitelisted The mapping of whitelisted addresses.
     /// @param isActivated The flag to check if the whitelist is activated.
     struct WhitelistableStorage {
         mapping(address => bool) isWhitelisted;
-        bool isActivated;
+        // in v0.6.0, we replace the bool isActivated with a enum AccessMode
+        // bool isActivated; --> AccessMode accessMode;
+        AccessMode accessMode;
+        // added in v0.6.0
+        mapping(address => bool) isBlacklisted;
+        SanctionsList externalSanctionList;
     }
 
     /// @dev Initializes the whitelist.
-    /// @param activate if the whitelist should be activated.
+    /// @param accessMode the access mode of the whitelist.
     // solhint-disable-next-line func-name-mixedcase
     function __Whitelistable_init(
-        bool activate
+        AccessMode accessMode,
+        address externalSanctionsList
     ) internal onlyInitializing {
-        if (activate) {
-            WhitelistableStorage storage $ = WhitelistableLib._getWhitelistableStorage();
-            $.isActivated = true;
-        }
+        WhitelistableLib.switchAccessMode(accessMode);
+        WhitelistableLib.setExternalSanctionsList(SanctionsList(externalSanctionsList));
     }
 
-    /// @notice Deactivates the whitelist
-    function disableWhitelist() public onlyOwner {
-        WhitelistableLib.disableWhitelist();
+    function switchAccessMode(
+        AccessMode newMode
+    ) public onlyOwner {
+        WhitelistableLib.switchAccessMode(newMode);
     }
 
-    /// @notice Checks if an account is whitelisted
+    /// @notice Checks if an account is whitelisted or blacklisted
+    /// @dev In v0.6.0, this function is extended to also enforce blacklist checks.
     /// @param account The address of the account to check
-    /// @return True if the account is whitelisted, false otherwise
+    /// @return True if the account is whitelisted or not blacklisted, false otherwise
     function isWhitelisted(
         address account
     ) public view returns (bool) {
-        WhitelistableStorage storage $ = WhitelistableLib._getWhitelistableStorage();
-        if (RolesLib._getRolesStorage().feeRegistry.protocolFeeReceiver() == account) {
-            return true;
-        }
-        return $.isActivated ? $.isWhitelisted[account] : true;
+        return WhitelistableLib.isWhitelisted(account);
     }
 
     /// @notice Adds multiple accounts to the whitelist
@@ -58,4 +62,82 @@ abstract contract Whitelistable is Roles {
     ) external onlyWhitelistManager {
         WhitelistableLib.revokeFromWhitelist(accounts);
     }
+
+    /// @notice Adds multiple accounts to the blacklist
+    function addToBlacklist(
+        address[] memory accounts
+    ) external onlyWhitelistManager {
+        WhitelistableLib.addToBlacklist(accounts);
+    }
+
+    /// @notice Removes multiple accounts from the blacklist
+    function revokeFromBlacklist(
+        address[] memory accounts
+    ) external onlyWhitelistManager {
+        WhitelistableLib.revokeFromBlacklist(accounts);
+    }
+
+    /// @notice Sets the external sanctions list
+    function setExternalSanctionsList(
+        SanctionsList sanctionsList
+    ) external onlyWhitelistManager {
+        WhitelistableLib.setExternalSanctionsList(sanctionsList);
+    }
 }
+
+// v0.6.0 storage layout changes:
+
+// ==================== ORIGINAL STORAGE LAYOUT ====================
+// slot 0: isWhitelisted (mapping pointer)
+// Type: mapping(address => bool)
+// Description: Pointer to the mapping of whitelisted addresses
+// Visual representation (bytes32):
+// 0x0000000000000000000000000000000000000000000000000000000000000000
+//   |                           32 bytes                            |
+
+// slot 1: isActivated
+// Type: bool
+// Description: Activation flag (only 1 byte used, right-aligned)
+// Visual representation (bytes32):
+//                                                          isActivated
+// 0x0000000000000000000000000000000000000000000000000000000000000000
+//   |                      31 bytes unused                      |xx|
+//                                                               (1 byte)
+
+// ==================== NEW STORAGE LAYOUT ====================
+// slot 0: isWhitelisted (mapping pointer)
+// Type: mapping(address => bool)
+// Description: Pointer to the mapping of whitelisted addresses
+// Visual representation (bytes32):
+// 0x0000000000000000000000000000000000000000000000000000000000000000
+//   |                           32 bytes                            |
+// Note: The actual mapping data is stored at keccak256(key . slot)
+
+// slot 1: accessMode
+// Type: enum AccessMode (uint8)
+// Description: Access mode enum value (only 1 byte used, right-aligned)
+// Possible values: 0x00 (BlacklistMode), 0x01 (WhitelistMode), 0x02 (Deactivated), etc.
+// Visual representation (bytes32):
+//                                                          accessMode
+// 0x0000000000000000000000000000000000000000000000000000000000000001
+//   |                      31 bytes unused                      |xx|
+//                                                               (1 byte)
+
+// slot 2: isBlacklisted (mapping pointer)
+// Type: mapping(address => bool)
+// Description: Pointer to the mapping of blacklisted addresses
+// Visual representation (bytes32):
+// 0x0000000000000000000000000000000000000000000000000000000000000000
+//   |                           32 bytes                            |
+// Note: The actual mapping data is stored at keccak256(key . slot)
+
+// Upgrades scenario:
+// we upgrade the whitelistable contract from v0.5.0 to v0.6.0
+// 1) isActivated is 0 (deactivated)
+//   1.1) accessMode is 0 (blacklist)
+// --> vault remains as accessible as before the upgrade
+//     if the admin wants to disable the blacklist, he can call the disableWhitelist function
+// 2) isActivated is 1 (activated)
+//   2.1) accessMode is 1 (whitelist)
+// --> vault remains in whitelist mode
+//     if the admin wants to disable the whitelist, he can call the disableWhitelist function

src/v0.6.0/interfaces/SanctionsList.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+interface SanctionsList {
+    function isSanctioned(
+        address addr
+    ) external view returns (bool);
+}

src/v0.6.0/libraries/WhitelistableLib.sol

@@ -2,7 +2,16 @@
 pragma solidity 0.8.26;
 
 import {Whitelistable} from "../Whitelistable.sol";
-import {WhitelistDisabled, WhitelistUpdated} from "../primitives/Events.sol";
+import {SanctionsList} from "../interfaces/SanctionsList.sol";
+import {AccessMode} from "../primitives/Enums.sol";
+import {
+    AccessModeUpdated,
+    BlacklistUpdated,
+    ExternalSanctionsListUpdated,
+    WhitelistDisabled,
+    WhitelistUpdated
+} from "../primitives/Events.sol";
+import {RolesLib} from "./RolesLib.sol";
 
 library WhitelistableLib {
     // keccak256(abi.encode(uint256(keccak256("hopper.storage.Whitelistable")) - 1)) & ~bytes32(uint256(0xff))
@@ -23,16 +32,23 @@ library WhitelistableLib {
         }
     }
 
+    /// @notice Adds multiple accounts to the whitelist
     function addToWhitelist(
         address[] memory accounts
     ) public {
         Whitelistable.WhitelistableStorage storage $ = _getWhitelistableStorage();
-        for (uint256 i = 0; i < accounts.length; i++) {
+        uint256 i = 0;
+        for (; i < accounts.length;) {
             $.isWhitelisted[accounts[i]] = true;
             emit WhitelistUpdated(accounts[i], true);
+            // solhint-disable-next-line no-inline-assembly
+            unchecked {
+                ++i;
+            }
         }
     }
 
+    /// @notice Removes multiple accounts from the whitelist
     function revokeFromWhitelist(
         address[] memory accounts
     ) public {
@@ -48,9 +64,87 @@ library WhitelistableLib {
         }
     }
 
-    function disableWhitelist() public {
+    /// @notice Adds multiple accounts to the blacklist
+    function addToBlacklist(
+        address[] memory accounts
+    ) public {
         Whitelistable.WhitelistableStorage storage $ = _getWhitelistableStorage();
-        $.isActivated = false;
-        emit WhitelistDisabled();
+        uint256 i = 0;
+        for (; i < accounts.length;) {
+            $.isBlacklisted[accounts[i]] = true;
+            emit BlacklistUpdated(accounts[i], true);
+            // solhint-disable-next-line no-inline-assembly
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /// @notice Removes multiple accounts from the blacklist
+    function revokeFromBlacklist(
+        address[] memory accounts
+    ) public {
+        Whitelistable.WhitelistableStorage storage $ = _getWhitelistableStorage();
+        uint256 i = 0;
+        for (; i < accounts.length;) {
+            $.isBlacklisted[accounts[i]] = false;
+            emit BlacklistUpdated(accounts[i], false);
+            // solhint-disable-next-line no-inline-assembly
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    /// @notice Switches the access mode
+    /// @param newMode The new access mode
+    /// @dev Emits an AccessModeUpdated event with the new mode
+    function switchAccessMode(
+        AccessMode newMode
+    ) public {
+        Whitelistable.WhitelistableStorage storage $ = _getWhitelistableStorage();
+
+        $.accessMode = newMode;
+        emit AccessModeUpdated(newMode);
+    }
+
+    /// @notice Sets the external sanctions list
+    function setExternalSanctionsList(
+        SanctionsList externalSanctionList
+    ) public {
+        Whitelistable.WhitelistableStorage storage $ = _getWhitelistableStorage();
+        emit ExternalSanctionsListUpdated(address($.externalSanctionList), address(externalSanctionList));
+        $.externalSanctionList = externalSanctionList;
+    }
+
+    /// @notice Checks if an account is whitelisted or blacklisted
+    /// @dev In v0.6.0, this function is extended to also enforce blacklist checks.
+    /// @param account The address of the account to check
+    /// @return True if the account is whitelisted or not blacklisted, false otherwise
+    function isWhitelisted(
+        address account
+    ) public view returns (bool) {
+        Whitelistable.WhitelistableStorage storage $ = _getWhitelistableStorage();
+        AccessMode _accessMode = $.accessMode;
+
+        if (RolesLib._getRolesStorage().feeRegistry.protocolFeeReceiver() == account) {
+            // if the account is the protocol fee receiver, it is always whitelisted
+            return true;
+        }
+        // if the whitelist is active, we check if the account is whitelisted
+        // if the whitelist is in blacklist mode and the account is blacklisted we return false
+        bool internalListApproval =
+            _accessMode == AccessMode.Whitelist ? $.isWhitelisted[account] : !$.isBlacklisted[account];
+
+        // by default, we consider that the external sanctions list is not set, so we set it to true
+        bool externalListApproval = true;
+
+        // if the external sanctions list is set, we check if the account is not sanctioned
+        if ($.externalSanctionList != SanctionsList(address(0))) {
+            externalListApproval = !$.externalSanctionList.isSanctioned(account);
+        }
+
+        // if the account is whitelisted and not sanctioned, we return true
+        return internalListApproval && externalListApproval;
     }
 }

src/v0.6.0/primitives/Enums.sol

@@ -9,6 +9,11 @@ enum State {
     Closed // The vault is closed; settlement are locked; withdrawals are guaranteed at fixed price per share
 }
 
+// ********************* WHITELISTABLE ********************* //
+enum AccessMode {
+    Blacklist,
+    Whitelist
+}
 // ********************* FEE MANAGER ********************* //
 
 enum FeeType {

src/v0.6.0/primitives/Events.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: BUSL-1.1
 pragma solidity 0.8.26;
 
-import {FeeType, State} from "./Enums.sol";
+import {AccessMode, FeeType, State} from "./Enums.sol";
 import {Rates} from "./Struct.sol";
 
 // ********************* VAULT ********************* //
@@ -46,9 +46,19 @@ event RootUpdated(bytes32 indexed root);
 /// @param authorized Indicates whether the account is authorized (true) or not (false).
 event WhitelistUpdated(address indexed account, bool authorized);
 
+/// @notice Emitted when a blacklist entry is updated.
+/// @param account The address of the account being updated.
+/// @param blacklisted Indicates whether the account is blacklisted (true) or not (false).
+event BlacklistUpdated(address indexed account, bool blacklisted);
+
 /// @notice Emitted when the whitelist is disabled.
 event WhitelistDisabled();
 
+/// @notice Emitted when the external sanctions list is updated.
+/// @param oldExternalSanctionList The old external sanctions list.
+/// @param newExternalSanctionList The new external sanctions list.
+event ExternalSanctionsListUpdated(address oldExternalSanctionList, address newExternalSanctionList);
+
 // ********************* ROLES ********************* //
 
 /// @notice Emitted when the whitelist manager role is updated.
@@ -129,6 +139,10 @@ event TotalAssetsLifespanUpdated(uint128 oldLifespan, uint128 newLifespan);
 /// @param shares Amount of shares minted to owner
 event DepositSync(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
 
+/// @notice Emitted when the access mode is updated.
+/// @param newMode The new access mode (Blacklist or Whitelist).
+event AccessModeUpdated(AccessMode newMode);
+
 /// @notice Emitted when the max cap is updated.
 /// @param previousMaxCap The previous max cap.
 /// @param maxCap The new max cap.