Merge branch 'develop' into contracts-bedrock/deploy-fix

op-challenger/types/game_type.go

+package types
+
+import (
+	"fmt"
+
+	"github.com/ethereum-optimism/optimism/op-service/enum"
+)
+
+// GameType is the type of dispute game
+type GameType uint8
+
+// DefaultGameType returns the default dispute game type.
+func DefaultGameType() GameType {
+	return AttestationDisputeGameType
+}
+
+// String returns the string value of a dispute game type.
+func (g GameType) String() string {
+	return DisputeGameTypes[g]
+}
+
+const (
+	// AttestationDisputeGameType is the uint8 enum value for the attestation dispute game
+	AttestationDisputeGameType GameType = iota
+	// FaultDisputeGameType is the uint8 enum value for the fault dispute game
+	FaultDisputeGameType
+	// ValidityDisputeGameType is the uint8 enum value for the validity dispute game
+	ValidityDisputeGameType
+)
+
+// DisputeGameTypes is a list of dispute game types.
+var DisputeGameTypes = []string{"attestation", "fault", "validity"}
+
+// Valid returns true if the game type is within the valid range.
+func (g GameType) Valid() bool {
+	return g >= AttestationDisputeGameType && g <= ValidityDisputeGameType
+}
+
+// DisputeGameType is a custom flag type for dispute game type.
+type DisputeGameType struct {
+	Enum     []enum.Stringered
+	selected GameType
+}
+
+// NewDisputeGameType returns a new dispute game type.
+func NewDisputeGameType() *DisputeGameType {
+	return &DisputeGameType{
+		Enum:     enum.StringeredList(DisputeGameTypes),
+		selected: DefaultGameType(),
+	}
+}
+
+// Set sets the dispute game type.
+func (d *DisputeGameType) Set(value string) error {
+	for i, enum := range d.Enum {
+		if enum.String() == value {
+			d.selected = GameType(i)
+			return nil
+		}
+	}
+
+	return fmt.Errorf("allowed values are %s", enum.EnumString(d.Enum))
+}
+
+// String returns the selected dispute game type.
+func (d DisputeGameType) String() string {
+	return d.selected.String()
+}
+
+// Type maps the [DisputeGameType] string value to a [GameType] enum value.
+func (d DisputeGameType) Type() GameType {
+	return d.selected
+}

op-challenger/types/game_type_test.go

+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	disputeGames = []struct {
+		name     string
+		gameType GameType
+	}{
+		{"attestation", AttestationDisputeGameType},
+		{"fault", FaultDisputeGameType},
+		{"validity", ValidityDisputeGameType},
+	}
+)
+
+// TestDefaultGameType returns the default dispute game type.
+func TestDefaultGameType(t *testing.T) {
+	defaultGameType := disputeGames[0].gameType
+	require.Equal(t, defaultGameType, DefaultGameType())
+}
+
+// TestGameType_Valid tests the Valid function with valid inputs.
+func TestGameType_Valid(t *testing.T) {
+	for _, game := range disputeGames {
+		require.True(t, game.gameType.Valid())
+	}
+}
+
+// TestGameType_Invalid tests the Valid function with an invalid input.
+func TestGameType_Invalid(t *testing.T) {
+	invalid := disputeGames[len(disputeGames)-1].gameType + 1
+	require.False(t, GameType(invalid).Valid())
+}
+
+// FuzzGameType_Invalid checks that invalid game types are correctly
+// returned as invalid by the validation [Valid] function.
+func FuzzGameType_Invalid(f *testing.F) {
+	maxCount := len(DisputeGameTypes)
+	f.Fuzz(func(t *testing.T, number uint8) {
+		if number >= uint8(maxCount) {
+			require.False(t, GameType(number).Valid())
+		} else {
+			require.True(t, GameType(number).Valid())
+		}
+	})
+}
+
+// TestGameType_Default tests the default value of the DisputeGameType.
+func TestGameType_Default(t *testing.T) {
+	d := NewDisputeGameType()
+	require.Equal(t, DefaultGameType(), d.selected)
+	require.Equal(t, DefaultGameType(), d.Type())
+}
+
+// TestGameType_String tests the Set and String function on the DisputeGameType.
+func TestGameType_String(t *testing.T) {
+	for _, dg := range disputeGames {
+		t.Run(dg.name, func(t *testing.T) {
+			d := NewDisputeGameType()
+			require.Equal(t, dg.name, dg.gameType.String())
+			require.NoError(t, d.Set(dg.name))
+			require.Equal(t, dg.name, d.String())
+			require.Equal(t, dg.gameType, d.selected)
+		})
+	}
+}
+
+// TestGameType_Type tests the Type function on the DisputeGameType.
+func TestGameType_Type(t *testing.T) {
+	for _, dg := range disputeGames {
+		t.Run(dg.name, func(t *testing.T) {
+			d := NewDisputeGameType()
+			require.Equal(t, dg.name, dg.gameType.String())
+			require.NoError(t, d.Set(dg.name))
+			require.Equal(t, dg.gameType, d.Type())
+			require.Equal(t, dg.gameType, d.selected)
+		})
+	}
+}

