feat: operator-sets-3-registration

foundry.toml

@@ -15,6 +15,7 @@ optimizer_runs = 200
 via_ir = false
 # Override the Solidity version (this overrides `auto_detect_solc`)
 solc_version = '0.8.12'
+gas_limit = "18446744073709551615"
 
 [fmt]
 bracket_spacing = false

script/upgrades/ECDSAServiceManagerUpgrade.s.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.12;
+
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {MiddlewareBaseScript} from "./MiddlewareBaseScript.s.sol";
+import {EigenUpgradesLib} from "./EigenUpgradesLib.sol";
+
+/// Replace with your ECDSAServiceManagerBase
+contract ECDSAServiceManagerBaseV2 {
+    constructor() {}
+}
+
+contract UpgradeECDSAServiceManager is MiddlewareBaseScript {
+    function setUp() public virtual override {
+        super.setUp();
+        string memory network = vm.envString("NETWORK");
+        string memory localDeploymentPath = EigenUpgradesLib
+            .getLocalDeploymentConfigPath(network);
+
+        // Load deployment data
+        string memory localDeployment = vm.readFile(localDeploymentPath);
+
+        // Parse deployment data
+        proxyAddress = vm.parseJsonAddress(
+            localDeployment,
+            ".addresses.serviceManager"
+        );
+    }
+
+    function run() public {
+        newImplementation = deployNewImplementation();
+        upgradeContract();
+        address currentImplementation = EigenUpgradesLib
+            .getImplementationAddress(proxyAddress);
+        require(
+            currentImplementation == newImplementation,
+            "Upgrade failed: Implementation address mismatch"
+        );
+    }
+
+    function getProxyAddress(
+        string memory,
+        string memory
+    ) internal view override returns (address) {
+        return proxyAddress;
+    }
+
+    function deployNewImplementation() internal returns (address) {
+        return deployNewImplementation("ECDSAServiceManagerBaseV2", "");
+    }
+}

script/upgrades/ECDSAStakeRegistryContractsUpgrade.s.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.12;
+
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {MiddlewareBaseScript} from "./MiddlewareBaseScript.s.sol";
+import {EigenUpgradesLib} from "./EigenUpgradesLib.sol";
+
+contract ECDSAStakeRegistryBaseV2 {
+    constructor() {}
+}
+
+contract UpgradeECDSAStakeRegistry is MiddlewareBaseScript {
+    function setUp() public virtual override {
+        super.setUp();
+        string memory network = vm.envString("NETWORK");
+        string memory localDeploymentPath = EigenUpgradesLib
+            .getLocalDeploymentConfigPath(network);
+
+        string memory localDeployment = vm.readFile(localDeploymentPath);
+
+        proxyAddress = vm.parseJsonAddress(
+            localDeployment,
+            ".addresses.stakeRegistry"
+        );
+    }
+
+    function run() public {
+        newImplementation = EigenUpgradesLib.deployNewImplementation(
+            "ECDSAStakeRegistryBaseV2",
+            ""
+        );
+
+        upgradeContract();
+
+        address currentImplementation = EigenUpgradesLib
+            .getImplementationAddress(proxyAddress);
+        require(
+            currentImplementation == newImplementation,
+            "Upgrade failed: Implementation address mismatch"
+        );
+    }
+}

