Merge pull request #7972 from ethereum-optimism/inphi/mcp-fac

feat(ctb): reusable post-deploy checks

codecov.yml

@@ -33,7 +33,7 @@ flag_management:
   individual_flags:
     - name: contracts-bedrock-tests
       paths:
-        - packages/contracts-bedrock
+        - packages/contracts-bedrock/src
       statuses:
         - type: patch
           target: 100%

packages/contracts-bedrock/scripts/ChainAssertions.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { ProxyAdmin } from "src/universal/ProxyAdmin.sol";
+import { ResourceMetering } from "src/L1/ResourceMetering.sol";
+import { DeployConfig } from "scripts/DeployConfig.s.sol";
+import { SystemConfig } from "src/L1/SystemConfig.sol";
+import { Constants } from "src/libraries/Constants.sol";
+import { L1StandardBridge } from "src/L1/L1StandardBridge.sol";
+import { L2OutputOracle } from "src/L1/L2OutputOracle.sol";
+import { ProtocolVersion, ProtocolVersions } from "src/L1/ProtocolVersions.sol";
+import { OptimismPortal } from "src/L1/OptimismPortal.sol";
+import { L1CrossDomainMessenger } from "src/L1/L1CrossDomainMessenger.sol";
+import { OptimismMintableERC20Factory } from "src/universal/OptimismMintableERC20Factory.sol";
+import { L1ERC721Bridge } from "src/L1/L1ERC721Bridge.sol";
+import { Predeploys } from "src/libraries/Predeploys.sol";
+import { Types } from "scripts/Types.sol";
+import { Vm } from "forge-std/Vm.sol";
+import { ISystemConfigV0 } from "scripts/interfaces/ISystemConfigV0.sol";
+
+library ChainAssertions {
+    /// @notice Asserts the correctness of an L1 deployment
+    function postDeployAssertions(
+        Types.ContractSet memory prox,
+        DeployConfig cfg,
+        uint256 l2OutputOracleStartingTimestamp,
+        Vm vm
+    )
+        internal
+        view
+    {
+        ResourceMetering.ResourceConfig memory rcfg = SystemConfig(prox.SystemConfig).resourceConfig();
+        ResourceMetering.ResourceConfig memory dflt = Constants.DEFAULT_RESOURCE_CONFIG();
+        require(keccak256(abi.encode(rcfg)) == keccak256(abi.encode(dflt)));
+
+        checkSystemConfig(prox, cfg);
+        checkL1CrossDomainMessenger(prox, vm);
+        checkL1StandardBridge(prox, vm);
+        checkL2OutputOracle(prox, cfg, l2OutputOracleStartingTimestamp);
+        checkOptimismMintableERC20Factory(prox);
+        checkL1ERC721Bridge(prox);
+        checkOptimismPortal(prox, cfg);
+        checkProtocolVersions(prox, cfg);
+    }
+
+    /// @notice Asserts that the SystemConfig is setup correctly
+    function checkSystemConfig(Types.ContractSet memory proxies, DeployConfig cfg) internal view {
+        ISystemConfigV0 config = ISystemConfigV0(proxies.SystemConfig);
+        require(config.owner() == cfg.finalSystemOwner());
+        require(config.overhead() == cfg.gasPriceOracleOverhead());
+        require(config.scalar() == cfg.gasPriceOracleScalar());
+        require(config.batcherHash() == bytes32(uint256(uint160(cfg.batchSenderAddress()))));
+        require(config.unsafeBlockSigner() == cfg.p2pSequencerAddress());
+
+        ResourceMetering.ResourceConfig memory rconfig = Constants.DEFAULT_RESOURCE_CONFIG();
+        ResourceMetering.ResourceConfig memory resourceConfig = config.resourceConfig();
+        require(resourceConfig.maxResourceLimit == rconfig.maxResourceLimit);
+        require(resourceConfig.elasticityMultiplier == rconfig.elasticityMultiplier);
+        require(resourceConfig.baseFeeMaxChangeDenominator == rconfig.baseFeeMaxChangeDenominator);
+        require(resourceConfig.systemTxMaxGas == rconfig.systemTxMaxGas);
+        require(resourceConfig.minimumBaseFee == rconfig.minimumBaseFee);
+        require(resourceConfig.maximumBaseFee == rconfig.maximumBaseFee);
+    }
+
+    /// @notice Asserts that the L1CrossDomainMessenger is setup correctly
+    function checkL1CrossDomainMessenger(Types.ContractSet memory proxies, Vm vm) internal view {
+        L1CrossDomainMessenger messenger = L1CrossDomainMessenger(proxies.L1CrossDomainMessenger);
+        require(address(messenger.portal()) == proxies.OptimismPortal);
+        require(address(messenger.PORTAL()) == proxies.OptimismPortal);
+        bytes32 xdmSenderSlot = vm.load(address(messenger), bytes32(uint256(204)));
+        require(address(uint160(uint256(xdmSenderSlot))) == Constants.DEFAULT_L2_SENDER);
+    }
+
+    /// @notice Asserts that the L1StandardBridge is setup correctly
+    function checkL1StandardBridge(Types.ContractSet memory proxies, Vm vm) internal view {
+        L1StandardBridge bridge = L1StandardBridge(payable(proxies.L1StandardBridge));
+        require(address(bridge.MESSENGER()) == proxies.L1CrossDomainMessenger);
+        require(address(bridge.messenger()) == proxies.L1CrossDomainMessenger);
+        require(address(bridge.OTHER_BRIDGE()) == Predeploys.L2_STANDARD_BRIDGE);
+        require(address(bridge.otherBridge()) == Predeploys.L2_STANDARD_BRIDGE);
+        // Ensures that the legacy slot is modified correctly. This will fail
+        // during predeployment simulation on OP Mainnet if there is a bug.
+        bytes32 slot0 = vm.load(address(bridge), bytes32(uint256(0)));
+        require(slot0 == bytes32(uint256(Constants.INITIALIZER)));
+    }
+
+    /// @notice Asserts that the L2OutputOracle is setup correctly
+    function checkL2OutputOracle(
+        Types.ContractSet memory proxies,
+        DeployConfig cfg,
+        uint256 l2OutputOracleStartingTimestamp
+    )
+        internal
+        view
+    {
+        L2OutputOracle oracle = L2OutputOracle(proxies.L2OutputOracle);
+        require(oracle.SUBMISSION_INTERVAL() == cfg.l2OutputOracleSubmissionInterval());
+        require(oracle.submissionInterval() == cfg.l2OutputOracleSubmissionInterval());
+        require(oracle.L2_BLOCK_TIME() == cfg.l2BlockTime());
+        require(oracle.l2BlockTime() == cfg.l2BlockTime());
+        require(oracle.PROPOSER() == cfg.l2OutputOracleProposer());
+        require(oracle.proposer() == cfg.l2OutputOracleProposer());
+        require(oracle.CHALLENGER() == cfg.l2OutputOracleChallenger());
+        require(oracle.challenger() == cfg.l2OutputOracleChallenger());
+        require(oracle.FINALIZATION_PERIOD_SECONDS() == cfg.finalizationPeriodSeconds());
+        require(oracle.finalizationPeriodSeconds() == cfg.finalizationPeriodSeconds());
+        require(oracle.startingBlockNumber() == cfg.l2OutputOracleStartingBlockNumber());
+        require(oracle.startingTimestamp() == l2OutputOracleStartingTimestamp);
+    }
+
+    /// @notice Asserts that the OptimismMintableERC20Factory is setup correctly
+    function checkOptimismMintableERC20Factory(Types.ContractSet memory proxies) internal view {
+        OptimismMintableERC20Factory factory = OptimismMintableERC20Factory(proxies.OptimismMintableERC20Factory);
+        require(factory.BRIDGE() == proxies.L1StandardBridge);
+        require(factory.bridge() == proxies.L1StandardBridge);
+    }
+
+    /// @notice Asserts that the L1ERC721Bridge is setup correctly
+    function checkL1ERC721Bridge(Types.ContractSet memory proxies) internal view {
+        L1ERC721Bridge bridge = L1ERC721Bridge(proxies.L1ERC721Bridge);
+        require(address(bridge.MESSENGER()) == proxies.L1CrossDomainMessenger);
+        require(bridge.OTHER_BRIDGE() == Predeploys.L2_ERC721_BRIDGE);
+    }
+
+    /// @notice Asserts the OptimismPortal is setup correctly
+    function checkOptimismPortal(Types.ContractSet memory proxies, DeployConfig cfg) internal view {
+        OptimismPortal portal = OptimismPortal(payable(proxies.OptimismPortal));
+        require(address(portal.L2_ORACLE()) == proxies.L2OutputOracle);
+        require(portal.GUARDIAN() == cfg.portalGuardian());
+        require(address(portal.SYSTEM_CONFIG()) == proxies.SystemConfig);
+        require(portal.paused() == false);
+    }
+
+    /// @notice Asserts that the ProtocolVersions is setup correctly
+    function checkProtocolVersions(Types.ContractSet memory proxies, DeployConfig cfg) internal view {
+        ProtocolVersions versions = ProtocolVersions(proxies.ProtocolVersions);
+        require(versions.owner() == cfg.finalSystemOwner());
+        require(ProtocolVersion.unwrap(versions.required()) == cfg.requiredProtocolVersion());
+        require(ProtocolVersion.unwrap(versions.recommended()) == cfg.recommendedProtocolVersion());
+    }
+}

