Merge branch 'develop' into coverage/badge-and-ignore

.changeset/red-lemons-rhyme.md

+---
+'@eth-optimism/l2geth': patch
+---
+
+Fixes a small l2geth bug when trying to dump state

.changeset/smart-moles-add.md

+---
+'@eth-optimism/ci-builder': patch
+---
+
+Update geth to 1.10.25

indexer/services/l1/bridge/bridge.go.orig

-package bridge
-
-import (
-	"context"
-	"errors"
-	"math/big"
-
-	"github.com/ethereum-optimism/optimism/indexer/bindings/legacy/scc"
-	"github.com/ethereum-optimism/optimism/indexer/db"
-	"github.com/ethereum-optimism/optimism/indexer/services"
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-)
-
-// DepositsMap is a collection of deposit objects keyed
-// on block hashes.
-type DepositsMap map[common.Hash][]db.Deposit
-<<<<<<< HEAD
-
-// WithdrawalsMap is a collection of withdrawal objects keyed
-// on block hashes.
-type WithdrawalsMap map[common.Hash][]db.Withdrawal
-
-// FinalizedWithdrawalsMap is a collection of finalized withdrawal
-// objected keyed on block hashes.
-=======
-type InitiatedWithdrawalMap map[common.Hash][]db.Withdrawal
->>>>>>> 22c039efc (indexer: Upgrade L1 services)
-type FinalizedWithdrawalsMap map[common.Hash][]db.FinalizedWithdrawal
-
-type Bridge interface {
-	Address() common.Address
-	GetDepositsByBlockRange(context.Context, uint64, uint64) (DepositsMap, error)
-	String() string
-}
-
-type implConfig struct {
-	name string
-	impl string
-	addr common.Address
-}
-
-var customBridgeCfgs = map[uint64][]*implConfig{
-	// Mainnet
-	1: {
-		{"BitBTC", "StandardBridge", common.HexToAddress("0xaBA2c5F108F7E820C049D5Af70B16ac266c8f128")},
-		{"DAI", "StandardBridge", common.HexToAddress("0x10E6593CDda8c58a1d0f14C5164B376352a55f2F")},
-		{"wstETH", "StandardBridge", common.HexToAddress("0x76943C0D61395d8F2edF9060e1533529cAe05dE6")},
-	},
-	// Kovan
-	42: {
-		{"BitBTC", "StandardBridge", common.HexToAddress("0x0b651A42F32069d62d5ECf4f2a7e5Bd3E9438746")},
-		{"USX", "StandardBridge", common.HexToAddress("0x40E862341b2416345F02c41Ac70df08525150dC7")},
-		{"DAI", "StandardBridge", common.HexToAddress("0xb415e822C4983ecD6B1c1596e8a5f976cf6CD9e3")},
-		{"wstETH", "StandardBridge", common.HexToAddress("0x65321bf24210b81500230dCEce14Faa70a9f50a7")},
-	},
-}
-
-func BridgesByChainID(chainID *big.Int, client bind.ContractBackend, addrs services.AddressManager) (map[string]Bridge, error) {
-	l1SBAddr, _ := addrs.L1StandardBridge()
-	allCfgs := []*implConfig{
-		{"Standard", "StandardBridge", l1SBAddr},
-		{"ETH", "ETHBridge", l1SBAddr},
-	}
-	allCfgs = append(allCfgs, customBridgeCfgs[chainID.Uint64()]...)
-
-	bridges := make(map[string]Bridge)
-	for _, bridge := range allCfgs {
-		switch bridge.impl {
-		case "StandardBridge":
-			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
-			if err != nil {
-				return nil, err
-			}
-			standardBridge := &StandardBridge{
-				name:     bridge.name,
-				address:  bridge.addr,
-				contract: l1SB,
-			}
-			bridges[bridge.name] = standardBridge
-		case "ETHBridge":
-			l1SB, err := bindings.NewL1StandardBridge(bridge.addr, client)
-			if err != nil {
-				return nil, err
-			}
-			ethBridge := &EthBridge{
-				name:     bridge.name,
-				address:  bridge.addr,
-				contract: l1SB,
-			}
-			bridges[bridge.name] = ethBridge
-		default:
-			return nil, errors.New("unsupported bridge")
-		}
-	}
-	return bridges, nil
-}
-
-func StateCommitmentChainScanner(client bind.ContractFilterer, addrs services.AddressManager) (*scc.StateCommitmentChainFilterer, error) {
-	sccAddr, _ := addrs.StateCommitmentChain()
-	filter, err := scc.NewStateCommitmentChainFilterer(sccAddr, client)
-	if err != nil {
-		return nil, err
-	}
-	return filter, nil
-}

l2geth/statedumper/dumper.go

@@ -2,10 +2,11 @@ package statedumper
 
 import (
 	"fmt"
-	"github.com/ethereum-optimism/optimism/l2geth/common"
 	"io"
 	"os"
 	"sync"
+
+	"github.com/ethereum-optimism/optimism/l2geth/common"
 )
 
 type StateDumper interface {
@@ -21,7 +22,7 @@ func NewStateDumper() StateDumper {
 		return &noopStateDumper{}
 	}
 
-	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE, 0o755)
+	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o755)
 	if err != nil {
 		panic(err)
 	}

op-bindings/Makefile

@@ -108,7 +108,7 @@ more:
 	go run ./gen/main.go \
 		-artifacts ../packages/contracts-bedrock/artifacts \
 		-out ./bindings \
-		-contracts OptimismMintableERC20Factory,L2StandardBridge,L1BlockNumber,LegacyMessagePasser,DeployerWhitelist,Proxy,OptimismPortal,L2ToL1MessagePasser,L2CrossDomainMessenger,GasPriceOracle,SequencerFeeVault,L1Block,LegacyERC20ETH,WETH9,GovernanceToken,L1CrossDomainMessenger,L2ERC721Bridge,OptimismMintableERC721Factory \
+		-contracts OptimismMintableERC20Factory,L2StandardBridge,L1BlockNumber,LegacyMessagePasser,DeployerWhitelist,Proxy,OptimismPortal,L2ToL1MessagePasser,L2CrossDomainMessenger,GasPriceOracle,SequencerFeeVault,L1Block,LegacyERC20ETH,WETH9,GovernanceToken,L1CrossDomainMessenger,L2ERC721Bridge,OptimismMintableERC721Factory,ProxyAdmin \
 		-package bindings
 
 mkdir:

op-bindings/README.md

+# op-bindings
+
+This package contains built go bindings of the smart contracts. It must be
+updated after any changes to the smart contracts to ensure that the bindings are
+up to date.
+
+The bindings include the bytecode for each contract so that go based tests
+can deploy the contracts. There are also `more` files that include the deployed
+bytecode as well as the storage layout. These are used to dynamically set
+bytecode and storage slots in state.
+
+## Dependencies
+
+- `abigen` version 1.10.25
+- `make`
+
+To check the version of `abigen`, run the command `abigen --version`.
+
+## abigen
+
+The `abigen` tool is part of `go-ethereum` and can be used to build go bindings
+for smart contracts. It can be installed with go using the commands:
+
+```bash
+$ go get -u github.com/ethereum/go-ethereum
+$ cd $GOPATH/src/github.com/ethereum/go-ethereum/
+$ make devtools
+```
+
+The geth docs for `abigen` can be found [here](https://geth.ethereum.org/docs/dapp/native-bindings).

op-bindings/bindings/deployerwhitelist_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const DeployerWhitelistStorageLayoutJSON = "{\"storage\":[{\"astId\":3252,\"contract\":\"contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist\",\"label\":\"owner\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":3257,\"contract\":\"contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist\",\"label\":\"whitelist\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_bool)\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_mapping(t_address,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_bool\"}}}"
+const DeployerWhitelistStorageLayoutJSON = "{\"storage\":[{\"astId\":3248,\"contract\":\"contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist\",\"label\":\"owner\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":3253,\"contract\":\"contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist\",\"label\":\"whitelist\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_bool)\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_mapping(t_address,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_bool\"}}}"
 
 var DeployerWhitelistStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/gaspriceoracle_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const GasPriceOracleStorageLayoutJSON = "{\"storage\":[{\"astId\":28501,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":1951,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"spacer_1_0_32\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"},{\"astId\":1954,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"spacer_2_0_32\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":1957,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"overhead\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_uint256\"},{\"astId\":1960,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"scalar\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_uint256\"},{\"astId\":1963,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"decimals\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_uint256\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+const GasPriceOracleStorageLayoutJSON = "{\"storage\":[{\"astId\":28513,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":1953,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"spacer_1_0_32\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"},{\"astId\":1956,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"spacer_2_0_32\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":1959,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"overhead\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_uint256\"},{\"astId\":1962,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"scalar\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_uint256\"},{\"astId\":1965,\"contract\":\"contracts/L2/GasPriceOracle.sol:GasPriceOracle\",\"label\":\"decimals\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_uint256\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
 
 var GasPriceOracleStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/governancetoken_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const GovernanceTokenStorageLayoutJSON = "{\"storage\":[{\"astId\":28851,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_balances\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_uint256)\"},{\"astId\":28857,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_allowances\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":28859,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_totalSupply\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":28861,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_name\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_string_storage\"},{\"astId\":28863,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_symbol\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_string_storage\"},{\"astId\":30228,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_nonces\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_mapping(t_address,t_struct(Counter)32414_storage)\"},{\"astId\":30236,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_PERMIT_TYPEHASH_DEPRECATED_SLOT\",\"offset\":0,\"slot\":\"6\",\"type\":\"t_bytes32\"},{\"astId\":29569,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_delegates\",\"offset\":0,\"slot\":\"7\",\"type\":\"t_mapping(t_address,t_address)\"},{\"astId\":29575,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_checkpoints\",\"offset\":0,\"slot\":\"8\",\"type\":\"t_mapping(t_address,t_array(t_struct(Checkpoint)29560_storage)dyn_storage)\"},{\"astId\":29579,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_totalSupplyCheckpoints\",\"offset\":0,\"slot\":\"9\",\"type\":\"t_array(t_struct(Checkpoint)29560_storage)dyn_storage\"},{\"astId\":28501,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"10\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_struct(Checkpoint)29560_storage)dyn_storage\":{\"encoding\":\"dynamic_array\",\"label\":\"struct ERC20Votes.Checkpoint[]\",\"numberOfBytes\":\"32\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_address,t_address)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e address)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_address\"},\"t_mapping(t_address,t_array(t_struct(Checkpoint)29560_storage)dyn_storage)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e struct ERC20Votes.Checkpoint[])\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_array(t_struct(Checkpoint)29560_storage)dyn_storage\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_struct(Counter)32414_storage)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e struct Counters.Counter)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_struct(Counter)32414_storage\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_string_storage\":{\"encoding\":\"bytes\",\"label\":\"string\",\"numberOfBytes\":\"32\"},\"t_struct(Checkpoint)29560_storage\":{\"encoding\":\"inplace\",\"label\":\"struct ERC20Votes.Checkpoint\",\"numberOfBytes\":\"32\"},\"t_struct(Counter)32414_storage\":{\"encoding\":\"inplace\",\"label\":\"struct Counters.Counter\",\"numberOfBytes\":\"32\"},\"t_uint224\":{\"encoding\":\"inplace\",\"label\":\"uint224\",\"numberOfBytes\":\"28\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint32\":{\"encoding\":\"inplace\",\"label\":\"uint32\",\"numberOfBytes\":\"4\"}}}"