script/upgrades/EigenUpgradesLib.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.12;
+
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {Vm} from "forge-std/Vm.sol";
+
+library EigenUpgradesLib {
+    Vm internal constant vm =
+        Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
+    bytes32 internal constant ADMIN_SLOT =
+        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
+
+    bytes32 internal constant IMPLEMENTATION_SLOT =
+        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+
+    function upgradeContract(
+        ProxyAdmin proxyAdmin,
+        address proxy,
+        address newImplementation
+    ) internal {
+        address preUpgradeOwner = Ownable(proxy).owner();
+
+        require(
+            msg.sender == proxyAdmin.owner(),
+            "Caller is not the owner of the proxy admin"
+        );
+        proxyAdmin.upgrade({
+            proxy: TransparentUpgradeableProxy(payable(proxy)),
+            implementation: newImplementation
+        });
+
+        address postUpgradeOwner = Ownable(proxy).owner();
+
+        require(
+            preUpgradeOwner == postUpgradeOwner,
+            "Owner changed after upgrade"
+        );
+    }
+
+    function getAdminAddress(address proxy) internal view returns (address) {
+        bytes32 adminSlot = vm.load(proxy, ADMIN_SLOT);
+        return address(uint160(uint256(adminSlot)));
+    }
+
+    function getImplementationAddress(
+        address proxy
+    ) internal view returns (address) {
+        bytes32 implSlot = vm.load(proxy, IMPLEMENTATION_SLOT);
+        return address(uint160(uint256(implSlot)));
+    }
+
+    function deployNewImplementation(
+        string memory contractName,
+        bytes memory constructorArgs
+    ) internal returns (address) {
+        bytes memory bytecode = abi.encodePacked(
+            vm.getCode(contractName),
+            constructorArgs
+        );
+        address newImplementation;
+        assembly {
+            newImplementation := create(0, add(bytecode, 0x20), mload(bytecode))
+        }
+        require(
+            newImplementation != address(0),
+            "Deployment of new implementation failed"
+        );
+        return newImplementation;
+    }
+
+    function getEigenlayerCoreConfigPath(
+        string memory network
+    ) internal pure returns (string memory) {
+        return
+            string(
+                abi.encodePacked(
+                    "lib/eigenlayer-contracts/script/output/",
+                    network,
+                    "/deployment_output.json"
+                )
+            );
+    }
+
+    function getLocalDeploymentConfigPath(
+        string memory network
+    ) internal pure returns (string memory) {
+        return
+            string(
+                abi.encodePacked("script/output/", network, "/deployment.json")
+            );
+    }
+}

script/upgrades/MiddlewareBaseScript.s.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.12;
+
+import {Script} from "forge-std/Script.sol";
+import {Test} from "forge-std/Test.sol";
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {EigenUpgradesLib} from "./EigenUpgradesLib.sol";
+
+abstract contract MiddlewareBaseScript is Script, Test {
+    ProxyAdmin internal proxyAdmin;
+    address internal proxyAddress;
+    address internal newImplementation;
+
+    function setUp() public virtual {
+        string memory network = vm.envString("NETWORK");
+        string memory eigenlayerConfigPath = EigenUpgradesLib
+            .getEigenlayerCoreConfigPath(network);
+        string memory localConfigPath = EigenUpgradesLib
+            .getLocalDeploymentConfigPath(network);
+
+        string memory eigenlayerConfig = vm.readFile(eigenlayerConfigPath);
+        string memory localConfig = vm.readFile(localConfigPath);
+
+        proxyAddress = getProxyAddress(eigenlayerConfig, localConfig);
+        proxyAdmin = ProxyAdmin(EigenUpgradesLib.getAdminAddress(proxyAddress));
+
+        vm.label(msg.sender, "Caller");
+        vm.label(address(proxyAdmin), "Proxy Admin");
+        vm.label(proxyAdmin.owner(), "Proxy Admin Owner");
+        vm.label(proxyAddress, "Proxy Address");
+    }
+
+    function getProxyAddress(
+        string memory eigenlayerConfig,
+        string memory localConfig
+    ) internal virtual returns (address) {}
+
+    function deployNewImplementation(
+        string memory contractName,
+        bytes memory constructorArgs
+    ) internal virtual returns (address) {
+        return
+            EigenUpgradesLib.deployNewImplementation(
+                contractName,
+                constructorArgs
+            );
+    }
+
+    function upgradeContract() internal virtual {
+        EigenUpgradesLib.upgradeContract(
+            proxyAdmin,
+            proxyAddress,
+            newImplementation
+        );
+    }
+}