packages/contracts-bedrock/scripts/Deploy.s.sol

@@ -43,6 +43,8 @@ import { IBigStepper } from "src/dispute/interfaces/IBigStepper.sol";
 import { IPreimageOracle } from "src/cannon/interfaces/IPreimageOracle.sol";
 import { AlphabetVM } from "test/mocks/AlphabetVM.sol";
 import "src/libraries/DisputeTypes.sol";
+import { ChainAssertions } from "scripts/ChainAssertions.sol";
+import { Types } from "scripts/Types.sol";
 
 /// @title Deploy
 /// @notice Script used to deploy a bedrock system. The entire system is deployed within the `run` function.
@@ -642,33 +644,7 @@ contract Deploy is Deployer {
         string memory version = config.version();
         console.log("SystemConfig version: %s", version);
 
-        require(config.owner() == cfg.finalSystemOwner());
-        require(config.overhead() == cfg.gasPriceOracleOverhead());
-        require(config.scalar() == cfg.gasPriceOracleScalar());
-        require(config.unsafeBlockSigner() == cfg.p2pSequencerAddress());
-        require(config.batcherHash() == batcherHash);
-
-        ResourceMetering.ResourceConfig memory rconfig = Constants.DEFAULT_RESOURCE_CONFIG();
-        ResourceMetering.ResourceConfig memory resourceConfig = config.resourceConfig();
-        require(resourceConfig.maxResourceLimit == rconfig.maxResourceLimit);
-        require(resourceConfig.elasticityMultiplier == rconfig.elasticityMultiplier);
-        require(resourceConfig.baseFeeMaxChangeDenominator == rconfig.baseFeeMaxChangeDenominator);
-        require(resourceConfig.systemTxMaxGas == rconfig.systemTxMaxGas);
-        require(resourceConfig.minimumBaseFee == rconfig.minimumBaseFee);
-        require(resourceConfig.maximumBaseFee == rconfig.maximumBaseFee);
-
-        require(config.l1ERC721Bridge() == mustGetAddress("L1ERC721BridgeProxy"));
-        require(config.l1StandardBridge() == mustGetAddress("L1StandardBridgeProxy"));
-        require(config.l2OutputOracle() == mustGetAddress("L2OutputOracleProxy"));
-        require(config.optimismPortal() == mustGetAddress("OptimismPortalProxy"));
-        require(config.l1CrossDomainMessenger() == mustGetAddress("L1CrossDomainMessengerProxy"));
-
-        // A non zero start block is an override
-        if (startBlock != 0) {
-            require(config.startBlock() == startBlock);
-        } else {
-            require(config.startBlock() == block.number);
-        }
+        ChainAssertions.checkSystemConfig(_proxies(), cfg);
     }
 
     /// @notice Initialize the L1StandardBridge