+const GovernanceTokenStorageLayoutJSON = "{\"storage\":[{\"astId\":28863,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_balances\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_uint256)\"},{\"astId\":28869,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_allowances\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":28871,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_totalSupply\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":28873,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_name\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_string_storage\"},{\"astId\":28875,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_symbol\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_string_storage\"},{\"astId\":30240,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_nonces\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_mapping(t_address,t_struct(Counter)32426_storage)\"},{\"astId\":30248,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_PERMIT_TYPEHASH_DEPRECATED_SLOT\",\"offset\":0,\"slot\":\"6\",\"type\":\"t_bytes32\"},{\"astId\":29581,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_delegates\",\"offset\":0,\"slot\":\"7\",\"type\":\"t_mapping(t_address,t_address)\"},{\"astId\":29587,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_checkpoints\",\"offset\":0,\"slot\":\"8\",\"type\":\"t_mapping(t_address,t_array(t_struct(Checkpoint)29572_storage)dyn_storage)\"},{\"astId\":29591,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_totalSupplyCheckpoints\",\"offset\":0,\"slot\":\"9\",\"type\":\"t_array(t_struct(Checkpoint)29572_storage)dyn_storage\"},{\"astId\":28513,\"contract\":\"contracts/L2/GovernanceToken.sol:GovernanceToken\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"10\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_struct(Checkpoint)29572_storage)dyn_storage\":{\"encoding\":\"dynamic_array\",\"label\":\"struct ERC20Votes.Checkpoint[]\",\"numberOfBytes\":\"32\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_address,t_address)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e address)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_address\"},\"t_mapping(t_address,t_array(t_struct(Checkpoint)29572_storage)dyn_storage)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e struct ERC20Votes.Checkpoint[])\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_array(t_struct(Checkpoint)29572_storage)dyn_storage\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_struct(Counter)32426_storage)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e struct Counters.Counter)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_struct(Counter)32426_storage\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_string_storage\":{\"encoding\":\"bytes\",\"label\":\"string\",\"numberOfBytes\":\"32\"},\"t_struct(Checkpoint)29572_storage\":{\"encoding\":\"inplace\",\"label\":\"struct ERC20Votes.Checkpoint\",\"numberOfBytes\":\"32\"},\"t_struct(Counter)32426_storage\":{\"encoding\":\"inplace\",\"label\":\"struct Counters.Counter\",\"numberOfBytes\":\"32\"},\"t_uint224\":{\"encoding\":\"inplace\",\"label\":\"uint224\",\"numberOfBytes\":\"28\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint32\":{\"encoding\":\"inplace\",\"label\":\"uint32\",\"numberOfBytes\":\"4\"}}}"
 
 var GovernanceTokenStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l1block_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L1BlockStorageLayoutJSON = "{\"storage\":[{\"astId\":2298,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"number\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_uint64\"},{\"astId\":2301,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"timestamp\",\"offset\":8,\"slot\":\"0\",\"type\":\"t_uint64\"},{\"astId\":2304,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"basefee\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"},{\"astId\":2307,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"hash\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_bytes32\"},{\"astId\":2310,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"sequenceNumber\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_uint64\"}],\"types\":{\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint64\":{\"encoding\":\"inplace\",\"label\":\"uint64\",\"numberOfBytes\":\"8\"}}}"
+const L1BlockStorageLayoutJSON = "{\"storage\":[{\"astId\":2300,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"number\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_uint64\"},{\"astId\":2303,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"timestamp\",\"offset\":8,\"slot\":\"0\",\"type\":\"t_uint64\"},{\"astId\":2306,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"basefee\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_uint256\"},{\"astId\":2309,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"hash\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_bytes32\"},{\"astId\":2312,\"contract\":\"contracts/L2/L1Block.sol:L1Block\",\"label\":\"sequenceNumber\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_uint64\"}],\"types\":{\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint64\":{\"encoding\":\"inplace\",\"label\":\"uint64\",\"numberOfBytes\":\"8\"}}}"
 
 var L1BlockStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l1crossdomainmessenger_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L1CrossDomainMessengerStorageLayoutJSON = "{\"storage\":[{\"astId\":24892,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27878,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_initialized\",\"offset\":20,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":27881,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_initializing\",\"offset\":21,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":28492,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_array(t_uint256)50_storage\"},{\"astId\":27750,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_address\"},{\"astId\":27870,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"52\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":28043,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_paused\",\"offset\":0,\"slot\":\"101\",\"type\":\"t_bool\"},{\"astId\":28148,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"102\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":28163,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_status\",\"offset\":0,\"slot\":\"151\",\"type\":\"t_uint256\"},{\"astId\":28207,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"152\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":24944,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_201_0_32\",\"offset\":0,\"slot\":\"201\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24949,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_202_0_32\",\"offset\":0,\"slot\":\"202\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24954,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"successfulMessages\",\"offset\":0,\"slot\":\"203\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24957,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"xDomainMsgSender\",\"offset\":0,\"slot\":\"204\",\"type\":\"t_address\"},{\"astId\":24960,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"msgNonce\",\"offset\":0,\"slot\":\"205\",\"type\":\"t_uint240\"},{\"astId\":24965,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"receivedMessages\",\"offset\":0,\"slot\":\"206\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24970,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"207\",\"type\":\"t_array(t_uint256)42_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)42_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[42]\",\"numberOfBytes\":\"1344\"},\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_array(t_uint256)50_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[50]\",\"numberOfBytes\":\"1600\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint240\":{\"encoding\":\"inplace\",\"label\":\"uint240\",\"numberOfBytes\":\"30\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
+const L1CrossDomainMessengerStorageLayoutJSON = "{\"storage\":[{\"astId\":24904,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27890,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_initialized\",\"offset\":20,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":27893,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_initializing\",\"offset\":21,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":28504,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_array(t_uint256)50_storage\"},{\"astId\":27762,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_address\"},{\"astId\":27882,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"52\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":28055,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_paused\",\"offset\":0,\"slot\":\"101\",\"type\":\"t_bool\"},{\"astId\":28160,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"102\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":28175,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"_status\",\"offset\":0,\"slot\":\"151\",\"type\":\"t_uint256\"},{\"astId\":28219,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"152\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":24956,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_201_0_32\",\"offset\":0,\"slot\":\"201\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24961,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"spacer_202_0_32\",\"offset\":0,\"slot\":\"202\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24966,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"successfulMessages\",\"offset\":0,\"slot\":\"203\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24969,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"xDomainMsgSender\",\"offset\":0,\"slot\":\"204\",\"type\":\"t_address\"},{\"astId\":24972,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"msgNonce\",\"offset\":0,\"slot\":\"205\",\"type\":\"t_uint240\"},{\"astId\":24977,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"receivedMessages\",\"offset\":0,\"slot\":\"206\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24982,\"contract\":\"contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"207\",\"type\":\"t_array(t_uint256)42_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)42_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[42]\",\"numberOfBytes\":\"1344\"},\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_array(t_uint256)50_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[50]\",\"numberOfBytes\":\"1600\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint240\":{\"encoding\":\"inplace\",\"label\":\"uint240\",\"numberOfBytes\":\"30\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
 
 var L1CrossDomainMessengerStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l2crossdomainmessenger_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L2CrossDomainMessengerStorageLayoutJSON = "{\"storage\":[{\"astId\":24892,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27878,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_initialized\",\"offset\":20,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":27881,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_initializing\",\"offset\":21,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":28492,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_array(t_uint256)50_storage\"},{\"astId\":27750,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_address\"},{\"astId\":27870,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"52\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":28043,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_paused\",\"offset\":0,\"slot\":\"101\",\"type\":\"t_bool\"},{\"astId\":28148,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"102\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":28163,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_status\",\"offset\":0,\"slot\":\"151\",\"type\":\"t_uint256\"},{\"astId\":28207,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"152\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":24944,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_201_0_32\",\"offset\":0,\"slot\":\"201\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24949,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_202_0_32\",\"offset\":0,\"slot\":\"202\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24954,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"successfulMessages\",\"offset\":0,\"slot\":\"203\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24957,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"xDomainMsgSender\",\"offset\":0,\"slot\":\"204\",\"type\":\"t_address\"},{\"astId\":24960,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"msgNonce\",\"offset\":0,\"slot\":\"205\",\"type\":\"t_uint240\"},{\"astId\":24965,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"receivedMessages\",\"offset\":0,\"slot\":\"206\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24970,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"207\",\"type\":\"t_array(t_uint256)42_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)42_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[42]\",\"numberOfBytes\":\"1344\"},\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_array(t_uint256)50_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[50]\",\"numberOfBytes\":\"1600\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint240\":{\"encoding\":\"inplace\",\"label\":\"uint240\",\"numberOfBytes\":\"30\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
