@layerzerolabs/utils-upgradeable-evm-contracts 1.2.19 → 1.2.21

package/contracts/credit-redirect/CreditRedirectBaseUpgradeable.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import { ICreditRedirect } from "@layerzerolabs/utils-evm-contracts/contracts/interfaces/ICreditRedirect.sol";
+import { ICreditRedirectAllowlist } from "@layerzerolabs/utils-evm-contracts/contracts/interfaces/ICreditRedirectAllowlist.sol";
+import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+/**
+ * @title CreditRedirectBaseUpgradeable
+ * @author LayerZero Labs (tinom.eth)
+ * @custom:version 1.0.0
+ * @notice Abstract upgradeable contract that implements configuration to redirect credits from non-allowlisted
+ *         addresses to an escrow address.
+ * @dev No public management functions are exposed by this contract, wrappers should be used with access control.
+ *      Alternatively, refer to `CreditRedirectRBACUpgradeable` for a permissioned implementation.
+ */
+abstract contract CreditRedirectBaseUpgradeable is ICreditRedirect, Initializable {
+    /// @custom:storage-location erc7201:layerzerov2.storage.creditredirect
+    struct CreditRedirectStorage {
+        address allowlist;
+        address escrow;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("layerzerov2.storage.creditredirect")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant CREDIT_REDIRECT_STORAGE_LOCATION =
+        0xb868bd7fc06fef88c81262b11fe9b85cff6f00e2736baf361fa258c33ba8cd00;
+
+    /**
+     * @notice Internal function to get the credit redirect storage.
+     * @return $ Storage pointer
+     */
+    function _getCreditRedirectStorage() internal pure returns (CreditRedirectStorage storage $) {
+        assembly {
+            $.slot := CREDIT_REDIRECT_STORAGE_LOCATION
+        }
+    }
+
+    /**
+     * @notice Initializes the contract.
+     * @dev This function is empty on purpose, as no custom logic is needed.
+     */
+    function __CreditRedirectBase_init() internal onlyInitializing {}
+
+    /**
+     * @notice Unchained initialization function for the contract.
+     * @dev This function is empty on purpose, as no custom logic is needed.
+     */
+    function __CreditRedirectBase_init_unchained() internal onlyInitializing {}
+
+    /**
+     * @inheritdoc ICreditRedirect
+     */
+    function creditRedirectConfig() public view virtual returns (CreditRedirectConfig memory config) {
+        CreditRedirectStorage storage $ = _getCreditRedirectStorage();
+        return CreditRedirectConfig({ allowlist: $.allowlist, escrow: $.escrow });
+    }
+
+    /**
+     * @notice Checks whether a user is allowlisted, for credit redirection purposes.
+     * @param _user Address to check
+     * @return isUserAllowlisted Whether the user is allowlisted
+     */
+    function _isAllowlisted(address _user) internal view virtual returns (bool isUserAllowlisted) {
+        address allowlist = _getCreditRedirectStorage().allowlist;
+        if (allowlist == address(0)) return true;
+        return ICreditRedirectAllowlist(allowlist).isAllowlisted(_user);
+    }
+
+    /**
+     * @notice Redirects a credit to the escrow when the recipient is not allowlisted.
+     * @dev Returns `_to` unchanged when credit redirect is disabled or the recipient is allowlisted.
+     * @param _to Intended credit recipient
+     * @param _amountLD Amount to credit in local decimals
+     * @return recipient Effective credit recipient
+     */
+    function _redirectCredit(address _to, uint256 _amountLD) internal virtual returns (address recipient) {
+        if (!_isAllowlisted(_to)) {
+            /// @dev `escrow` is guaranteed to be non-zero here.
+            address escrow = _getCreditRedirectStorage().escrow;
+            emit CreditRedirected(_to, escrow, _amountLD);
+            return escrow;
+        }
+        return _to;
+    }
+
+    // ============ Internal Functions to Wrap with Access Control ============
+
+    /**
+     * @notice Internal function to set the credit redirect configuration.
+     * @dev `allowlist` and `escrow` must both be set or both be `address(0)` (disabled).
+     * @dev To be wrapped with access control.
+     * @param _config New credit redirect configuration
+     */
+    function _setCreditRedirectConfig(CreditRedirectConfig memory _config) internal virtual {
+        if ((_config.allowlist == address(0)) != (_config.escrow == address(0))) {
+            revert InvalidCreditRedirectConfig();
+        }
+        CreditRedirectStorage storage $ = _getCreditRedirectStorage();
+        $.allowlist = _config.allowlist;
+        $.escrow = _config.escrow;
+        emit CreditRedirectConfigSet(_config);
+    }
+}

package/contracts/credit-redirect/CreditRedirectRBACUpgradeable.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import { ICreditRedirect } from "@layerzerolabs/utils-evm-contracts/contracts/interfaces/ICreditRedirect.sol";
+import { AccessControl2StepUpgradeable } from "./../access/AccessControl2StepUpgradeable.sol";
+import { CreditRedirectBaseUpgradeable } from "./CreditRedirectBaseUpgradeable.sol";
+
+/**
+ * @title CreditRedirectRBACUpgradeable
+ * @author LayerZero Labs (tinom.eth)
+ * @custom:version 1.0.0
+ * @notice Abstract upgradeable contract that implements configuration to redirect credits from non-allowlisted
+ *         addresses to an escrow address.
+ * @dev Exposes public management functions through `AccessControl2StepUpgradeable`.
+ */
+abstract contract CreditRedirectRBACUpgradeable is CreditRedirectBaseUpgradeable, AccessControl2StepUpgradeable {
+    /**
+     * @notice Initializes the contract.
+     * @dev This function is empty on purpose, as no custom logic is needed.
+     */
+    function __CreditRedirectRBAC_init() internal onlyInitializing {}
+
+    /**
+     * @notice Unchained initialization function for the contract.
+     * @dev This function is empty on purpose, as no custom logic is needed.
+     */
+    function __CreditRedirectRBAC_init_unchained() internal onlyInitializing {}
+
+    /**
+     * @inheritdoc ICreditRedirect
+     */
+    function setCreditRedirectConfig(
+        CreditRedirectConfig calldata _config
+    ) public virtual onlyRole(DEFAULT_ADMIN_ROLE) {
+        _setCreditRedirectConfig(_config);
+    }
+}

package/foundry.toml

@@ -1,5 +1,5 @@
 [profile.default]
-solc = '0.8.22'
+solc = '0.8.26'
 verbosity = 3
 src = "contracts"
 test = "test"
@@ -7,7 +7,7 @@ out = "out"
 cache_path = "cache"
 libs = ['node_modules', 'node_modules/@layerzerolabs/toolbox-foundry/lib']
 optimizer = true
-optimizer_runs = 200
+optimizer_runs = 20_000
 
 remappings = [
     'ds-test/=node_modules/@layerzerolabs/toolbox-foundry/lib/ds-test/',

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@layerzerolabs/utils-upgradeable-evm-contracts",
-  "version": "1.2.19",
+  "version": "1.2.21",
   "private": false,
   "description": "LayerZero Labs reference EVM upgradeable utility implementations",
   "license": "MIT",
   "devDependencies": {
     "@layerzerolabs/test-devtools-evm-foundry": "8.0.1",
     "@layerzerolabs/toolbox-foundry": "^0.1.13",
-    "@openzeppelin/contracts": ">=5.0.2 <5.5.0",
-    "@openzeppelin/contracts-upgradeable": ">=5.0.2 <5.5.0",
+    "@openzeppelin/contracts": "^5.0.2",
+    "@openzeppelin/contracts-upgradeable": "^5.0.2",
     "solhint": "^6.0.1",
-    "@layerzerolabs/utils-evm-contracts": "1.2.19",
-    "@layerzerolabs/solhint-configuration": "1.2.19",
-    "@layerzerolabs/vm-tooling-evm": "1.2.19"
+    "@layerzerolabs/utils-evm-contracts": "1.2.21",
+    "@layerzerolabs/vm-tooling-evm": "1.2.21",
+    "@layerzerolabs/solhint-configuration": "1.2.21"
   },
   "publishConfig": {
     "access": "public",

package/test/CreditRedirectBaseUpgradeable.t.sol

@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import { ICreditRedirect } from "@layerzerolabs/utils-evm-contracts/contracts/interfaces/ICreditRedirect.sol";
+import { ICreditRedirectAllowlist } from "@layerzerolabs/utils-evm-contracts/contracts/interfaces/ICreditRedirectAllowlist.sol";
+import { TransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import { Test } from "forge-std/Test.sol";
+import { CreditRedirectBaseUpgradeable } from "./../contracts/credit-redirect/CreditRedirectBaseUpgradeable.sol";
+
+contract CreditRedirectAllowlistMock is ICreditRedirectAllowlist {
+    mapping(address user => bool isAllowlisted) public allowlisted;
+
+    function setAllowlisted(address _user, bool _isAllowlisted) public {
+        allowlisted[_user] = _isAllowlisted;
+    }
+
+    function isAllowlisted(address _user) public view returns (bool isUserAllowlisted) {
+        return allowlisted[_user];
+    }
+}
+
+contract CreditRedirectBaseUpgradeableHarness is CreditRedirectBaseUpgradeable {
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize() public initializer {
+        __CreditRedirectBase_init();
+    }
+
+    function setCreditRedirectConfig(ICreditRedirect.CreditRedirectConfig calldata _config) public {
+        _setCreditRedirectConfig(_config);
+    }
+
+    function isAllowlisted(address _user) public view returns (bool isUserAllowlisted) {
+        return _isAllowlisted(_user);
+    }
+
+    function redirectCredit(address _to, uint256 _amountLD) public returns (address recipient) {
+        return _redirectCredit(_to, _amountLD);
+    }
+}
+
+contract CreditRedirectBaseUpgradeableTest is Test {
+    CreditRedirectBaseUpgradeableHarness public creditRedirect;
+
+    address alice = makeAddr("alice");
+    address bob = makeAddr("bob");
+
+    function _deployCreditRedirect() internal virtual returns (CreditRedirectBaseUpgradeableHarness) {
+        CreditRedirectBaseUpgradeableHarness impl = new CreditRedirectBaseUpgradeableHarness();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(
+            address(impl),
+            address(this),
+            abi.encodeWithSelector(CreditRedirectBaseUpgradeableHarness.initialize.selector)
+        );
+
+        return CreditRedirectBaseUpgradeableHarness(address(proxy));
+    }
+
+    function setUp() public virtual {
+        creditRedirect = _deployCreditRedirect();
+    }
+
+    function test_initialize() public view {
+        ICreditRedirect.CreditRedirectConfig memory config = creditRedirect.creditRedirectConfig();
+        assertEq(config.allowlist, address(0));
+        assertEq(config.escrow, address(0));
+    }
+
+    function test_setCreditRedirectConfig_Set() public {
+        ICreditRedirect.CreditRedirectConfig memory config = ICreditRedirect.CreditRedirectConfig({
+            allowlist: bob,
+            escrow: alice
+        });
+
+        vm.expectEmit(true, true, true, true, address(creditRedirect));
+        emit ICreditRedirect.CreditRedirectConfigSet(config);
+        creditRedirect.setCreditRedirectConfig(config);
+
+        ICreditRedirect.CreditRedirectConfig memory stored = creditRedirect.creditRedirectConfig();
+        assertEq(stored.allowlist, bob);
+        assertEq(stored.escrow, alice);
+    }
+
+    function test_setCreditRedirectConfig_Unset() public {
+        creditRedirect.setCreditRedirectConfig(ICreditRedirect.CreditRedirectConfig({ allowlist: bob, escrow: alice }));
+
+        ICreditRedirect.CreditRedirectConfig memory config = ICreditRedirect.CreditRedirectConfig({
+            allowlist: address(0),
+            escrow: address(0)
+        });
+
+        vm.expectEmit(true, true, true, true, address(creditRedirect));
+        emit ICreditRedirect.CreditRedirectConfigSet(config);
+        creditRedirect.setCreditRedirectConfig(config);
+
+        ICreditRedirect.CreditRedirectConfig memory stored = creditRedirect.creditRedirectConfig();
+        assertEq(stored.allowlist, address(0));
+        assertEq(stored.escrow, address(0));
+    }
+
+    function test_setCreditRedirectConfig_Fuzz(address _allowlist, address _escrow) public {
+        vm.assume((_allowlist == address(0)) == (_escrow == address(0)));
+
+        creditRedirect.setCreditRedirectConfig(
+            ICreditRedirect.CreditRedirectConfig({ allowlist: _allowlist, escrow: _escrow })
+        );
+
+        ICreditRedirect.CreditRedirectConfig memory stored = creditRedirect.creditRedirectConfig();
+        assertEq(stored.allowlist, _allowlist);
+        assertEq(stored.escrow, _escrow);
+    }
+
+    function test_setCreditRedirectConfig_Revert_AllowlistOnly() public {
+        vm.expectRevert(ICreditRedirect.InvalidCreditRedirectConfig.selector);
+        creditRedirect.setCreditRedirectConfig(
+            ICreditRedirect.CreditRedirectConfig({ allowlist: bob, escrow: address(0) })
+        );
+    }
+
+    function test_setCreditRedirectConfig_Revert_EscrowOnly() public {
+        vm.expectRevert(ICreditRedirect.InvalidCreditRedirectConfig.selector);
+        creditRedirect.setCreditRedirectConfig(
+            ICreditRedirect.CreditRedirectConfig({ allowlist: address(0), escrow: alice })
+        );
+    }
+
+    function test_isAllowlisted_NoAllowlist() public view {
+        assertTrue(creditRedirect.isAllowlisted(alice));
+        assertTrue(creditRedirect.isAllowlisted(bob));
+    }
+
+    function test_isAllowlisted_DelegatesToAllowlist() public {
+        CreditRedirectAllowlistMock allowlist = new CreditRedirectAllowlistMock();
+        allowlist.setAllowlisted(alice, true);
+        creditRedirect.setCreditRedirectConfig(
+            ICreditRedirect.CreditRedirectConfig({ allowlist: address(allowlist), escrow: bob })
+        );
+
+        assertTrue(creditRedirect.isAllowlisted(alice));
+        assertFalse(creditRedirect.isAllowlisted(bob));
+    }
+
+    function test_redirectCredit_Disabled() public {
+        assertEq(creditRedirect.redirectCredit(bob, 1 ether), bob);
+    }
+
+    function test_redirectCredit_Allowlisted() public {
+        CreditRedirectAllowlistMock allowlist = new CreditRedirectAllowlistMock();
+        allowlist.setAllowlisted(bob, true);
+        creditRedirect.setCreditRedirectConfig(
+            ICreditRedirect.CreditRedirectConfig({ allowlist: address(allowlist), escrow: alice })
+        );
+
+        assertEq(creditRedirect.redirectCredit(bob, 1 ether), bob);
+    }
+
+    function test_redirectCredit_NotAllowlisted() public {
+        CreditRedirectAllowlistMock allowlist = new CreditRedirectAllowlistMock();
+        creditRedirect.setCreditRedirectConfig(
+            ICreditRedirect.CreditRedirectConfig({ allowlist: address(allowlist), escrow: alice })
+        );
+
+        vm.expectEmit(true, true, true, true, address(creditRedirect));
+        emit ICreditRedirect.CreditRedirected(bob, alice, 1 ether);
+        assertEq(creditRedirect.redirectCredit(bob, 1 ether), alice);
+    }
+
+    function test_storageHash() public pure {
+        bytes32 storageHash = keccak256(abi.encode(uint256(keccak256("layerzerov2.storage.creditredirect")) - 1)) &
+            ~bytes32(uint256(0xff));
+        assertEq(storageHash, 0xb868bd7fc06fef88c81262b11fe9b85cff6f00e2736baf361fa258c33ba8cd00);
+    }
+}

package/test/CreditRedirectRBACUpgradeable.t.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import { ICreditRedirect } from "@layerzerolabs/utils-evm-contracts/contracts/interfaces/ICreditRedirect.sol";
+import { IAccessControl } from "@openzeppelin/contracts/access/IAccessControl.sol";
+import { TransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import { CreditRedirectRBACUpgradeable } from "./../contracts/credit-redirect/CreditRedirectRBACUpgradeable.sol";
+import {
+    CreditRedirectBaseUpgradeableTest,
+    CreditRedirectBaseUpgradeableHarness
+} from "./CreditRedirectBaseUpgradeable.t.sol";
+
+contract CreditRedirectRBACUpgradeableHarness is CreditRedirectRBACUpgradeable {
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address _initialAdmin) public initializer {
+        __AccessControl2Step_init(_initialAdmin);
+        __CreditRedirectBase_init();
+    }
+
+    function isAllowlisted(address _user) public view returns (bool isUserAllowlisted) {
+        return _isAllowlisted(_user);
+    }
+
+    function redirectCredit(address _to, uint256 _amountLD) public returns (address recipient) {
+        return _redirectCredit(_to, _amountLD);
+    }
+}
+
+contract CreditRedirectRBACUpgradeableTest is CreditRedirectBaseUpgradeableTest {
+    address charlie = makeAddr("charlie");
+    CreditRedirectRBACUpgradeableHarness creditRedirectRbac;
+
+    function _deployCreditRedirect() internal virtual override returns (CreditRedirectBaseUpgradeableHarness) {
+        CreditRedirectRBACUpgradeableHarness impl = new CreditRedirectRBACUpgradeableHarness();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(
+            address(impl),
+            address(this),
+            abi.encodeWithSelector(CreditRedirectRBACUpgradeableHarness.initialize.selector, address(this))
+        );
+
+        return CreditRedirectBaseUpgradeableHarness(address(proxy));
+    }
+
+    function setUp() public override {
+        super.setUp();
+        creditRedirectRbac = CreditRedirectRBACUpgradeableHarness(address(creditRedirect));
+    }
+
+    function test_setCreditRedirectConfig_Revert_Unauthorized() public {
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                IAccessControl.AccessControlUnauthorizedAccount.selector,
+                charlie,
+                creditRedirectRbac.DEFAULT_ADMIN_ROLE()
+            )
+        );
+        vm.prank(charlie);
+        creditRedirect.setCreditRedirectConfig(ICreditRedirect.CreditRedirectConfig({ allowlist: bob, escrow: alice }));
+    }
+}