unify genesis factories

fix predeploy documentation matrix to show ProxyAdmin as proxied

op-bindings/predeploys/addresses.go

@@ -5,7 +5,6 @@ import "github.com/ethereum/go-ethereum/common"
 const (
 	L2ToL1MessagePasser           = "0x4200000000000000000000000000000000000016"
 	DeployerWhitelist             = "0x4200000000000000000000000000000000000002"
-	LegacyERC20ETH                = "0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000"
 	WETH9                         = "0x4200000000000000000000000000000000000006"
 	L2CrossDomainMessenger        = "0x4200000000000000000000000000000000000007"
 	L2StandardBridge              = "0x4200000000000000000000000000000000000010"
@@ -26,7 +25,6 @@ const (
 var (
 	L2ToL1MessagePasserAddr           = common.HexToAddress(L2ToL1MessagePasser)
 	DeployerWhitelistAddr             = common.HexToAddress(DeployerWhitelist)
-	LegacyERC20ETHAddr                = common.HexToAddress(LegacyERC20ETH)
 	WETH9Addr                         = common.HexToAddress(WETH9)
 	L2CrossDomainMessengerAddr        = common.HexToAddress(L2CrossDomainMessenger)
 	L2StandardBridgeAddr              = common.HexToAddress(L2StandardBridge)
@@ -49,27 +47,17 @@ var (
 // IsProxied returns true for predeploys that will sit behind a proxy contract
 func IsProxied(predeployAddr common.Address) bool {
 	switch predeployAddr {
-	case LegacyERC20ETHAddr:
 	case WETH9Addr:
 	case GovernanceTokenAddr:
-	case ProxyAdminAddr:
 	default:
 		return true
 	}
 	return false
 }
 
-// IsDeprecated returns true for predeploys we should skip in post-bedrock genesis generation
-func IsDeprecated(predeployAddr common.Address) bool {
-	// TODO: confirm if we can safely add the remaining deprecated predeploys here
-	// (see https://github.com/ethereum-optimism/optimism/blob/develop/specs/predeploys.md#overview)
-	return predeployAddr == LegacyERC20ETHAddr
-}
-
 func init() {
 	Predeploys["L2ToL1MessagePasser"] = &L2ToL1MessagePasserAddr
 	Predeploys["DeployerWhitelist"] = &DeployerWhitelistAddr
-	Predeploys["LegacyERC20ETH"] = &LegacyERC20ETHAddr
 	Predeploys["WETH9"] = &WETH9Addr
 	Predeploys["L2CrossDomainMessenger"] = &L2CrossDomainMessengerAddr
 	Predeploys["L2StandardBridge"] = &L2StandardBridgeAddr

op-chain-ops/genesis/layer_two.go

 package genesis
 
 import (
-	"errors"
 	"fmt"
-	"math/big"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
 
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/immutables"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
 )
 
-// BuildL2DeveloperGenesis will build the developer Optimism Genesis
-// Block. Suitable for devnets.
-func BuildL2DeveloperGenesis(config *DeployConfig, l1StartBlock *types.Block) (*core.Genesis, error) {
+// BuildL2DeveloperGenesis will build the L2 genesis block.
+func BuildL2Genesis(config *DeployConfig, l1StartBlock *types.Block) (*core.Genesis, error) {
 	genspec, err := NewL2Genesis(config, l1StartBlock)
 	if err != nil {
 		return nil, err
 	}
 
 	db := state.NewMemoryStateDB(genspec)
-
 	if config.FundDevAccounts {
 		FundDevAccounts(db)
-	}
-	SetPrecompileBalances(db)
-
-	storage, err := NewL2StorageConfig(config, l1StartBlock)
-	if err != nil {
-		return nil, err
-	}
-
-	immutable, err := NewL2ImmutableConfig(config, l1StartBlock)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := SetL2Proxies(db); err != nil {
-		return nil, err
-	}
-
-	if err := SetImplementations(db, storage, immutable); err != nil {
-		return nil, err
+		SetPrecompileBalances(db)
 	}
 
-	if err := SetDevOnlyL2Implementations(db, storage, immutable); err != nil {
-		return nil, err
-	}
-
-	return db.Genesis(), nil
-}
-
-// BuildL2MainnetGenesis will build an L2 Genesis suitable for a Superchain mainnet that does not
-// require a pre-bedrock migration & supports optional governance token predeploy. Details:
-//
-//   - Creates proxies for predeploys in the address space:
-//     [0x4200000000000000000000000000000000000000, 0x4200000000000000000000000000000000000800)
-//
-//   - All predeploy proxies owned by the ProxyAdmin
-//
-//   - Predeploys as per the spec except for no LegacyERC20ETH predeploy at
-//     0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000
-//
-//   - optional governance token at 0x4200000000000000000000000000000000000042 if
-//     config.EnableGovernance is true (& otherwise a no-impl proxy remains at this address)
-//
-//   - no accounts are pre-funded
-func BuildL2MainnetGenesis(config *DeployConfig, l1StartBlock *types.Block) (*core.Genesis, error) {
-	genspec, err := NewL2Genesis(config, l1StartBlock)
-	if err != nil {
-		return nil, err
-	}
-
-	db := state.NewMemoryStateDB(genspec)
-
 	storage, err := NewL2StorageConfig(config, l1StartBlock)
 	if err != nil {
 		return nil, err
@@ -90,20 +36,10 @@ func BuildL2MainnetGenesis(config *DeployConfig, l1StartBlock *types.Block) (*co
 	}
 
 	// Set up the proxies
-	depBytecode, err := bindings.GetDeployedBytecode("Proxy")
+	err = setProxies(db, predeploys.ProxyAdminAddr, bigL2PredeployNamespace, 2048)
 	if err != nil {
 		return nil, err
 	}
-	if len(depBytecode) == 0 {
-		return nil, errors.New("Proxy has empty bytecode")
-	}
-	for i := uint64(0); i <= 2048; i++ {
-		bigAddr := new(big.Int).Or(bigL2PredeployNamespace, new(big.Int).SetUint64(i))
-		addr := common.BigToAddress(bigAddr)
-		db.CreateAccount(addr)
-		db.SetCode(addr, depBytecode)
-		db.SetState(addr, AdminSlot, predeploys.ProxyAdminAddr.Hash())
-	}
 
 	// Set up the implementations
 	deployResults, err := immutables.BuildOptimism(immutable)
@@ -112,9 +48,6 @@ func BuildL2MainnetGenesis(config *DeployConfig, l1StartBlock *types.Block) (*co
 	}
 	for name, predeploy := range predeploys.Predeploys {
 		addr := *predeploy
-		if predeploys.IsDeprecated(addr) {
-			continue
-		}
 		if addr == predeploys.GovernanceTokenAddr && !config.EnableGovernance {
 			// there is no governance token configured, so skip the governance token predeploy
 			log.Warn("Governance is not enabled, skipping governance token predeploy.")

op-chain-ops/genesis/layer_two_test.go

@@ -28,80 +28,8 @@ func init() {
 
 var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 
-func TestBuildL2DeveloperGenesis(t *testing.T) {
-	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
-	require.Nil(t, err)
-
-	backend := backends.NewSimulatedBackend(
-		core.GenesisAlloc{
-			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
-		},
-		15000000,
-	)
-	block, err := backend.BlockByNumber(context.Background(), common.Big0)
-	require.NoError(t, err)
-
-	gen, err := genesis.BuildL2DeveloperGenesis(config, block)
-	require.Nil(t, err)
-	require.NotNil(t, gen)
-
-	proxyBytecode, err := bindings.GetDeployedBytecode("Proxy")
-	require.NoError(t, err)
-
-	for name, address := range predeploys.Predeploys {
-		addr := *address
-
-		account, ok := gen.Alloc[addr]
-		require.Equal(t, true, ok)
-		require.Greater(t, len(account.Code), 0)
-
-		if name == "GovernanceToken" || name == "LegacyERC20ETH" || name == "ProxyAdmin" || name == "WETH9" {
-			continue
-		}
-
-		adminSlot, ok := account.Storage[genesis.AdminSlot]
-		require.Equal(t, true, ok, name)
-		require.Equal(t, predeploys.ProxyAdminAddr.Hash(), adminSlot)
-		require.Equal(t, proxyBytecode, account.Code)
-	}
-	require.Equal(t, 2343, len(gen.Alloc))
-
-	if writeFile {
-		file, _ := json.MarshalIndent(gen, "", " ")
-		_ = os.WriteFile("genesis.json", file, 0644)
-	}
-}
-
-func TestBuildL2DeveloperGenesisDevAccountsFunding(t *testing.T) {
-	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
-	require.Nil(t, err)
-	config.FundDevAccounts = false
-
-	err = config.InitDeveloperDeployedAddresses()
-	require.NoError(t, err)
-
-	backend := backends.NewSimulatedBackend(
-		core.GenesisAlloc{
-			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
-		},
-		15000000,
-	)
-	block, err := backend.BlockByNumber(context.Background(), common.Big0)
-	require.NoError(t, err)
-
-	gen, err := genesis.BuildL2DeveloperGenesis(config, block)
-	require.NoError(t, err)
-	require.Equal(t, 2321, len(gen.Alloc))
-}
-
-// Tests the BuildL2MainnetGenesis factory. enableGovernance is used to override enableGovernance
-// config option. When false, the test confirms the governance token predeploy address instead
-// holds a proxy contract.
-func testBuildL2Genesis(t *testing.T, enableGovernance bool) {
-	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
-	require.Nil(t, err)
-	config.EnableGovernance = enableGovernance
-
+// Tests the BuildL2MainnetGenesis factory with the provided config.
+func testBuildL2Genesis(t *testing.T, config *genesis.DeployConfig) *core.Genesis {
 	backend := backends.NewSimulatedBackend(
 		core.GenesisAlloc{
 			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
@@ -111,7 +39,7 @@ func testBuildL2Genesis(t *testing.T, enableGovernance bool) {
 	block, err := backend.BlockByNumber(context.Background(), common.Big0)
 	require.NoError(t, err)
 
-	gen, err := genesis.BuildL2MainnetGenesis(config, block)
+	gen, err := genesis.BuildL2Genesis(config, block)
 	require.Nil(t, err)
 	require.NotNil(t, gen)
 
@@ -122,17 +50,12 @@ func testBuildL2Genesis(t *testing.T, enableGovernance bool) {
 		addr := *predeploy
 
 		account, ok := gen.Alloc[addr]
-		if predeploys.IsDeprecated(addr) && !predeploys.IsProxied(addr) {
-			// deprecated, non-proxied predeploys should have no account
-			require.Equal(t, false, ok, name)
-			continue
-		}
 		require.Equal(t, true, ok, name)
 		require.Greater(t, len(account.Code), 0)
 
 		adminSlot, ok := account.Storage[genesis.AdminSlot]
 		isProxy := predeploys.IsProxied(addr) ||
-			(!enableGovernance && addr == predeploys.GovernanceTokenAddr)
+			(!config.EnableGovernance && addr == predeploys.GovernanceTokenAddr)
 		if isProxy {
 			require.Equal(t, true, ok, name)
 			require.Equal(t, predeploys.ProxyAdminAddr.Hash(), adminSlot)
@@ -142,18 +65,39 @@ func testBuildL2Genesis(t *testing.T, enableGovernance bool) {
 			require.NotEqual(t, proxyBytecode, account.Code, name)
 		}
 	}
-	require.Equal(t, 2063, len(gen.Alloc))
 
 	if writeFile {
 		file, _ := json.MarshalIndent(gen, "", " ")
 		_ = os.WriteFile("genesis.json", file, 0644)
 	}
+	return gen
+}
+
+func TestBuildL2DeveloperGenesis(t *testing.T) {
+	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
+	require.Nil(t, err)
+	config.EnableGovernance = false
+	config.FundDevAccounts = true
+	err = config.InitDeveloperDeployedAddresses()
+	require.NoError(t, err)
+	gen := testBuildL2Genesis(t, config)
+	require.Equal(t, 2342, len(gen.Alloc))
 }
 
 func TestBuildL2MainnetGenesis(t *testing.T) {
-	testBuildL2Genesis(t, true)
+	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
+	require.Nil(t, err)
+	config.EnableGovernance = true
+	config.FundDevAccounts = false
+	gen := testBuildL2Genesis(t, config)
+	require.Equal(t, 2064, len(gen.Alloc))
 }
 
 func TestBuildL2MainnetNoGovernanceGenesis(t *testing.T) {
-	testBuildL2Genesis(t, false)
+	config, err := genesis.NewDeployConfig("./testdata/test-deploy-config-devnet-l1.json")
+	require.Nil(t, err)
+	config.EnableGovernance = false
+	config.FundDevAccounts = false
+	gen := testBuildL2Genesis(t, config)
+	require.Equal(t, 2064, len(gen.Alloc))
 }

op-chain-ops/genesis/setters.go

@@ -2,12 +2,10 @@ package genesis
 
 import (
 	"errors"
-	"fmt"
 	"math/big"
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 
-	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/immutables"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
 	"github.com/ethereum/go-ethereum/common"
@@ -15,19 +13,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-// UntouchableCodeHashes contains code hashes of all the contracts
-// that should not be touched by the migration process.
-type ChainHashMap map[uint64]common.Hash
-
-var (
-	// UntouchablePredeploys are addresses in the predeploy namespace
-	// that should not be touched by the migration process.
-	UntouchablePredeploys = map[common.Address]bool{
-		predeploys.GovernanceTokenAddr: true,
-		predeploys.WETH9Addr:           true,
-	}
-)
-
 // FundDevAccounts will fund each of the development accounts.
 func FundDevAccounts(db vm.StateDB) {
 	for _, account := range DevAccounts {
@@ -36,14 +21,6 @@ func FundDevAccounts(db vm.StateDB) {
 	}
 }
 
-// SetL2Proxies will set each of the proxies in the state. It requires
-// 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) error {
-	return setProxies(db, predeploys.ProxyAdminAddr, bigL2PredeployNamespace, 2048)
-}
-
 // SetL1Proxies will set each of the proxies in the state. It requires
 // 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
@@ -65,11 +42,6 @@ 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)
 
-		if UntouchablePredeploys[addr] {
-			log.Info("Skipping setting proxy", "address", addr)
-			continue
-		}
-
 		if !db.Exist(addr) {
 			db.CreateAccount(addr)
 		}
@@ -82,87 +54,6 @@ func setProxies(db vm.StateDB, proxyAdminAddr common.Address, namespace *big.Int
 	return nil
 }
 
-func SetLegacyETH(db vm.StateDB, storage state.StorageConfig, immutable immutables.ImmutableConfig) error {
-	deployResults, err := immutables.BuildOptimism(immutable)
-	if err != nil {
-		return err
-	}
-
-	return setupPredeploy(db, deployResults, storage, "LegacyERC20ETH", predeploys.LegacyERC20ETHAddr, predeploys.LegacyERC20ETHAddr)
-}
-
-// SetImplementations will set the implementations of the contracts in the state
-// and configure the proxies to point to the implementations. It also sets
-// the appropriate storage values for each contract at the proxy address.
-func SetImplementations(db vm.StateDB, storage state.StorageConfig, immutable immutables.ImmutableConfig) error {
-	deployResults, err := immutables.BuildOptimism(immutable)
-	if err != nil {
-		return err
-	}
-
-	for name, address := range predeploys.Predeploys {
-		if UntouchablePredeploys[*address] {
-			continue
-		}
-
-		if *address == predeploys.LegacyERC20ETHAddr {
-			continue
-		}
-
-		codeAddr, err := AddressToCodeNamespace(*address)
-		if err != nil {
-			return fmt.Errorf("error converting to code namespace: %w", err)
-		}
-
-		if !db.Exist(codeAddr) {
-			db.CreateAccount(codeAddr)
-		}
-
-		db.SetState(*address, ImplementationSlot, codeAddr.Hash())
-
-		if err := setupPredeploy(db, deployResults, storage, name, *address, codeAddr); err != nil {
-			return err
-		}
-
-		code := db.GetCode(codeAddr)
-		if len(code) == 0 {
-			return fmt.Errorf("code not set for %s", name)
-		}
-	}
-	return nil
-}
-
-func SetDevOnlyL2Implementations(db vm.StateDB, storage state.StorageConfig, immutable immutables.ImmutableConfig) error {
-	deployResults, err := immutables.BuildOptimism(immutable)
-	if err != nil {
-		return err
-	}
-
-	for name, address := range predeploys.Predeploys {
-		if !UntouchablePredeploys[*address] {
-			continue
-		}
-
-		db.CreateAccount(*address)
-
-		if err := setupPredeploy(db, deployResults, storage, name, *address, *address); err != nil {
-			return err
-		}
-
-		code := db.GetCode(*address)
-		if len(code) == 0 {
-			return fmt.Errorf("code not set for %s", name)
-		}
-	}
-
-	db.CreateAccount(predeploys.LegacyERC20ETHAddr)
-	if err := setupPredeploy(db, deployResults, storage, "LegacyERC20ETH", predeploys.LegacyERC20ETHAddr, predeploys.LegacyERC20ETHAddr); err != nil {
-		return fmt.Errorf("error setting up legacy eth: %w", err)
-	}
-
-	return nil
-}
-
 // SetPrecompileBalances will set a single wei at each precompile address.
 // This is an optimization to make calling them cheaper. This should only
 // be used for devnets.

op-e2e/e2eutils/setup.go

@@ -185,7 +185,7 @@ func Setup(t require.TestingT, deployParams *DeployParams, alloc *AllocParams) *
 
 	l1Block := l1Genesis.ToBlock()
 
-	l2Genesis, err := genesis.BuildL2DeveloperGenesis(deployConf, l1Block)
+	l2Genesis, err := genesis.BuildL2Genesis(deployConf, l1Block)
 	require.NoError(t, err, "failed to create l2 genesis")
 	if alloc.PrefundTestUsers {
 		for _, addr := range deployParams.Addresses.All() {

op-e2e/op_geth.go

@@ -53,7 +53,7 @@ func NewOpGeth(t *testing.T, ctx context.Context, cfg *SystemConfig) (*OpGeth, e
 	require.Nil(t, err)
 	l1Block := l1Genesis.ToBlock()
 
-	l2Genesis, err := genesis.BuildL2DeveloperGenesis(cfg.DeployConfig, l1Block)
+	l2Genesis, err := genesis.BuildL2Genesis(cfg.DeployConfig, l1Block)
 	require.Nil(t, err)
 	l2GenesisBlock := l2Genesis.ToBlock()
 

op-e2e/setup.go

@@ -359,7 +359,7 @@ func (cfg SystemConfig) Start(_opts ...SystemConfigOption) (*System, error) {
 	}
 
 	l1Block := l1Genesis.ToBlock()
-	l2Genesis, err := genesis.BuildL2DeveloperGenesis(cfg.DeployConfig, l1Block)
+	l2Genesis, err := genesis.BuildL2Genesis(cfg.DeployConfig, l1Block)
 	if err != nil {
 		return nil, err
 	}

op-node/cmd/genesis/cmd.go

@@ -61,7 +61,7 @@ var Subcommands = cli.Commands{
 			}
 
 			l1StartBlock := l1Genesis.ToBlock()
-			l2Genesis, err := genesis.BuildL2DeveloperGenesis(config, l1StartBlock)
+			l2Genesis, err := genesis.BuildL2Genesis(config, l1StartBlock)
 			if err != nil {
 				return err
 			}
@@ -144,7 +144,7 @@ var Subcommands = cli.Commands{
 			}
 
 			// Build the developer L2 genesis block
-			l2Genesis, err := genesis.BuildL2DeveloperGenesis(config, l1StartBlock)
+			l2Genesis, err := genesis.BuildL2Genesis(config, l1StartBlock)
 			if err != nil {
 				return fmt.Errorf("error creating l2 developer genesis: %w", err)
 			}

packages/contracts-bedrock/tasks/check-l2.ts

@@ -465,46 +465,6 @@ const check = {
     await checkProxy(hre, 'L1Block', signer.provider)
     await assertProxy(hre, 'L1Block', signer.provider)
   },
-  // LegacyERC20ETH
-  // - not behind a proxy
-  // - check name
-  // - check symbol
-  // - check decimals
-  // - check BRIDGE
-  // - check REMOTE_TOKEN
-  // - totalSupply should be set to 0
-  LegacyERC20ETH: async (hre: HardhatRuntimeEnvironment, signer: Signer) => {
-    const LegacyERC20ETH = await hre.ethers.getContractAt(
-      'LegacyERC20ETH',
-      predeploys.LegacyERC20ETH,
-      signer
-    )
-
-    const name = await LegacyERC20ETH.name()
-    assert(name === 'Ether')
-    console.log(`  - name: ${name}`)
-
-    const symbol = await LegacyERC20ETH.symbol()
-    assert(symbol === 'ETH')
-    console.log(`  - symbol: ${symbol}`)
-
-    const decimals = await LegacyERC20ETH.decimals()
-    assert(decimals === 18)
-    console.log(`  - decimals: ${decimals}`)
-
-    const BRIDGE = await LegacyERC20ETH.BRIDGE()
-    assert(BRIDGE === predeploys.L2StandardBridge)
-
-    const REMOTE_TOKEN = await LegacyERC20ETH.REMOTE_TOKEN()
-    assert(REMOTE_TOKEN === hre.ethers.constants.AddressZero)
-
-    const totalSupply = await LegacyERC20ETH.totalSupply()
-    assert(totalSupply.eq(0))
-    console.log(`  - totalSupply: ${totalSupply}`)
-
-    await checkProxy(hre, 'LegacyERC20ETH', signer.provider)
-    // No proxy at this address, don't call assertProxy
-  },
   // WETH9
   // - check name
   // - check symbol

specs/predeploys.md

@@ -62,7 +62,7 @@ or `Bedrock`. Deprecated contracts should not be used.
 | L2ToL1MessagePasser           | 0x4200000000000000000000000000000000000016 | Bedrock    | No         | Yes     |
 | L2ERC721Bridge                | 0x4200000000000000000000000000000000000014 | Legacy     | No         | Yes     |
 | OptimismMintableERC721Factory | 0x4200000000000000000000000000000000000017 | Bedrock    | No         | Yes     |
-| ProxyAdmin                    | 0x4200000000000000000000000000000000000018 | Bedrock    | No         | No      |
+| ProxyAdmin                    | 0x4200000000000000000000000000000000000018 | Bedrock    | No         | Yes     |
 | BaseFeeVault                  | 0x4200000000000000000000000000000000000019 | Bedrock    | No         | Yes     |
 | L1FeeVault                    | 0x420000000000000000000000000000000000001a | Bedrock    | No         | Yes     |