core/types: Populate Jovian receipt fields

Author: sebastianst

core/types/gen_receipt_json.go

@@ -86,15 +86,16 @@ type Receipt struct {
 	TransactionIndex uint        `json:"transactionIndex"`
 
 	// Optimism: extend receipts with L1 and operator fee info
-	L1GasPrice          *big.Int   `json:"l1GasPrice,omitempty"`          // Present from pre-bedrock. L1 Basefee after Bedrock
-	L1BlobBaseFee       *big.Int   `json:"l1BlobBaseFee,omitempty"`       // Always nil prior to the Ecotone hardfork
-	L1GasUsed           *big.Int   `json:"l1GasUsed,omitempty"`           // Present from pre-bedrock, deprecated as of Fjord
-	L1Fee               *big.Int   `json:"l1Fee,omitempty"`               // Present from pre-bedrock
-	FeeScalar           *big.Float `json:"l1FeeScalar,omitempty"`         // Present from pre-bedrock to Ecotone. Nil after Ecotone
-	L1BaseFeeScalar     *uint64    `json:"l1BaseFeeScalar,omitempty"`     // Always nil prior to the Ecotone hardfork
-	L1BlobBaseFeeScalar *uint64    `json:"l1BlobBaseFeeScalar,omitempty"` // Always nil prior to the Ecotone hardfork
-	OperatorFeeScalar   *uint64    `json:"operatorFeeScalar,omitempty"`   // Always nil prior to the Isthmus hardfork
-	OperatorFeeConstant *uint64    `json:"operatorFeeConstant,omitempty"` // Always nil prior to the Isthmus hardfork
+	L1GasPrice           *big.Int   `json:"l1GasPrice,omitempty"`           // Present from pre-bedrock. L1 Basefee after Bedrock
+	L1BlobBaseFee        *big.Int   `json:"l1BlobBaseFee,omitempty"`        // Always nil prior to the Ecotone hardfork
+	L1GasUsed            *big.Int   `json:"l1GasUsed,omitempty"`            // Present from pre-bedrock, deprecated as of Fjord
+	L1Fee                *big.Int   `json:"l1Fee,omitempty"`                // Present from pre-bedrock
+	FeeScalar            *big.Float `json:"l1FeeScalar,omitempty"`          // Present from pre-bedrock to Ecotone. Nil after Ecotone
+	L1BaseFeeScalar      *uint64    `json:"l1BaseFeeScalar,omitempty"`      // Always nil prior to the Ecotone hardfork
+	L1BlobBaseFeeScalar  *uint64    `json:"l1BlobBaseFeeScalar,omitempty"`  // Always nil prior to the Ecotone hardfork
+	OperatorFeeScalar    *uint64    `json:"operatorFeeScalar,omitempty"`    // Always nil prior to the Isthmus hardfork
+	OperatorFeeConstant  *uint64    `json:"operatorFeeConstant,omitempty"`  // Always nil prior to the Isthmus hardfork
+	DAFootprintGasScalar *uint64    `json:"daFootprintGasScalar,omitempty"` // Always nil prior to the Jovian hardfork
 }
 
 type receiptMarshaling struct {
@@ -121,6 +122,7 @@ type receiptMarshaling struct {
 	DepositReceiptVersion *hexutil.Uint64
 	OperatorFeeScalar     *hexutil.Uint64
 	OperatorFeeConstant   *hexutil.Uint64
+	DAFootprintGasScalar  *hexutil.Uint64
 }
 
 // receiptRLP is the consensus encoding of a receipt.
@@ -612,26 +614,8 @@ func (rs Receipts) DeriveFields(config *params.ChainConfig, blockHash common.Has
 		logIndex += uint(len(rs[i].Logs))
 	}
 
-	if config.Optimism != nil && len(txs) >= 2 && config.IsBedrock(new(big.Int).SetUint64(blockNumber)) {
-		gasParams, err := extractL1GasParams(config, blockTime, txs[0].Data())
-		if err != nil {
-			return err
-		}
-		for i := 0; i < len(rs); i++ {
-			if txs[i].IsDepositTx() {
-				continue
-			}
-			rs[i].L1GasPrice = gasParams.l1BaseFee
-			rs[i].L1BlobBaseFee = gasParams.l1BlobBaseFee
-			rs[i].L1Fee, rs[i].L1GasUsed = gasParams.costFunc(txs[i].RollupCostData())
-			rs[i].FeeScalar = gasParams.feeScalar
-			rs[i].L1BaseFeeScalar = u32ptrTou64ptr(gasParams.l1BaseFeeScalar)
-			rs[i].L1BlobBaseFeeScalar = u32ptrTou64ptr(gasParams.l1BlobBaseFeeScalar)
-			if gasParams.operatorFeeScalar != nil && gasParams.operatorFeeConstant != nil && (*gasParams.operatorFeeScalar != 0 || *gasParams.operatorFeeConstant != 0) {
-				rs[i].OperatorFeeScalar = u32ptrTou64ptr(gasParams.operatorFeeScalar)
-				rs[i].OperatorFeeConstant = gasParams.operatorFeeConstant
-			}
-		}
+	if config.IsOptimismBedrock(new(big.Int).SetUint64(blockNumber)) && len(txs) >= 2 {
+		return rs.deriveOPStackFields(config, blockTime, txs)
 	}
 	return nil
 }

core/types/receipt.go

@@ -0,0 +1,54 @@
+package types
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/params"
+)
+
+// deriveOPStackFields derives the OP Stack specific fields for each receipt.
+// It must only be called for blocks with at least one transaction (the L1 attributes deposit).
+func (rs Receipts) deriveOPStackFields(config *params.ChainConfig, blockTime uint64, txs []*Transaction) error {
+	// Exit early if there are only deposit transactions, for which no fields are derived.
+	if txs[len(txs)-1].IsDepositTx() {
+		return nil
+	}
+
+	l1AttributesData := txs[0].Data()
+	gasParams, err := extractL1GasParams(config, blockTime, l1AttributesData)
+	if err != nil {
+		return fmt.Errorf("failed to extract L1 gas params: %w", err)
+	}
+
+	var daFootprintGasScalar uint64
+	isJovian := config.IsJovian(blockTime)
+	if isJovian {
+		scalar, err := ExtractDAFootprintGasScalar(l1AttributesData)
+		if err != nil {
+			return fmt.Errorf("failed to extract DA footprint gas scalar: %w", err)
+		}
+		daFootprintGasScalar = uint64(scalar)
+	}
+
+	for i := range rs {
+		if txs[i].IsDepositTx() {
+			continue
+		}
+		rs[i].L1GasPrice = gasParams.l1BaseFee
+		rs[i].L1BlobBaseFee = gasParams.l1BlobBaseFee
+		rcd := txs[i].RollupCostData()
+		rs[i].L1Fee, rs[i].L1GasUsed = gasParams.costFunc(rcd)
+		rs[i].FeeScalar = gasParams.feeScalar
+		rs[i].L1BaseFeeScalar = u32ptrTou64ptr(gasParams.l1BaseFeeScalar)
+		rs[i].L1BlobBaseFeeScalar = u32ptrTou64ptr(gasParams.l1BlobBaseFeeScalar)
+		if gasParams.operatorFeeScalar != nil && gasParams.operatorFeeConstant != nil && (*gasParams.operatorFeeScalar != 0 || *gasParams.operatorFeeConstant != 0) {
+			rs[i].OperatorFeeScalar = u32ptrTou64ptr(gasParams.operatorFeeScalar)
+			rs[i].OperatorFeeConstant = gasParams.operatorFeeConstant
+		}
+		if isJovian {
+			rs[i].DAFootprintGasScalar = &daFootprintGasScalar
+			rs[i].BlobGasUsed = daFootprintGasScalar * rcd.EstimatedDASize().Uint64()
+		}
+	}
+	return nil
+}

