op-node,op-program: rollup-configs from superchain-registry (#6581)

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

go.mod

@@ -8,6 +8,7 @@ require (
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0
 	github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3
+	github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20230817174831-5d3ca1966435
 	github.com/ethereum/go-ethereum v1.12.0
 	github.com/fsnotify/fsnotify v1.6.0
 	github.com/go-chi/chi/v5 v5.0.10
@@ -207,6 +208,6 @@ require (
 	rsc.io/tmplfunc v0.0.3 // indirect
 )
 
-replace github.com/ethereum/go-ethereum v1.12.0 => github.com/ethereum-optimism/op-geth v1.101106.1-0.20230724181546-b9c6d36ae9b8
+replace github.com/ethereum/go-ethereum v1.12.0 => github.com/ethereum-optimism/op-geth v1.101200.0-rc.1.0.20230818191139-f7376a28049b
 
 //replace github.com/ethereum/go-ethereum v1.12.0 => ../go-ethereum

go.sum

@@ -162,8 +162,10 @@ github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7
 github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3 h1:RWHKLhCrQThMfch+QJ1Z8veEq5ZO3DfIhZ7xgRP9WTc=
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3/go.mod h1:QziizLAiF0KqyLdNJYD7O5cpDlaFMNZzlxYNcWsJUxs=
-github.com/ethereum-optimism/op-geth v1.101106.1-0.20230724181546-b9c6d36ae9b8 h1:Kr4nvrI5WHLtjLiuuVGXMBfPX2Yeo3HdUWW8iXRH6oA=
-github.com/ethereum-optimism/op-geth v1.101106.1-0.20230724181546-b9c6d36ae9b8/go.mod h1:G224y5tCMfjaCqIrTu2Svcz13CbVjHIVZjuoacCvJ1w=
+github.com/ethereum-optimism/op-geth v1.101200.0-rc.1.0.20230818191139-f7376a28049b h1:YF2FE/QnbhvrHwDYJHnbTKgJvw2aKwB/dd7PO1zKNqY=
+github.com/ethereum-optimism/op-geth v1.101200.0-rc.1.0.20230818191139-f7376a28049b/go.mod h1:gRnPb21PoKcHm3kHqj9BQlQkwmhOGUvQoGEbC7z852Q=
+github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20230817174831-5d3ca1966435 h1:2CzkJkkTLuVyoVFkoW5w6vDB2Q7eJzxXw/ybA17xjqM=
+github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20230817174831-5d3ca1966435/go.mod h1:v2YpePbdGBF0Gr6VWq49MFFmcTW0kRYZ2ingBJYWEwg=
 github.com/ethereum/c-kzg-4844 v0.2.0 h1:+cUvymlnoDDQgMInp25Bo3OmLajmmY8mLJ/tLjqd77Q=
 github.com/ethereum/c-kzg-4844 v0.2.0/go.mod h1:WI2Nd82DMZAAZI1wV2neKGost9EKjvbpQR9OqE5Qqa8=
 github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=

op-challenger/config/config.go

@@ -157,7 +157,7 @@ func (c Config) Check() error {
 			if c.CannonL2GenesisPath != "" {
 				return ErrCannonNetworkAndL2Genesis
 			}
-			if _, ok := chaincfg.NetworksByName[c.CannonNetwork]; !ok {
+			if ch := chaincfg.ChainByName(c.CannonNetwork); ch == nil {
 				return fmt.Errorf("%w: %v", ErrCannonNetworkUnknown, c.CannonNetwork)
 			}
 		}

op-e2e/setup.go

@@ -586,7 +586,7 @@ func (cfg SystemConfig) Start(t *testing.T, _opts ...SystemConfigOption) (*Syste
 			}
 		}
 
-		c.Rollup.LogDescription(cfg.Loggers[name], chaincfg.L2ChainIDToNetworkName)
+		c.Rollup.LogDescription(cfg.Loggers[name], chaincfg.L2ChainIDToNetworkDisplayName)
 
 		node, err := rollupNode.New(context.Background(), &c, cfg.Loggers[name], snapLog, "", metrics.NewMetrics(""))
 		if err != nil {

op-node/chaincfg/chains.go

@@ -2,135 +2,100 @@ package chaincfg
 
 import (
 	"fmt"
-	"math/big"
+	"strings"
 
-	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum-optimism/superchain-registry/superchain"
 
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
-	"github.com/ethereum-optimism/optimism/op-service/eth"
 )
 
-var Mainnet = rollup.Config{
-	Genesis: rollup.Genesis{
-		L1: eth.BlockID{
-			Hash:   common.HexToHash("0x438335a20d98863a4c0c97999eb2481921ccd28553eac6f913af7c12aec04108"),
-			Number: 17422590,
-		},
-		L2: eth.BlockID{
-			Hash:   common.HexToHash("0xdbf6a80fef073de06add9b0d14026d6e5a86c85f6d102c36d3d8e9cf89c2afd3"),
-			Number: 105235063,
-		},
-		L2Time: 1686068903,
-		SystemConfig: eth.SystemConfig{
-			BatcherAddr: common.HexToAddress("0x6887246668a3b87f54deb3b94ba47a6f63f32985"),
-			Overhead:    eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000000bc")),
-			Scalar:      eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000a6fe0")),
-			GasLimit:    30_000_000,
-		},
-	},
-	BlockTime:              2,
-	MaxSequencerDrift:      600,
-	SeqWindowSize:          3600,
-	ChannelTimeout:         300,
-	L1ChainID:              big.NewInt(1),
-	L2ChainID:              big.NewInt(10),
-	BatchInboxAddress:      common.HexToAddress("0xff00000000000000000000000000000000000010"),
-	DepositContractAddress: common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
-	L1SystemConfigAddress:  common.HexToAddress("0x229047fed2591dbec1eF1118d64F7aF3dB9EB290"),
-	RegolithTime:           u64Ptr(0),
-}
-
-var Goerli = rollup.Config{
-	Genesis: rollup.Genesis{
-		L1: eth.BlockID{
-			Hash:   common.HexToHash("0x6ffc1bf3754c01f6bb9fe057c1578b87a8571ce2e9be5ca14bace6eccfd336c7"),
-			Number: 8300214,
-		},
-		L2: eth.BlockID{
-			Hash:   common.HexToHash("0x0f783549ea4313b784eadd9b8e8a69913b368b7366363ea814d7707ac505175f"),
-			Number: 4061224,
-		},
-		L2Time: 1673550516,
-		SystemConfig: eth.SystemConfig{
-			BatcherAddr: common.HexToAddress("0x7431310e026B69BFC676C0013E12A1A11411EEc9"),
-			Overhead:    eth.Bytes32(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000834")),
-			Scalar:      eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000f4240")),
-			GasLimit:    25_000_000,
-		},
-	},
-	BlockTime:              2,
-	MaxSequencerDrift:      600,
-	SeqWindowSize:          3600,
-	ChannelTimeout:         300,
-	L1ChainID:              big.NewInt(5),
-	L2ChainID:              big.NewInt(420),
-	BatchInboxAddress:      common.HexToAddress("0xff00000000000000000000000000000000000420"),
-	DepositContractAddress: common.HexToAddress("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
-	L1SystemConfigAddress:  common.HexToAddress("0xAe851f927Ee40dE99aaBb7461C00f9622ab91d60"),
-	RegolithTime:           u64Ptr(1679079600),
-}
-
-var Sepolia = rollup.Config{
-	Genesis: rollup.Genesis{
-		L1: eth.BlockID{
-			Hash:   common.HexToHash("0x48f520cf4ddaf34c8336e6e490632ea3cf1e5e93b0b2bc6e917557e31845371b"),
-			Number: 4071408,
-		},
-		L2: eth.BlockID{
-			Hash:   common.HexToHash("0x102de6ffb001480cc9b8b548fd05c34cd4f46ae4aa91759393db90ea0409887d"),
-			Number: 0,
-		},
-		L2Time: 1691802540,
-		SystemConfig: eth.SystemConfig{
-			BatcherAddr: common.HexToAddress("0x8F23BB38F531600e5d8FDDaAEC41F13FaB46E98c"),
-			Overhead:    eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000000bc")),
-			Scalar:      eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000a6fe0")),
-			GasLimit:    30000000,
-		},
-	},
-	BlockTime:              2,
-	MaxSequencerDrift:      600,
-	SeqWindowSize:          3600,
-	ChannelTimeout:         300,
-	L1ChainID:              big.NewInt(11155111),
-	L2ChainID:              big.NewInt(11155420),
-	BatchInboxAddress:      common.HexToAddress("0xff00000000000000000000000000000011155420"),
-	DepositContractAddress: common.HexToAddress("0x16fc5058f25648194471939df75cf27a2fdc48bc"),
-	L1SystemConfigAddress:  common.HexToAddress("0x034edd2a225f7f429a63e0f1d2084b9e0a93b538"),
-	RegolithTime:           u64Ptr(0),
-}
+var Mainnet, Goerli, Sepolia *rollup.Config
 
-var NetworksByName = map[string]rollup.Config{
-	"goerli":  Goerli,
-	"mainnet": Mainnet,
-	"sepolia": Sepolia,
+func init() {
+	mustCfg := func(name string) *rollup.Config {
+		cfg, err := GetRollupConfig(name)
+		if err != nil {
+			panic(fmt.Errorf("failed to load rollup config %q: %w", name, err))
+		}
+		return cfg
+	}
+	Mainnet = mustCfg("op-mainnet")
+	Goerli = mustCfg("op-goerli")
+	Sepolia = mustCfg("op-sepolia")
 }
 
-var L2ChainIDToNetworkName = func() map[string]string {
+var L2ChainIDToNetworkDisplayName = func() map[string]string {
 	out := make(map[string]string)
-	for name, netCfg := range NetworksByName {
-		out[netCfg.L2ChainID.String()] = name
+	for _, netCfg := range superchain.OPChains {
+		out[fmt.Sprintf("%d", netCfg.ChainID)] = netCfg.Name
 	}
 	return out
 }()
 
+// AvailableNetworks returns the selection of network configurations that is available by default.
+// Other configurations that are part of the superchain-registry can be used with the --beta.network flag.
 func AvailableNetworks() []string {
+	return []string{"op-mainnet", "op-goerli", "op-sepolia"}
+}
+
+// BetaAvailableNetworks returns all available network configurations in the superchain-registry.
+// This set of configurations is experimental, and may change at any time.
+func BetaAvailableNetworks() []string {
 	var networks []string
-	for name := range NetworksByName {
-		networks = append(networks, name)
+	for _, cfg := range superchain.OPChains {
+		networks = append(networks, cfg.Chain+"-"+cfg.Superchain)
 	}
 	return networks
 }
 
-func GetRollupConfig(name string) (rollup.Config, error) {
-	network, ok := NetworksByName[name]
-	if !ok {
-		return rollup.Config{}, fmt.Errorf("invalid network %s", name)
+func IsAvailableNetwork(name string, beta bool) bool {
+	name = handleLegacyName(name)
+	available := AvailableNetworks()
+	if beta {
+		available = BetaAvailableNetworks()
 	}
+	for _, v := range available {
+		if v == name {
+			return true
+		}
+	}
+	return false
+}
+
+func handleLegacyName(name string) string {
+	switch name {
+	case "goerli":
+		return "op-goerli"
+	case "mainnet":
+		return "op-mainnet"
+	case "sepolia":
+		return "op-sepolia"
+	default:
+		return name
+	}
+}
 
-	return network, nil
+// ChainByName returns a chain, from known available configurations, by name.
+// ChainByName returns nil when the chain name is unknown.
+func ChainByName(name string) *superchain.ChainConfig {
+	// Handle legacy name aliases
+	name = handleLegacyName(name)
+	for _, chainCfg := range superchain.OPChains {
+		if strings.EqualFold(chainCfg.Chain+"-"+chainCfg.Superchain, name) {
+			return chainCfg
+		}
+	}
+	return nil
 }
 
-func u64Ptr(v uint64) *uint64 {
-	return &v
+func GetRollupConfig(name string) (*rollup.Config, error) {
+	chainCfg := ChainByName(name)
+	if chainCfg == nil {
+		return nil, fmt.Errorf("invalid network %s", name)
+	}
+	rollupCfg, err := rollup.LoadOPStackRollupConfig(chainCfg.ChainID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load rollup config: %w", err)
+	}
+	return rollupCfg, nil
 }

op-node/chaincfg/chains_test.go

+package chaincfg
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+// TestGetRollupConfig tests that the configs sourced from the superchain-registry match
+// the configs that were embedded in the op-node manually before the superchain-registry was utilized.
+//
+// The superchain-registry repository is a work in progress.
+// At a later date, it will be proposed to, and must be approved by, Optimism Governance.
+// Until that time, the configuration described in the superchain-registry is subject to change.
+//
+// This test ensures no op-node config-loading behavior changes before
+// the superchain-registry is no longer deemed experimental.
+func TestGetRollupConfig(t *testing.T) {
+	var configsByName = map[string]rollup.Config{
+		"goerli":  goerliCfg,
+		"mainnet": mainnetCfg,
+		"sepolia": sepoliaCfg,
+	}
+
+	for name, expectedCfg := range configsByName {
+		require.True(t, IsAvailableNetwork(name, false))
+
+		gotCfg, err := GetRollupConfig(name)
+		require.NoError(t, err)
+
+		require.Equal(t, expectedCfg, *gotCfg, "rollup-configs from superchain-registry must match")
+	}
+}
+
+var mainnetCfg = rollup.Config{
+	Genesis: rollup.Genesis{
+		L1: eth.BlockID{
+			Hash:   common.HexToHash("0x438335a20d98863a4c0c97999eb2481921ccd28553eac6f913af7c12aec04108"),
+			Number: 17422590,
+		},
+		L2: eth.BlockID{
+			Hash:   common.HexToHash("0xdbf6a80fef073de06add9b0d14026d6e5a86c85f6d102c36d3d8e9cf89c2afd3"),
+			Number: 105235063,
+		},
+		L2Time: 1686068903,
+		SystemConfig: eth.SystemConfig{
+			BatcherAddr: common.HexToAddress("0x6887246668a3b87f54deb3b94ba47a6f63f32985"),
+			Overhead:    eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000000bc")),
+			Scalar:      eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000a6fe0")),
+			GasLimit:    30_000_000,
+		},
+	},
+	BlockTime:              2,
+	MaxSequencerDrift:      600,
+	SeqWindowSize:          3600,
+	ChannelTimeout:         300,
+	L1ChainID:              big.NewInt(1),
+	L2ChainID:              big.NewInt(10),
+	BatchInboxAddress:      common.HexToAddress("0xff00000000000000000000000000000000000010"),
+	DepositContractAddress: common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
+	L1SystemConfigAddress:  common.HexToAddress("0x229047fed2591dbec1eF1118d64F7aF3dB9EB290"),
+	RegolithTime:           u64Ptr(0),
+}
+
+var goerliCfg = rollup.Config{
+	Genesis: rollup.Genesis{
+		L1: eth.BlockID{
+			Hash:   common.HexToHash("0x6ffc1bf3754c01f6bb9fe057c1578b87a8571ce2e9be5ca14bace6eccfd336c7"),
+			Number: 8300214,
+		},
+		L2: eth.BlockID{
+			Hash:   common.HexToHash("0x0f783549ea4313b784eadd9b8e8a69913b368b7366363ea814d7707ac505175f"),
+			Number: 4061224,
+		},
+		L2Time: 1673550516,
+		SystemConfig: eth.SystemConfig{
+			BatcherAddr: common.HexToAddress("0x7431310e026B69BFC676C0013E12A1A11411EEc9"),
+			Overhead:    eth.Bytes32(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000834")),
+			Scalar:      eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000f4240")),
+			GasLimit:    25_000_000,
+		},
+	},
+	BlockTime:              2,
+	MaxSequencerDrift:      600,
+	SeqWindowSize:          3600,
+	ChannelTimeout:         300,
+	L1ChainID:              big.NewInt(5),
+	L2ChainID:              big.NewInt(420),
+	BatchInboxAddress:      common.HexToAddress("0xff00000000000000000000000000000000000420"),
+	DepositContractAddress: common.HexToAddress("0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383"),
+	L1SystemConfigAddress:  common.HexToAddress("0xAe851f927Ee40dE99aaBb7461C00f9622ab91d60"),
+	RegolithTime:           u64Ptr(1679079600),
+}
+
+var sepoliaCfg = rollup.Config{
+	Genesis: rollup.Genesis{
+		L1: eth.BlockID{
+			Hash:   common.HexToHash("0x48f520cf4ddaf34c8336e6e490632ea3cf1e5e93b0b2bc6e917557e31845371b"),
+			Number: 4071408,
+		},
+		L2: eth.BlockID{
+			Hash:   common.HexToHash("0x102de6ffb001480cc9b8b548fd05c34cd4f46ae4aa91759393db90ea0409887d"),
+			Number: 0,
+		},
+		L2Time: 1691802540,
+		SystemConfig: eth.SystemConfig{
+			BatcherAddr: common.HexToAddress("0x8F23BB38F531600e5d8FDDaAEC41F13FaB46E98c"),
+			Overhead:    eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000000bc")),
+			Scalar:      eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000a6fe0")),
+			GasLimit:    30000000,
+		},
+	},
+	BlockTime:              2,
+	MaxSequencerDrift:      600,
+	SeqWindowSize:          3600,
+	ChannelTimeout:         300,
+	L1ChainID:              big.NewInt(11155111),
+	L2ChainID:              big.NewInt(11155420),
+	BatchInboxAddress:      common.HexToAddress("0xff00000000000000000000000000000011155420"),
+	DepositContractAddress: common.HexToAddress("0x16fc5058f25648194471939df75cf27a2fdc48bc"),
+	L1SystemConfigAddress:  common.HexToAddress("0x034edd2a225f7f429a63e0f1d2084b9e0a93b538"),
+	RegolithTime:           u64Ptr(0),
+}
+
+func u64Ptr(v uint64) *uint64 {
+	return &v
+}

op-node/cmd/main.go

@@ -104,9 +104,9 @@ func RollupNodeMain(ctx *cli.Context) error {
 
 	// Only pretty-print the banner if it is a terminal log. Other log it as key-value pairs.
 	if logCfg.Format == "terminal" {
-		log.Info("rollup config:\n" + cfg.Rollup.Description(chaincfg.L2ChainIDToNetworkName))
+		log.Info("rollup config:\n" + cfg.Rollup.Description(chaincfg.L2ChainIDToNetworkDisplayName))
 	} else {
-		cfg.Rollup.LogDescription(log, chaincfg.L2ChainIDToNetworkName)
+		cfg.Rollup.LogDescription(log, chaincfg.L2ChainIDToNetworkDisplayName)
 	}
 
 	n, err := node.New(context.Background(), cfg, log, snapshotLog, VersionWithMeta, m)

op-node/flags/flags.go

@@ -229,6 +229,14 @@ var (
 		Required: false,
 		Value:    false,
 	}
+	BetaExtraNetworks = &cli.BoolFlag{
+		Name: "beta.extra-networks",
+		Usage: fmt.Sprintf("Beta feature: enable selection of a predefined-network from the superchain-registry. "+
+			"The superchain-registry is experimental, and the availability of configurations may change."+
+			"Available networks: %s", strings.Join(chaincfg.BetaAvailableNetworks(), ", ")),
+		EnvVars: prefixEnvVars("BETA_EXTRA_NETWORKS"),
+		Hidden:  true,
+	}
 )
 
 var requiredFlags = []cli.Flag{
@@ -269,6 +277,7 @@ var optionalFlags = []cli.Flag{
 	BackupL2UnsafeSyncRPCTrustRPC,
 	L2EngineSyncEnabled,
 	SkipSyncStartCheck,
+	BetaExtraNetworks,
 }
 
 // Flags contains the list of configuration options available to the binary.

op-node/p2p/peer_params_test.go

@@ -43,7 +43,7 @@ func (testSuite *PeerParamsTestSuite) TestNewPeerScoreThresholds() {
 
 // TestGetPeerScoreParams validates the peer score parameters.
 func (testSuite *PeerParamsTestSuite) TestGetPeerScoreParams_None() {
-	params, err := GetScoringParams("none", &chaincfg.Goerli)
+	params, err := GetScoringParams("none", chaincfg.Goerli)
 	testSuite.NoError(err)
 	testSuite.Nil(params)
 }
@@ -62,12 +62,12 @@ func (testSuite *PeerParamsTestSuite) TestGetPeerScoreParams_Light() {
 	testSuite.Equal(0.9261187281287935, decay)
 
 	// Test the params
-	scoringParams, err := GetScoringParams("light", &cfg)
+	scoringParams, err := GetScoringParams("light", cfg)
 	peerParams := scoringParams.PeerScoring
 	testSuite.NoError(err)
 	// Topics should contain options for block topic
 	testSuite.Len(peerParams.Topics, 1)
-	topicParams, ok := peerParams.Topics[blocksTopicV1(&cfg)]
+	topicParams, ok := peerParams.Topics[blocksTopicV1(cfg)]
 	testSuite.True(ok, "should have block topic params")
 	testSuite.NotZero(topicParams.TimeInMeshQuantum)
 	testSuite.Equal(peerParams.TopicScoreCap, float64(34))
@@ -101,7 +101,7 @@ func (testSuite *PeerParamsTestSuite) TestParamsZeroBlockTime() {
 	cfg := chaincfg.Goerli
 	cfg.BlockTime = 0
 	slot := 2 * time.Second
-	params, err := GetScoringParams("light", &cfg)
+	params, err := GetScoringParams("light", cfg)
 	testSuite.NoError(err)
 	testSuite.Equal(params.PeerScoring.DecayInterval, slot)
 	testSuite.Equal(params.ApplicationScoring.DecayInterval, slot)

op-node/rollup/superchain.go

+package rollup
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+	"github.com/ethereum-optimism/superchain-registry/superchain"
+)
+
+const (
+	opMainnet   = 10
+	opGoerli    = 420
+	opSepolia   = 11155420
+	baseGoerli  = 84531
+	baseMainnet = 8453
+	pgnMainnet  = 424
+	pgnSepolia  = 58008
+	zoraGoerli  = 999
+	zoraMainnet = 7777777
+)
+
+// LoadOPStackRollupConfig loads the rollup configuration of the requested chain ID from the superchain-registry.
+// Some chains may require a SystemConfigProvider to retrieve any values not part of the registry.
+func LoadOPStackRollupConfig(chainID uint64) (*Config, error) {
+	chConfig, ok := superchain.OPChains[chainID]
+	if !ok {
+		return nil, fmt.Errorf("unknown chain ID: %d", chainID)
+	}
+
+	superChain, ok := superchain.Superchains[chConfig.Superchain]
+	if !ok {
+		return nil, fmt.Errorf("chain %d specifies unknown superchain: %q", chainID, chConfig.Superchain)
+	}
+
+	var genesisSysConfig eth.SystemConfig
+	if sysCfg, ok := superchain.GenesisSystemConfigs[chainID]; ok {
+		genesisSysConfig = eth.SystemConfig{
+			BatcherAddr: common.Address(sysCfg.BatcherAddr),
+			Overhead:    eth.Bytes32(sysCfg.Overhead),
+			Scalar:      eth.Bytes32(sysCfg.Scalar),
+			GasLimit:    sysCfg.GasLimit,
+		}
+	} else {
+		return nil, fmt.Errorf("unable to retrieve genesis SystemConfig of chain %d", chainID)
+	}
+
+	var depositContractAddress common.Address
+	if addrs, ok := superchain.Addresses[chainID]; ok {
+		depositContractAddress = common.Address(addrs.OptimismPortalProxy)
+	} else {
+		return nil, fmt.Errorf("unable to retrieve deposit contract address")
+	}
+
+	regolithTime := uint64(0)
+	// two goerli testnets test-ran Bedrock and later upgraded to Regolith.
+	// All other OP-Stack chains have Regolith enabled from the start.
+	switch chainID {
+	case baseGoerli:
+		regolithTime = 1683219600
+	case opGoerli:
+		regolithTime = 1679079600
+	}
+
+	cfg := &Config{
+		Genesis: Genesis{
+			L1: eth.BlockID{
+				Hash:   common.Hash(chConfig.Genesis.L1.Hash),
+				Number: chConfig.Genesis.L1.Number,
+			},
+			L2: eth.BlockID{
+				Hash:   common.Hash(chConfig.Genesis.L2.Hash),
+				Number: chConfig.Genesis.L2.Number,
+			},
+			L2Time:       chConfig.Genesis.L2Time,
+			SystemConfig: genesisSysConfig,
+		},
+		// The below chain parameters can be different per OP-Stack chain,
+		// but since none of the superchain chains differ, it's not represented in the superchain-registry yet.
+		// This restriction on superchain-chains may change in the future.
+		// Test/Alt configurations can still load custom rollup-configs when necessary.
+		BlockTime:              2,
+		MaxSequencerDrift:      600,
+		SeqWindowSize:          3600,
+		ChannelTimeout:         300,
+		L1ChainID:              new(big.Int).SetUint64(superChain.Config.L1.ChainID),
+		L2ChainID:              new(big.Int).SetUint64(chConfig.ChainID),
+		RegolithTime:           &regolithTime,
+		BatchInboxAddress:      common.Address(chConfig.BatchInboxAddr),
+		DepositContractAddress: depositContractAddress,
+		L1SystemConfigAddress:  common.Address(chConfig.SystemConfigAddr),
+	}
+	return cfg, nil
+}

op-node/service.go

@@ -182,12 +182,16 @@ Startup will proceed to use the network-parameter and ignore the rollup config.
 Conflicting configuration is deprecated, and will stop the op-node from starting in the future.
 `, "network", network, "rollup_config", rollupConfigPath)
 		}
+		// check that the network is available
+		if !chaincfg.IsAvailableNetwork(network, ctx.Bool(flags.BetaExtraNetworks.Name)) {
+			return nil, fmt.Errorf("unavailable network: %q", network)
+		}
 		config, err := chaincfg.GetRollupConfig(network)
 		if err != nil {
 			return nil, err
 		}
 
-		return &config, nil
+		return config, nil
 	}
 
 	file, err := os.Open(rollupConfigPath)

op-program/chainconfig/chaincfg.go

@@ -2,123 +2,40 @@ package chainconfig
 
 import (
 	"fmt"
-	"math/big"
-	"strconv"
 
-	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum/go-ethereum/params"
 )
 
-var enabledFromBedrockBlock = uint64(0)
+var OPGoerliChainConfig, OPSepoliaChainConfig, OPMainnetChainConfig *params.ChainConfig
 
-var OPGoerliChainConfig = &params.ChainConfig{
-	ChainID:                       big.NewInt(420),
-	HomesteadBlock:                big.NewInt(0),
-	DAOForkBlock:                  nil,
-	DAOForkSupport:                false,
-	EIP150Block:                   big.NewInt(0),
-	EIP155Block:                   big.NewInt(0),
-	EIP158Block:                   big.NewInt(0),
-	ByzantiumBlock:                big.NewInt(0),
-	ConstantinopleBlock:           big.NewInt(0),
-	PetersburgBlock:               big.NewInt(0),
-	IstanbulBlock:                 big.NewInt(0),
-	MuirGlacierBlock:              big.NewInt(0),
-	BerlinBlock:                   big.NewInt(0),
-	LondonBlock:                   big.NewInt(4061224),
-	ArrowGlacierBlock:             big.NewInt(4061224),
-	GrayGlacierBlock:              big.NewInt(4061224),
-	MergeNetsplitBlock:            big.NewInt(4061224),
-	BedrockBlock:                  big.NewInt(4061224),
-	RegolithTime:                  &params.OptimismGoerliRegolithTime,
-	TerminalTotalDifficulty:       big.NewInt(0),
-	TerminalTotalDifficultyPassed: true,
-	Optimism: &params.OptimismConfig{
-		EIP1559Elasticity:  10,
-		EIP1559Denominator: 50,
-	},
-}
-
-var OPSepoliaChainConfig = &params.ChainConfig{
-	ChainID:                       big.NewInt(11155420),
-	HomesteadBlock:                big.NewInt(0),
-	DAOForkBlock:                  nil,
-	DAOForkSupport:                false,
-	EIP150Block:                   big.NewInt(0),
-	EIP155Block:                   big.NewInt(0),
-	EIP158Block:                   big.NewInt(0),
-	ByzantiumBlock:                big.NewInt(0),
-	ConstantinopleBlock:           big.NewInt(0),
-	PetersburgBlock:               big.NewInt(0),
-	IstanbulBlock:                 big.NewInt(0),
-	MuirGlacierBlock:              big.NewInt(0),
-	BerlinBlock:                   big.NewInt(0),
-	LondonBlock:                   big.NewInt(0),
-	ArrowGlacierBlock:             big.NewInt(0),
-	GrayGlacierBlock:              big.NewInt(0),
-	MergeNetsplitBlock:            big.NewInt(0),
-	BedrockBlock:                  big.NewInt(0),
-	RegolithTime:                  &enabledFromBedrockBlock,
-	TerminalTotalDifficulty:       big.NewInt(0),
-	TerminalTotalDifficultyPassed: true,
-	Optimism: &params.OptimismConfig{
-		EIP1559Elasticity:  6,
-		EIP1559Denominator: 50,
-	},
-}
-
-var OPMainnetChainConfig = &params.ChainConfig{
-	ChainID:                       big.NewInt(10),
-	HomesteadBlock:                big.NewInt(0),
-	DAOForkBlock:                  nil,
-	DAOForkSupport:                false,
-	EIP150Block:                   big.NewInt(0),
-	EIP155Block:                   big.NewInt(0),
-	EIP158Block:                   big.NewInt(0),
-	ByzantiumBlock:                big.NewInt(0),
-	ConstantinopleBlock:           big.NewInt(0),
-	PetersburgBlock:               big.NewInt(0),
-	IstanbulBlock:                 big.NewInt(0),
-	MuirGlacierBlock:              big.NewInt(0),
-	BerlinBlock:                   big.NewInt(3950000),
-	LondonBlock:                   big.NewInt(105235063),
-	ArrowGlacierBlock:             big.NewInt(105235063),
-	GrayGlacierBlock:              big.NewInt(105235063),
-	MergeNetsplitBlock:            big.NewInt(105235063),
-	BedrockBlock:                  big.NewInt(105235063),
-	RegolithTime:                  &enabledFromBedrockBlock,
-	TerminalTotalDifficulty:       big.NewInt(0),
-	TerminalTotalDifficultyPassed: true,
-	Optimism: &params.OptimismConfig{
-		EIP1559Elasticity:  6,
-		EIP1559Denominator: 50,
-	},
+func init() {
+	mustLoadConfig := func(chainID uint64) *params.ChainConfig {
+		cfg, err := params.LoadOPStackChainConfig(chainID)
+		if err != nil {
+			panic(err)
+		}
+		return cfg
+	}
+	OPGoerliChainConfig = mustLoadConfig(420)
+	OPSepoliaChainConfig = mustLoadConfig(11155420)
+	OPMainnetChainConfig = mustLoadConfig(10)
 }
 
-var L2ChainConfigsByName = map[string]*params.ChainConfig{
-	"goerli":  OPGoerliChainConfig,
-	"sepolia": OPSepoliaChainConfig,
-	"mainnet": OPMainnetChainConfig,
+var L2ChainConfigsByChainID = map[uint64]*params.ChainConfig{
+	420:      OPGoerliChainConfig,
+	11155420: OPSepoliaChainConfig,
+	10:       OPMainnetChainConfig,
 }
 
 func RollupConfigByChainID(chainID uint64) (*rollup.Config, error) {
-	network := chaincfg.L2ChainIDToNetworkName[strconv.FormatUint(chainID, 10)]
-	if network == "" {
-		return nil, fmt.Errorf("unknown chain ID: %d", chainID)
-	}
-	config, ok := chaincfg.NetworksByName[network]
-	if !ok {
-		return nil, fmt.Errorf("unknown network %s for chain ID %d", network, chainID)
+	config, err := rollup.LoadOPStackRollupConfig(chainID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get rollup config for chain ID %d: %w", chainID, err)
 	}
-	return &config, nil
+	return config, nil
 }
 
 func ChainConfigByChainID(chainID uint64) (*params.ChainConfig, error) {
-	network := chaincfg.L2ChainIDToNetworkName[strconv.FormatUint(chainID, 10)]
-	chainConfig, ok := L2ChainConfigsByName[network]
-	if !ok {
-		return nil, fmt.Errorf("unknown network %s for chain ID %d", network, chainID)
-	}
-	return chainConfig, nil
+	return params.LoadOPStackChainConfig(chainID)
 }

op-program/client/boot_test.go

@@ -21,7 +21,7 @@ func TestBootstrapClient(t *testing.T) {
 		L2ClaimBlockNumber: 1,
 		L2ChainID:          chaincfg.Goerli.L2ChainID.Uint64(),
 		L2ChainConfig:      chainconfig.OPGoerliChainConfig,
-		RollupConfig:       &chaincfg.Goerli,
+		RollupConfig:       chaincfg.Goerli,
 	}
 	mockOracle := &mockBoostrapOracle{bootInfo, false}
 	readBootInfo := NewBootstrapClient(mockOracle).BootInfo()
@@ -36,7 +36,7 @@ func TestBootstrapClient_CustomChain(t *testing.T) {
 		L2ClaimBlockNumber: 1,
 		L2ChainID:          CustomChainIDIndicator,
 		L2ChainConfig:      chainconfig.OPGoerliChainConfig,
-		RollupConfig:       &chaincfg.Goerli,
+		RollupConfig:       chaincfg.Goerli,
 	}
 	mockOracle := &mockBoostrapOracle{bootInfo, true}
 	readBootInfo := NewBootstrapClient(mockOracle).BootInfo()

op-program/client/l2/engine_test.go

@@ -161,7 +161,7 @@ func createOracleEngine(t *testing.T) (*OracleEngine, *stubEngineBackend) {
 	}
 	engine := OracleEngine{
 		backend:   backend,
-		rollupCfg: &chaincfg.Goerli,
+		rollupCfg: chaincfg.Goerli,
 	}
 	return &engine, backend
 }

op-program/host/cmd/main_test.go

@@ -45,8 +45,10 @@ func TestLogLevel(t *testing.T) {
 
 func TestDefaultCLIOptionsMatchDefaultConfig(t *testing.T) {
 	cfg := configForArgs(t, addRequiredArgs())
+	rollupCfg, err := chaincfg.GetRollupConfig("op-goerli")
+	require.NoError(t, err)
 	defaultCfg := config.NewConfig(
-		&chaincfg.Goerli,
+		rollupCfg,
 		chainconfig.OPGoerliChainConfig,
 		common.HexToHash(l1HeadValue),
 		common.HexToHash(l2HeadValue),
@@ -58,7 +60,7 @@ func TestDefaultCLIOptionsMatchDefaultConfig(t *testing.T) {
 
 func TestNetwork(t *testing.T) {
 	t.Run("Unknown", func(t *testing.T) {
-		verifyArgsInvalid(t, "invalid network bar", replaceRequiredArg("--network", "bar"))
+		verifyArgsInvalid(t, "unavailable network: \"bar\"", replaceRequiredArg("--network", "bar"))
 	})
 
 	t.Run("Required", func(t *testing.T) {
@@ -74,16 +76,17 @@ func TestNetwork(t *testing.T) {
 		genesisFile := writeValidGenesis(t)
 
 		cfg := configForArgs(t, addRequiredArgsExcept("--network", "--rollup.config", configFile, "--l2.genesis", genesisFile))
-		require.Equal(t, chaincfg.Goerli, *cfg.Rollup)
+		require.Equal(t, *chaincfg.Goerli, *cfg.Rollup)
 	})
 
-	for name, cfg := range chaincfg.NetworksByName {
+	for _, name := range chaincfg.AvailableNetworks() {
 		name := name
-		expected := cfg
+		expected, err := chaincfg.GetRollupConfig(name)
+		require.NoError(t, err)
 		t.Run("Network_"+name, func(t *testing.T) {
 			args := replaceRequiredArg("--network", name)
 			cfg := configForArgs(t, args)
-			require.Equal(t, expected, *cfg.Rollup)
+			require.Equal(t, *expected, *cfg.Rollup)
 		})
 	}
 }

op-program/host/config/config.go

@@ -6,10 +6,11 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
+
 	opnode "github.com/ethereum-optimism/optimism/op-node"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
-	"github.com/ethereum-optimism/optimism/op-program/chainconfig"
 	"github.com/ethereum-optimism/optimism/op-program/host/flags"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@@ -157,10 +158,15 @@ func NewConfigFromCLI(log log.Logger, ctx *cli.Context) (*Config, error) {
 	var l2ChainConfig *params.ChainConfig
 	if l2GenesisPath == "" {
 		networkName := ctx.String(flags.Network.Name)
-		l2ChainConfig = chainconfig.L2ChainConfigsByName[networkName]
-		if l2ChainConfig == nil {
+		ch := chaincfg.ChainByName(networkName)
+		if ch == nil {
 			return nil, fmt.Errorf("flag %s is required for network %s", flags.L2GenesisPath.Name, networkName)
 		}
+		cfg, err := params.LoadOPStackChainConfig(ch.ChainID)
+		if err != nil {
+			return nil, fmt.Errorf("failed to load chain config for chain %d: %w", ch.ChainID, err)
+		}
+		l2ChainConfig = cfg
 	} else {
 		l2ChainConfig, err = loadChainConfigFromGenesis(l2GenesisPath)
 	}

op-program/host/config/config_test.go

@@ -11,7 +11,7 @@ import (
 )
 
 var (
-	validRollupConfig    = &chaincfg.Goerli
+	validRollupConfig    = chaincfg.Goerli
 	validL2Genesis       = params.GoerliChainConfig
 	validL1Head          = common.Hash{0xaa}
 	validL2Head          = common.Hash{0xbb}

op-program/host/host.go

@@ -35,7 +35,7 @@ func Main(logger log.Logger, cfg *config.Config) error {
 		return fmt.Errorf("invalid config: %w", err)
 	}
 	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, logger)
-	cfg.Rollup.LogDescription(logger, chaincfg.L2ChainIDToNetworkName)
+	cfg.Rollup.LogDescription(logger, chaincfg.L2ChainIDToNetworkDisplayName)
 
 	ctx := context.Background()
 	if cfg.ServerMode {

op-program/host/host_test.go

@@ -25,7 +25,7 @@ func TestServerMode(t *testing.T) {
 
 	l1Head := common.Hash{0x11}
 	l2OutputRoot := common.Hash{0x33}
-	cfg := config.NewConfig(&chaincfg.Goerli, chainconfig.OPGoerliChainConfig, l1Head, common.Hash{0x22}, l2OutputRoot, common.Hash{0x44}, 1000)
+	cfg := config.NewConfig(chaincfg.Goerli, chainconfig.OPGoerliChainConfig, l1Head, common.Hash{0x22}, l2OutputRoot, common.Hash{0x44}, 1000)
 	cfg.DataDir = dir
 	cfg.ServerMode = true
 

op-program/host/kvstore/local_test.go

@@ -16,7 +16,7 @@ import (
 
 func TestLocalPreimageSource(t *testing.T) {
 	cfg := &config.Config{
-		Rollup:             &chaincfg.Goerli,
+		Rollup:             chaincfg.Goerli,
 		L1Head:             common.HexToHash("0x1111"),
 		L2OutputRoot:       common.HexToHash("0x2222"),
 		L2Claim:            common.HexToHash("0x3333"),