Merge pull request #8489 from ethereum-optimism/op-upgrade/extended-pause

op-upgrade: extended pause

op-chain-ops/cmd/op-upgrade-extended-pause/README.md

+# op-upgrade-extended-pause
+
+One off CLI tooling for the extended pause upgrade

op-chain-ops/cmd/op-upgrade-extended-pause/main.go

+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/mattn/go-isatty"
+	"github.com/urfave/cli/v2"
+
+	"github.com/ethereum-optimism/optimism/op-chain-ops/clients"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/safe"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/upgrades"
+
+	"github.com/ethereum-optimism/superchain-registry/superchain"
+)
+
+// deployments contains the L1 addresses of the contracts that are being upgraded to.
+// Note that the key is the L2 chain id. This is because the L1 contracts must be specific
+// for a particular OP Stack chain and cannot currently be used by multiple chains.
+var deployments = map[uint64]superchain.ImplementationList{
+	// Base Sepolia
+	84532: {
+		L1CrossDomainMessenger: superchain.VersionedContract{
+			Version: "2.1.1",
+			Address: superchain.HexToAddress("0x442d5c024a80c34d64fed048bdc7c50dd84665c4"),
+		},
+		L1ERC721Bridge: superchain.VersionedContract{
+			Version: "2.0.0",
+			Address: superchain.HexToAddress("0x30e2c20c73353b8ddb6021d5636aef1b91727077"),
+		},
+		L1StandardBridge: superchain.VersionedContract{
+			Version: "2.0.0",
+			Address: superchain.HexToAddress("0xf71db0a6955b3edc78a267cd6441feed4ee0197b"),
+		},
+		OptimismPortal: superchain.VersionedContract{
+			Version: "2.1.0",
+			Address: superchain.HexToAddress("0x770d02b87e081e61ab30713b0ece6dfade792aff"),
+		},
+		SystemConfig: superchain.VersionedContract{
+			Version: "1.11.0",
+			Address: superchain.HexToAddress("0xf55b3dbb3bd2f2fa9236b0be6e8b9e91b819fd14"),
+		},
+		L2OutputOracle: superchain.VersionedContract{
+			Version: "1.7.0",
+			Address: superchain.HexToAddress("0x1187d73b0580f607e1b9c03698238fcad483e776"),
+		},
+		OptimismMintableERC20Factory: superchain.VersionedContract{
+			Version: "1.8.0",
+			Address: superchain.HexToAddress("0x6B047052dc3DafbA003e2fA4fEEe2e883dd5575B"),
+		},
+	},
+	// OP Sepolia
+	11155420: {
+		L1CrossDomainMessenger: superchain.VersionedContract{
+			Version: "2.1.1",
+			Address: superchain.HexToAddress("0xc3c7e6f4ad6a593a9731a39fa883ec1999d7d873"),
+		},
+		L1ERC721Bridge: superchain.VersionedContract{
+			Version: "2.0.0",
+			Address: superchain.HexToAddress("0x532cad52e1f812eeb9c9a9571e07fef55993fefa"),
+		},
+		L1StandardBridge: superchain.VersionedContract{
+			Version: "2.0.0",
+			Address: superchain.HexToAddress("0xe19c7a2c0bb32287731ea75da9b1c836815964f1"),
+		},
+		OptimismPortal: superchain.VersionedContract{
+			Version: "2.1.0",
+			Address: superchain.HexToAddress("0x592B7D3255a8037307d23C16cC8c13a9563c8Ab1"),
+		},
+		SystemConfig: superchain.VersionedContract{
+			Version: "1.11.0",
+			Address: superchain.HexToAddress("0xce77d580e0befbb1561376a722217017651b9dbf"),
+		},
+		L2OutputOracle: superchain.VersionedContract{
+			Version: "1.7.0",
+			Address: superchain.HexToAddress("0x83aEb8B156cD90E64C702781C84A681DADb1DDe2"),
+		},
+		OptimismMintableERC20Factory: superchain.VersionedContract{
+			Version: "1.8.0",
+			Address: superchain.HexToAddress("0xd7e63ec8ec03803236be93642a610641dee51e62"),
+		},
+	},
+	// Zora Sepolia
+	999999999: {
+		L1CrossDomainMessenger: superchain.VersionedContract{
+			Version: "2.1.1",
+			Address: superchain.HexToAddress("0xb74e6f01cddfc53cd48fb94e14137a0801a67ee4"),
+		},
+		L1ERC721Bridge: superchain.VersionedContract{
+			Version: "2.0.0",
+			Address: superchain.HexToAddress("0x5ff51b220049151710752ebe65d0a060020f6018"),
+		},
+		L1StandardBridge: superchain.VersionedContract{
+			Version: "2.0.0",
+			Address: superchain.HexToAddress("0xf8e25ec7ca94a960a9392c56c55b68414f5c7ded"),
+		},
+		OptimismPortal: superchain.VersionedContract{
+			Version: "2.1.0",
+			Address: superchain.HexToAddress("0xd2b5f6dfa6fdfd89327a5aa4c787a89456ef0ca8"),
+		},
+		SystemConfig: superchain.VersionedContract{
+			Version: "1.11.0",
+			Address: superchain.HexToAddress("0xaeb5f8ed2977e70f4ddacf2f603c0dcf8e561873"),
+		},
+		L2OutputOracle: superchain.VersionedContract{
+			Version: "1.7.0",
+			Address: superchain.HexToAddress("0x1d5a9755983fa8520bb0fc5caf7904fac77ede76"),
+		},
+		OptimismMintableERC20Factory: superchain.VersionedContract{
+			Version: "1.8.0",
+			Address: superchain.HexToAddress("0xc1fa0ca70cd4f392883d2abe00d3971230382996"),
+		},
+	},
+	// PGN Sepolia
+	58008: {
+		L1CrossDomainMessenger: superchain.VersionedContract{
+			Version: "2.1.1",
+			Address: superchain.HexToAddress("0x99bb19a985e1def20d363405c5943d10e715dc12"),
+		},
+		L1ERC721Bridge: superchain.VersionedContract{
+			Version: "2.0.0",
+			Address: superchain.HexToAddress("0x89eba5aeb024534e6e1575c6bdb0f4f70d32f7da"),
+		},
+		L1StandardBridge: superchain.VersionedContract{
+			Version: "2.0.0",
+			Address: superchain.HexToAddress("0x9cde10006cac4423505864c904e2cfcf124dcaee"),
+		},
+		OptimismPortal: superchain.VersionedContract{
+			Version: "2.1.0",
+			Address: superchain.HexToAddress("0x725da050f385e52c0ae700e8c433c3636aba4592"),
+		},
+		SystemConfig: superchain.VersionedContract{
+			Version: "1.11.0",
+			Address: superchain.HexToAddress("0xd1557adfee8eda61619fc227c3dbb41fc16fc840"),
+		},
+		L2OutputOracle: superchain.VersionedContract{
+			Version: "1.7.0",
+			Address: superchain.HexToAddress("0xfae8e4695a0c96ea7ce20e1ed8d401604964315a"),
+		},
+		OptimismMintableERC20Factory: superchain.VersionedContract{
+			Version: "1.8.0",
+			Address: superchain.HexToAddress("0x8b55bf68569a9561a60d48419453ee570f87f7f0"),
+		},
+	},
+}
+
+func main() {
+	log.Root().SetHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(isatty.IsTerminal(os.Stderr.Fd()))))
+
+	app := &cli.App{
+		Name:  "op-upgrade",
+		Usage: "Build transactions useful for upgrading the Superchain",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:     "l1-rpc-url",
+				Value:    "http://127.0.0.1:8545",
+				Usage:    "L1 RPC URL, the chain ID will be used to determine the superchain",
+				Required: true,
+				EnvVars:  []string{"L1_RPC_URL"},
+			},
+			&cli.StringFlag{
+				Name:     "l2-rpc-url",
+				Value:    "http://127.0.0.1:9545",
+				Usage:    "L2 RPC URL",
+				Required: true,
+				EnvVars:  []string{"L2_RPC_URL"},
+			},
+			&cli.PathFlag{
+				Name:     "deploy-config",
+				Usage:    "The path to the deploy config file",
+				Required: true,
+				EnvVars:  []string{"DEPLOY_CONFIG"},
+			},
+			&cli.PathFlag{
+				Name:    "outfile",
+				Usage:   "The file to write the output to. If not specified, output is written to stdout",
+				EnvVars: []string{"OUTFILE"},
+			},
+		},
+		Action: entrypoint,
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		log.Crit("error op-upgrade", "err", err)
+	}
+}
+
+// entrypoint contains the main logic of the script
+func entrypoint(ctx *cli.Context) error {
+	config, err := genesis.NewDeployConfig(ctx.Path("deploy-config"))
+	if err != nil {
+		return err
+	}
+	if err := config.Check(); err != nil {
+		return fmt.Errorf("error checking deploy config: %w", err)
+	}
+
+	clients, err := clients.NewClients(ctx.String("l1-rpc-url"), ctx.String("l2-rpc-url"))
+	if err != nil {
+		return fmt.Errorf("cannot create RPC clients: %w", err)
+	}
+	if clients.L1Client == nil {
+		return errors.New("Cannot create L1 client")
+	}
+	if clients.L2Client == nil {
+		return errors.New("Cannot create L2 client")
+	}
+
+	l1ChainID, err := clients.L1Client.ChainID(ctx.Context)
+	if err != nil {
+		return fmt.Errorf("cannot fetch L1 chain ID: %w", err)
+	}
+	l2ChainID, err := clients.L2Client.ChainID(ctx.Context)
+	if err != nil {
+		return fmt.Errorf("cannot fetch L2 chain ID: %w", err)
+	}
+
+	log.Info("connected to chains", "l1-chain-id", l1ChainID, "l2-chain-id", l2ChainID)
+
+	// Create a batch of transactions
+	batch := safe.Batch{}
+
+	list, ok := deployments[l2ChainID.Uint64()]
+	if !ok {
+		return fmt.Errorf("no implementations for chain ID %d", l2ChainID)
+	}
+
+	proxyAddresses, ok := superchain.Addresses[l2ChainID.Uint64()]
+	if !ok {
+		return fmt.Errorf("no proxy addresses for chain ID %d", l2ChainID)
+	}
+
+	chainConfig, ok := superchain.OPChains[l2ChainID.Uint64()]
+	if !ok {
+		return fmt.Errorf("no chain config for chain ID %d", l2ChainID)
+	}
+
+	log.Info("Upgrading to the following versions")
+	log.Info("L1CrossDomainMessenger", "version", list.L1CrossDomainMessenger.Version, "address", list.L1CrossDomainMessenger.Address)
+	log.Info("L1ERC721Bridge", "version", list.L1ERC721Bridge.Version, "address", list.L1ERC721Bridge.Address)
+	log.Info("L1StandardBridge", "version", list.L1StandardBridge.Version, "address", list.L1StandardBridge.Address)
+	log.Info("L2OutputOracle", "version", list.L2OutputOracle.Version, "address", list.L2OutputOracle.Address)
+	log.Info("OptimismMintableERC20Factory", "version", list.OptimismMintableERC20Factory.Version, "address", list.OptimismMintableERC20Factory.Address)
+	log.Info("OptimismPortal", "version", list.OptimismPortal.Version, "address", list.OptimismPortal.Address)
+	log.Info("SystemConfig", "version", list.SystemConfig.Version, "address", list.SystemConfig.Address)
+
+	if err := upgrades.CheckL1(ctx.Context, &list, clients.L1Client); err != nil {
+		return fmt.Errorf("error checking L1 contracts: %w", err)
+	}
+
+	// Build the batch
+	if err := upgrades.L1(&batch, list, *proxyAddresses, config, chainConfig, clients.L1Client); err != nil {
+		return fmt.Errorf("cannot build L1 upgrade batch: %w", err)
+	}
+
+	// Write the batch to disk or stdout
+	if outfile := ctx.Path("outfile"); outfile != "" {
+		if err := writeJSON(outfile, batch); err != nil {
+			return err
+		}
+	} else {
+		data, err := json.MarshalIndent(batch, "", "  ")
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(data))
+	}
+	return nil
+}
+
+func writeJSON(outfile string, input interface{}) error {
+	f, err := os.OpenFile(outfile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o666)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	enc := json.NewEncoder(f)
+	enc.SetIndent("", "  ")
+	return enc.Encode(input)
+}