+const L2CrossDomainMessengerStorageLayoutJSON = "{\"storage\":[{\"astId\":24904,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27890,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_initialized\",\"offset\":20,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":27893,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_initializing\",\"offset\":21,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":28504,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_array(t_uint256)50_storage\"},{\"astId\":27762,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_address\"},{\"astId\":27882,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"52\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":28055,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_paused\",\"offset\":0,\"slot\":\"101\",\"type\":\"t_bool\"},{\"astId\":28160,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"102\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":28175,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"_status\",\"offset\":0,\"slot\":\"151\",\"type\":\"t_uint256\"},{\"astId\":28219,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"152\",\"type\":\"t_array(t_uint256)49_storage\"},{\"astId\":24956,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_201_0_32\",\"offset\":0,\"slot\":\"201\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24961,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"spacer_202_0_32\",\"offset\":0,\"slot\":\"202\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24966,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"successfulMessages\",\"offset\":0,\"slot\":\"203\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24969,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"xDomainMsgSender\",\"offset\":0,\"slot\":\"204\",\"type\":\"t_address\"},{\"astId\":24972,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"msgNonce\",\"offset\":0,\"slot\":\"205\",\"type\":\"t_uint240\"},{\"astId\":24977,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"receivedMessages\",\"offset\":0,\"slot\":\"206\",\"type\":\"t_mapping(t_bytes32,t_bool)\"},{\"astId\":24982,\"contract\":\"contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"207\",\"type\":\"t_array(t_uint256)42_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)42_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[42]\",\"numberOfBytes\":\"1344\"},\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_array(t_uint256)50_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[50]\",\"numberOfBytes\":\"1600\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"},\"t_uint240\":{\"encoding\":\"inplace\",\"label\":\"uint240\",\"numberOfBytes\":\"30\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
 
 var L2CrossDomainMessengerStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l2erc721bridge_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L2ERC721BridgeStorageLayoutJSON = "{\"storage\":[{\"astId\":25398,\"contract\":\"contracts/L2/L2ERC721Bridge.sol:L2ERC721Bridge\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_array(t_uint256)49_storage\"}],\"types\":{\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+const L2ERC721BridgeStorageLayoutJSON = "{\"storage\":[{\"astId\":25410,\"contract\":\"contracts/L2/L2ERC721Bridge.sol:L2ERC721Bridge\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_array(t_uint256)49_storage\"}],\"types\":{\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
 
 var L2ERC721BridgeStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/l2standardbridge_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const L2StandardBridgeStorageLayoutJSON = "{\"storage\":[{\"astId\":27051,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27054,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"spacer_1_0_20\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_address\"},{\"astId\":27061,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"deposits\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":27066,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_array(t_uint256)47_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)47_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[47]\",\"numberOfBytes\":\"1504\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+const L2StandardBridgeStorageLayoutJSON = "{\"storage\":[{\"astId\":27063,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"spacer_0_0_20\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"},{\"astId\":27066,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"spacer_1_0_20\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_address\"},{\"astId\":27073,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"deposits\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":27078,\"contract\":\"contracts/L2/L2StandardBridge.sol:L2StandardBridge\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_array(t_uint256)47_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)47_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[47]\",\"numberOfBytes\":\"1504\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
 
 var L2StandardBridgeStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/legacyerc20eth_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const LegacyERC20ETHStorageLayoutJSON = "{\"storage\":[{\"astId\":28851,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_balances\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_uint256)\"},{\"astId\":28857,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_allowances\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":28859,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_totalSupply\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":28861,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_name\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_string_storage\"},{\"astId\":28863,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_symbol\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_string_storage\"},{\"astId\":25627,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"remoteToken\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_address\"},{\"astId\":25630,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"bridge\",\"offset\":0,\"slot\":\"6\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_string_storage\":{\"encoding\":\"bytes\",\"label\":\"string\",\"numberOfBytes\":\"32\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+const LegacyERC20ETHStorageLayoutJSON = "{\"storage\":[{\"astId\":28863,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_balances\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_uint256)\"},{\"astId\":28869,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_allowances\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_address,t_mapping(t_address,t_uint256))\"},{\"astId\":28871,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_totalSupply\",\"offset\":0,\"slot\":\"2\",\"type\":\"t_uint256\"},{\"astId\":28873,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_name\",\"offset\":0,\"slot\":\"3\",\"type\":\"t_string_storage\"},{\"astId\":28875,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"_symbol\",\"offset\":0,\"slot\":\"4\",\"type\":\"t_string_storage\"},{\"astId\":25639,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"remoteToken\",\"offset\":0,\"slot\":\"5\",\"type\":\"t_address\"},{\"astId\":25642,\"contract\":\"contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH\",\"label\":\"bridge\",\"offset\":0,\"slot\":\"6\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_mapping(t_address,t_mapping(t_address,t_uint256))\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e mapping(address =\u003e uint256))\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_mapping(t_address,t_uint256)\"},\"t_mapping(t_address,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_uint256\"},\"t_string_storage\":{\"encoding\":\"bytes\",\"label\":\"string\",\"numberOfBytes\":\"32\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
 
 var LegacyERC20ETHStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/legacymessagepasser_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const LegacyMessagePasserStorageLayoutJSON = "{\"storage\":[{\"astId\":3895,\"contract\":\"contracts/legacy/LegacyMessagePasser.sol:LegacyMessagePasser\",\"label\":\"sentMessages\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_bytes32,t_bool)\"}],\"types\":{\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"}}}"
+const LegacyMessagePasserStorageLayoutJSON = "{\"storage\":[{\"astId\":3891,\"contract\":\"contracts/legacy/LegacyMessagePasser.sol:LegacyMessagePasser\",\"label\":\"sentMessages\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_bytes32,t_bool)\"}],\"types\":{\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_bool\"}}}"
 
 var LegacyMessagePasserStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/optimismmintableerc721factory_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const OptimismMintableERC721FactoryStorageLayoutJSON = "{\"storage\":[{\"astId\":26150,\"contract\":\"contracts/universal/OptimismMintableERC721Factory.sol:OptimismMintableERC721Factory\",\"label\":\"isOptimismMintableERC721\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_bool)\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_mapping(t_address,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_bool\"}}}"
+const OptimismMintableERC721FactoryStorageLayoutJSON = "{\"storage\":[{\"astId\":26162,\"contract\":\"contracts/universal/OptimismMintableERC721Factory.sol:OptimismMintableERC721Factory\",\"label\":\"isOptimismMintableERC721\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_mapping(t_address,t_bool)\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_mapping(t_address,t_bool)\":{\"encoding\":\"mapping\",\"label\":\"mapping(address =\u003e bool)\",\"numberOfBytes\":\"32\",\"key\":\"t_address\",\"value\":\"t_bool\"}}}"
 
 var OptimismMintableERC721FactoryStorageLayout = new(solc.StorageLayout)
 

op-bindings/bindings/sequencerfeevault_more.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/solc"
 )
 
-const SequencerFeeVaultStorageLayoutJSON = "{\"storage\":[{\"astId\":3093,\"contract\":\"contracts/L2/SequencerFeeVault.sol:SequencerFeeVault\",\"label\":\"l1FeeWallet\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"}}}"
+const SequencerFeeVaultStorageLayoutJSON = "{\"storage\":[{\"astId\":3089,\"contract\":\"contracts/L2/SequencerFeeVault.sol:SequencerFeeVault\",\"label\":\"l1FeeWallet\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_address\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"}}}"
 
 var SequencerFeeVaultStorageLayout = new(solc.StorageLayout)
 

op-bindings/predeploys/addresses.go

