feat(feynman): add new compression-aware rollup fee formula

params/config.go

@@ -988,6 +988,11 @@ func (c *ChainConfig) IsEuclidV2(now uint64) bool {
 	return isForkedTime(now, c.EuclidV2Time)
 }
 
+// IsFeynman returns whether num is either equal to the Feynman fork block or greater.
+func (c *ChainConfig) IsFeynman(num *big.Int) bool {
+	return false // placeholder
+}
+
 // IsTerminalPoWBlock returns whether the given block is the last block of PoW stage.
 func (c *ChainConfig) IsTerminalPoWBlock(parentTotalDiff *big.Int, totalDiff *big.Int) bool {
 	if c.TerminalTotalDifficulty == nil {

rollup/fees/rollup_fee.go

@@ -74,15 +74,17 @@ func EstimateL1DataFeeForMessage(msg Message, baseFee *big.Int, config *params.C
 
 	gpoState := readGPOStorageSlots(rcfg.L1GasPriceOracleAddress, state)
 
-	var l1DataFee *big.Int
+	var rollupFee *big.Int
 
 	if !config.IsCurie(blockNumber) {
-		l1DataFee = calculateEncodedL1DataFee(raw, gpoState.overhead, gpoState.l1BaseFee, gpoState.scalar)
+		rollupFee = calculateEncodedL1DataFee(raw, gpoState.overhead, gpoState.l1BaseFee, gpoState.scalar)
+	} else if !config.IsFeynman(blockNumber) {
+		rollupFee = calculateEncodedL1DataFeeCurie(raw, gpoState.l1BaseFee, gpoState.l1BlobBaseFee, gpoState.commitScalar, gpoState.blobScalar)
 	} else {
-		l1DataFee = calculateEncodedL1DataFeeCurie(raw, gpoState.l1BaseFee, gpoState.l1BlobBaseFee, gpoState.commitScalar, gpoState.blobScalar)
+		rollupFee = calculateEncodedL1DataFeeFeynman(raw, gpoState.l1BaseFee, gpoState.l1BlobBaseFee, gpoState.commitScalar, gpoState.blobScalar)
 	}
 
-	return l1DataFee, nil
+	return rollupFee, nil
 }
 
 // asUnsignedTx turns a Message into a types.Transaction
@@ -193,6 +195,38 @@ func calculateEncodedL1DataFeeCurie(data []byte, l1BaseFee *big.Int, l1BlobBaseF
 	return l1DataFee
 }
 
+// calculateEncodedL1DataFeeFeynman computes the L1 fee for an RLP-encoded tx, post Feynman
+func calculateEncodedL1DataFeeFeynman(
+	data []byte,
+	l1BaseFee *big.Int,
+	l1BlobBaseFee *big.Int,
+	execScalar *big.Int,
+	blobScalar *big.Int,
+) *big.Int {
+	// tx size (RLP-encoded)
+	txSize := big.NewInt(int64(len(data)))
+
+	// compression_ratio(tx) = 1 (placeholder, scaled to match scalars precision)
+	compressionRatio := big.NewInt(rcfg.Precision.Int64())
+
+	// compute gas components
+	execGas := new(big.Int).Mul(execScalar, l1BaseFee)
+	blobGas := new(big.Int).Mul(blobScalar, l1BlobBaseFee)
+
+	// fee per byte = execGas + blobGas
+	feePerByte := new(big.Int).Add(execGas, blobGas)
+
+	// l1DataFee = compression_ratio * tx_size * feePerByte
+	l1DataFee := new(big.Int).Mul(compressionRatio, txSize)
+	l1DataFee.Mul(l1DataFee, feePerByte)
+
+	// Divide by rcfg.Precision (once for ratio, once for scalar)
+	l1DataFee.Div(l1DataFee, rcfg.Precision)
+	l1DataFee.Div(l1DataFee, rcfg.Precision)
+
+	return l1DataFee
+}
+
 // calculateL1GasUsed computes the L1 gas used based on the calldata and
 // constant sized overhead. The overhead can be decreased as the cost of the
 // batch submission goes down via contract optimizations. This will not overflow
@@ -242,8 +276,10 @@ func CalculateL1DataFee(tx *types.Transaction, state StateDB, config *params.Cha
 
 	if !config.IsCurie(blockNumber) {
 		l1DataFee = calculateEncodedL1DataFee(raw, gpoState.overhead, gpoState.l1BaseFee, gpoState.scalar)
-	} else {
+	} else if !config.IsFeynman(blockNumber) {
 		l1DataFee = calculateEncodedL1DataFeeCurie(raw, gpoState.l1BaseFee, gpoState.l1BlobBaseFee, gpoState.commitScalar, gpoState.blobScalar)
+	} else {
+		l1DataFee = calculateEncodedL1DataFeeFeynman(raw, gpoState.l1BaseFee, gpoState.l1BlobBaseFee, gpoState.commitScalar, gpoState.blobScalar)
 	}
 
 	// ensure l1DataFee fits into uint64 for circuit compatibility