core/types/receipt_opstack.go

@@ -37,6 +37,12 @@ var (
 		conf.IsthmusTime = &time
 		return &conf
 	}()
+	jovianTestConfig = func() *params.ChainConfig {
+		conf := *isthmusTestConfig // copy the config
+		time := uint64(0)
+		conf.JovianTime = &time
+		return &conf
+	}()
 
 	depositReceiptNoNonce = &Receipt{
 		Status:            ReceiptStatusFailed,
@@ -95,6 +101,8 @@ var (
 		},
 		Type: DepositTxType,
 	}
+
+	daFootprintGasScalar = uint16(400)
 )
 
 func clearComputedFieldsOnOPStackReceipts(receipts []*Receipt) []*Receipt {
@@ -109,6 +117,7 @@ func clearComputedFieldsOnOPStackReceipts(receipts []*Receipt) []*Receipt {
 		receipt.L1BlobBaseFeeScalar = nil
 		receipt.OperatorFeeScalar = nil
 		receipt.OperatorFeeConstant = nil
+		receipt.DAFootprintGasScalar = nil
 	}
 	return receipts
 }
@@ -200,6 +209,15 @@ func getOptimismIsthmusTxReceipts(l1AttributesPayload []byte, l1GasPrice, l1Blob
 	return txs, receipts
 }
 