@@ -18,6 +18,7 @@ const (
 	LegacyMessagePasser           = "0x4200000000000000000000000000000000000000"
 	L2ERC721Bridge                = "0x4200000000000000000000000000000000000014"
 	OptimismMintableERC721Factory = "0x4200000000000000000000000000000000000017"
+	ProxyAdmin                    = "0x4200000000000000000000000000000000000018"
 )
 
 var (
@@ -36,6 +37,7 @@ var (
 	LegacyMessagePasserAddr           = common.HexToAddress(LegacyMessagePasser)
 	L2ERC721BridgeAddr                = common.HexToAddress(L2ERC721Bridge)
 	OptimismMintableERC721FactoryAddr = common.HexToAddress(OptimismMintableERC721Factory)
+	ProxyAdminAddr                    = common.HexToAddress(ProxyAdmin)
 
 	Predeploys = make(map[string]*common.Address)
 )
@@ -56,4 +58,5 @@ func init() {
 	Predeploys["LegacyMessagePasser"] = &LegacyMessagePasserAddr
 	Predeploys["L2ERC721Bridge"] = &L2ERC721BridgeAddr
 	Predeploys["OptimismMintableERC721Factory"] = &OptimismMintableERC721FactoryAddr
+	Predeploys["ProxyAdmin"] = &ProxyAdminAddr
 }

op-chain-ops/genesis/config.go

@@ -63,6 +63,7 @@ type DeployConfig struct {
 	L2GenesisBlockParentHash    common.Hash    `json:"l2GenesisBlockParentHash"`
 	L2GenesisBlockBaseFeePerGas *hexutil.Big   `json:"l2GenesisBlockBaseFeePerGas"`
 
+	ProxyAdminOwner             common.Address `json:"proxyAdminOwner"`
 	L2CrossDomainMessengerOwner common.Address `json:"l2CrossDomainMessengerOwner"`
 	OptimismBaseFeeRecipient    common.Address `json:"optimismBaseFeeRecipient"`
 	OptimismL1FeeRecipient      common.Address `json:"optimismL1FeeRecipient"`
@@ -104,22 +105,26 @@ func NewDeployConfigWithNetwork(network, path string) (*DeployConfig, error) {
 
 // NewL2ImmutableConfig will create an ImmutableConfig given an instance of a
 // Hardhat and a DeployConfig.
-func NewL2ImmutableConfig(config *DeployConfig, block *types.Block, proxyL1StandardBridge, proxyL1CrossDomainMessenger, proxyL1ERC721Bridge common.Address) (immutables.ImmutableConfig, error) {
+func NewL2ImmutableConfig(config *DeployConfig, block *types.Block, l2Addrs *L2Addresses) (immutables.ImmutableConfig, error) {
 	immutable := make(immutables.ImmutableConfig)
 
-	if proxyL1ERC721Bridge == (common.Address{}) {
+	if l2Addrs == nil {
+		return immutable, errors.New("must pass L1 contract addresses")
+	}
+
+	if l2Addrs.L1ERC721BridgeProxy == (common.Address{}) {
 		return immutable, errors.New("L1ERC721BridgeProxy cannot be address(0)")
 	}
 
 	immutable["L2StandardBridge"] = immutables.ImmutableValues{
-		"otherBridge": proxyL1StandardBridge,
+		"otherBridge": l2Addrs.L1StandardBridgeProxy,
 	}
 	immutable["L2CrossDomainMessenger"] = immutables.ImmutableValues{
-		"otherMessenger": proxyL1CrossDomainMessenger,
+		"otherMessenger": l2Addrs.L1CrossDomainMessengerProxy,
 	}
 	immutable["L2ERC721Bridge"] = immutables.ImmutableValues{
 		"messenger":   predeploys.L2CrossDomainMessengerAddr,
-		"otherBridge": proxyL1ERC721Bridge,
+		"otherBridge": l2Addrs.L1ERC721BridgeProxy,
 	}
 	immutable["OptimismMintableERC721Factory"] = immutables.ImmutableValues{
 		"bridge":        predeploys.L2ERC721BridgeAddr,
@@ -131,7 +136,7 @@ func NewL2ImmutableConfig(config *DeployConfig, block *types.Block, proxyL1Stand
 
 // NewL2StorageConfig will create a StorageConfig given an instance of a
 // Hardhat and a DeployConfig.
-func NewL2StorageConfig(config *DeployConfig, block *types.Block, proxyL1StandardBridge common.Address, proxyL1CrossDomainMessenger common.Address) (state.StorageConfig, error) {
+func NewL2StorageConfig(config *DeployConfig, block *types.Block, l2Addrs *L2Addresses) (state.StorageConfig, error) {
 	storage := make(state.StorageConfig)
 
 	if block.Number() == nil {
@@ -140,6 +145,9 @@ func NewL2StorageConfig(config *DeployConfig, block *types.Block, proxyL1Standar
 	if block.BaseFee() == nil {
 		return storage, errors.New("block base fee not set")
 	}
+	if l2Addrs == nil {
+		return storage, errors.New("must pass L1 address info")
+	}
 
 	storage["L2ToL1MessagePasser"] = state.StorageValues{
 		"nonce": 0,
@@ -187,5 +195,8 @@ func NewL2StorageConfig(config *DeployConfig, block *types.Block, proxyL1Standar
 		// TODO: this should be set to the MintManager
 		"_owner": common.Address{},
 	}
+	storage["ProxyAdmin"] = state.StorageValues{
+		"owner": l2Addrs.ProxyAdminOwner,
+	}
 	return storage, nil
 }

op-chain-ops/genesis/layer_two.go

@@ -9,8 +9,10 @@ import (
 	"github.com/ethereum/go-ethereum/core"
 )
 
+// L2Addresses represents L1 contract addresses
+// that are required for the construction of an L2 state
 type L2Addresses struct {
-	ProxyAdmin                  common.Address
+	ProxyAdminOwner             common.Address
 	L1StandardBridgeProxy       common.Address
 	L1CrossDomainMessengerProxy common.Address
 	L1ERC721BridgeProxy         common.Address
@@ -31,9 +33,11 @@ func BuildL2DeveloperGenesis(config *DeployConfig, l1StartBlock *types.Block, l2
 	}
 	SetPrecompileBalances(db)
 
+	// Use the known developer addresses if they are not set
 	if l2Addrs == nil {
 		l2Addrs = &L2Addresses{
-			ProxyAdmin:                  predeploys.DevProxyAdminAddr,
+			// corresponds to m/44'/60'/0'/0/1 in the 'test test... junk' mnemonic
+			ProxyAdminOwner:             common.HexToAddress("0x70997970C51812dc3A010C7d01b50e0d17dc79C8"),
 			L1StandardBridgeProxy:       predeploys.DevL1StandardBridgeAddr,
 			L1CrossDomainMessengerProxy: predeploys.DevL1CrossDomainMessengerAddr,
 			L1ERC721BridgeProxy:         predeploys.DevL1ERC721BridgeAddr,
@@ -45,31 +49,16 @@ func BuildL2DeveloperGenesis(config *DeployConfig, l1StartBlock *types.Block, l2
 
 // BuildL2Genesis will build the L2 Optimism Genesis Block
 func BuildL2Genesis(db *state.MemoryStateDB, config *DeployConfig, l1Block *types.Block, l2Addrs *L2Addresses) (*core.Genesis, error) {
-	// TODO(tynes): need a function for clearing old, unused storage slots.
-	// Each deployed contract on L2 needs to have its existing storage
-	// inspected and then cleared if they are no longer used.
-
-	if err := SetL2Proxies(db, l2Addrs.ProxyAdmin); err != nil {
+	if err := SetL2Proxies(db); err != nil {
 		return nil, err
 	}
 
-	storage, err := NewL2StorageConfig(
-		config,
-		l1Block,
-		l2Addrs.L1StandardBridgeProxy,
-		l2Addrs.L1CrossDomainMessengerProxy,
-	)
+	storage, err := NewL2StorageConfig(config, l1Block, l2Addrs)
 	if err != nil {
 		return nil, err
 	}
 
-	immutable, err := NewL2ImmutableConfig(
-		config,
-		l1Block,
-		l2Addrs.L1StandardBridgeProxy,
-		l2Addrs.L1CrossDomainMessengerProxy,
-		l2Addrs.L1ERC721BridgeProxy,
-	)
+	immutable, err := NewL2ImmutableConfig(config, l1Block, l2Addrs)
 	if err != nil {
 		return nil, err
 	}

op-chain-ops/genesis/layer_two_test.go

@@ -16,7 +16,6 @@ import (
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/crypto"
 
-	"github.com/ethereum-optimism/optimism/op-bindings/hardhat"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
 	"github.com/stretchr/testify/require"
@@ -31,19 +30,9 @@ func init() {
 var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 
 func TestBuildL2DeveloperGenesis(t *testing.T) {
-	hh, err := hardhat.New(
-		"alpha-1",
-		nil,
-		[]string{"../../packages/contracts-bedrock/deployments"},
-	)
-	require.Nil(t, err)
-
 	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
 	require.Nil(t, err)
 
-	proxyAdmin, err := hh.GetDeployment("ProxyAdmin")
-	require.Nil(t, err)
-
 	backend := backends.NewSimulatedBackend(
 		core.GenesisAlloc{
 			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
@@ -52,12 +41,8 @@ func TestBuildL2DeveloperGenesis(t *testing.T) {
 	)
 	block, err := backend.BlockByNumber(context.Background(), common.Big0)
 	require.NoError(t, err)
-	gen, err := genesis.BuildL2DeveloperGenesis(config, block, &genesis.L2Addresses{
-		ProxyAdmin:                  proxyAdmin.Address,
-		L1ERC721BridgeProxy:         predeploys.DevL1ERC721BridgeAddr,
-		L1CrossDomainMessengerProxy: predeploys.DevL1CrossDomainMessengerAddr,
-		L1StandardBridgeProxy:       predeploys.DevL1StandardBridgeAddr,
-	})
+
+	gen, err := genesis.BuildL2DeveloperGenesis(config, block, nil)
 	require.Nil(t, err)
 	require.NotNil(t, gen)
 
@@ -71,13 +56,13 @@ func TestBuildL2DeveloperGenesis(t *testing.T) {
 		require.Equal(t, ok, true)
 		require.Greater(t, len(account.Code), 0)
 
-		if name == "GovernanceToken" || name == "LegacyERC20ETH" {
+		if name == "GovernanceToken" || name == "LegacyERC20ETH" || name == "ProxyAdmin" {
 			continue
 		}
 
 		adminSlot, ok := account.Storage[genesis.AdminSlot]
 		require.Equal(t, ok, true)
-		require.Equal(t, adminSlot, proxyAdmin.Address.Hash())
+		require.Equal(t, adminSlot, predeploys.ProxyAdminAddr.Hash())
 		require.Equal(t, account.Code, depB)
 	}
 	require.Equal(t, 2341, len(gen.Alloc))
@@ -101,12 +86,8 @@ func TestBuildL2DeveloperGenesisDevAccountsFunding(t *testing.T) {
 	)
 	block, err := backend.BlockByNumber(context.Background(), common.Big0)
 	require.NoError(t, err)
-	gen, err := genesis.BuildL2DeveloperGenesis(config, block, &genesis.L2Addresses{
-		ProxyAdmin:                  common.Address{},
-		L1ERC721BridgeProxy:         predeploys.DevL1ERC721BridgeAddr,
-		L1CrossDomainMessengerProxy: predeploys.DevL1CrossDomainMessengerAddr,
-		L1StandardBridgeProxy:       predeploys.DevL1StandardBridgeAddr,
-	})
+
+	gen, err := genesis.BuildL2DeveloperGenesis(config, block, nil)
 	require.NoError(t, err)
 	require.Equal(t, 2319, len(gen.Alloc))
 }

op-chain-ops/genesis/setters.go

@@ -25,8 +25,8 @@ func FundDevAccounts(db vm.StateDB) {
 // a Proxy and ProxyAdmin deployment present so that the Proxy bytecode
 // can be set in state and the ProxyAdmin can be set as the admin of the
 // Proxy.
-func SetL2Proxies(db vm.StateDB, proxyAdminAddr common.Address) error {
-	return setProxies(db, proxyAdminAddr, bigL2PredeployNamespace, 2048)
+func SetL2Proxies(db vm.StateDB) error {
+	return setProxies(db, predeploys.ProxyAdminAddr, bigL2PredeployNamespace, 2048)
 }
 
 // SetL1Proxies will set each of the proxies in the state. It requires
@@ -47,8 +47,10 @@ func setProxies(db vm.StateDB, proxyAdminAddr common.Address, namespace *big.Int
 		bigAddr := new(big.Int).Or(namespace, new(big.Int).SetUint64(i))
 		addr := common.BigToAddress(bigAddr)
 
-		// There is no proxy at the governance token address
-		if addr == predeploys.GovernanceTokenAddr {
+		// There is no proxy at the governance token address or
+		// the proxy admin address. LegacyERC20ETH lives in the
+		// 0xDead namespace so it can be ignored here
+		if addr == predeploys.GovernanceTokenAddr || addr == predeploys.ProxyAdminAddr {
 			continue
 		}
 
@@ -69,13 +71,16 @@ func SetImplementations(db vm.StateDB, storage state.StorageConfig, immutable im
 	}
 
 	for name, address := range predeploys.Predeploys {
-		// Convert the address to the code address
+		// Convert the address to the code address unless it is
+		// designed to not be behind a proxy
 		var addr common.Address
 		switch *address {
 		case predeploys.GovernanceTokenAddr:
 			addr = predeploys.GovernanceTokenAddr
 		case predeploys.LegacyERC20ETHAddr:
 			addr = predeploys.LegacyERC20ETHAddr
+		case predeploys.ProxyAdminAddr:
+			addr = predeploys.ProxyAdminAddr
 		default:
 			addr, err = AddressToCodeNamespace(*address)
 			if err != nil {

op-chain-ops/genesis/testdata/test-deploy-config-full.json

@@ -42,6 +42,7 @@
   "optimismL1FeeRecipient": "0x0000000000000000000000000000000000000000",
   "l2CrossDomainMessengerOwner": "0x42000000000000000000000000000000000000f2",
   "gasPriceOracleOwner": "0x42000000000000000000000000000000000000f3",
+  "proxyAdminOwner": "0x0000000000000000000000000000000000000000",
   "gasPriceOracleOverhead": 2100,
   "gasPriceOracleScalar": 1000000,
   "gasPriceOracleDecimals": 6,

op-e2e/e2eutils/setup.go

@@ -168,6 +168,7 @@ func Setup(t require.TestingT, deployParams *DeployParams, alloc *AllocParams) *
 	}
 
 	l1Block := l1Genesis.ToBlock()
+
 	l2Genesis, err := genesis.BuildL2DeveloperGenesis(deployConf, l1Block, nil)
 	require.NoError(t, err, "failed to create l2 genesis")
 	if alloc.PrefundTestUsers {

op-node/cmd/genesis/cmd.go

@@ -57,13 +57,7 @@ var Subcommands = cli.Commands{
 			}
 
 			l1StartBlock := l1Genesis.ToBlock()
-			l2Addrs := &genesis.L2Addresses{
-				ProxyAdmin:                  predeploys.DevProxyAdminAddr,
-				L1StandardBridgeProxy:       predeploys.DevL1StandardBridgeAddr,
-				L1CrossDomainMessengerProxy: predeploys.DevL1CrossDomainMessengerAddr,
-				L1ERC721BridgeProxy:         predeploys.DevL1ERC721BridgeAddr,
-			}
-			l2Genesis, err := genesis.BuildL2DeveloperGenesis(config, l1StartBlock, l2Addrs)
+			l2Genesis, err := genesis.BuildL2DeveloperGenesis(config, l1StartBlock, nil)
 			if err != nil {
 				return err
 			}
@@ -136,10 +130,6 @@ var Subcommands = cli.Commands{
 				return err
 			}
 
-			proxyAdmin, err := hh.GetDeployment("ProxyAdmin")
-			if err != nil {
-				return err
-			}
 			l1SBP, err := hh.GetDeployment("L1StandardBridgeProxy")
 			if err != nil {
 				return err
@@ -158,7 +148,7 @@ var Subcommands = cli.Commands{
 			}
 
 			l2Addrs := &genesis.L2Addresses{
-				ProxyAdmin:                  proxyAdmin.Address,
+				ProxyAdminOwner:             config.ProxyAdminOwner,
 				L1StandardBridgeProxy:       l1SBP.Address,
 				L1CrossDomainMessengerProxy: l1XDMP.Address,
 				L1ERC721BridgeProxy:         l1ERC721BP.Address,

op-node/withdrawals/testdata/bridge-withdrawal.json

@@ -37,12 +37,12 @@
     {
       "address": "0x4200000000000000000000000000000000000016",
       "topics": [
-        "0x7744840cae4793a72467311120512aa98e4398bcd2b9d379b2b9c3b60fa03d72",
+        "0x02a52367d10742d8032712c1bb8e0144ff1ec5ffda1ed7d70bb05a2744955054",
         "0x0000000000000000000000000000000000000000000000000000000000000000",
         "0x0000000000000000000000004200000000000000000000000000000000000007",
         "0x0000000000000000000000006900000000000000000000000000000000000002"
       ],
-      "data": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031b80000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000001e4d764ad0b0001000000000000000000000000000000000000000000000000000000000000000000000000000000000000420000000000000000000000000000000000001000000000000000000000000069000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000e40166a07a00000000000000000000000089d51be807d98fc974a0f41b2e67a8228d7846ef0000000000000000000000007c6b91d9be155a6db01f749217d76ff02a7227f2000000000000000000000000c20c5ec92fda6e611a08485123cdc0d5b84bd3a2000000000000000000000000c20c5ec92fda6e611a08485123cdc0d5b84bd3a200000000000000000000000000000000000000000000000000000000000001f400000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "data": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031b8000000000000000000000000000000000000000000000000000000000000000800d827f8148288e3a2466018f71b968ece4ea9f9e2a81c30da9bd46cce286828500000000000000000000000000000000000000000000000000000000000001e4d764ad0b0001000000000000000000000000000000000000000000000000000000000000000000000000000000000000420000000000000000000000000000000000001000000000000000000000000069000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000e40166a07a00000000000000000000000089d51be807d98fc974a0f41b2e67a8228d7846ef0000000000000000000000007c6b91d9be155a6db01f749217d76ff02a7227f2000000000000000000000000c20c5ec92fda6e611a08485123cdc0d5b84bd3a2000000000000000000000000c20c5ec92fda6e611a08485123cdc0d5b84bd3a200000000000000000000000000000000000000000000000000000000000001f400000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
       "blockNumber": "0x36",
       "transactionHash": "0x9346381068b59d2098495baa72ed2f773c1e09458610a7a208984859dff73add",
       "transactionIndex": "0x1",

op-node/withdrawals/utils.go

@@ -17,12 +17,10 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/ethclient/gethclient"
-	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
-var MessagePassedTopic = crypto.Keccak256Hash([]byte("MessagePassed(uint256,address,address,uint256,uint256,bytes)"))
-var MessagePassedExtension1Topic = crypto.Keccak256Hash([]byte("MessagePassedExtension1(bytes32)"))
+var MessagePassedTopic = crypto.Keccak256Hash([]byte("MessagePassed(uint256,address,address,uint256,uint256,bytes,bytes32)"))
 
 // WaitForFinalizationPeriod waits until there is OutputProof for an L2 block number larger than the supplied l2BlockNumber
 // and that the output is finalized.
@@ -159,7 +157,7 @@ type FinalizedWithdrawalParameters struct {
 	BlockNumber     *big.Int
 	Data            []byte
 	OutputRootProof bindings.TypesOutputRootProof
-	WithdrawalProof []byte // RLP Encoded list of trie nodes to prove L2 storage
+	WithdrawalProof [][]byte // List of trie nodes to prove L2 storage
 }
 
 // FinalizeWithdrawalParameters queries L2 to generate all withdrawal parameters and proof necessary to finalize an withdrawal on L1.
@@ -176,13 +174,9 @@ func FinalizeWithdrawalParameters(ctx context.Context, l2client ProofClient, txH
 	if err != nil {
 		return FinalizedWithdrawalParameters{}, err
 	}
-	ev1, err := ParseMessagePassedExtension1(receipt)
-	if err != nil {
-		return FinalizedWithdrawalParameters{}, err
-	}
 	// Generate then verify the withdrawal proof
 	withdrawalHash, err := WithdrawalHash(ev)
-	if !bytes.Equal(withdrawalHash[:], ev1.Hash[:]) {
+	if !bytes.Equal(withdrawalHash[:], ev.WithdrawalHash[:]) {
 		return FinalizedWithdrawalParameters{}, errors.New("Computed withdrawal hash incorrectly")
 	}
 	if err != nil {
@@ -208,11 +202,6 @@ func FinalizeWithdrawalParameters(ctx context.Context, l2client ProofClient, txH
 		trieNodes[i] = common.FromHex(s)
 	}
 
-	withdrawalProof, err := rlp.EncodeToBytes(trieNodes)
-	if err != nil {
-		return FinalizedWithdrawalParameters{}, err
-	}
-
 	return FinalizedWithdrawalParameters{
 		Nonce:       ev.Nonce,
 		Sender:      ev.Sender,
@@ -227,7 +216,7 @@ func FinalizeWithdrawalParameters(ctx context.Context, l2client ProofClient, txH
 			MessagePasserStorageRoot: p.StorageHash,
 			LatestBlockhash:          header.Hash(),
 		},
-		WithdrawalProof: withdrawalProof,
+		WithdrawalProof: trieNodes,
 	}, nil
 }
 
@@ -284,29 +273,6 @@ func ParseMessagePassed(receipt *types.Receipt) (*bindings.L2ToL1MessagePasserMe
 	return nil, errors.New("Unable to find MessagePassed event")
 }
 
-// ParseMessagePassedExtension1 parses MessagePassedExtension1 events
-// from a transaction receipt. It does not support multiple withdrawals per
-// receipt.
-func ParseMessagePassedExtension1(receipt *types.Receipt) (*bindings.L2ToL1MessagePasserMessagePassedExtension1, error) {
-	contract, err := bindings.NewL2ToL1MessagePasser(common.Address{}, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, log := range receipt.Logs {
-		if len(log.Topics) == 0 || log.Topics[0] != MessagePassedExtension1Topic {
-			continue
-		}
-
-		ev, err := contract.ParseMessagePassedExtension1(*log)
-		if err != nil {
-			return nil, fmt.Errorf("failed to parse log: %w", err)
-		}
-		return ev, nil
-	}
-	return nil, errors.New("Unable to find MessagePassedExtension1 event")
-}
-
 // StorageSlotOfWithdrawalHash determines the storage slot of the Withdrawer contract to look at
 // given a WithdrawalHash
 func StorageSlotOfWithdrawalHash(hash common.Hash) common.Hash {

op-node/withdrawals/utils_test.go

@@ -32,26 +32,26 @@ func TestParseMessagePassed(t *testing.T) {
 				GasLimit: big.NewInt(203648),
 				Data: hexutil.MustDecode(
 					"0xd764ad0b00010000000000000000000000000000000000000000000000000000" +
-						"0000000000000000000000000000000042000000000000000000000000000000" +
-						"0000001000000000000000000000000069000000000000000000000000000000" +
-						"0000000300000000000000000000000000000000000000000000000000000000" +
-						"0000000000000000000000000000000000000000000000000000000000000000" +
-						"0000000000000000000000000000000000000000000000000000000000000000" +
-						"000000c000000000000000000000000000000000000000000000000000000000" +
-						"000000e40166a07a00000000000000000000000089d51be807d98fc974a0f41b" +
-						"2e67a8228d7846ef0000000000000000000000007c6b91d9be155a6db01f7492" +
-						"17d76ff02a7227f2000000000000000000000000c20c5ec92fda6e611a084851" +
-						"23cdc0d5b84bd3a2000000000000000000000000c20c5ec92fda6e611a084851" +
-						"23cdc0d5b84bd3a2000000000000000000000000000000000000000000000000" +
-						"00000000000001f4000000000000000000000000000000000000000000000000" +
-						"00000000000000c0000000000000000000000000000000000000000000000000" +
-						"0000000000000000000000000000000000000000000000000000000000000000" +
-						"00000000",
+						"00000000000000000000000000000000420000000000000000000000000000000000" +
+						"00100000000000000000000000006900000000000000000000000000000000000003" +
+						"00000000000000000000000000000000000000000000000000000000000000000000" +
+						"00000000000000000000000000000000000000000000000000000000000000000000" +
+						"000000000000000000000000000000000000000000000000000000c0000000000000" +
+						"00000000000000000000000000000000000000000000000000e40166a07a00000000" +
+						"000000000000000089d51be807d98fc974a0f41b2e67a8228d7846ef000000000000" +
+						"0000000000007c6b91d9be155a6db01f749217d76ff02a7227f20000000000000000" +
+						"00000000c20c5ec92fda6e611a08485123cdc0d5b84bd3a200000000000000000000" +
+						"0000c20c5ec92fda6e611a08485123cdc0d5b84bd3a2000000000000000000000000" +
+						"00000000000000000000000000000000000001f40000000000000000000000000000" +
+						"0000000000000000000000000000000000c000000000000000000000000000000000" +
+						"00000000000000000000000000000000000000000000000000000000000000000000" +
+						"00000000000000000000",
 				),
+				WithdrawalHash: common.HexToHash("0x0d827f8148288e3a2466018f71b968ece4ea9f9e2a81c30da9bd46cce2868285"),
 				Raw: types.Log{
 					Address: common.HexToAddress("0x4200000000000000000000000000000000000016"),
 					Topics: []common.Hash{
-						common.HexToHash("0x7744840cae4793a72467311120512aa98e4398bcd2b9d379b2b9c3b60fa03d72"),
+						common.HexToHash("0x02a52367d10742d8032712c1bb8e0144ff1ec5ffda1ed7d70bb05a2744955054"),
 						common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
 						common.HexToHash("0x0000000000000000000000004200000000000000000000000000000000000007"),
 						common.HexToHash("0x0000000000000000000000006900000000000000000000000000000000000002"),
@@ -59,24 +59,25 @@ func TestParseMessagePassed(t *testing.T) {
 					Data: hexutil.MustDecode(
 						"0x00000000000000000000000000000000000000000000000000000000000000" +
 							"000000000000000000000000000000000000000000000000000000000000031b80" +
-							"000000000000000000000000000000000000000000000000000000000000006000" +
-							"000000000000000000000000000000000000000000000000000000000001e4d764" +
-							"ad0b00010000000000000000000000000000000000000000000000000000000000" +
-							"000000000000000000000000004200000000000000000000000000000000000010" +
-							"000000000000000000000000690000000000000000000000000000000000000300" +
+							"00000000000000000000000000000000000000000000000000000000000000800d" +
+							"827f8148288e3a2466018f71b968ece4ea9f9e2a81c30da9bd46cce28682850000" +
+							"0000000000000000000000000000000000000000000000000000000001e4d764ad" +
+							"0b0001000000000000000000000000000000000000000000000000000000000000" +
+							"000000000000000000000000420000000000000000000000000000000000001000" +
+							"000000000000000000000069000000000000000000000000000000000000030000" +
 							"000000000000000000000000000000000000000000000000000000000000000000" +
 							"000000000000000000000000000000000000000000000000000000000000000000" +
-							"00000000000000000000000000000000000000000000000000000000c000000000" +
-							"000000000000000000000000000000000000000000000000000000e40166a07a00" +
-							"000000000000000000000089d51be807d98fc974a0f41b2e67a8228d7846ef0000" +
-							"000000000000000000007c6b91d9be155a6db01f749217d76ff02a7227f2000000" +
-							"000000000000000000c20c5ec92fda6e611a08485123cdc0d5b84bd3a200000000" +
+							"000000000000000000000000000000000000000000000000000000c00000000000" +
+							"0000000000000000000000000000000000000000000000000000e40166a07a0000" +
+							"0000000000000000000089d51be807d98fc974a0f41b2e67a8228d7846ef000000" +
+							"0000000000000000007c6b91d9be155a6db01f749217d76ff02a7227f200000000" +
 							"0000000000000000c20c5ec92fda6e611a08485123cdc0d5b84bd3a20000000000" +
-							"0000000000000000000000000000000000000000000000000001f4000000000000" +
-							"00000000000000000000000000000000000000000000000000c000000000000000" +
+							"00000000000000c20c5ec92fda6e611a08485123cdc0d5b84bd3a2000000000000" +
+							"00000000000000000000000000000000000000000000000001f400000000000000" +
+							"000000000000000000000000000000000000000000000000c00000000000000000" +
 							"000000000000000000000000000000000000000000000000000000000000000000" +
 							"000000000000000000000000000000000000000000000000000000000000000000" +
-							"000000000000000000000000000000",
+							"0000000000000000000000000000",
 					),
 					BlockNumber: 0x36,
 					TxHash:      common.HexToHash("0x9346381068b59d2098495baa72ed2f773c1e09458610a7a208984859dff73add"),
@@ -116,45 +117,3 @@ func TestParseMessagePassed(t *testing.T) {
 		})
 	}
 }
-
-func TestParseMessagePassedExtension1(t *testing.T) {
-	tests := []struct {
-		name     string
-		file     string
-		expected *bindings.L2ToL1MessagePasserMessagePassedExtension1
-	}{
-		{
-			"withdrawal through bridge",
-			"bridge-withdrawal.json",
-			&bindings.L2ToL1MessagePasserMessagePassedExtension1{
-				Hash: common.HexToHash("0x0d827f8148288e3a2466018f71b968ece4ea9f9e2a81c30da9bd46cce2868285"),
-				Raw: types.Log{
-					Address: common.HexToAddress("0x4200000000000000000000000000000000000016"),
-					Topics: []common.Hash{
-						common.HexToHash("0xedd348f9c36ef1a5b0747bb5039752707059f0b934c8e508b3271e08fbd0122c"),
-						common.HexToHash("0x0d827f8148288e3a2466018f71b968ece4ea9f9e2a81c30da9bd46cce2868285"),
-					},
-					Data:        []byte{},
-					BlockNumber: 0x36,
-					TxHash:      common.HexToHash("0x9346381068b59d2098495baa72ed2f773c1e09458610a7a208984859dff73add"),
-					TxIndex:     0x1,
-					BlockHash:   common.HexToHash("0xfdd4ad8a984b45687aca0463db491cbd0e85273d970019a3f8bf618b614938df"),
-					Index:       0x3,
-					Removed:     false,
-				},
-			},
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			f, err := os.Open(path.Join("testdata", test.file))
-			require.NoError(t, err)
-			dec := json.NewDecoder(f)
-			receipt := new(types.Receipt)
-			require.NoError(t, dec.Decode(receipt))
-			parsed, err := ParseMessagePassedExtension1(receipt)
-			require.NoError(t, err)
-			require.EqualValues(t, test.expected, parsed)
-		})
-	}
-}

ops/docker/ci-builder/Dockerfile

@@ -24,7 +24,7 @@ RUN source $HOME/.profile && \
     strip /opt/foundry/target/release/cast && \
     strip /opt/foundry/target/release/anvil
 
-FROM ethereum/client-go:alltools-v1.10.21 as geth
+FROM ethereum/client-go:alltools-v1.10.25 as geth
 
 FROM python:3.8.13-slim-bullseye
 

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

@@ -129,7 +129,7 @@ contract OptimismPortal is Initializable, ResourceMetering, Semver {
         Types.WithdrawalTransaction memory _tx,
         uint256 _l2BlockNumber,
         Types.OutputRootProof calldata _outputRootProof,
-        bytes calldata _withdrawalProof
+        bytes[] calldata _withdrawalProof
     ) external {
         // Prevent nested withdrawals within withdrawals.
         require(
@@ -293,7 +293,7 @@ contract OptimismPortal is Initializable, ResourceMetering, Semver {
     function _verifyWithdrawalInclusion(
         bytes32 _withdrawalHash,
         bytes32 _storageRoot,
-        bytes memory _proof
+        bytes[] memory _proof
     ) internal pure returns (bool) {
         bytes32 storageKey = keccak256(
             abi.encode(

packages/contracts-bedrock/contracts/L2/L2ToL1MessagePasser.sol

@@ -39,6 +39,7 @@ contract L2ToL1MessagePasser is Semver {
      * @param value    The ETH value submitted for withdrawal, to be forwarded to the target.
      * @param gasLimit The minimum amount of gas that must be provided when withdrawing on L1.
      * @param data     The data to be forwarded to the target on L1.
+     * @param withdrawalHash     The hash of the withdrawal.
      */
     event MessagePassed(
         uint256 indexed nonce,
@@ -46,17 +47,10 @@ contract L2ToL1MessagePasser is Semver {
         address indexed target,
         uint256 value,
         uint256 gasLimit,
-        bytes data
+        bytes data,
+        bytes32 withdrawalHash
     );
 
-    /**
-     * @notice Emitted any time a withdrawal is initiated. An extension to
-     *         MessagePassed to allow for a 4th indexed argument.
-     *
-     * @param hash The hash of the withdrawal
-     */
-    event MessagePassedExtension1(bytes32 indexed hash);
-
     /**
      * @notice Emitted when the balance of this contract is burned.
      *
@@ -113,9 +107,7 @@ contract L2ToL1MessagePasser is Semver {
 
         sentMessages[withdrawalHash] = true;
 
-        emit MessagePassed(nonce, msg.sender, _target, msg.value, _gasLimit, _data);
-        emit MessagePassedExtension1(withdrawalHash);
-
+        emit MessagePassed(nonce, msg.sender, _target, msg.value, _gasLimit, _data, withdrawalHash);
         unchecked {
             ++nonce;
         }

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

@@ -112,11 +112,19 @@ library Bytes {
      * @return Resulting nibble array.
      */
     function toNibbles(bytes memory _bytes) internal pure returns (bytes memory) {
-        bytes memory nibbles = new bytes(_bytes.length * 2);
-        for (uint256 i = 0; i < _bytes.length; i++) {
-            nibbles[i * 2] = _bytes[i] >> 4;
-            nibbles[i * 2 + 1] = bytes1(uint8(_bytes[i]) % 16);
+        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;
             }
+        }
+
         return nibbles;
     }
 

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

@@ -89,4 +89,9 @@ library Predeploys {
      *         L2ToL1MessagePasser contract instead.
      */
     address internal constant LEGACY_MESSAGE_PASSER = 0x4200000000000000000000000000000000000000;
+
+    /**
+     * @notice Address of the ProxyAdmin predeploy.
+     */
+    address internal constant PROXY_ADMIN = 0x4200000000000000000000000000000000000018;
 }

packages/contracts-bedrock/contracts/libraries/trie/MerkleTrie.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.0;
 
 import { Bytes } from "../Bytes.sol";
 import { RLPReader } from "../rlp/RLPReader.sol";
-import { RLPWriter } from "../rlp/RLPWriter.sol";
 
 /**
  * @title MerkleTrie
@@ -58,7 +57,7 @@ library MerkleTrie {
     /**
      * @notice RLP representation of `NULL`.
      */
-    bytes1 internal constant RLP_NULL = bytes1(0x80);
+    bytes internal constant RLP_NULL = hex"80";
 
     /**
      * @notice Verifies a proof that a given key/value pair is present in the trie.
@@ -76,7 +75,7 @@ library MerkleTrie {
     function verifyInclusionProof(
         bytes memory _key,
         bytes memory _value,
-        bytes memory _proof,
+        bytes[] memory _proof,
         bytes32 _root
     ) internal pure returns (bool) {
         (bool exists, bytes memory value) = get(_key, _proof, _root);
@@ -95,7 +94,7 @@ library MerkleTrie {
      */
     function get(
         bytes memory _key,
-        bytes memory _proof,
+        bytes[] memory _proof,
         bytes32 _root
     ) internal pure returns (bool, bytes memory) {
         TrieNode[] memory proof = _parseProof(_proof);
@@ -105,13 +104,13 @@ library MerkleTrie {
             _root
         );
 
-        bool exists = keyRemainder.length == 0;
+        bool noRemainder = keyRemainder.length == 0;
 
-        require(exists || isFinalNode, "MerkleTrie: provided proof is invalid");
+        require(noRemainder || isFinalNode, "MerkleTrie: provided proof is invalid");
 
-        bytes memory value = exists ? _getNodeValue(proof[pathLength - 1]) : bytes("");
+        bytes memory value = noRemainder ? _getNodeValue(proof[pathLength - 1]) : bytes("");
 
-        return (exists, value);
+        return (value.length > 0, value);
     }
 
     /**
@@ -142,7 +141,7 @@ library MerkleTrie {
         uint256 pathLength = 0;
         bytes memory key = Bytes.toNibbles(_key);
 
-        bytes32 currentNodeID = _root;
+        bytes memory currentNodeID = abi.encodePacked(_root);
         uint256 currentKeyIndex = 0;
         uint256 currentKeyIncrement = 0;
         TrieNode memory currentNode;
@@ -159,19 +158,19 @@ library MerkleTrie {
             if (currentKeyIndex == 0) {
                 // First proof element is always the root node.
                 require(
-                    keccak256(currentNode.encoded) == currentNodeID,
+                    Bytes.equal(abi.encodePacked(keccak256(currentNode.encoded)), currentNodeID),
                     "MerkleTrie: invalid root hash"
                 );
             } else if (currentNode.encoded.length >= 32) {
                 // Nodes 32 bytes or larger are hashed inside branch nodes.
                 require(
-                    keccak256(currentNode.encoded) == currentNodeID,
+                    Bytes.equal(abi.encodePacked(keccak256(currentNode.encoded)), currentNodeID),
                     "MerkleTrie: invalid large internal hash"
                 );
             } else {
-                // Nodes smaller than 31 bytes aren't hashed.
+                // Nodes smaller than 32 bytes aren't hashed.
                 require(
-                    bytes32(currentNode.encoded) == currentNodeID,
+                    Bytes.equal(currentNode.encoded, currentNodeID),
                     "MerkleTrie: invalid internal node hash"
                 );
             }
@@ -198,6 +197,11 @@ library MerkleTrie {
                 bytes memory keyRemainder = Bytes.slice(key, currentKeyIndex);
                 uint256 sharedNibbleLength = _getSharedNibbleLength(pathRemainder, keyRemainder);
 
+                require(
+                    keyRemainder.length >= pathRemainder.length,
+                    "MerkleTrie: invalid key length for leaf or extension node"
+                );
+
                 if (prefix == PREFIX_LEAF_EVEN || prefix == PREFIX_LEAF_ODD) {
                     if (
                         pathRemainder.length == sharedNibbleLength &&
@@ -209,14 +213,14 @@ library MerkleTrie {
                     }
 
                     // We've hit a leaf node, so our next node should be NULL.
-                    currentNodeID = bytes32(RLP_NULL);
+                    currentNodeID = RLP_NULL;
                     break;
                 } else if (prefix == PREFIX_EXTENSION_EVEN || prefix == PREFIX_EXTENSION_ODD) {
                     if (sharedNibbleLength != pathRemainder.length) {
                         // Our extension node is not identical to the remainder.
                         // We've hit the end of this path
                         // updates will need to modify this extension.
-                        currentNodeID = bytes32(RLP_NULL);
+                        currentNodeID = RLP_NULL;
                         break;
                     } else {
                         // Our extension shares some nibbles.
@@ -233,27 +237,30 @@ library MerkleTrie {
             }
         }
 
-        // If our node ID is NULL, then we're at a dead end.
-        bool isFinalNode = currentNodeID == bytes32(RLP_NULL);
-        return (pathLength, Bytes.slice(key, currentKeyIndex), isFinalNode);
+        return (
+            pathLength,
+            Bytes.slice(key, currentKeyIndex),
+            Bytes.equal(currentNodeID, RLP_NULL)
+        );
     }
 
     /**
-     * @notice Parses an RLP-encoded proof into something more useful.
+     * @notice Parses an array of proof elements into a new array that contains both the original
+     *         encoded element and the RLP-decoded element.
      *
-     * @param _proof RLP-encoded proof to parse.
+     * @param _proof Array of proof elements to parse.
      *
      * @return Proof parsed into easily accessible structs.
      */
-    function _parseProof(bytes memory _proof) private pure returns (TrieNode[] memory) {
-        RLPReader.RLPItem[] memory nodes = RLPReader.readList(_proof);
-        TrieNode[] memory proof = new TrieNode[](nodes.length);
-
-        for (uint256 i = 0; i < nodes.length; i++) {
-            bytes memory encoded = RLPReader.readBytes(nodes[i]);
-            proof[i] = TrieNode({ encoded: encoded, decoded: RLPReader.readList(encoded) });
+    function _parseProof(bytes[] memory _proof) private pure returns (TrieNode[] memory) {
+        uint256 length = _proof.length;
+        TrieNode[] memory proof = new TrieNode[](length);
+        for (uint256 i = 0; i < length; ) {
+            proof[i] = TrieNode({ encoded: _proof[i], decoded: RLPReader.readList(_proof[i]) });
+            unchecked {
+                ++i;
+            }
         }
-
         return proof;
     }
 
@@ -265,18 +272,8 @@ library MerkleTrie {
      *
      * @return ID for the node, depending on the size of its contents.
      */
-    function _getNodeID(RLPReader.RLPItem memory _node) private pure returns (bytes32) {
-        bytes memory nodeID;
-
-        if (_node.length < 32) {
-            // Nodes smaller than 32 bytes are RLP encoded.
-            nodeID = RLPReader.readRawBytes(_node);
-        } else {
-            // Nodes 32 bytes or larger are hashed.
-            nodeID = RLPReader.readBytes(_node);
-        }
-
-        return bytes32(nodeID);
+    function _getNodeID(RLPReader.RLPItem memory _node) private pure returns (bytes memory) {
+        return _node.length < 32 ? RLPReader.readRawBytes(_node) : RLPReader.readBytes(_node);
     }
 
     /**
@@ -291,7 +288,7 @@ library MerkleTrie {
     }
 
     /**
-     * @notice Gets the path for a node.
+     * @notice Gets the value for a node.
      *
      * @param _node Node to get a value for.
      *
@@ -314,10 +311,13 @@ library MerkleTrie {
         pure
         returns (uint256)
     {
-        uint256 i = 0;
-        while (_a.length > i && _b.length > i && _a[i] == _b[i]) {
-            i++;
+        uint256 shared;
+        uint256 max = (_a.length < _b.length) ? _a.length : _b.length;
+        for (; shared < max && _a[shared] == _b[shared]; ) {
+            unchecked {
+                ++shared;
+            }
         }
-        return i;
+        return shared;
     }
 }

packages/contracts-bedrock/contracts/libraries/trie/SecureMerkleTrie.sol

@@ -26,7 +26,7 @@ library SecureMerkleTrie {
     function verifyInclusionProof(
         bytes memory _key,
         bytes memory _value,
-        bytes memory _proof,
+        bytes[] memory _proof,
         bytes32 _root
     ) internal pure returns (bool) {
         bytes memory key = _getSecureKey(_key);
@@ -45,7 +45,7 @@ library SecureMerkleTrie {
      */
     function get(
         bytes memory _key,
-        bytes memory _proof,
+        bytes[] memory _proof,
         bytes32 _root
     ) internal pure returns (bool, bytes memory) {
         bytes memory key = _getSecureKey(_key);

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

@@ -187,7 +187,8 @@ contract Messenger_Initializer is L2OutputOracle_Initializer {
         address indexed target,
         uint256 value,
         uint256 gasLimit,
-        bytes data
+        bytes data,
+        bytes32 withdrawalHash
     );
 
     event RelayedMessage(bytes32 indexed msgHash);
@@ -462,7 +463,7 @@ contract FFIInterface is Test {
             bytes32,
             bytes32,
             bytes32,
-            bytes memory
+            bytes[] memory
         )
     {
         string[] memory cmds = new string[](9);
@@ -482,8 +483,8 @@ contract FFIInterface is Test {
             bytes32 storageRoot,
             bytes32 outputRoot,
             bytes32 withdrawalHash,
-            bytes memory withdrawalProof
-        ) = abi.decode(result, (bytes32, bytes32, bytes32, bytes32, bytes));
+            bytes[] memory withdrawalProof
+        ) = abi.decode(result, (bytes32, bytes32, bytes32, bytes32, bytes[]));
 
         return (stateRoot, storageRoot, outputRoot, withdrawalHash, withdrawalProof);
     }

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

@@ -10,6 +10,7 @@ import { L2CrossDomainMessenger } from "../L2/L2CrossDomainMessenger.sol";
 import { L1CrossDomainMessenger } from "../L1/L1CrossDomainMessenger.sol";
 import { Hashing } from "../libraries/Hashing.sol";
 import { Encoding } from "../libraries/Encoding.sol";
+import { Types } from "../libraries/Types.sol";
 
 contract L2CrossDomainMessenger_Test is Messenger_Initializer {
     // Receiver address for testing
@@ -36,23 +37,25 @@ contract L2CrossDomainMessenger_Test is Messenger_Initializer {
     }
 
     function test_L2MessengerSendMessage() external {
-        vm.expectCall(
-            address(messagePasser),
-            abi.encodeWithSelector(
-                L2ToL1MessagePasser.initiateWithdrawal.selector,
-                address(L1Messenger),
-                L2Messenger.baseGas(hex"ff", 100),
-                Encoding.encodeCrossDomainMessage(
+        bytes memory xDomainCallData = Encoding.encodeCrossDomainMessage(
             L2Messenger.messageNonce(),
             alice,
             recipient,
             0,
             100,
             hex"ff"
-                )
+        );
+        vm.expectCall(
+            address(messagePasser),
+            abi.encodeWithSelector(
+                L2ToL1MessagePasser.initiateWithdrawal.selector,
+                address(L1Messenger),
+                L2Messenger.baseGas(hex"ff", 100),
+                xDomainCallData
             )
         );
 
+
         // MessagePassed event
         vm.expectEmit(true, true, true, true);
         emit MessagePassed(
@@ -61,13 +64,16 @@ contract L2CrossDomainMessenger_Test is Messenger_Initializer {
             address(L1Messenger),
             0,
             L2Messenger.baseGas(hex"ff", 100),
-            Encoding.encodeCrossDomainMessage(
-                L2Messenger.messageNonce(),
-                alice,
-                recipient,
-                0,
-                100,
-                hex"ff"
+            xDomainCallData,
+            Hashing.hashWithdrawal(
+                Types.WithdrawalTransaction({
+                    nonce: messagePasser.nonce(),
+                    sender: address(L2Messenger),
+                    target: address(L1Messenger),
+                    value: 0,
+                    gasLimit: L2Messenger.baseGas(hex"ff", 100),
+                    data: xDomainCallData
+                })
             )
         );
 

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

@@ -15,11 +15,10 @@ contract L2ToL1MessagePasserTest is CommonTest {
         address indexed target,
         uint256 value,
         uint256 gasLimit,
-        bytes data
+        bytes data,
+        bytes32 withdrawalHash
     );
 
-    event MessagePassedExtension1(bytes32 indexed hash);
-
     event WithdrawerBalanceBurnt(uint256 indexed amount);
 
     function setUp() public virtual {
@@ -35,9 +34,6 @@ contract L2ToL1MessagePasserTest is CommonTest {
     ) external {
         uint256 nonce = messagePasser.nonce();
 
-        vm.expectEmit(true, true, true, true);
-        emit MessagePassed(nonce, _sender, _target, _value, _gasLimit, _data);
-
         bytes32 withdrawalHash = Hashing.hashWithdrawal(
             Types.WithdrawalTransaction({
                 nonce: nonce,
@@ -50,7 +46,7 @@ contract L2ToL1MessagePasserTest is CommonTest {
         );
 
         vm.expectEmit(true, true, true, true);
-        emit MessagePassedExtension1(withdrawalHash);
+        emit MessagePassed(nonce, _sender, _target, _value, _gasLimit, _data, withdrawalHash);
 
         vm.deal(_sender, _value);
         vm.prank(_sender);
@@ -65,9 +61,6 @@ contract L2ToL1MessagePasserTest is CommonTest {
 
     // Test: initiateWithdrawal should emit the correct log when called by a contract
     function test_initiateWithdrawal_fromContract() external {
-        vm.expectEmit(true, true, true, true);
-        emit MessagePassed(messagePasser.nonce(), address(this), address(4), 100, 64000, hex"");
-
         bytes32 withdrawalHash = Hashing.hashWithdrawal(
             Types.WithdrawalTransaction(
                 messagePasser.nonce(),
@@ -80,7 +73,15 @@ contract L2ToL1MessagePasserTest is CommonTest {
         );
 
         vm.expectEmit(true, true, true, true);
-        emit MessagePassedExtension1(withdrawalHash);
+        emit MessagePassed(
+            messagePasser.nonce(),
+            address(this),
+            address(4),
+            100,
+            64000,
+            hex"",
+            withdrawalHash
+        );
 
         vm.deal(address(this), 2**64);
         messagePasser.initiateWithdrawal{ value: 100 }(address(4), 64000, hex"");
@@ -97,13 +98,13 @@ contract L2ToL1MessagePasserTest is CommonTest {
         // EOA emulation
         vm.prank(alice, alice);
         vm.deal(alice, 2**64);
-        vm.expectEmit(true, true, true, true);
-        emit MessagePassed(nonce, alice, target, value, gasLimit, data);
-
         bytes32 withdrawalHash = Hashing.hashWithdrawal(
             Types.WithdrawalTransaction(nonce, alice, target, value, gasLimit, data)
         );
 
+        vm.expectEmit(true, true, true, true);
+        emit MessagePassed(nonce, alice, target, value, gasLimit, data, withdrawalHash);
+
         messagePasser.initiateWithdrawal{ value: value }(target, gasLimit, data);
 
         // the sent messages mapping is filled

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

@@ -269,7 +269,7 @@ contract OptimismPortal_FinalizeWithdrawal_Test is Portal_Initializer {
     bytes32 _storageRoot;
     bytes32 _outputRoot;
     bytes32 _withdrawalHash;
-    bytes _withdrawalProof;
+    bytes[] _withdrawalProof;
     Types.OutputRootProof internal _outputRootProof;
 
     event WithdrawalFinalized(bytes32 indexed, bool success);
@@ -422,7 +422,7 @@ contract OptimismPortal_FinalizeWithdrawal_Test is Portal_Initializer {
             gasLimit: gasLimit,
             data: hex""
         });
-        (bytes32 stateRoot, bytes32 storageRoot, , , bytes memory withdrawalProof) = ffi
+        (bytes32 stateRoot, bytes32 storageRoot, , , bytes[] memory withdrawalProof) = ffi
             .getFinalizeWithdrawalTransactionInputs(insufficientGasTx);
         Types.OutputRootProof memory outputRootProof = Types.OutputRootProof({
             version: bytes32(0),
@@ -463,7 +463,8 @@ contract OptimismPortal_FinalizeWithdrawal_Test is Portal_Initializer {
     function callPortalAndExpectRevert() external payable {
         vm.expectRevert("OptimismPortal: can only trigger one withdrawal per transaction");
         // Arguments here don't matter, as the require check is the first thing that happens.
-        op.finalizeWithdrawalTransaction(_defaultTx, 0, _outputRootProof, hex"");
+        bytes[] memory proof = new bytes[](1);
+        op.finalizeWithdrawalTransaction(_defaultTx, 0, _outputRootProof, proof);
         // Assert that the withdrawal was not finalized.
         assertFalse(op.finalizedWithdrawals(Hashing.hashWithdrawal(_defaultTx)));
     }
@@ -484,7 +485,7 @@ contract OptimismPortal_FinalizeWithdrawal_Test is Portal_Initializer {
             bytes32 storageRoot,
             bytes32 outputRoot,
             bytes32 withdrawalHash,
-            bytes memory withdrawalProof
+            bytes[] memory withdrawalProof
         ) = ffi.getFinalizeWithdrawalTransactionInputs(_testTx);
         Types.OutputRootProof memory outputRootProof = Types.OutputRootProof({
             version: bytes32(0),
@@ -544,7 +545,7 @@ contract OptimismPortal_FinalizeWithdrawal_Test is Portal_Initializer {
             bytes32 storageRoot,
             bytes32 outputRoot,
             bytes32 withdrawalHash,
-            bytes memory withdrawalProof
+            bytes[] memory withdrawalProof
         ) = ffi.getFinalizeWithdrawalTransactionInputs(_tx);
 
         Types.OutputRootProof memory proof = Types.OutputRootProof({

packages/contracts-bedrock/hardhat.config.ts

@@ -309,6 +309,10 @@ const config: HardhatUserConfig = {
       type: 'address',
       default: ethers.constants.AddressZero,
     },
+    proxyAdminOwner: {
+      type: 'address',
+      default: ethers.constants.AddressZero,
+    },
     gasPriceOracleOwner: {
       type: 'address',
       default: ethers.constants.AddressZero,

packages/contracts-bedrock/scripts/differential-testing.ts

@@ -13,7 +13,7 @@ import { Account, Address, toBuffer, bufferToHex } from '@ethereumjs/util'
 
 import { predeploys } from '../src'
 
-const { hexZeroPad, RLP, keccak256 } = utils
+const { hexZeroPad, keccak256 } = utils
 
 const args = process.argv.slice(2)
 const command = args[0]
@@ -215,11 +215,9 @@ const command = args[0]
         latestBlockhash: constants.HashZero,
       })
 
-      const encodedProof = RLP.encode(proof)
-
       const output = utils.defaultAbiCoder.encode(
-        ['bytes32', 'bytes32', 'bytes32', 'bytes32', 'bytes'],
-        [world.root, storage.root, outputRoot, withdrawalHash, encodedProof]
+        ['bytes32', 'bytes32', 'bytes32', 'bytes32', 'bytes[]'],
+        [world.root, storage.root, outputRoot, withdrawalHash, proof]
       )
       process.stdout.write(output)
       break

packages/contracts-bedrock/src/constants.ts

@@ -22,4 +22,9 @@ export const predeploys = {
   LegacyMessagePasser: '0x4200000000000000000000000000000000000000',
   L2ERC721Bridge: '0x4200000000000000000000000000000000000014',
   OptimismMintableERC721Factory: '0x4200000000000000000000000000000000000017',
+  ProxyAdmin: '0x4200000000000000000000000000000000000018',
+}
+
+export const futurePredeploys = {
+  System1: '0x4200000000000000000000000000000000000014',
 }

packages/contracts-bedrock/tasks/rekey.ts

@@ -8,7 +8,7 @@ task('rekey', 'Generates a new set of keys for a test network').setAction(
     const pathPrefix = "m/44'/60'/0'/0"
     const labels = [
       'l2OutputOracleProposer',
-      'proxyAdmin',
+      'proxyAdminOwner',
       'optimismBaseFeeRecipient',
       'optimismL1FeeRecipient',
       'optimismL2FeeRecipient',

packages/core-utils/src/optimism/hashing.ts

@@ -34,7 +34,7 @@ export interface OutputRootProof {
  */
 export interface BedrockCrossChainMessageProof {
   outputRootProof: OutputRootProof
-  withdrawalProof: string
+  withdrawalProof: string[]
 }
 
 /**

packages/sdk/src/cross-chain-messenger.ts

@@ -311,7 +311,7 @@ export class CrossChainMessenger {
         return parsed.name === 'SentMessage'
       })
       .map((log) => {
-        // Try to pull out the value field, but only if the very next log is a SentMessageExtraData
+        // Try to pull out the value field, but only if the very next log is a SentMessageExtension1
         // event which was introduced in the Bedrock upgrade.
         let value = ethers.BigNumber.from(0)
         const next = receipt.logs.find((l) => {
@@ -1214,11 +1214,9 @@ export class CrossChainMessenger {
 
     interface WithdrawalEntry {
       MessagePassed: any
-      MessagePassedExtension1: any
     }
 
-    // Handle multiple withdrawals in the same tx and be backwards
-    // compatible without MessagePassedExtension1
+    // Handle multiple withdrawals in the same tx
     const logs: Partial<{ number: WithdrawalEntry }> = {}
     for (const [i, log] of Object.entries(receipt.logs)) {
       if (log.address === this.contracts.l2.BedrockMessagePasser.address) {
@@ -1228,16 +1226,6 @@ export class CrossChainMessenger {
         if (decoded.name === 'MessagePassed') {
           logs[log.logIndex] = {
             MessagePassed: decoded.args,
-            MessagePassedExtension1: null,
-          }
-          if (receipt.logs[i + 1]) {
-            const next =
-              this.contracts.l2.L2ToL1MessagePasser.interface.parseLog(
-                receipt.logs[i + 1]
-              )
-            if (next.name === 'MessagePassedExtension1') {
-              logs[log.logIndex].MessagePassedExtension1 = next.args
-            }
           }
         }
       }
@@ -1262,11 +1250,9 @@ export class CrossChainMessenger {
     )
 
     // Sanity check
-    if (withdrawal.MessagePassedExtension1) {
-      if (withdrawal.MessagePassedExtension1.hash !== withdrawalHash) {
+    if (withdrawal.MessagePassed.withdrawalHash !== withdrawalHash) {
       throw new Error(`Mismatched withdrawal hashes`)
     }
-    }
 
     // TODO: turn into util
     const preimage = ethers.utils.defaultAbiCoder.encode(
@@ -1310,7 +1296,7 @@ export class CrossChainMessenger {
           messagePasserStorageRoot: stateTrieProof.storageRoot,
           latestBlockhash: block.hash,
         },
-        withdrawalProof: ethers.utils.RLP.encode(stateTrieProof.storageProof),
+        withdrawalProof: stateTrieProof.storageProof,
       },
       output,
       // TODO(tynes): use better type, typechain?

specs/predeploys.md

@@ -5,8 +5,8 @@
 **Table of Contents**
 
 - [Overview](#overview)
-- [OVM\_L2ToL1MessagePasser](#ovm%5C_l2tol1messagepasser)
-- [OVM\_DeployerWhitelist](#ovm%5C_deployerwhitelist)
+- [L2ToL1MessagePasser](#l2tol1messagepasser)
+- [DeployerWhitelist](#deployerwhitelist)
 - [OVM\_ETH](#ovm%5C_eth)
 - [WETH9](#weth9)
 - [L2CrossDomainMessenger](#l2crossdomainmessenger)
@@ -14,8 +14,9 @@
 - [SequencerFeeVault](#sequencerfeevault)
 - [OptimismMintableERC20Factory](#optimismmintableerc20factory)
 - [L1BlockNumber](#l1blocknumber)
-- [OVM\_GasPriceOracle](#ovm%5C_gaspriceoracle)
+- [GasPriceOracle](#gaspriceoracle)
 - [L1Block](#l1block)
+- [ProxyAdmin](#proxyadmin)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
@@ -52,8 +53,9 @@ or `Bedrock`. Deprecated contracts should not be used.
 | L2ToL1MessagePasser           | 0x4200000000000000000000000000000000000016 | Bedrock    | No         |
 | L2ERC721Bridge                | 0x4200000000000000000000000000000000000014 | Legacy     | No         |
 | OptimismMintableERC721Factory | 0x4200000000000000000000000000000000000017 | Bedrock    | No         |
+| ProxyAdmin                    | 0x4200000000000000000000000000000000000018 | Bedrock    | No         |
 
-## OVM\_L2ToL1MessagePasser
+## L2ToL1MessagePasser
 
 The `OVM_L2ToL1MessagePasser` stores commitments to withdrawal transactions.
 When a user is submitting the withdrawing transaction on L1, they provide a
@@ -73,9 +75,9 @@ interface iLegacyOVM_L2ToL1MessagePasser {
 }
 ```
 
-## OVM\_DeployerWhitelist
+## DeployerWhitelist
 
-The `OVM_DeployerWhitelist` is a predeploy used to provide additional
+The `DeployerWhitelist` is a predeploy used to provide additional
 safety during the initial phases of Optimism. It is owned by the
 Optimism team, and defines accounts which are allowed to deploy contracts to the
 network.
@@ -90,7 +92,7 @@ In the Bedrock system, this contract will no longer be used as part of the
 This contract is deprecated and its usage should be avoided.
 
 ```solidity
-interface iOVM_DeployerWhitelist {
+interface iDeployerWhitelist {
     event OwnerChanged(address,address);
     event WhitelistStatusChanged(address,bool);
     event WhitelistDisabled(address);
@@ -249,9 +251,9 @@ interface iOVM_L1BlockNumber {
 }
 ```
 
-## OVM\_GasPriceOracle
+## GasPriceOracle
 
-The `OVM_GasPriceOracle` is pushed the L1 basefee and the L2 gas price by
+The `GasPriceOracle` is pushed the L1 basefee and the L2 gas price by
 an offchain actor. The offchain actor observes the L1 blockheaders to get the
 L1 basefee as well as the gas usage on L2 to compute what the L2 gas price
 should be based on a congestion control algorithm.
@@ -261,7 +263,7 @@ Bedrock, but it is still used to hold the `overhead`, `scalar`, and `decimals`
 values which are used to compute the L1 portion of the transaction fee.
 
 ```solidity
-interface OVM_GasPriceOracle {
+interface GasPriceOracle {
     /**
      * @dev Returns the current gas price on L2
      */
@@ -370,3 +372,9 @@ interface L1Block {
     ) external;
 }
 ```
+
+## ProxyAdmin
+
+The `ProxyAdmin` is the owner of all of the proxy contracts set at the
+predeploys. It is not behind a proxy itself. The owner of the `ProxyAdmin` will
+have the ability to upgrade any of the other predeploy contracts.

specs/withdrawals.md

@@ -84,11 +84,10 @@ interface L2ToL1MessagePasser {
         address indexed target,
         uint256 value,
         uint256 gasLimit,
-        bytes data
+        bytes data,
+        bytes32 withdrawalHash
     );
 
-    event MessagePassedExtension1(bytes32 indexed hash);
-
     event WithdrawerBalanceBurnt(uint256 indexed amount);
 
     function burn() external;
@@ -103,12 +102,7 @@ interface L2ToL1MessagePasser {
 ```
 
 The `MessagePassed` event includes all of the data that is hashed and
-stored in the `sentMessages` mapping. The `MessagePassedExtension1` emits
-the hash that was computed and used as part of the storage proof used to
-finalize the withdrawal on L1.
-
-The events are separate as to preserve backwards compatibility. The hashing
-scheme could be upgraded in the future through a contract upgrade.
+stored in the `sentMessages` mapping, as well as the hash itself.
 
 ### Addresses are not Aliased on Withdrawals