core,params: Check implied fork times during genesis setup (#587)

The chain config must have consistent fork times set when OP Stack forks
are active that imply Ethereum forks.
This is already guaranteed for chains in the superchain-registry which
are loaded via the network flag, or when using the override flags.
But checks were missing when a custom genesis.json file is used. So it
could happen that a chain operator misconfigures to only set e.g.
Isthmus but not the Prague time.

Fixes #586

Author: sebastianst

core/genesis.go

@@ -375,6 +375,13 @@ func (o *ChainOverrides) apply(cfg *params.ChainConfig) error {
 		cfg.InteropTime = o.OverrideOptimismInterop
 	}
 
+	// We check for validity after applying the overrides, even if there weren't any.
+	// This has the added benefit that the check always happens when
+	// applying overrides, which is at the right places during genesis setup.
+	if verr := cfg.CheckOptimismValidity(); verr != nil {
+		return fmt.Errorf("OP-Stack invalidity after applying overrides: %w", verr)
+	}
+
 	return cfg.CheckConfigForkOrder()
 }
 

params/config.go

@@ -1306,3 +1306,46 @@ func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64) Rules
 func (c *ChainConfig) HasOptimismWithdrawalsRoot(blockTime uint64) bool {
 	return c.IsOptimismIsthmus(blockTime)
 }
+
+// CheckOptimismValidity checks for OP Stack chains:
+// - the EIP159 params are set
+// - the Ethereum forks are set to the same time as the OP Stack forks that imply them
+func (c *ChainConfig) CheckOptimismValidity() error {
+	if c.Optimism == nil {
+		return nil
+	}
+
+	if c.Optimism.EIP1559Denominator == 0 {
+		return errors.New("zero EIP1559Denominator")
+	}
+	if c.Optimism.EIP1559Elasticity == 0 {
+		return errors.New("zero EIP1559Elasticity")
+	}
+	if c.CanyonTime != nil && (c.Optimism.EIP1559DenominatorCanyon == nil || *c.Optimism.EIP1559DenominatorCanyon == 0) {
+		return errors.New("missing or zero EIP1559DenominatorCanyon")
+	}
+
+	if !equalPtrValues(c.ShanghaiTime, c.CanyonTime) {
+		return fmt.Errorf("ShanghaiTime (%s) must equal CanyonTime (%s)", ptrValueString(c.ShanghaiTime), ptrValueString(c.CanyonTime))
+	}
+	if !equalPtrValues(c.CancunTime, c.EcotoneTime) {
+		return fmt.Errorf("CancunTime (%s) must equal EcotoneTime (%s)", ptrValueString(c.CancunTime), ptrValueString(c.EcotoneTime))
+	}
+	if !equalPtrValues(c.PragueTime, c.IsthmusTime) {
+		return fmt.Errorf("PragueTime (%s) must equal IsthmusTime (%s)", ptrValueString(c.PragueTime), ptrValueString(c.IsthmusTime))
+	}
+
+	return nil
+}
+
+func equalPtrValues[T comparable](a, b *T) bool {
+	// also captures nil == nil
+	return a == b || (a != nil && b != nil && *a == *b)
+}
+
+func ptrValueString[T any](t *T) string {
+	if t == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("%v", *t)
+}

params/config_test.go

@@ -235,3 +235,132 @@ func TestConfigRulesRegolith(t *testing.T) {
 		t.Errorf("expected %v to be regolith", stamp)
 	}
 }
+
+func TestCheckOptimismValidity(t *testing.T) {
+	validOpConfig := &OptimismConfig{
+		EIP1559Denominator:       10,
+		EIP1559Elasticity:        50,
+		EIP1559DenominatorCanyon: newUint64(250),
+	}
+
+	tests := []struct {
+		name    string
+		config  *ChainConfig
+		wantErr *string
+	}{
+		{
+			name: "valid",
+			config: &ChainConfig{
+				Optimism:     validOpConfig,
+				CanyonTime:   newUint64(100),
+				ShanghaiTime: newUint64(100),
+				CancunTime:   newUint64(200),
+				EcotoneTime:  newUint64(200),
+				PragueTime:   newUint64(300),
+				IsthmusTime:  newUint64(300),
+			},
+			wantErr: nil,
+		},
+		{
+			name: "zero EIP1559Denominator",
+			config: &ChainConfig{
+				Optimism: &OptimismConfig{
+					EIP1559Denominator: 0,
+					EIP1559Elasticity:  50,
+				},
+			},
+			wantErr: ptr("zero EIP1559Denominator"),
+		},
+		{
+			name: "zero EIP1559Elasticity",
+			config: &ChainConfig{
+				Optimism: &OptimismConfig{
+					EIP1559Denominator: 10,
+					EIP1559Elasticity:  0,
+				},
+			},
+			wantErr: ptr("zero EIP1559Elasticity"),
+		},
+		{
+			name: "missing EIP1559DenominatorCanyon",
+			config: &ChainConfig{
+				Optimism: &OptimismConfig{
+					EIP1559Denominator: 10,
+					EIP1559Elasticity:  50,
+				},
+				CanyonTime: newUint64(100),
+			},
+			wantErr: ptr("missing or zero EIP1559DenominatorCanyon"),
+		},
+		{
+			name: "ShanghaiTime not equal to CanyonTime",
+			config: &ChainConfig{
+				Optimism:     validOpConfig,
+				ShanghaiTime: newUint64(100),
+				CanyonTime:   newUint64(200),
+			},
+			wantErr: ptr("ShanghaiTime (100) must equal CanyonTime (200)"),
+		},
+		{
+			name: "CancunTime not equal to EcotoneTime",
+			config: &ChainConfig{
+				Optimism:    validOpConfig,
+				CancunTime:  newUint64(200),
+				EcotoneTime: newUint64(300),
+			},
+			wantErr: ptr("CancunTime (200) must equal EcotoneTime (300)"),
+		},
+		{
+			name: "PragueTime not equal to IsthmusTime",
+			config: &ChainConfig{
+				Optimism:    validOpConfig,
+				PragueTime:  newUint64(300),
+				IsthmusTime: newUint64(400),
+			},
+			wantErr: ptr("PragueTime (300) must equal IsthmusTime (400)"),
+		},
+		{
+			name: "nil ShanghaiTime",
+			config: &ChainConfig{
+				Optimism:   validOpConfig,
+				CanyonTime: newUint64(200),
+			},
+			wantErr: ptr("ShanghaiTime (<nil>) must equal CanyonTime (200)"),
+		},
+		{
+			name: "nil CancunTime",
+			config: &ChainConfig{
+				Optimism:    validOpConfig,
+				EcotoneTime: newUint64(300),
+			},
+			wantErr: ptr("CancunTime (<nil>) must equal EcotoneTime (300)"),
+		},
+		{
+			name: "nil PragueTime",
+			config: &ChainConfig{
+				Optimism: &OptimismConfig{
+					EIP1559Denominator:       10,
+					EIP1559Elasticity:        50,
+					EIP1559DenominatorCanyon: newUint64(250),
+				},
+				IsthmusTime: newUint64(400),
+			},
+			wantErr: ptr("PragueTime (<nil>) must equal IsthmusTime (400)"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.config.CheckOptimismValidity()
+			if tt.wantErr != nil {
+				require.EqualError(t, err, *tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func ptr[T any](t T) *T {
+	return &t
+}