@layerzerolabs/proxy-v5-6-evm-contracts 1.2.20

package/hardhat.config.js

@@ -0,0 +1,58 @@
+require('@matterlabs/hardhat-zksync-solc');
+// `hardhat-deploy` is required by `@layerzerolabs/hardhat-tron`.
+require('hardhat-deploy');
+require('@layerzerolabs/hardhat-tron');
+
+module.exports = {
+    paths: {
+        cache: 'hh-cache',
+    },
+    solidity: {
+        compilers: [
+            {
+                version: '0.8.26',
+                settings: {
+                    evmVersion: 'cancun',
+                    viaIR: true,
+                    optimizer: {
+                        enabled: true,
+                        runs: 20_000,
+                    },
+                    // Making the implicit `hardhat-deploy` behaviour explicit.
+                    // https://github.com/wighawag/hardhat-deploy/blob/v0.12.4/src/index.ts#L317
+                    metadata: { useLiteralContent: true },
+                },
+            },
+        ],
+    },
+    zksolc: {
+        version: '1.5.15',
+        compilerSource: 'binary',
+        settings: {},
+    },
+    tronSolc: {
+        enable: true,
+        compilers: [
+            {
+                version: '0.8.24',
+                settings: {
+                    optimizer: {
+                        enabled: true,
+                        runs: 20_000,
+                    },
+                },
+            },
+        ],
+    },
+    networks: {
+        'zksync-mainnet': {
+            url: 'https://zksync2-mainnet.zksync.io',
+            ethNetwork: 'https://eth-mainnet.public.blastapi.io',
+            zksync: true,
+        },
+        'tron-mainnet': {
+            url: 'http://127.0.0.1:8514/jsonrpc',
+            tron: true,
+        },
+    },
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@layerzerolabs/proxy-v5-6-evm-contracts",
+  "version": "1.2.20",
+  "private": false,
+  "description": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@layerzerolabs/hardhat-tron": "3.0.168",
+    "@layerzerolabs/toolbox-foundry": "^0.1.13",
+    "@matterlabs/hardhat-zksync-solc": "^1.4.0",
+    "@openzeppelin/contracts": "5.6.1",
+    "hardhat-deploy": "^0.12.4",
+    "solhint": "^6.0.1",
+    "@layerzerolabs/solhint-configuration": "1.2.20",
+    "@layerzerolabs/vm-tooling-evm": "1.2.20"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "externalRepoConfig": {
+    "targets": [
+      "audit-external",
+      "console-pen-test",
+      "monorepo-external"
+    ]
+  },
+  "scripts": {
+    "build": "pnpm compile:evm && pnpm compile:zksync && pnpm compile:tron && pnpm flatten:all",
+    "clean": "rm -rf ./node_modules .turbo ./dist && pnpm generated:clean",
+    "compile:evm": "pnpm lz-tool hardhat compile --config ./hardhat.config.js",
+    "compile:tron": "pnpm lz-tool hardhat compile --config ./hardhat.config.js --network tron-mainnet",
+    "compile:zksync": "pnpm lz-tool hardhat compile --config ./hardhat.config.js --network zksync-mainnet",
+    "flatten:all": "mkdir -p ./artifacts-flattened-contracts/contracts && pnpm flatten:proxyadmin2step && pnpm flatten:transparentupgradeableproxy2step",
+    "flatten:proxyadmin2step": "pnpm exec lz-tool -e sol_merger.sh hardhat ./contracts/ProxyAdmin2Step.sol ./artifacts-flattened-contracts/contracts/ProxyAdmin2Step.flattened.sol",
+    "flatten:transparentupgradeableproxy2step": "pnpm exec lz-tool -e sol_merger.sh hardhat ./contracts/TransparentUpgradeableProxy2Step.sol ./artifacts-flattened-contracts/contracts/TransparentUpgradeableProxy2Step.flattened.sol",
+    "generated:clean": "rm -rf ./artifacts* ./hh-cache* ./out ./cache",
+    "lint": "solhint --config solhint.config.js 'contracts/**/*.sol' 'test/**/*.sol' --fix --noPrompt",
+    "test": "pnpm lz-tool forge test",
+    "test:snapshot:check": "pnpm exec turbo-snapshot check",
+    "test:snapshot:update": "pnpm exec turbo-snapshot update"
+  }
+}

package/solhint.config.js

@@ -0,0 +1,3 @@
+const baseConfig = require('@layerzerolabs/solhint-configuration');
+
+module.exports = baseConfig;

package/test/TransparentUpgradeableProxy2Step.t.sol

