Merge branch 'develop' into cleanup-genesis

packages/contracts-bedrock/.storage-layout

@@ -255,15 +255,11 @@
 
 | Name            | Type                                       | Slot | Offset | Bytes | Contract                                                    |
 |-----------------|--------------------------------------------|------|--------|-------|-------------------------------------------------------------|
-| _owner          | address                                    | 0    | 0      | 20    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
-| gameImpls       | mapping(GameType => contract IDisputeGame) | 1    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
-| disputeGames    | mapping(Hash => contract IDisputeGame)     | 2    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
-| disputeGameList | contract IDisputeGame[]                    | 3    | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
-
-=======================
-➡ contracts/dispute/BondManager.sol:BondManager
-=======================
-
-| Name  | Type                                        | Slot | Offset | Bytes | Contract                                      |
-|-------|---------------------------------------------|------|--------|-------|-----------------------------------------------|
-| bonds | mapping(bytes32 => struct BondManager.Bond) | 0    | 0      | 32    | contracts/dispute/BondManager.sol:BondManager |
+| _initialized    | uint8                                      | 0    | 0      | 1     | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| _initializing   | bool                                       | 0    | 1      | 1     | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| __gap           | uint256[50]                                | 1    | 0      | 1600  | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| _owner          | address                                    | 51   | 0      | 20    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| __gap           | uint256[49]                                | 52   | 0      | 1568  | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| gameImpls       | mapping(GameType => contract IDisputeGame) | 101  | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| disputeGames    | mapping(Hash => contract IDisputeGame)     | 102  | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |
+| disputeGameList | contract IDisputeGame[]                    | 103  | 0      | 32    | contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory |

packages/contracts-bedrock/contracts/L1/OptimismPortal.sol