op-chain-ops/upgrades/l1.go

@@ -14,9 +14,25 @@ import (
 	"github.com/ethereum-optimism/superchain-registry/superchain"
 )
 
-// upgradeAndCall represents the signature of the upgradeAndCall function
-// on the ProxyAdmin contract.
-const upgradeAndCall = "upgradeAndCall(address,address,bytes)"
+const (
+	// upgradeAndCall represents the signature of the upgradeAndCall function
+	// on the ProxyAdmin contract.
+	upgradeAndCall = "upgradeAndCall(address,address,bytes)"
+	// upgrade represents the signature of the upgrade function on the ProxyAdmin contract.
+	upgrade = "upgrade(address,address)"
+
+	method = "setBytes32"
+)
+
+var (
+	// storageSetterAddr represents the address of the StorageSetter contract.
+	storageSetterAddr = common.HexToAddress("0xd81f43eDBCAcb4c29a9bA38a13Ee5d79278270cC")
+
+	// superchainConfigProxy refers to the address of the Sepolia superchain config proxy.
+	// NOTE: this is currently hardcoded and we will need to move this to the superchain-registry
+	// and have 1 deployed for each superchain target.
+	superchainConfigProxy = common.HexToAddress("0xC2Be75506d5724086DEB7245bd260Cc9753911Be")
+)
 
 // L1 will add calls for upgrading each of the L1 contracts.
 func L1(batch *safe.Batch, implementations superchain.ImplementationList, list superchain.AddressList, config *genesis.DeployConfig, chainConfig *superchain.ChainConfig, backend bind.ContractBackend) error {
@@ -51,12 +67,47 @@ func L1CrossDomainMessenger(batch *safe.Batch, implementations superchain.Implem
 		return err
 	}
 
+	// 2 Step Upgrade
+	{
+		storageSetterABI, err := bindings.StorageSetterMetaData.GetAbi()
+		if err != nil {
+			return err
+		}
+
+		input := []bindings.StorageSetterSlot{
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L11-L13
+			{
+				Key:   common.Hash{},
+				Value: common.Hash{},
+			},
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L28
+			{
+				Key:   common.Hash{31: 249},
+				Value: common.Hash{},
+			},
+		}
+
+		calldata, err := storageSetterABI.Pack(method, input)
+		if err != nil {
+			return err
+		}
+		args := []any{
+			common.HexToAddress(list.L1CrossDomainMessengerProxy.String()),
+			storageSetterAddr,
+			calldata,
+		}
+		proxyAdmin := common.HexToAddress(list.ProxyAdmin.String())
+		if err := batch.AddCall(proxyAdmin, common.Big0, upgradeAndCall, args, proxyAdminABI); err != nil {
+			return err
+		}
+	}
+
 	l1CrossDomainMessengerABI, err := bindings.L1CrossDomainMessengerMetaData.GetAbi()
 	if err != nil {
 		return err
 	}
 
-	calldata, err := l1CrossDomainMessengerABI.Pack("initialize", common.HexToAddress(list.OptimismPortalProxy.String()))
+	calldata, err := l1CrossDomainMessengerABI.Pack("initialize", superchainConfigProxy)
 	if err != nil {
 		return err
 	}
@@ -82,12 +133,42 @@ func L1ERC721Bridge(batch *safe.Batch, implementations superchain.Implementation
 		return err
 	}
 
+	// 2 Step Upgrade
+	{
+		storageSetterABI, err := bindings.StorageSetterMetaData.GetAbi()
+		if err != nil {
+			return err
+		}
+
+		input := []bindings.StorageSetterSlot{
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L100-L102
+			{
+				Key:   common.Hash{},
+				Value: common.Hash{},
+			},
+		}
+
+		calldata, err := storageSetterABI.Pack(method, input)
+		if err != nil {
+			return fmt.Errorf("setBytes32: %w", err)
+		}
+		args := []any{
+			common.HexToAddress(list.L1ERC721BridgeProxy.String()),
+			storageSetterAddr,
+			calldata,
+		}
+		proxyAdmin := common.HexToAddress(list.ProxyAdmin.String())
+		if err := batch.AddCall(proxyAdmin, common.Big0, upgradeAndCall, args, proxyAdminABI); err != nil {
+			return err
+		}
+	}
+
 	l1ERC721BridgeABI, err := bindings.L1ERC721BridgeMetaData.GetAbi()
 	if err != nil {
 		return err
 	}
 
-	calldata, err := l1ERC721BridgeABI.Pack("initialize", common.HexToAddress(list.L1CrossDomainMessengerProxy.String()))
+	calldata, err := l1ERC721BridgeABI.Pack("initialize", superchainConfigProxy)
 	if err != nil {
 		return err
 	}
@@ -113,24 +194,37 @@ func L1StandardBridge(batch *safe.Batch, implementations superchain.Implementati
 		return err
 	}
 
-	// Add in OP Mainnet specific upgrade logic here
-	if chainConfig.ChainID == 10 {
+	// 2 Step Upgrade
+	{
 		storageSetterABI, err := bindings.StorageSetterMetaData.GetAbi()
 		if err != nil {
 			return err
 		}
-		calldata, err := storageSetterABI.Pack("setBytes32", common.Hash{}, common.Hash{})
+
+		input := []bindings.StorageSetterSlot{
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L36-L37
+			{
+				Key:   common.Hash{},
+				Value: common.Hash{},
+			},
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L41
+			{
+				Key:   common.Hash{31: 0x03},
+				Value: common.Hash{},
+			},
+		}
+
+		calldata, err := storageSetterABI.Pack(method, input)
 		if err != nil {
 			return err
 		}
 		args := []any{
 			common.HexToAddress(list.L1StandardBridgeProxy.String()),
-			common.HexToAddress("0xf30CE41cA2f24D28b95Eb861553dAc2948e0157F"),
+			storageSetterAddr,
 			calldata,
 		}
 		proxyAdmin := common.HexToAddress(list.ProxyAdmin.String())
-		sig := "upgradeAndCall(address,address,bytes)"
-		if err := batch.AddCall(proxyAdmin, common.Big0, sig, args, proxyAdminABI); err != nil {
+		if err := batch.AddCall(proxyAdmin, common.Big0, upgradeAndCall, args, proxyAdminABI); err != nil {
 			return err
 		}
 	}
@@ -140,7 +234,7 @@ func L1StandardBridge(batch *safe.Batch, implementations superchain.Implementati
 		return err
 	}
 
-	calldata, err := l1StandardBridgeABI.Pack("initialize", common.HexToAddress(list.L1CrossDomainMessengerProxy.String()))
+	calldata, err := l1StandardBridgeABI.Pack("initialize", superchainConfigProxy)
 	if err != nil {
 		return err
 	}
@@ -166,21 +260,58 @@ func L2OutputOracle(batch *safe.Batch, implementations superchain.Implementation
 		return err
 	}
 
+	// 2 Step Upgrade
+	{
+		storageSetterABI, err := bindings.StorageSetterMetaData.GetAbi()
+		if err != nil {
+			return err
+		}
+
+		input := []bindings.StorageSetterSlot{
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L50-L51
+			{
+				Key:   common.Hash{},
+				Value: common.Hash{},
+			},
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L55
+			{
+				Key:   common.Hash{31: 0x04},
+				Value: common.Hash{},
+			},
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L56
+			{
+				Key:   common.Hash{31: 0x05},
+				Value: common.Hash{},
+			},
+		}
+
+		calldata, err := storageSetterABI.Pack(method, input)
+		if err != nil {
+			return err
+		}
+		args := []any{
+			common.HexToAddress(list.L2OutputOracleProxy.String()),
+			storageSetterAddr,
+			calldata,
+		}
+		proxyAdmin := common.HexToAddress(list.ProxyAdmin.String())
+		if err := batch.AddCall(proxyAdmin, common.Big0, upgradeAndCall, args, proxyAdminABI); err != nil {
+			return err
+		}
+	}
+
 	l2OutputOracleABI, err := bindings.L2OutputOracleMetaData.GetAbi()
 	if err != nil {
 		return err
 	}
 
 	var l2OutputOracleStartingBlockNumber, l2OutputOracleStartingTimestamp *big.Int
-	var l2OutputOracleProposer, l2OutputOracleChallenger common.Address
 	if config != nil {
 		l2OutputOracleStartingBlockNumber = new(big.Int).SetUint64(config.L2OutputOracleStartingBlockNumber)
 		if config.L2OutputOracleStartingTimestamp < 0 {
 			return fmt.Errorf("L2OutputOracleStartingTimestamp must be concrete")
 		}
 		l2OutputOracleStartingTimestamp = new(big.Int).SetInt64(int64(config.L2OutputOracleStartingTimestamp))
-		l2OutputOracleProposer = config.L2OutputOracleProposer
-		l2OutputOracleChallenger = config.L2OutputOracleChallenger
 	} else {
 		l2OutputOracle, err := bindings.NewL2OutputOracleCaller(common.HexToAddress(list.L2OutputOracleProxy.String()), backend)
 		if err != nil {
@@ -195,19 +326,9 @@ func L2OutputOracle(batch *safe.Batch, implementations superchain.Implementation
 		if err != nil {
 			return err
 		}
-
-		l2OutputOracleProposer, err = l2OutputOracle.PROPOSER(&bind.CallOpts{})
-		if err != nil {
-			return err
-		}
-
-		l2OutputOracleChallenger, err = l2OutputOracle.CHALLENGER(&bind.CallOpts{})
-		if err != nil {
-			return err
-		}
 	}
 
-	calldata, err := l2OutputOracleABI.Pack("initialize", l2OutputOracleStartingBlockNumber, l2OutputOracleStartingTimestamp, l2OutputOracleProposer, l2OutputOracleChallenger)
+	calldata, err := l2OutputOracleABI.Pack("initialize", l2OutputOracleStartingBlockNumber, l2OutputOracleStartingTimestamp)
 	if err != nil {
 		return err
 	}
@@ -233,24 +354,43 @@ func OptimismMintableERC20Factory(batch *safe.Batch, implementations superchain.
 		return err
 	}
 
-	optimismMintableERC20FactoryABI, err := bindings.OptimismMintableERC20FactoryMetaData.GetAbi()
-	if err != nil {
-		return err
-	}
+	// 2 Step Upgrade
+	{
+		storageSetterABI, err := bindings.StorageSetterMetaData.GetAbi()
+		if err != nil {
+			return err
+		}
 
-	calldata, err := optimismMintableERC20FactoryABI.Pack("initialize", common.HexToAddress(list.L1StandardBridgeProxy.String()))
-	if err != nil {
-		return err
+		input := []bindings.StorageSetterSlot{
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L287-L289
+			{
+				Key:   common.Hash{},
+				Value: common.Hash{},
+			},
+		}
+
+		calldata, err := storageSetterABI.Pack(method, input)
+		if err != nil {
+			return err
+		}
+		args := []any{
+			common.HexToAddress(list.OptimismMintableERC20FactoryProxy.String()),
+			storageSetterAddr,
+			calldata,
+		}
+		proxyAdmin := common.HexToAddress(list.ProxyAdmin.String())
+		if err := batch.AddCall(proxyAdmin, common.Big0, upgradeAndCall, args, proxyAdminABI); err != nil {
+			return err
+		}
 	}
 
 	args := []any{
 		common.HexToAddress(list.OptimismMintableERC20FactoryProxy.String()),
 		common.HexToAddress(implementations.OptimismMintableERC20Factory.Address.String()),
-		calldata,
 	}
 
 	proxyAdmin := common.HexToAddress(list.ProxyAdmin.String())
-	if err := batch.AddCall(proxyAdmin, common.Big0, upgradeAndCall, args, proxyAdminABI); err != nil {
+	if err := batch.AddCall(proxyAdmin, common.Big0, upgrade, args, proxyAdminABI); err != nil {
 		return err
 	}
 
@@ -264,27 +404,57 @@ func OptimismPortal(batch *safe.Batch, implementations superchain.Implementation
 		return err
 	}
 
-	optimismPortalABI, err := bindings.OptimismPortalMetaData.GetAbi()
-	if err != nil {
-		return err
-	}
-
-	var superchainConfigGuardian common.Address
-	if config != nil {
-		superchainConfigGuardian = config.SuperchainConfigGuardian
-	} else {
-		optimismPortal, err := bindings.NewOptimismPortalCaller(common.HexToAddress(list.OptimismPortalProxy.String()), backend)
+	// 2 Step Upgrade
+	{
+		storageSetterABI, err := bindings.StorageSetterMetaData.GetAbi()
 		if err != nil {
 			return err
 		}
-		guardian, err := optimismPortal.GUARDIAN(&bind.CallOpts{})
+
+		input := []bindings.StorageSetterSlot{
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L64-L65
+			{
+				Key:   common.Hash{},
+				Value: common.Hash{},
+			},
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L72
+			{
+				Key:   common.Hash{31: 53},
+				Value: common.Hash{},
+			},
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L73
+			{
+				Key:   common.Hash{31: 54},
+				Value: common.Hash{},
+			},
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L74
+			{
+				Key:   common.Hash{31: 55},
+				Value: common.Hash{},
+			},
+		}
+
+		calldata, err := storageSetterABI.Pack(method, input)
 		if err != nil {
 			return err
 		}
-		superchainConfigGuardian = guardian
+		args := []any{
+			common.HexToAddress(list.OptimismPortalProxy.String()),
+			storageSetterAddr,
+			calldata,
+		}
+		proxyAdmin := common.HexToAddress(list.ProxyAdmin.String())
+		if err := batch.AddCall(proxyAdmin, common.Big0, upgradeAndCall, args, proxyAdminABI); err != nil {
+			return err
+		}
+	}
+
+	optimismPortalABI, err := bindings.OptimismPortalMetaData.GetAbi()
+	if err != nil {
+		return err
 	}
 
-	calldata, err := optimismPortalABI.Pack("initialize", common.HexToAddress(list.L2OutputOracleProxy.String()), superchainConfigGuardian, common.HexToAddress(chainConfig.SystemConfigAddr.String()), false)
+	calldata, err := optimismPortalABI.Pack("initialize", superchainConfigProxy)
 	if err != nil {
 		return err
 	}
@@ -310,6 +480,76 @@ func SystemConfig(batch *safe.Batch, implementations superchain.ImplementationLi
 		return err
 	}
 
+	// 2 Step Upgrade
+	{
+		storageSetterABI, err := bindings.StorageSetterMetaData.GetAbi()
+		if err != nil {
+			return err
+		}
+
+		input := []bindings.StorageSetterSlot{
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L82-L83
+			{
+				Key:   common.Hash{},
+				Value: common.Hash{},
+			},
+			// https://github.com/ethereum-optimism/optimism/blob/86a96023ffd04d119296dff095d02fff79fa15de/packages/contracts-bedrock/.storage-layout#L92
+			{
+				Key:   common.Hash{31: 106},
+				Value: common.Hash{},
+			},
+			// bytes32 public constant L1_CROSS_DOMAIN_MESSENGER_SLOT = bytes32(uint256(keccak256("systemconfig.l1crossdomainmessenger")) - 1);
+			{
+				Key:   common.HexToHash("0x383f291819e6d54073bc9a648251d97421076bdd101933c0c022219ce9580636"),
+				Value: common.Hash{},
+			},
+			// bytes32 public constant L1_ERC_721_BRIDGE_SLOT = bytes32(uint256(keccak256("systemconfig.l1erc721bridge")) - 1);
+			{
+				Key:   common.HexToHash("0x46adcbebc6be8ce551740c29c47c8798210f23f7f4086c41752944352568d5a7"),
+				Value: common.Hash{},
+			},
+			// bytes32 public constant L1_STANDARD_BRIDGE_SLOT = bytes32(uint256(keccak256("systemconfig.l1standardbridge")) - 1);
+			{
+				Key:   common.HexToHash("0x9904ba90dde5696cda05c9e0dab5cbaa0fea005ace4d11218a02ac668dad6376"),
+				Value: common.Hash{},
+			},
+			// bytes32 public constant L2_OUTPUT_ORACLE_SLOT = bytes32(uint256(keccak256("systemconfig.l2outputoracle")) - 1);
+			{
+				Key:   common.HexToHash("0xe52a667f71ec761b9b381c7b76ca9b852adf7e8905da0e0ad49986a0a6871815"),
+				Value: common.Hash{},
+			},
+			// bytes32 public constant OPTIMISM_PORTAL_SLOT = bytes32(uint256(keccak256("systemconfig.optimismportal")) - 1);
+			{
+				Key:   common.HexToHash("0x4b6c74f9e688cb39801f2112c14a8c57232a3fc5202e1444126d4bce86eb19ac"),
+				Value: common.Hash{},
+			},
+			// bytes32 public constant OPTIMISM_MINTABLE_ERC20_FACTORY_SLOT = bytes32(uint256(keccak256("systemconfig.optimismmintableerc20factory")) - 1);
+			{
+				Key:   common.HexToHash("0xa04c5bb938ca6fc46d95553abf0a76345ce3e722a30bf4f74928b8e7d852320c"),
+				Value: common.Hash{},
+			},
+			// bytes32 public constant BATCH_INBOX_SLOT = bytes32(uint256(keccak256("systemconfig.batchinbox")) - 1);
+			{
+				Key:   common.HexToHash("0x71ac12829d66ee73d8d95bff50b3589745ce57edae70a3fb111a2342464dc597"),
+				Value: common.Hash{},
+			},
+		}
+
+		calldata, err := storageSetterABI.Pack(method, input)
+		if err != nil {
+			return err
+		}
+		args := []any{
+			common.HexToAddress(chainConfig.SystemConfigAddr.String()),
+			storageSetterAddr,
+			calldata,
+		}
+		proxyAdmin := common.HexToAddress(list.ProxyAdmin.String())
+		if err := batch.AddCall(proxyAdmin, common.Big0, upgradeAndCall, args, proxyAdminABI); err != nil {
+			return err
+		}
+	}
+
 	systemConfigABI, err := bindings.SystemConfigMetaData.GetAbi()
 	if err != nil {
 		return err

packages/contracts-bedrock/deploy-config/sepolia.json

@@ -14,7 +14,7 @@
   "batchSenderAddress": "0x8F23BB38F531600e5d8FDDaAEC41F13FaB46E98c",
   "l2OutputOracleSubmissionInterval": 120,
   "l2OutputOracleStartingBlockNumber": 0,
-  "l2OutputOracleStartingTimestamp": -1,
+  "l2OutputOracleStartingTimestamp": 1690493568,
   "l2OutputOracleProposer": "0x49277EE36A024120Ee218127354c4a3591dc90A9",
   "l2OutputOracleChallenger": "0xfd1D2e729aE8eEe2E146c033bf4400fE75284301",
   "finalizationPeriodSeconds": 12,

packages/contracts-bedrock/deploy-config/zora-sepolia.json

@@ -23,7 +23,7 @@
   "l2GenesisRegolithTimeOffset": "0x0",
   "superchainConfigGuardian": "0x45eFFbD799Ab49122eeEAB75B78D9C56A187F9A7",
   "l2OutputOracleSubmissionInterval": 180,
-  "l2OutputOracleStartingTimestamp": -1,
+  "l2OutputOracleStartingTimestamp": 1698080004,
   "l2OutputOracleStartingBlockNumber": 0,
   "l2OutputOracleProposer": "0xe8326a5839175dE7f467e66D8bB443aa70DA1c3e",
   "sequencerFeeVaultWithdrawalNetwork": 0,