@@ -698,11 +674,7 @@ contract Deploy is Deployer {
         string memory version = L1StandardBridge(payable(l1StandardBridgeProxy)).version();
         console.log("L1StandardBridge version: %s", version);
 
-        L1StandardBridge bridge = L1StandardBridge(payable(l1StandardBridgeProxy));
-        require(address(bridge.MESSENGER()) == l1CrossDomainMessengerProxy);
-        require(address(bridge.messenger()) == l1CrossDomainMessengerProxy);
-        require(address(bridge.OTHER_BRIDGE()) == Predeploys.L2_STANDARD_BRIDGE);
-        require(address(bridge.otherBridge()) == Predeploys.L2_STANDARD_BRIDGE);
+        ChainAssertions.checkL1StandardBridge(_proxies(), vm);
     }
 
     /// @notice Initialize the L1ERC721Bridge
@@ -721,8 +693,7 @@ contract Deploy is Deployer {
         string memory version = bridge.version();
         console.log("L1ERC721Bridge version: %s", version);
 
-        require(address(bridge.MESSENGER()) == l1CrossDomainMessengerProxy);
-        require(bridge.OTHER_BRIDGE() == Predeploys.L2_ERC721_BRIDGE);
+        ChainAssertions.checkL1ERC721Bridge(_proxies());
     }
 
     /// @notice Ininitialize the OptimismMintableERC20Factory