@@ -140,7 +140,7 @@ contract OptimismPortal is Initializable, ResourceMetering, Semver {
     }
 
     /**
-     * @custom:semver 1.6.0
+     * @custom:semver 1.7.0
      *
      * @param _l2Oracle                  Address of the L2OutputOracle contract.
      * @param _guardian                  Address that can pause deposits and withdrawals.
@@ -152,7 +152,7 @@ contract OptimismPortal is Initializable, ResourceMetering, Semver {
         address _guardian,
         bool _paused,
         SystemConfig _config
-    ) Semver(1, 6, 0) {
+    ) Semver(1, 7, 0) {
         L2_ORACLE = _l2Oracle;
         GUARDIAN = _guardian;
         SYSTEM_CONFIG = _config;

packages/contracts-bedrock/contracts/dispute/BondManager.sol

-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.15;
-
-import "../libraries/DisputeTypes.sol";
-
-import { SafeCall } from "../libraries/SafeCall.sol";
-
-import { IDisputeGame } from "./interfaces/IDisputeGame.sol";
-import { IDisputeGameFactory } from "./interfaces/IDisputeGameFactory.sol";
-import { IBondManager } from "./interfaces/IBondManager.sol";
-
-/**
- * @title BondManager
- * @notice The Bond Manager serves as an escrow for permissionless output proposal bonds.
- */
-contract BondManager is IBondManager {
-    /**
-     * @notice The Bond Type
-     */
-    struct Bond {
-        address owner;
-        bytes32 id;
-        uint128 expiration;
-        uint128 amount;
-    }
-
-    /**
-     * @notice The permissioned dispute game factory.
-     * @dev Used to verify the status of bonds.
-     */
-    IDisputeGameFactory public immutable DISPUTE_GAME_FACTORY;
-
-    /**
-     * @notice Amount of gas used to transfer ether when splitting the bond.
-     *         This is a reasonable amount of gas for a transfer, even to a smart contract.
-     *         The number of participants is bound of by the block gas limit.
-     */
-    uint256 private constant TRANSFER_GAS = 30_000;
-
-    /**
-     * @notice Mapping from bondId to bond.
-     */
-    mapping(bytes32 => Bond) public bonds;
-
-    /**
-     * @notice Instantiates the bond maanger with the registered dispute game factory.
-     * @param _disputeGameFactory is the dispute game factory.
-     */
-    constructor(IDisputeGameFactory _disputeGameFactory) {
-        DISPUTE_GAME_FACTORY = _disputeGameFactory;
-    }
-
-    /**
-     * @inheritdoc IBondManager
-     */
-    function post(
-        bytes32 _bondId,
-        address _bondOwner,
-        uint128 _minClaimHold
-    ) external payable {
-        require(bonds[_bondId].owner == address(0), "BondManager: BondId already posted.");
-        require(_bondOwner != address(0), "BondManager: Owner cannot be the zero address.");
-        require(msg.value > 0, "BondManager: Value must be non-zero.");
-
-        uint128 expiration = uint128(_minClaimHold + block.timestamp);
-        bonds[_bondId] = Bond({
-            owner: _bondOwner,
-            id: _bondId,
-            expiration: expiration,
-            amount: uint128(msg.value)
-        });
-
-        emit BondPosted(_bondId, _bondOwner, expiration, msg.value);
-    }
-
-    /**
-     * @inheritdoc IBondManager
-     */
-    function seize(bytes32 _bondId) external {
-        Bond memory b = bonds[_bondId];
-        require(b.owner != address(0), "BondManager: The bond does not exist.");
-        require(b.expiration >= block.timestamp, "BondManager: Bond expired.");
-
-        IDisputeGame caller = IDisputeGame(msg.sender);
-        IDisputeGame game = DISPUTE_GAME_FACTORY.games(
-            GameTypes.ATTESTATION,
-            caller.rootClaim(),
-            caller.extraData()
-        );
-        require(msg.sender == address(game), "BondManager: Unauthorized seizure.");
-        require(game.status() == GameStatus.CHALLENGER_WINS, "BondManager: Game incomplete.");
-
-        delete bonds[_bondId];
-
-        emit BondSeized(_bondId, b.owner, msg.sender, b.amount);
-
-        bool success = SafeCall.send(payable(msg.sender), gasleft(), b.amount);
-        require(success, "BondManager: Failed to send Ether.");
-    }
-
-    /**
-     * @inheritdoc IBondManager
-     */
-    function seizeAndSplit(bytes32 _bondId, address[] calldata _claimRecipients) external {
-        Bond memory b = bonds[_bondId];
-        require(b.owner != address(0), "BondManager: The bond does not exist.");
-        require(b.expiration >= block.timestamp, "BondManager: Bond expired.");
-
-        IDisputeGame caller = IDisputeGame(msg.sender);
-        IDisputeGame game = DISPUTE_GAME_FACTORY.games(
-            GameTypes.ATTESTATION,
-            caller.rootClaim(),
-            caller.extraData()
-        );
-        require(msg.sender == address(game), "BondManager: Unauthorized seizure.");
-        require(game.status() == GameStatus.CHALLENGER_WINS, "BondManager: Game incomplete.");
-
-        delete bonds[_bondId];
-
-        emit BondSeized(_bondId, b.owner, msg.sender, b.amount);
-
-        uint256 len = _claimRecipients.length;
-        uint256 proportionalAmount = b.amount / len;
-        // Send the proportional amount to each recipient. Do not revert if a send fails as that
-        // will prevent other recipients from receiving their share.
-        for (uint256 i; i < len; i++) {
-            SafeCall.send({
-                _target: payable(_claimRecipients[i]),
-                _gas: TRANSFER_GAS,
-                _value: proportionalAmount
-            });
-        }
-    }
-
-    /**
-     * @inheritdoc IBondManager
-     */
-    function reclaim(bytes32 _bondId) external {
-        Bond memory b = bonds[_bondId];
-        require(b.owner == msg.sender, "BondManager: Unauthorized claimant.");
-        require(b.expiration <= block.timestamp, "BondManager: Bond isn't claimable yet.");
-
-        delete bonds[_bondId];
-
-        emit BondReclaimed(_bondId, msg.sender, b.amount);
-
-        bool success = SafeCall.send(payable(msg.sender), gasleft(), b.amount);
-        require(success, "BondManager: Failed to send Ether.");
-    }
-}

packages/contracts-bedrock/contracts/dispute/DisputeGameFactory.sol

@@ -4,17 +4,20 @@ pragma solidity ^0.8.15;
 import "../libraries/DisputeTypes.sol";
 import "../libraries/DisputeErrors.sol";
 
-import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
 import { ClonesWithImmutableArgs } from "@cwia/ClonesWithImmutableArgs.sol";
+import {
+    OwnableUpgradeable
+} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 import { IDisputeGame } from "./interfaces/IDisputeGame.sol";
 import { IDisputeGameFactory } from "./interfaces/IDisputeGameFactory.sol";