op-node/flags/flags.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
+	openum "github.com/ethereum-optimism/optimism/op-service/enum"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 
 	"github.com/urfave/cli"
@@ -68,7 +69,7 @@ var (
 	L1RPCProviderKind = cli.GenericFlag{
 		Name: "l1.rpckind",
 		Usage: "The kind of RPC provider, used to inform optimal transactions receipts fetching, and thus reduce costs. Valid options: " +
-			EnumString[sources.RPCProviderKind](sources.RPCProviderKinds),
+			openum.EnumString(sources.RPCProviderKinds),
 		EnvVar: prefixEnvVar("L1_RPC_KIND"),
 		Value: func() *sources.RPCProviderKind {
 			out := sources.RPCKindBasic

op-program/host/flags/flags.go

@@ -7,9 +7,9 @@ import (
 	"github.com/urfave/cli"
 
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
-	nodeflags "github.com/ethereum-optimism/optimism/op-node/flags"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
 	service "github.com/ethereum-optimism/optimism/op-service"
+	openum "github.com/ethereum-optimism/optimism/op-service/enum"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 )
 
@@ -74,7 +74,7 @@ var (
 	L1RPCProviderKind = cli.GenericFlag{
 		Name: "l1.rpckind",
 		Usage: "The kind of RPC provider, used to inform optimal transactions receipts fetching, and thus reduce costs. Valid options: " +
-			nodeflags.EnumString[sources.RPCProviderKind](sources.RPCProviderKinds),
+			openum.EnumString(sources.RPCProviderKinds),
 		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L1_RPC_KIND"),
 		Value: func() *sources.RPCProviderKind {
 			out := sources.RPCKindBasic

op-node/flags/util.go → op-service/enum/enum.go

-package flags
+package enum
 
 import (
 	"fmt"
 	"strings"
 )
 
+// Stringered wraps the string type to implement the fmt.Stringer interface.
+type Stringered string
+
+// String returns the string value.
+func (s Stringered) String() string {
+	return string(s)
+}
+
+// StringeredList converts a list of strings to a list of Stringered.
+func StringeredList(values []string) []Stringered {
+	var out []Stringered
+	for _, v := range values {
+		out = append(out, Stringered(v))
+	}
+	return out
+}
+
+// EnumString returns a comma-separated string of the enum values.
+// This is primarily used to generate a cli flag.
 func EnumString[T fmt.Stringer](values []T) string {
 	var out strings.Builder
 	for i, v := range values {

op-service/enum/enum_test.go

+package enum
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestEnumString_MultipleInputs tests the EnumString function with multiple inputs.
+func TestEnumString_MultipleInputs(t *testing.T) {
+	require.Equal(t, "a, b, c", EnumString([]Stringered{"a", "b", "c"}))
+}
+
+// TestEnumString_SingleString tests the EnumString function with a single input.
+func TestEnumString_SingleString(t *testing.T) {
+	require.Equal(t, "a", EnumString([]Stringered{"a"}))
+}
+
+// TestEnumString_EmptyString tests the EnumString function with no inputs.
+func TestEnumString_EmptyString(t *testing.T) {
+	require.Equal(t, "", EnumString([]Stringered{}))
+}
+
+// TestStringeredList_MultipleInputs tests the StringeredList function with multiple inputs.
+func TestStringeredList_MultipleInputs(t *testing.T) {
+	require.Equal(t, []Stringered{"a", "b", "c"}, StringeredList([]string{"a", "b", "c"}))
+}
+
+// TestStringeredList_SingleString tests the StringeredList function with a single input.
+func TestStringeredList_SingleString(t *testing.T) {
+	require.Equal(t, []Stringered{"a"}, StringeredList([]string{"a"}))
+}
+
+// TestStringeredList_EmptyString tests the StringeredList function with no inputs.
+func TestStringeredList_EmptyString(t *testing.T) {
+	require.Equal(t, []Stringered(nil), StringeredList([]string{}))
+}

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

 {
   "finalSystemOwner": "0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A",
-  "controller": "0x78339d822c23d943e4a2d4c3dd5408f66e6d662d",
-  "portalGuardian": "0x78339d822c23d943e4a2d4c3dd5408f66e6d662d",
-  "l1StartingBlockTag": "0x126e52a0cc0ae18948f567ee9443f4a8f0db67c437706e35baee424eb314a0d0",
+  "controller": "0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A",
+  "portalGuardian": "0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A",
+  "l1StartingBlockTag": "",
   "l1ChainID": 1,
   "l2ChainID": 10,
   "l2BlockTime": 2,
   "maxSequencerDrift": 600,
   "sequencerWindowSize": 3600,
   "channelTimeout": 300,
-  "p2pSequencerAddress": "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
+  "p2pSequencerAddress": "0xAAAA45d9549EDA09E70937013520214382Ffc4A2",
   "batchInboxAddress": "0xff00000000000000000000000000000000000010",
-  "batchSenderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
-  "l2OutputOracleSubmissionInterval": 20,
-  "l2OutputOracleStartingTimestamp": 1679069195,
-  "l2OutputOracleStartingBlockNumber": 79149704,
-  "l2OutputOracleProposer": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-  "l2OutputOracleChallenger": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-  "finalizationPeriodSeconds": 2,
-  "proxyAdminOwner": "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
+  "batchSenderAddress": "0x6887246668a3b87F54DeB3b94Ba47a6f63F32985",
+  "l2OutputOracleSubmissionInterval": 1800,
+  "l2OutputOracleStartingTimestamp": 0,
+  "l2OutputOracleStartingBlockNumber": 0,
+  "l2OutputOracleProposer": "0x473300df21D047806A082244b417f96b32f13A33",
+  "l2OutputOracleChallenger": "0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A",
+  "finalizationPeriodSeconds": 604800,
+  "proxyAdminOwner": "0x7871d1187A97cbbE40710aC119AA3d412944e4Fe",
   "baseFeeVaultRecipient": "0xa3d596EAfaB6B13Ab18D40FaE1A962700C84ADEa",
   "l1FeeVaultRecipient": "0xa3d596EAfaB6B13Ab18D40FaE1A962700C84ADEa",
   "sequencerFeeVaultRecipient": "0xa3d596EAfaB6B13Ab18D40FaE1A962700C84ADEa",
   "governanceTokenName": "Optimism",
   "governanceTokenSymbol": "OP",
-  "governanceTokenOwner": "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
+  "governanceTokenOwner": "0x5C4e7Ba1E219E47948e6e3F55019A647bA501005",
   "l2GenesisBlockGasLimit": "0x1c9c380",
   "l2GenesisBlockCoinbase": "0x4200000000000000000000000000000000000011",
   "l2GenesisBlockBaseFeePerGas": "0x3b9aca00",
-  "gasPriceOracleOverhead": 2100,
-  "gasPriceOracleScalar": 1000000,
+  "gasPriceOracleOverhead": 188,
+  "gasPriceOracleScalar": 684000,
   "eip1559Denominator": 50,
-  "eip1559Elasticity": 10,
+  "eip1559Elasticity": 6,
   "l2GenesisRegolithTimeOffset": "0x0"
 }

proxyd/backend.go

@@ -564,8 +564,8 @@ func (bg *BackendGroup) Forward(ctx context.Context, rpcReqs []*RPCReq, isBatch
 		// We also rewrite block tags to enforce compliance with consensus
 		rctx := RewriteContext{
 			latest:    bg.Consensus.GetLatestBlockNumber(),
-			finalized: bg.Consensus.GetFinalizedBlockNumber(),
 			safe:      bg.Consensus.GetSafeBlockNumber(),
+			finalized: bg.Consensus.GetFinalizedBlockNumber(),
 		}
 
 		for i, req := range rpcReqs {