script/upgrades/RegistryContractsUpgrade.s.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.12;
+
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {IAVSDirectory} from "eigenlayer-contracts/src/contracts/interfaces/IAVSDirectory.sol";
+import {IRegistryCoordinator} from "../../src/interfaces/IRegistryCoordinator.sol";
+import {IBLSApkRegistry} from "../../src/interfaces/IBLSApkRegistry.sol";
+import {IIndexRegistry} from "../../src/interfaces/IIndexRegistry.sol";
+import {IStakeRegistry} from "../../src/interfaces/IStakeRegistry.sol";
+
+import {Script} from "forge-std/Script.sol";
+import {Test} from "forge-std/Test.sol";
+
+contract RegistryContractsUpgrade is Script, Test {
+    bytes32 internal constant ADMIN_SLOT =
+        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
+
+    bytes32 internal constant IMPLEMENTATION_SLOT =
+        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+
+    ProxyAdmin internal proxyAdmin;
+    address internal registryCoordinatorProxy;
+    address internal blsApkRegistryProxy;
+    address internal indexRegistryProxy;
+    address internal stakeRegistryProxy;
+    address internal newImplementationV2;
+
+    string internal localDeploymentPath;
+    string internal coreDeploymentPath;
+
+    function run() public virtual {
+        string memory network = vm.envString("NETWORK");
+        coreDeploymentPath = string.concat(
+            "lib/eigenlayer-contracts/script/output/",
+            network,
+            "/deployment_output.json"
+        );
+
+        /// This is your local path, so you can import this script into your repo
+        localDeploymentPath = string.concat(
+            "script/output/",
+            network,
+            "/deployment.json"
+        );
+
+        // Load deployment data
+        string memory deploymentOutput = vm.readFile(coreDeploymentPath);
+        string memory localDeployment = vm.readFile(localDeploymentPath);
+
+        // Parse deployment data
+        registryCoordinatorProxy = vm.parseJsonAddress(
+            deploymentOutput,
+            ".addresses.registryCoordinator"
+        );
+        blsApkRegistryProxy = vm.parseJsonAddress(
+            deploymentOutput,
+            ".addresses.blsApkRegistry"
+        );
+        indexRegistryProxy = vm.parseJsonAddress(
+            deploymentOutput,
+            ".addresses.indexRegistry"
+        );
+        stakeRegistryProxy = vm.parseJsonAddress(
+            deploymentOutput,
+            ".addresses.stakeRegistry"
+        );
+
+        proxyAdmin = ProxyAdmin(getAdminAddress(registryCoordinatorProxy));
+        vm.label(msg.sender, "Caller");
+        vm.label(address(proxyAdmin), "Proxy Admin");
+        vm.label(proxyAdmin.owner(), "Proxy Admin Owner");
+
+        vm.startBroadcast();
+        newImplementationV2 = deployNewImplementation("YourContractV2", "");
+
+        _upgradeContract(registryCoordinatorProxy, newImplementationV2);
+        _upgradeContract(blsApkRegistryProxy, newImplementationV2);
+        _upgradeContract(indexRegistryProxy, newImplementationV2);
+        _upgradeContract(stakeRegistryProxy, newImplementationV2);
+
+        vm.stopBroadcast();
+    }
+
+    function _upgradeContract(
+        address proxy,
+        address newImplementation
+    ) internal {
+        address preUpgradeOwner = Ownable(proxy).owner();
+
+        require(
+            msg.sender == proxyAdmin.owner(),
+            "Call with private key for owner of the proxy admin"
+        );
+        proxyAdmin.upgrade({
+            proxy: TransparentUpgradeableProxy(payable(proxy)),
+            implementation: newImplementation
+        });
+
+        address postUpgradeOwner = Ownable(proxy).owner();
+
+        assertEq(preUpgradeOwner, postUpgradeOwner, "Owner changed");
+    }
+
+    function getAdminAddress(address proxy) internal view returns (address) {
+        bytes32 adminSlot = vm.load(proxy, ADMIN_SLOT);
+        return address(uint160(uint256(adminSlot)));
+    }
+
+    function getImplementationAddress(
+        address proxy
+    ) internal view returns (address) {
+        bytes32 implSlot = vm.load(proxy, IMPLEMENTATION_SLOT);
+        return address(uint160(uint256(implSlot)));
+    }
+
+    function deployNewImplementation(
+        string memory contractName,
+        bytes memory constructorArgs
+    ) internal returns (address) {
+        bytes memory bytecode = abi.encodePacked(
+            vm.getCode(contractName),
+            constructorArgs
+        );
+        address newImplementation;
+        assembly {
+            newImplementation := create(0, add(bytecode, 0x20), mload(bytecode))
+        }
+        require(
+            newImplementation != address(0),
+            "Deployment of new implementation failed"
+        );
+        return newImplementation;
+    }
+}