@@ -0,0 +1,276 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { Ownable2Step } from "@openzeppelin/contracts/access/Ownable2Step.sol";
+import { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import { ERC1967Utils } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
+import { ITransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import { Test } from "forge-std/Test.sol";
+
+import { IProxyAdmin2Step } from "../contracts/interfaces/IProxyAdmin2Step.sol";
+import { ProxyAdmin2Step } from "../contracts/ProxyAdmin2Step.sol";
+import { TransparentUpgradeableProxy2Step } from "../contracts/TransparentUpgradeableProxy2Step.sol";
+
+contract ImplementationV1 {
+    uint256 public value;
+    bool public initialized;
+
+    function initialize() external {
+        initialized = true;
+    }
+
+    function setValue(uint256 _value) external {
+        value = _value;
+    }
+}
+
+contract ImplementationV2 {
+    uint256 public value;
+
+    function setValue(uint256 _value) external {
+        value = _value * 2;
+    }
+}
+
+contract TransparentUpgradeableProxy2StepTest is Test {
+    ImplementationV1 implV1;
+    ImplementationV2 implV2;
+    TransparentUpgradeableProxy2Step proxy;
+    ProxyAdmin2Step proxyAdmin;
+
+    address alice = makeAddr("alice");
+    address bob = makeAddr("bob");
+    address charlie = makeAddr("charlie");
+    address dave = makeAddr("dave");
+
+    function _getProxyAdminAddress(address _proxy) internal view returns (address) {
+        bytes32 adminSlot = vm.load(_proxy, ERC1967Utils.ADMIN_SLOT);
+        return address(uint160(uint256(adminSlot)));
+    }
+
+    function setUp() public {
+        implV1 = new ImplementationV1();
+        implV2 = new ImplementationV2();
+
+        proxy = new TransparentUpgradeableProxy2Step(
+            address(implV1),
+            dave,
+            abi.encodeCall(ImplementationV1.initialize, ())
+        );
+        proxyAdmin = ProxyAdmin2Step(_getProxyAdminAddress(address(proxy)));
+    }
+
+    // ============ Constructor ============
+
+    function test_constructor_DeploysProxyAdmin2StepOwnedByInitialOwner() public view {
+        assertEq(proxyAdmin.owner(), dave);
+        assertEq(proxyAdmin.pendingOwner(), address(0));
+        assertEq(ImplementationV1(address(proxy)).value(), 0);
+        assertTrue(ImplementationV1(address(proxy)).initialized());
+    }
+
+    function test_constructor_RevertsOnEmptyData() public {
+        vm.expectRevert(ERC1967Proxy.ERC1967ProxyUninitialized.selector);
+        new TransparentUpgradeableProxy2Step(address(implV1), dave, "");
+    }
+
+    // ============ transferOwnership ============
+
+    function test_transferOwnership_Success() public {
+        vm.expectEmit(true, true, true, true, address(proxyAdmin));
+        emit Ownable2Step.OwnershipTransferStarted(dave, alice);
+
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(alice);
+
+        assertEq(proxyAdmin.owner(), dave);
+        assertEq(proxyAdmin.pendingOwner(), alice);
+    }
+
+    function test_transferOwnership_Success_OverwritesPending() public {
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(alice);
+        assertEq(proxyAdmin.pendingOwner(), alice);
+
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(bob);
+        assertEq(proxyAdmin.owner(), dave);
+        assertEq(proxyAdmin.pendingOwner(), bob);
+    }
+
+    function test_transferOwnership_Success_CancelsBySettingZero() public {
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(alice);
+        assertEq(proxyAdmin.pendingOwner(), alice);
+
+        vm.expectEmit(true, true, true, true, address(proxyAdmin));
+        emit Ownable2Step.OwnershipTransferStarted(dave, address(0));
+
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(address(0));
+
+        assertEq(proxyAdmin.owner(), dave);
+        assertEq(proxyAdmin.pendingOwner(), address(0));
+
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        vm.prank(alice);
+        proxyAdmin.acceptOwnership();
+    }
+
+    function test_transferOwnership_Revert_Unauthorized() public {
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        vm.prank(alice);
+        proxyAdmin.transferOwnership(bob);
+    }
+
+    function test_transferOwnership_Fuzz(address _newOwner) public {
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(_newOwner);
+
+        assertEq(proxyAdmin.pendingOwner(), _newOwner);
+        assertEq(proxyAdmin.owner(), dave);
+    }
+
+    // ============ acceptOwnership ============
+
+    function test_acceptOwnership_Success() public {
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(alice);
+
+        vm.expectEmit(true, true, true, true, address(proxyAdmin));
+        emit Ownable.OwnershipTransferred(dave, alice);
+
+        vm.prank(alice);
+        proxyAdmin.acceptOwnership();
+
+        assertEq(proxyAdmin.owner(), alice);
+        assertEq(proxyAdmin.pendingOwner(), address(0));
+    }
+
+    function test_acceptOwnership_Revert_NotPendingOwner() public {
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(alice);
+
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, bob));
+        vm.prank(bob);
+        proxyAdmin.acceptOwnership();
+
+        assertEq(proxyAdmin.owner(), dave);
+        assertEq(proxyAdmin.pendingOwner(), alice);
+    }
+
+    function test_acceptOwnership_Revert_NoPendingTransfer() public {
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        vm.prank(alice);
+        proxyAdmin.acceptOwnership();
+    }
+
+    function test_acceptOwnership_Fuzz(address _newOwner) public {
+        vm.assume(_newOwner != address(0));
+        vm.assume(_newOwner != dave);
+
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(_newOwner);
+        vm.prank(_newOwner);
+        proxyAdmin.acceptOwnership();
+
+        assertEq(proxyAdmin.owner(), _newOwner);
+        assertEq(proxyAdmin.pendingOwner(), address(0));
+
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, dave));
+        vm.prank(dave);
+        proxyAdmin.upgradeAndCall(ITransparentUpgradeableProxy(address(proxy)), address(implV2), "");
+
+        vm.prank(_newOwner);
+        proxyAdmin.upgradeAndCall(ITransparentUpgradeableProxy(address(proxy)), address(implV2), "");
+        assertEq(address(uint160(uint256(vm.load(address(proxy), ERC1967Utils.IMPLEMENTATION_SLOT)))), address(implV2));
+    }
+
+    function test_acceptOwnership_Fuzz_Revert_NotPendingOwner(address _newOwner, address _caller) public {
+        vm.assume(_newOwner != address(0));
+        vm.assume(_caller != _newOwner);
+
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(_newOwner);
+
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, _caller));
+        vm.prank(_caller);
+        proxyAdmin.acceptOwnership();
+
+        assertEq(proxyAdmin.owner(), dave);
+        assertEq(proxyAdmin.pendingOwner(), _newOwner);
+    }
+
+    // ============ upgradeAndCall ============
+
+    function test_upgradeAndCall_Success() public {
+        vm.prank(dave);
+        proxyAdmin.upgradeAndCall(ITransparentUpgradeableProxy(address(proxy)), address(implV2), "");
+
+        ImplementationV2(address(proxy)).setValue(4);
+        assertEq(ImplementationV2(address(proxy)).value(), 8);
+    }
+
+    function test_upgradeAndCall_Success_AfterOwnershipTransfer() public {
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(alice);
+        vm.prank(alice);
+        proxyAdmin.acceptOwnership();
+
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, dave));
+        vm.prank(dave);
+        proxyAdmin.upgradeAndCall(ITransparentUpgradeableProxy(address(proxy)), address(implV2), "");
+
+        vm.prank(alice);
+        proxyAdmin.upgradeAndCall(ITransparentUpgradeableProxy(address(proxy)), address(implV2), "");
+
+        ImplementationV2(address(proxy)).setValue(3);
+        assertEq(ImplementationV2(address(proxy)).value(), 6);
+    }
+
+    function test_upgradeAndCall_Revert_Unauthorized() public {
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, charlie));
+        vm.prank(charlie);
+        proxyAdmin.upgradeAndCall(ITransparentUpgradeableProxy(address(proxy)), address(implV2), "");
+    }
+
+    // ============ Fallback ============
+
+    function test_fallback_Revert_ProxyDeniedAdminAccess() public {
+        vm.expectRevert(TransparentUpgradeableProxy2Step.ProxyDeniedAdminAccess.selector);
+        vm.prank(address(proxyAdmin));
+        ImplementationV1(address(proxy)).setValue(1);
+    }
+
+    // ============ renounceOwnership ============
+
+    function test_renounceOwnership_Revert() public {
+        vm.expectRevert(IProxyAdmin2Step.CannotRenounceOwnership.selector);
+        vm.prank(dave);
+        proxyAdmin.renounceOwnership();
+
+        assertEq(proxyAdmin.owner(), dave);
+        assertEq(proxyAdmin.pendingOwner(), address(0));
+    }
+
+    function test_renounceOwnership_Revert_DuringPendingTransfer() public {
+        vm.prank(dave);
+        proxyAdmin.transferOwnership(alice);
+
+        vm.expectRevert(IProxyAdmin2Step.CannotRenounceOwnership.selector);
+        vm.prank(dave);
+        proxyAdmin.renounceOwnership();
+
+        assertEq(proxyAdmin.owner(), dave);
+        assertEq(proxyAdmin.pendingOwner(), alice);
+    }
+
+    function test_renounceOwnership_Fuzz_Revert(address _caller) public {
+        vm.expectRevert(IProxyAdmin2Step.CannotRenounceOwnership.selector);
+        vm.prank(_caller);
+        proxyAdmin.renounceOwnership();
+
+        assertEq(proxyAdmin.owner(), dave);
+    }
+}