+import { IVersioned } from "./interfaces/IVersioned.sol";
 
 /**
  * @title DisputeGameFactory
  * @notice A factory contract for creating `IDisputeGame` contracts.
  */
-contract DisputeGameFactory is Ownable, IDisputeGameFactory {
+contract DisputeGameFactory is OwnableUpgradeable, IDisputeGameFactory, IVersioned {
     /**
      * @dev Allows for the creation of clone proxies with immutable arguments.
      */
@@ -40,11 +43,27 @@ contract DisputeGameFactory is Ownable, IDisputeGameFactory {
     IDisputeGame[] public disputeGameList;
 
     /**
-     * @notice Constructs a new DisputeGameFactory contract.
+     * @notice Constructs a new DisputeGameFactory contract. Set the owner
+     *         to `address(0)` to prevent accidental usage of the implementation.
+     */
+    constructor() OwnableUpgradeable() {
+        _transferOwnership(address(0));
+    }
+
+    /**
+     * @notice Initializes the contract.
      * @param _owner The owner of the contract.
      */
-    constructor(address _owner) Ownable() {
-        transferOwnership(_owner);
+    function initialize(address _owner) external initializer {
+        __Ownable_init();
+        _transferOwnership(_owner);
+    }
+
+    /**
+     * @inheritdoc IVersioned
+     */
+    function version() external pure returns (string memory) {
+        return "0.0.1";
     }
 
     /**

packages/contracts-bedrock/contracts/libraries/Bytes.sol

@@ -112,20 +112,50 @@ library Bytes {
      * @return Resulting nibble array.
      */
     function toNibbles(bytes memory _bytes) internal pure returns (bytes memory) {
-        uint256 bytesLength = _bytes.length;
-        bytes memory nibbles = new bytes(bytesLength * 2);
-        bytes1 b;
-
-        for (uint256 i = 0; i < bytesLength; ) {
-            b = _bytes[i];
-            nibbles[i * 2] = b >> 4;
-            nibbles[i * 2 + 1] = b & 0x0f;
-            unchecked {
-                ++i;
+        bytes memory _nibbles;
+        assembly {
+            // Grab a free memory offset for the new array
+            _nibbles := mload(0x40)
+
+            // Load the length of the passed bytes array from memory
+            let bytesLength := mload(_bytes)
+
+            // Calculate the length of the new nibble array
+            // This is the length of the input array times 2
+            let nibblesLength := shl(0x01, bytesLength)
+
+            // Update the free memory pointer to allocate memory for the new array.
+            // To do this, we add the length of the new array + 32 bytes for the array length
+            // rounded up to the nearest 32 byte boundary to the current free memory pointer.
+            mstore(0x40, add(_nibbles, and(not(0x1F), add(nibblesLength, 0x3F))))
+
+            // Store the length of the new array in memory
+            mstore(_nibbles, nibblesLength)
+
+            // Store the memory offset of the _bytes array's contents on the stack
+            let bytesStart := add(_bytes, 0x20)
+
+            // Store the memory offset of the nibbles array's contents on the stack
+            let nibblesStart := add(_nibbles, 0x20)
+
+            // Loop through each byte in the input array
+            for {
+                let i := 0x00
+            } lt(i, bytesLength) {
+                i := add(i, 0x01)
+            } {
+                // Get the starting offset of the next 2 bytes in the nibbles array
+                let offset := add(nibblesStart, shl(0x01, i))
+                // Load the byte at the current index within the `_bytes` array
+                let b := byte(0x00, mload(add(bytesStart, i)))
+
+                // Pull out the first nibble and store it in the new array
+                mstore8(offset, shr(0x04, b))
+                // Pull out the second nibble and store it in the new array
+                mstore8(add(offset, 0x01), and(b, 0x0F))
             }
         }
-
-        return nibbles;
+        return _nibbles;
     }
 
     /**

packages/contracts-bedrock/contracts/test/Bytes.t.sol

@@ -182,49 +182,6 @@ contract Bytes_slice_Test is Test {
 }
 
 contract Bytes_toNibbles_Test is Test {
-    /**
-     * @notice Diffs the test Solidity version of `toNibbles` against the Yul version.
-     *
-     * @param _bytes The `bytes` array to convert to nibbles.
-     *
-     * @return Yul version of `toNibbles` applied to `_bytes`.
-     */
-    function _toNibblesYul(bytes memory _bytes) internal pure returns (bytes memory) {
-        // Allocate memory for the `nibbles` array.
-        bytes memory nibbles = new bytes(_bytes.length << 1);
-
-        assembly {
-            // Load the length of the passed bytes array from memory
-            let bytesLength := mload(_bytes)
-
-            // Store the memory offset of the _bytes array's contents on the stack
-            let bytesStart := add(_bytes, 0x20)
-
-            // Store the memory offset of the nibbles array's contents on the stack
-            let nibblesStart := add(nibbles, 0x20)
-
-            // Loop through each byte in the input array
-            for {
-                let i := 0x00
-            } lt(i, bytesLength) {
-                i := add(i, 0x01)
-            } {
-                // Get the starting offset of the next 2 bytes in the nibbles array
-                let offset := add(nibblesStart, shl(0x01, i))
-
-                // Load the byte at the current index within the `_bytes` array
-                let b := byte(0x00, mload(add(bytesStart, i)))
-
-                // Pull out the first nibble and store it in the new array
-                mstore8(offset, shr(0x04, b))
-                // Pull out the second nibble and store it in the new array
-                mstore8(add(offset, 0x01), and(b, 0x0F))
-            }
-        }
-
-        return nibbles;
-    }
-
     /**
      * @notice Tests that, given an input of 5 bytes, the `toNibbles` function returns an array of
      *         10 nibbles corresponding to the input data.
@@ -272,11 +229,49 @@ contract Bytes_toNibbles_Test is Test {
     }
 
     /**
-     * @notice Test that the `toNibbles` function in the `Bytes` library is equivalent to the Yul
-     *         implementation.
+     * @notice Tests that the `toNibbles` function correctly updates the free memory pointer depending
+     *         on the length of the resulting array.
      */
-    function testDiff_toNibbles_succeeds(bytes memory _input) public {
-        assertEq(Bytes.toNibbles(_input), _toNibblesYul(_input));
+    function testFuzz_toNibbles_memorySafety_succeeds(bytes memory _input) public {
+        // Grab the free memory pointer before the `toNibbles` operation
+        uint64 initPtr;
+        assembly {
+            initPtr := mload(0x40)
+        }
+        uint64 expectedPtr = uint64(initPtr + 0x20 + ((_input.length * 2 + 0x1F) & ~uint256(0x1F)));
+
+        // Ensure that all memory outside of the expected range is safe.
+        vm.expectSafeMemory(initPtr, expectedPtr);
+
+        // Pull out each individual nibble from the input bytes array
+        bytes memory nibbles = Bytes.toNibbles(_input);
+
+        // Grab the free memory pointer after the `toNibbles` operation
+        uint64 finalPtr;
+        assembly {
+            finalPtr := mload(0x40)
+        }
+
+        // The free memory pointer should have been updated properly
+        if (_input.length == 0) {
+            // If the input length is zero, only 32 bytes of memory should have been allocated.
+            assertEq(finalPtr, initPtr + 0x20);
+        } else {
+            // If the input length is greater than zero, the memory allocated should be the
+            // length of the input * 2 + 32 bytes for the length field.
+            //
+            // Note that we use a slightly less efficient, but equivalent method of rounding
+            // up `_length` to the next multiple of 32 than is used in the `toNibbles` function.
+            // This is to diff test the method used in `toNibbles`.
+            uint64 _expectedPtr = uint64(initPtr + 0x20 + (((_input.length * 2 + 0x1F) >> 5) << 5));
+            assertEq(finalPtr, _expectedPtr);
+
+            // Sanity check for equivalence of the rounding methods.
+            assertEq(_expectedPtr, expectedPtr);
+        }
+
+        // The nibbles length should be equal to `_length * 2`
+        assertEq(nibbles.length, _input.length << 1);
     }
 }
 

packages/contracts-bedrock/contracts/test/DisputeGameFactory.t.sol

@@ -7,10 +7,10 @@ import "../libraries/DisputeErrors.sol";
 import { Test } from "forge-std/Test.sol";
 import { DisputeGameFactory } from "../dispute/DisputeGameFactory.sol";
 import { IDisputeGame } from "../dispute/interfaces/IDisputeGame.sol";
+import { Proxy } from "../universal/Proxy.sol";
 
-contract DisputeGameFactory_Test is Test {
+contract DisputeGameFactory_Initializer is Test {
     DisputeGameFactory factory;
-    FakeClone fakeClone;
 
     event DisputeGameCreated(
         address indexed disputeProxy,
@@ -20,8 +20,23 @@ contract DisputeGameFactory_Test is Test {
 
     event ImplementationSet(address indexed impl, GameType indexed gameType);
 
-    function setUp() public {
-        factory = new DisputeGameFactory(address(this));
+    function setUp() public virtual {
+        Proxy proxy = new Proxy(address(this));
+        DisputeGameFactory impl = new DisputeGameFactory();
+
+        proxy.upgradeToAndCall({
+            _implementation: address(impl),
+            _data: abi.encodeCall(impl.initialize, (address(this)))
+        });
+        factory = DisputeGameFactory(address(proxy));
+    }
+}
+
+contract DisputeGameFactory_Test is DisputeGameFactory_Initializer {
+    FakeClone fakeClone;
+
+    function setUp() public override {
+        super.setUp();
         fakeClone = new FakeClone();
     }
 

packages/contracts-bedrock/invariant-docs/ResourceMetering.md

 # `ResourceMetering` Invariants
 
+## The base fee should increase if the last block used more than the target amount of gas
+**Test:** [`ResourceMetering.t.sol#L180`](../contracts/test/invariants/ResourceMetering.t.sol#L180)
+
+If the last block used more than the target amount of gas (and there were no empty blocks in between), ensure this block's baseFee increased, but not by more than the max amount per block. 
+
+
+## The base fee should decrease if the last block used less than the target amount of gas
+**Test:** [`ResourceMetering.t.sol#L191`](../contracts/test/invariants/ResourceMetering.t.sol#L191)
+
+If the previous block used less than the target amount of gas, the base fee should decrease, but not more than the max amount. 
+
+
+## A block's base fee should never be below `MINIMUM_BASE_FEE`
+**Test:** [`ResourceMetering.t.sol#L201`](../contracts/test/invariants/ResourceMetering.t.sol#L201)
+
+This test asserts that a block's base fee can never drop below the `MINIMUM_BASE_FEE` threshold. 
+
+
+## A block can never consume more than `MAX_RESOURCE_LIMIT` gas.
+**Test:** [`ResourceMetering.t.sol#L211`](../contracts/test/invariants/ResourceMetering.t.sol#L211)
+
+This test asserts that a block can never consume more than the `MAX_RESOURCE_LIMIT` gas threshold. 
+
+
+## The base fee can never be raised more than the max base fee change.
+**Test:** [`ResourceMetering.t.sol#L222`](../contracts/test/invariants/ResourceMetering.t.sol#L222)
+
+After a block consumes more gas than the target gas, the base fee cannot be raised more than the maximum amount allowed. The max base fee change (per-block) is derived as follows: `prevBaseFee / BASE_FEE_MAX_CHANGE_DENOMINATOR` 
+
+
+## The base fee can never be lowered more than the max base fee change.
+**Test:** [`ResourceMetering.t.sol#L233`](../contracts/test/invariants/ResourceMetering.t.sol#L233)
+
+After a block consumes less than the target gas, the base fee cannot be lowered more than the maximum amount allowed. The max base fee change (per-block) is derived as follows: `prevBaseFee / BASE_FEE_MAX_CHANGE_DENOMINATOR` 
+
+
+## The `maxBaseFeeChange` calculation over multiple blocks can never underflow.
+**Test:** [`ResourceMetering.t.sol#L244`](../contracts/test/invariants/ResourceMetering.t.sol#L244)
+
+When calculating the `maxBaseFeeChange` after multiple empty blocks, the calculation should never be allowed to underflow. 
+
+
 ## The base fee should increase if the last block used more than the target amount of gas
 **Test:** [`FuzzResourceMetering.sol#L158`](../contracts/echidna/FuzzResourceMetering.sol#L158)
 

packages/contracts-bedrock/scripts/eoa-migration.sh

-#!/bin/sh
-
-# RPC endpoint for the migration rehearsal network
-export ETH_RPC_URL="https://mainnet-l1-rehearsal.optimism.io/"
-# export ETH_RPC_URL="localhost:8545"
-
-# Default HH key
-HH_KEY="0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
-# Default HH addr
-HH_ADDR="0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
-
-# SystemDictator contract (deployed by Maurelian on 2023-05-09)
-MSD="0x49149a233de6E4cD6835971506F47EE5862289c1"
-
-# ProxyAdmin contract
-PROXY_ADMIN="0x43cA9bAe8dF108684E5EAaA720C25e1b32B0A075"
-
-# AddressManager contract
-ADDRESS_MANAGER="0xdE1FCfB0851916CA5101820A69b13a4E276bd81F"
-
-# ResolvedDelegateProxy contract
-RESOLVED_DELEGATE_PROXY="0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1"
-
-# L1ChugSplashProxy contract
-# use `setOwner(address)` for this one
-L1_CHUG_SPLASH_PROXY="0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
-
-# Proxy contract
-# use `changeAdmin(address)` for this one
-PROXY="0x5a7749f83b81B301cAb5f48EB8516B986DAef23D"
-
-# OptimismPortal proxy
-PORTAL_PROXY="0x59C4e2c6a6dC27c259D6d067a039c831e1ff4947"
-
-# Check existing owners (should all be $HH_ADDR)
-# cast call $PROXY_ADMIN "owner()(address)"
-# cast call $ADDRESS_MANAGER "owner()(address)" 
-# cast admin $L1_CHUG_SPLASH_PROXY 
-# cast admin $PROXY
-
-# ---
-# Transfer ownership
-# ---
-# cast send --private-key $HH_KEY $PROXY_ADMIN "transferOwnership(address)" $MSD
-# cast send --private-key $HH_KEY $ADDRESS_MANAGER "transferOwnership(address)" $MSD
-# cast send --private-key $HH_KEY $L1_CHUG_SPLASH_PROXY "setOwner(address)" $MSD
-# cast send --private-key $HH_KEY $PROXY "changeAdmin(address)" $MSD
-
-# ---
-# Execute Phase 1
-# ---
-# cast send --private-key $HH_KEY $MSD "phase1()"
-
-# updateDynamicConfig signature
-SIG="updateDynamicConfig((uint256,uint256),bool)"
-# Encode calldata
-CALLDATA=$(cast abi-encode $SIG "(17377105,1685641931)" true)
-# Grab the selector
-SELECTOR=$(cast sig $SIG)
-# Prepare full payload
-PAYLOAD=$(cast --concat-hex $SELECTOR $CALLDATA)
-
-# Sanity check calldata
-# cast pretty-calldata $PAYLOAD
-
-# ---
-# Update dynamic config
-# ---
-# cast send --private-key $HH_KEY $MSD $PAYLOAD
-
-# ---
-# !!!POINT OF NO RETURN!!!
-# Execute phase 2
-# ---
-# cast send --private-key $HH_KEY $MSD "phase2()"
-
-# ---
-# Unpause the portal
-# ---
-# cast send --private-key $HH_KEY $PORTAL_PROXY "unpause()"
-
-# ---
-# Unpause Portal with CallForwarder
-# ---
-
-# Fetch portal guardian
-# cast call $PORTAL_PROXY "GUARDIAN()(address)"
-
-SIG="forward(address,bytes)"
-FORWARD_SIG=$(cast sig $SIG)
-CALLDATA=$(cast abi-encode $SIG $PORTAL_PROXY $(cast sig "unpause()"))
-PAYLOAD=$(cast --concat-hex $FORWARD_SIG $CALLDATA)
-
-# Sanity check calldata
-# cast pretty-calldata $PAYLOAD
-
-# Send unpause tx from multisig
-# cast send "0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A" $PAYLOAD --private-key $HH_KEY
-
-# Check if paused
-# cast call $PORTAL_PROXY "paused()(bool)"
-
-# Check bytecode of multisig
-# cast code "0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A" --rpc-url https://mainnet-l1-rehearsal.optimism.io

packages/contracts-bedrock/scripts/storage-snapshot.sh

@@ -32,7 +32,6 @@ contracts=(
   contracts/universal/OptimismMintableERC20.sol:OptimismMintableERC20
   contracts/universal/OptimismMintableERC20Factory.sol:OptimismMintableERC20Factory
   contracts/dispute/DisputeGameFactory.sol:DisputeGameFactory
-  contracts/dispute/BondManager.sol:BondManager
 )
 
 dir=$(dirname "$0")