feat: introduce SharedLockbox

packages/contracts-bedrock/interfaces/L1/ILiquidityMigrator.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { ISharedLockbox } from "interfaces/L1/ISharedLockbox.sol";
+
+/// @title ILiquidityMigrator
+/// @notice Interface for the LiquidityMigrator contract
+interface ILiquidityMigrator {
+    event ETHMigrated(uint256 amount);
+
+    function __constructor__(address _sharedLockbox) external;
+
+    function SHARED_LOCKBOX() external view returns (ISharedLockbox);
+
+    function migrateETH() external;
+
+    function version() external view returns (string memory);
+}

packages/contracts-bedrock/interfaces/L1/IOptimismPortal2.sol

@@ -7,6 +7,7 @@ import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol";
 import { IDisputeGameFactory } from "interfaces/dispute/IDisputeGameFactory.sol";
 import { ISystemConfig } from "interfaces/L1/ISystemConfig.sol";
 import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol";
+import { ISharedLockbox } from "interfaces/L1/ISharedLockbox.sol";
 
 interface IOptimismPortal2 {
     error AlreadyFinalized();
@@ -69,6 +70,7 @@ interface IOptimismPortal2 {
     function disputeGameBlacklist(IDisputeGame) external view returns (bool);
     function disputeGameFactory() external view returns (IDisputeGameFactory);
     function disputeGameFinalityDelaySeconds() external view returns (uint256);
+    function sharedLockbox() external view returns (ISharedLockbox);
     function donateETH() external payable;
     function finalizeWithdrawalTransaction(Types.WithdrawalTransaction memory _tx) external;
     function finalizeWithdrawalTransactionExternalProof(

packages/contracts-bedrock/interfaces/L1/IOptimismPortalInterop.sol

@@ -8,6 +8,7 @@ import { IDisputeGameFactory } from "interfaces/dispute/IDisputeGameFactory.sol"
 import { ISystemConfig } from "interfaces/L1/ISystemConfig.sol";
 import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol";
 import { ConfigType } from "interfaces/L2/IL1BlockInterop.sol";
+import { ISharedLockbox } from "interfaces/L1/ISharedLockbox.sol";
 
 interface IOptimismPortalInterop {
     error AlreadyFinalized();
@@ -70,6 +71,7 @@ interface IOptimismPortalInterop {
     function disputeGameBlacklist(IDisputeGame) external view returns (bool);
     function disputeGameFactory() external view returns (IDisputeGameFactory);
     function disputeGameFinalityDelaySeconds() external view returns (uint256);
+    function sharedLockbox() external view returns (ISharedLockbox);
     function donateETH() external payable;
     function finalizeWithdrawalTransaction(Types.WithdrawalTransaction memory _tx) external;
     function finalizeWithdrawalTransactionExternalProof(

packages/contracts-bedrock/interfaces/L1/ISharedLockbox.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { ISemver } from "interfaces/universal/ISemver.sol";
+import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol";
+
+/// @title ISharedLockbox
+/// @notice Interface for the SharedLockbox contract
+interface ISharedLockbox is ISemver {
+    error Unauthorized();
+
+    error Paused();
+
+    event ETHLocked(address indexed portal, uint256 amount);
+
+    event ETHUnlocked(address indexed portal, uint256 amount);
+
+    event PortalAuthorized(address indexed portal);
+
+    function SUPERCHAIN_CONFIG() external view returns (ISuperchainConfig);
+
+    function authorizedPortals(address) external view returns (bool);
+
+    function __constructor__(address _superchainConfig) external;
+
+    function paused() external view returns (bool);
+
+    function unlockETH(uint256 _value) external;
+
+    function lockETH() external payable;
+
+    function authorizePortal(address _portal) external;
+}

packages/contracts-bedrock/interfaces/L1/ISuperchainConfig.sol

@@ -1,7 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-interface ISuperchainConfig {
+import { IDependencySet } from "interfaces/L2/IDependencySet.sol";
+import { ISharedLockbox } from "interfaces/L1/ISharedLockbox.sol";
+
+interface ISuperchainConfig is IDependencySet {
     enum UpdateType {
         GUARDIAN
     }
@@ -10,15 +13,26 @@ interface ISuperchainConfig {
     event Initialized(uint8 version);
     event Paused(string identifier);
     event Unpaused();
+    event ChainAdded(uint256 indexed chainId, address indexed systemConfig, address indexed portal);
+
+    error Unauthorized();
+    error ChainAlreadyHasDependencies();
+    error ChainAlreadyAdded();
 
     function GUARDIAN_SLOT() external view returns (bytes32);
     function PAUSED_SLOT() external view returns (bytes32);
+    function UPGRADER_SLOT() external view returns (bytes32);
+    function SHARED_LOCKBOX() external view returns (ISharedLockbox);
     function guardian() external view returns (address guardian_);
-    function initialize(address _guardian, bool _paused) external;
+    function systemConfigs(uint256) external view returns (address);
+    function upgrader() external view returns (address upgrader_);
+    function initialize(address _guardian, address _upgrader, bool _paused) external;
     function pause(string memory _identifier) external;
     function paused() external view returns (bool paused_);
     function unpause() external;
     function version() external view returns (string memory);
+    function addChain(uint256 _chainId, address _systemConfig) external;
+    function dependencySet() external view returns (uint256[] memory);
 
-    function __constructor__() external;
+    function __constructor__(address _sharedLockbox) external;
 }

packages/contracts-bedrock/interfaces/L1/ISystemConfigInterop.sol

@@ -55,7 +55,7 @@ interface ISystemConfigInterop {
 
     function addDependency(uint256 _chainId) external;
     function removeDependency(uint256 _chainId) external;
-    function dependencyManager() external view returns (address);
+    function dependencyCounter() external view returns (uint256);
     function initialize(
         address _owner,
         uint32 _basefeeScalar,
@@ -65,11 +65,11 @@ interface ISystemConfigInterop {
         address _unsafeBlockSigner,
         IResourceMetering.ResourceConfig memory _config,
         address _batchInbox,
-        ISystemConfig.Addresses memory _addresses,
-        address _dependencyManager
+        ISystemConfig.Addresses memory _addresses
     )
         external;
     function version() external pure returns (string memory);
+    function SUPERCHAIN_CONFIG() external view returns (address);
 
-    function __constructor__() external;
+    function __constructor__(address _superchainConfig) external;
 }

packages/contracts-bedrock/scripts/checks/interfaces/main.go

@@ -26,7 +26,7 @@ var excludeContracts = []string{
 
 	// TODO: Interfaces that need to be fixed
 	"IInitializable", "IOptimismMintableERC20", "ILegacyMintableERC20",
-	"KontrolCheatsBase", "ISystemConfigInterop", "IResolvedDelegateProxy",
+	"KontrolCheatsBase", "IResolvedDelegateProxy",
 }
 
 type ContractDefinition struct {

packages/contracts-bedrock/scripts/deploy/ChainAssertions.sol

@@ -23,6 +23,8 @@ import { IResourceMetering } from "interfaces/L1/IResourceMetering.sol";
 import { ISystemConfig } from "interfaces/L1/ISystemConfig.sol";
 import { IL2OutputOracle } from "interfaces/L1/IL2OutputOracle.sol";
 import { ISuperchainConfig } from "interfaces/L1/ISuperchainConfig.sol";
+import { ISharedLockbox } from "interfaces/L1/ISharedLockbox.sol";
+import { ILiquidityMigrator } from "interfaces/L1/ILiquidityMigrator.sol";
 import { IL1CrossDomainMessenger } from "interfaces/L1/IL1CrossDomainMessenger.sol";
 import { IOptimismPortal } from "interfaces/L1/IOptimismPortal.sol";
 import { IOptimismPortal2 } from "interfaces/L1/IOptimismPortal2.sol";
@@ -142,27 +144,26 @@ library ChainAssertions {
     /// @notice Asserts that the SystemConfigInterop is setup correctly
     function checkSystemConfigInterop(
         Types.ContractSet memory _contracts,
+        Types.ContractSet memory _proxies,
         DeployConfig _cfg,
         bool _isProxy
     )
         internal
         view
     {
         ISystemConfigInterop config = ISystemConfigInterop(_contracts.SystemConfig);
+        ISuperchainConfig superchainConfig = ISuperchainConfig(_proxies.SuperchainConfig);
+
         console.log(
             "Running chain assertions on the SystemConfigInterop %s at %s",
             _isProxy ? "proxy" : "implementation",
             address(config)
         );
 
         checkSystemConfig(_contracts, _cfg, _isProxy);
-        if (_isProxy) {
-            // TODO: this is not being set in the deployment, nor is a config value.
-            // Update this when it has an entry in hardhat.json
-            require(config.dependencyManager() == address(0), "CHECK-SCFGI-10");
-        } else {
-            require(config.dependencyManager() == address(0), "CHECK-SCFGI-20");
-        }
+
+        require(config.dependencyCounter() == 0, "CHECK-SCFGI-10");
+        require(config.SUPERCHAIN_CONFIG() == address(superchainConfig), "CHECK-SCFGI-20");
     }
 
     /// @notice Asserts that the L1CrossDomainMessenger is setup correctly
@@ -586,4 +587,26 @@ library ChainAssertions {
 
         // TODO: Add assertions for blueprints and setters?
     }
+
+    /// @notice Asserts that the SharedLockbox is setup correctly
+    function checkSharedLockbox(Types.ContractSet memory _contracts, bool _isProxy) internal view {
+        ISharedLockbox sharedLockbox = ISharedLockbox(_contracts.SharedLockbox);
+        ISuperchainConfig superchainConfig = ISuperchainConfig(_contracts.SuperchainConfig);
+
+        console.log(
+            "Running chain assertions on the SharedLockbox %s at %s",
+            _isProxy ? "proxy" : "implementation",
+            address(sharedLockbox)
+        );
+
+        require(address(sharedLockbox) != address(0), "CHECK-SLB-10");
+        require(sharedLockbox.SUPERCHAIN_CONFIG() == superchainConfig, "CHECK-SLB-20");
+    }
+
+    /// @notice Asserts that the LiquidityMigrator is setup correctly
+    function checkLiquidityMigrator(Types.ContractSet memory _contracts, address _liquidityMigrator) internal view {
+        ISharedLockbox sharedLockbox = ISharedLockbox(_contracts.SharedLockbox);
+
+        require(ILiquidityMigrator(_liquidityMigrator).SHARED_LOCKBOX() == sharedLockbox, "LM-10");
+    }
 }

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

@@ -129,7 +129,8 @@ contract Deploy is Deployer {
             L1ERC721Bridge: getAddress("L1ERC721BridgeProxy"),
             ProtocolVersions: getAddress("ProtocolVersionsProxy"),
             SuperchainConfig: getAddress("SuperchainConfigProxy"),
-            OPContractsManager: getAddress("OPContractsManager")
+            OPContractsManager: getAddress("OPContractsManager"),
+            SharedLockbox: getAddress("SharedLockboxProxy")
         });
     }
 
@@ -150,7 +151,8 @@ contract Deploy is Deployer {
             L1ERC721Bridge: getAddress("L1ERC721Bridge"),
             ProtocolVersions: getAddress("ProtocolVersions"),
             SuperchainConfig: getAddress("SuperchainConfig"),
-            OPContractsManager: getAddress("OPContractsManager")
+            OPContractsManager: getAddress("OPContractsManager"),
+            SharedLockbox: getAddress("SharedLockbox")
         });
     }
 
@@ -167,9 +169,17 @@ contract Deploy is Deployer {
     /// @notice Deploy a new OP Chain using an existing SuperchainConfig and ProtocolVersions
     /// @param _superchainConfigProxy Address of the existing SuperchainConfig proxy
     /// @param _protocolVersionsProxy Address of the existing ProtocolVersions proxy
-    function runWithSuperchain(address payable _superchainConfigProxy, address payable _protocolVersionsProxy) public {
+    /// @param _sharedLockboxProxy Address of the existing SharedLockbox proxy
+    function runWithSuperchain(
+        address payable _superchainConfigProxy,
+        address payable _protocolVersionsProxy,
+        address payable _sharedLockboxProxy
+    )
+        public
+    {
         require(_superchainConfigProxy != address(0), "Deploy: must specify address for superchain config proxy");
         require(_protocolVersionsProxy != address(0), "Deploy: must specify address for protocol versions proxy");
+        require(_sharedLockboxProxy != address(0), "Deploy: must specify address for shared lockbox proxy");
 
         vm.chainId(cfg.l1ChainID());
 
@@ -183,6 +193,10 @@ contract Deploy is Deployer {
         save("ProtocolVersions", pvProxy.implementation());
         save("ProtocolVersionsProxy", _protocolVersionsProxy);
 
+        IProxy slProxy = IProxy(_sharedLockboxProxy);
+        save("SharedLockbox", slProxy.implementation());
+        save("SharedLockboxProxy", _sharedLockboxProxy);
+
         _run({ _needsSuperchain: false });
     }
 
@@ -255,9 +269,10 @@ contract Deploy is Deployer {
     ////////////////////////////////////////////////////////////////
 
     /// @notice Deploy a full system with a new SuperchainConfig
-    ///         The Superchain system has 2 singleton contracts which lie outside of an OP Chain:
+    ///         The Superchain system has 3 singleton contracts which lie outside of an OP Chain:
     ///         1. The SuperchainConfig contract
     ///         2. The ProtocolVersions contract
+    ///         3. The SharedLockbox contract
     function deploySuperchain() public {
         console.log("Setting up Superchain");
         DeploySuperchain ds = new DeploySuperchain();
@@ -279,11 +294,25 @@ contract Deploy is Deployer {
         save("SuperchainConfig", address(dso.superchainConfigImpl()));
         save("ProtocolVersionsProxy", address(dso.protocolVersionsProxy()));
         save("ProtocolVersions", address(dso.protocolVersionsImpl()));
+        save("SharedLockboxProxy", address(dso.sharedLockboxProxy()));
+        save("SharedLockbox", address(dso.sharedLockboxImpl()));
+        save("LiquidityMigrator", address(dso.liquidityMigratorImpl()));
 
-        // First run assertions for the ProtocolVersions and SuperchainConfig proxy contracts.
+        // First run assertions for the ProtocolVersions, SuperchainConfig and SharedLockbox proxy contracts.
         Types.ContractSet memory contracts = _proxies();
         ChainAssertions.checkProtocolVersions({ _contracts: contracts, _cfg: cfg, _isProxy: true });
         ChainAssertions.checkSuperchainConfig({ _contracts: contracts, _cfg: cfg, _isProxy: true, _isPaused: false });
+        ChainAssertions.checkSharedLockbox({ _contracts: contracts, _isProxy: true });
+
+        // Test the LiquidityMigrator contract is setup correctly.
+        ChainAssertions.checkLiquidityMigrator({
+            _contracts: contracts,
+            _liquidityMigrator: mustGetAddress("LiquidityMigrator")
+        });
+
+        // Then replace the SharedLockbox proxy with the implementation address and run assertions on it.
+        contracts.SharedLockbox = mustGetAddress("SharedLockbox");
+        ChainAssertions.checkSharedLockbox({ _contracts: contracts, _isProxy: false });
 
         // Then replace the ProtocolVersions proxy with the implementation address and run assertions on it.
         contracts.ProtocolVersions = mustGetAddress("ProtocolVersions");
@@ -315,6 +344,7 @@ contract Deploy is Deployer {
         );
         dii.set(dii.superchainConfigProxy.selector, mustGetAddress("SuperchainConfigProxy"));
         dii.set(dii.protocolVersionsProxy.selector, mustGetAddress("ProtocolVersionsProxy"));
+        dii.set(dii.sharedLockboxProxy.selector, mustGetAddress("SharedLockboxProxy"));
         dii.set(dii.salt.selector, _implSalt());
 
         if (_isInterop) {
@@ -364,7 +394,13 @@ contract Deploy is Deployer {
             _oracle: IPreimageOracle(address(dio.preimageOracleSingleton()))
         });
         if (_isInterop) {
-            ChainAssertions.checkSystemConfigInterop({ _contracts: contracts, _cfg: cfg, _isProxy: false });
+            Types.ContractSet memory proxies = _proxies();
+            ChainAssertions.checkSystemConfigInterop({
+                _contracts: contracts,
+                _proxies: proxies,
+                _cfg: cfg,
+                _isProxy: false
+            });
         } else {
             ChainAssertions.checkSystemConfig({ _contracts: contracts, _cfg: cfg, _isProxy: false });
         }