core/types: implement operator fee fix (Jovian) (#696)

* fix!: multiply operatorFeeScalar by 100 instead of dividing by 1e6

* apply comments

* apply comments

* remove dup IsOperatorFeeFix

---------

Co-authored-by: fakedev9999 <[email protected]>

Author: geoknee

core/types/rollup_cost.go

@@ -83,6 +83,7 @@ var (
 	// attributes
 	OperatorFeeParamsSlot = common.BigToHash(big.NewInt(8))
 
+	oneHundred     = big.NewInt(100)
 	oneMillion     = big.NewInt(1_000_000)
 	ecotoneDivisor = big.NewInt(1_000_000 * 16)
 	fjordDivisor   = big.NewInt(1_000_000_000_000)
@@ -232,7 +233,11 @@ func NewOperatorCostFunc(config *params.ChainConfig, statedb StateGetter) Operat
 		}
 		operatorFeeScalar, operatorFeeConstant := ExtractOperatorFeeParams(operatorFeeParams)
 
-		return newOperatorCostFunc(operatorFeeScalar, operatorFeeConstant)
+		// Return the Operator Fee fix version if the feature is active
+		if config.IsOperatorFeeFix(blockTime) {
+			return newOperatorCostFuncOperatorFeeFix(operatorFeeScalar, operatorFeeConstant)
+		}
+		return newOperatorCostFuncIsthmus(operatorFeeScalar, operatorFeeConstant)
 	}
 
 	return func(gas uint64, blockTime uint64) *uint256.Int {
@@ -245,7 +250,8 @@ func NewOperatorCostFunc(config *params.ChainConfig, statedb StateGetter) Operat
 	}
 }
 
-func newOperatorCostFunc(operatorFeeScalar *big.Int, operatorFeeConstant *big.Int) operatorCostFunc {
+// newOperatorCostFuncIsthmus returns the operator cost function introduced with Isthmus.
+func newOperatorCostFuncIsthmus(operatorFeeScalar *big.Int, operatorFeeConstant *big.Int) operatorCostFunc {
 	return func(gas uint64) *uint256.Int {
 		fee := new(big.Int).SetUint64(gas)
 		fee = fee.Mul(fee, operatorFeeScalar)
@@ -254,7 +260,25 @@ func newOperatorCostFunc(operatorFeeScalar *big.Int, operatorFeeConstant *big.In
 
 		feeU256, overflow := uint256.FromBig(fee)
 		if overflow {
-			// This should never happen, as (u64.max * u32.max / 1e6) + u64.max is an int of bit length 77
+			// This should never happen, as ((u64.max * u32.max) / 1e6) + u64.max fits in 77 bits
+			panic("overflow in operator cost calculation")
+		}
+
+		return feeU256
+	}
+}
+
+// newOperatorCostFuncOperatorFeeFix returns the operator cost function for the operator fee fix feature.
+func newOperatorCostFuncOperatorFeeFix(operatorFeeScalar *big.Int, operatorFeeConstant *big.Int) operatorCostFunc {
+	return func(gas uint64) *uint256.Int {
+		fee := new(big.Int).SetUint64(gas)
+		fee = fee.Mul(fee, operatorFeeScalar)
+		fee = fee.Mul(fee, oneHundred)
+		fee = fee.Add(fee, operatorFeeConstant)
+
+		feeU256, overflow := uint256.FromBig(fee)
+		if overflow {
+			// This should never happen, as (u64.max * u32.max * 100) + u64.max fits in 103 bits
 			panic("overflow in operator cost calculation")
 		}
 

core/types/rollup_cost_test.go

@@ -33,6 +33,7 @@ var (
 	// the emptyTx is out of bounds for the linear regression so it uses the minimum size
 	fjordFee          = big.NewInt(3203000)                 // 100_000_000 * (2 * 1000 * 1e6 * 16 + 3 * 10 * 1e6) / 1e12
 	ithmusOperatorFee = uint256.NewInt(1256417826611659930) // 1618 * 1439103868 / 1e6 + 1256417826609331460
+	jovianOperatorFee = uint256.NewInt(1256650673615173860) // 1618 * 1439103868 * 100 + 1256417826609331460
 
 	bedrockGas      = big.NewInt(1618)
 	regolithGas     = big.NewInt(530) // 530  = 1618 - (16*68)
@@ -461,6 +462,13 @@ func TestNewOperatorCostFunc(t *testing.T) {
 	fee = costFunc(bedrockGas.Uint64(), time)
 	require.NotNil(t, fee)
 	require.Equal(t, ithmusOperatorFee, fee)
+
+	// emptyTx fee w/ jovian config should be not 0
+	config.JovianTime = &time
+	costFunc = NewOperatorCostFunc(config, statedb)
+	fee = costFunc(bedrockGas.Uint64(), time)
+	require.NotNil(t, fee)
+	require.Equal(t, jovianOperatorFee, fee)
 }
 
 func TestFlzCompressLen(t *testing.T) {
@@ -516,14 +524,16 @@ var emptyTxWithGas = NewTransaction(
 // combines the L1 cost and operator cost.
 func TestTotalRollupCostFunc(t *testing.T) {
 	zero := uint64(0)
-	later := uint64(10)
+	isthmusTime := uint64(10)
+	jovianTime := uint64(20)
 	config := &params.ChainConfig{
 		Optimism:     params.OptimismTestConfig.Optimism,
 		RegolithTime: &zero,
 		EcotoneTime:  &zero,
 		FjordTime:    &zero,
 		HoloceneTime: &zero,
-		IsthmusTime:  &later,
+		IsthmusTime:  &isthmusTime,
+		JovianTime:   &jovianTime,
 	}
 	statedb := &testStateGetter{
 		baseFee:             baseFee,
@@ -537,13 +547,24 @@ func TestTotalRollupCostFunc(t *testing.T) {
 	}
 
 	costFunc := NewTotalRollupCostFunc(config, statedb)
-	cost := costFunc(emptyTxWithGas, later-1)
+
+	// Pre-Isthmus: only L1 cost
+	cost := costFunc(emptyTxWithGas, isthmusTime-1)
 	require.NotNil(t, cost)
 	expCost := uint256.MustFromBig(fjordFee)
 	require.Equal(t, expCost, cost, "pre-Isthmus total rollup cost should only contain L1 cost")
 
-	cost = costFunc(emptyTxWithGas, later+1)
+	// Isthmus: L1 cost + Isthmus operator cost
+	cost = costFunc(emptyTxWithGas, isthmusTime+1)
 	require.NotNil(t, cost)
+	expCost = uint256.MustFromBig(fjordFee)
 	expCost.Add(expCost, ithmusOperatorFee)
-	require.Equal(t, expCost, cost, "Isthmus total rollup cost should contain L1 cost and operator cost")
+	require.Equal(t, expCost, cost, "Isthmus total rollup cost should contain L1 cost and Isthmus operator cost")
+
+	// Jovian: L1 cost + fixed operator cost
+	cost = costFunc(emptyTxWithGas, jovianTime+1)
+	require.NotNil(t, cost)
+	expCost = uint256.MustFromBig(fjordFee)
+	expCost.Add(expCost, jovianOperatorFee)
+	require.Equal(t, expCost, cost, "Jovian total rollup cost should contain L1 cost and Jovian operator cost")
 }