+func getOptimismJovianTxReceipts(l1AttributesPayload []byte, l1GasPrice, l1BlobBaseFee, l1GasUsed, l1Fee *big.Int, baseFeeScalar, blobBaseFeeScalar, operatorFeeScalar, operatorFeeConstant, daFootprintGasScalar *uint64) ([]*Transaction, []*Receipt) {
+	txs, receipts := getOptimismIsthmusTxReceipts(l1AttributesPayload, l1GasPrice, l1BlobBaseFee, l1GasUsed, l1Fee, baseFeeScalar, blobBaseFeeScalar, operatorFeeScalar, operatorFeeConstant)
+	receipts[1].DAFootprintGasScalar = daFootprintGasScalar
+	if daFootprintGasScalar != nil {
+		receipts[1].BlobGasUsed = *daFootprintGasScalar * txs[1].RollupCostData().EstimatedDASize().Uint64()
+	}
+	return txs, receipts
+}
+
 func TestDeriveOptimismBedrockTxReceipts(t *testing.T) {
 	// Bedrock style l1 attributes with L1Scalar=7_000_000 (becomes 7 after division), L1Overhead=50, L1BaseFee=1000*1e6
 	payload := common.Hex2Bytes("015d8eb900000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d2000000000000000000000000000000000000000000000000000000003b9aca0000000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d2000000000000000000000000000000000000000000000000000000000000003200000000000000000000000000000000000000000000000000000000006acfc0015d8eb900000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d2000000000000000000000000000000000000000000000000000000003b9aca0000000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d2000000000000000000000000000000000000000000000000000000000000003200000000000000000000000000000000000000000000000000000000006acfc0")
@@ -286,6 +304,29 @@ func TestDeriveOptimismIsthmusTxReceiptsNoOperatorFee(t *testing.T) {
 	diffReceipts(t, receipts, derivedReceipts)
 }
 
+func TestDeriveOptimismJovianTxReceipts(t *testing.T) {
+	// Jovian style l1 attributes with baseFeeScalar=2, blobBaseFeeScalar=3, baseFee=1000*1e6, blobBaseFee=10*1e6, operatorFeeScalar=1439103868, operatorFeeConstant=1256417826609331460, daFootprintGasScalar=400
+	payload := common.Hex2Bytes("3db6be2b000000020000000300000000000004d200000000000004d200000000000004d2000000000000000000000000000000000000000000000000000000003b9aca00000000000000000000000000000000000000000000000000000000000098968000000000000000000000000000000000000000000000000000000000000004d200000000000000000000000000000000000000000000000000000000000004d255c6fb7c116fb15b44847d040190")
+	// the parameters we use below are defined in rollup_test.go
+	baseFeeScalarUint64 := baseFeeScalar.Uint64()
+	blobBaseFeeScalarUint64 := blobBaseFeeScalar.Uint64()
+	operatorFeeScalarUint64 := operatorFeeScalar.Uint64()
+	operatorFeeConstantUint64 := operatorFeeConstant.Uint64()
+	daFootprintGasScalarUint64 := uint64(daFootprintGasScalar)
+	txs, receipts := getOptimismJovianTxReceipts(payload, baseFee, blobBaseFee, minimumFjordGas, fjordFee, &baseFeeScalarUint64, &blobBaseFeeScalarUint64, &operatorFeeScalarUint64, &operatorFeeConstantUint64, &daFootprintGasScalarUint64)
+
+	// Re-derive receipts.
+	baseFee := big.NewInt(1000)
+	derivedReceipts := clearComputedFieldsOnOPStackReceipts(receipts)
+	// Should error out if we try to process this with a pre-Jovian config
+	err := Receipts(derivedReceipts).DeriveFields(bedrockGenesisTestConfig, blockHash, blockNumber.Uint64(), 0, baseFee, nil, txs)
+	require.Error(t, err)
+
+	err = Receipts(derivedReceipts).DeriveFields(jovianTestConfig, blockHash, blockNumber.Uint64(), 0, baseFee, nil, txs)
+	require.NoError(t, err)
+	diffReceipts(t, receipts, derivedReceipts)
+}
+
 func diffReceipts(t *testing.T, receipts, derivedReceipts []*Receipt) {
 	// Check diff of receipts against derivedReceipts.
 	r1, err := json.MarshalIndent(receipts, "", "  ")

core/types/receipt_opstack_test.go

@@ -253,12 +253,15 @@ def:
     - title: "User API enhancements"
       description: "Encode the Deposit Tx properties, the L1 costs, and daisy-chain RPC-calls for pre-Bedrock historical data"
       sub:
-        - title: "Receipts metadata"
+        - title: "Receipts metadata & deposit receipts"
           description: |
             Pre-Bedrock L1-cost receipt data is loaded from the database if available, and post-Bedrock the L1-cost
             metadata is hydrated on-the-fly based on the L1 fee information in the corresponding block.
+            We also populate receipts with L1 block attributes like Operator Fee and DA Footprint parameters.
+            Furthermore, OP Stack introduces Deposit receipts, a special kind of receipts for Deposit transactions.
           globs:
             - "core/types/receipt.go"
+            - "core/types/receipt_opstack.go"
             - "core/types/gen_receipt_json.go"
             - "core/rawdb/accessors_chain.go"
         - title: "API Backend"

fork.yaml

@@ -1710,7 +1710,7 @@ func marshalReceipt(receipt *types.Receipt, blockHash common.Hash, blockNumber u
 		"effectiveGasPrice": (*hexutil.Big)(receipt.EffectiveGasPrice),
 	}
 
-	if chainConfig.Optimism != nil && !tx.IsDepositTx() {
+	if chainConfig.IsOptimism() && !tx.IsDepositTx() {
 		fields["l1GasPrice"] = (*hexutil.Big)(receipt.L1GasPrice)
 		fields["l1GasUsed"] = (*hexutil.Big)(receipt.L1GasUsed)
 		fields["l1Fee"] = (*hexutil.Big)(receipt.L1Fee)
@@ -1735,8 +1735,14 @@ func marshalReceipt(receipt *types.Receipt, blockHash common.Hash, blockNumber u
 		if receipt.OperatorFeeConstant != nil {
 			fields["operatorFeeConstant"] = hexutil.Uint64(*receipt.OperatorFeeConstant)
 		}
+		// Fields added in Jovian
+		if receipt.DAFootprintGasScalar != nil {
+			fields["daFootprintGasScalar"] = hexutil.Uint64(*receipt.OperatorFeeScalar)
+			// Jovian repurposes blobGasUsed for DA footprint gas used
+			fields["blobGasUsed"] = hexutil.Uint64(receipt.BlobGasUsed)
+		}
 	}
-	if chainConfig.Optimism != nil && tx.IsDepositTx() && receipt.DepositNonce != nil {
+	if chainConfig.IsOptimism() && tx.IsDepositTx() && receipt.DepositNonce != nil {
 		fields["depositNonce"] = hexutil.Uint64(*receipt.DepositNonce)
 		if receipt.DepositReceiptVersion != nil {
 			fields["depositReceiptVersion"] = hexutil.Uint64(*receipt.DepositReceiptVersion)