@@ -741,8 +712,7 @@ contract Deploy is Deployer {
         string memory version = factory.version();
         console.log("OptimismMintableERC20Factory version: %s", version);
 
-        require(factory.BRIDGE() == l1StandardBridgeProxy);
-        require(factory.bridge() == l1StandardBridgeProxy);
+        ChainAssertions.checkOptimismMintableERC20Factory(_proxies());
     }
 
     /// @notice initializeL1CrossDomainMessenger
@@ -786,10 +756,7 @@ contract Deploy is Deployer {
         string memory version = messenger.version();
         console.log("L1CrossDomainMessenger version: %s", version);
 
-        require(address(messenger.PORTAL()) == optimismPortalProxy);
-        require(address(messenger.portal()) == optimismPortalProxy);
-        bytes32 xdmSenderSlot = vm.load(address(messenger), bytes32(uint256(204)));
-        require(address(uint160(uint256(xdmSenderSlot))) == Constants.DEFAULT_L2_SENDER);
+        ChainAssertions.checkL1CrossDomainMessenger(_proxies(), vm);
     }
 
     /// @notice Initialize the L2OutputOracle
@@ -815,18 +782,7 @@ contract Deploy is Deployer {
         string memory version = oracle.version();
         console.log("L2OutputOracle version: %s", version);
 
-        require(oracle.SUBMISSION_INTERVAL() == cfg.l2OutputOracleSubmissionInterval());
-        require(oracle.submissionInterval() == cfg.l2OutputOracleSubmissionInterval());
-        require(oracle.L2_BLOCK_TIME() == cfg.l2BlockTime());
-        require(oracle.l2BlockTime() == cfg.l2BlockTime());
-        require(oracle.PROPOSER() == cfg.l2OutputOracleProposer());
-        require(oracle.proposer() == cfg.l2OutputOracleProposer());
-        require(oracle.CHALLENGER() == cfg.l2OutputOracleChallenger());
-        require(oracle.challenger() == cfg.l2OutputOracleChallenger());
-        require(oracle.FINALIZATION_PERIOD_SECONDS() == cfg.finalizationPeriodSeconds());
-        require(oracle.finalizationPeriodSeconds() == cfg.finalizationPeriodSeconds());
-        require(oracle.startingBlockNumber() == cfg.l2OutputOracleStartingBlockNumber());
-        require(oracle.startingTimestamp() == cfg.l2OutputOracleStartingTimestamp());
+        ChainAssertions.checkL2OutputOracle(_proxies(), cfg, cfg.l2OutputOracleStartingTimestamp());
     }
 
     /// @notice Initialize the OptimismPortal
@@ -854,10 +810,7 @@ contract Deploy is Deployer {
         string memory version = portal.version();
         console.log("OptimismPortal version: %s", version);
 
-        require(address(portal.L2_ORACLE()) == l2OutputOracleProxy);
-        require(portal.GUARDIAN() == cfg.portalGuardian());
-        require(address(portal.SYSTEM_CONFIG()) == systemConfigProxy);
-        require(portal.paused() == false);
+        ChainAssertions.checkOptimismPortal(_proxies(), cfg);
     }
 
     function initializeProtocolVersions() public broadcast {
@@ -885,9 +838,7 @@ contract Deploy is Deployer {
         string memory version = versions.version();
         console.log("ProtocolVersions version: %s", version);
 
-        require(versions.owner() == finalSystemOwner);
-        require(ProtocolVersion.unwrap(versions.required()) == requiredProtocolVersion);
-        require(ProtocolVersion.unwrap(versions.recommended()) == recommendedProtocolVersion);
+        ChainAssertions.checkProtocolVersions(_proxies(), cfg);
     }
 
     /// @notice Transfer ownership of the ProxyAdmin contract to the final system owner
@@ -1008,4 +959,18 @@ contract Deploy is Deployer {
         console.log("StorageSetter version: %s", version);
         addr_ = address(setter);
     }
+
+    /// @notice Returns the proxy addresses
+    function _proxies() private view returns (Types.ContractSet memory proxies_) {
+        proxies_ = Types.ContractSet({
+            L1CrossDomainMessenger: mustGetAddress("L1CrossDomainMessengerProxy"),
+            L1StandardBridge: mustGetAddress("L1StandardBridgeProxy"),
+            L2OutputOracle: mustGetAddress("L2OutputOracleProxy"),
+            OptimismMintableERC20Factory: mustGetAddress("OptimismMintableERC20FactoryProxy"),
+            OptimismPortal: mustGetAddress("OptimismPortalProxy"),
+            SystemConfig: mustGetAddress("SystemConfigProxy"),
+            L1ERC721Bridge: mustGetAddress("L1ERC721BridgeProxy"),
+            ProtocolVersions: mustGetAddress("ProtocolVersionsProxy")
+        });
+    }
 }

packages/contracts-bedrock/scripts/Types.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+library Types {
+    /// @notice Represents a set of L1 contracts. Used to represent a set of proxies.
+    struct ContractSet {
+        address L1CrossDomainMessenger;
+        address L1StandardBridge;
+        address L2OutputOracle;
+        address OptimismMintableERC20Factory;
+        address OptimismPortal;
+        address SystemConfig;
+        address L1ERC721Bridge;
+        address ProtocolVersions;
+    }
+}

packages/contracts-bedrock/scripts/interfaces/ISystemConfigV0.sol

+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+import { ResourceMetering } from "src/L1/ResourceMetering.sol";
+
+/// @title ISystemConfigV0
+/// @notice Minimal interface of the Legacy SystemConfig containing only getters.
+///         Based on
+/// https://github.com/ethereum-optimism/optimism/blob/f54a2234f2f350795552011f35f704a3feb56a08/packages/contracts-bedrock/src/L1/SystemConfig.sol
+interface ISystemConfigV0 {
+    function owner() external view returns (address);
+    function VERSION() external view returns (uint256);
+    function overhead() external view returns (uint256);
+    function scalar() external view returns (uint256);
+    function batcherHash() external view returns (bytes32);
+    function gasLimit() external view returns (uint64);
+    function resourceConfig() external view returns (ResourceMetering.ResourceConfig memory);
+    function unsafeBlockSigner() external view returns (address);
+}