all: Make DA footprint gas scalar configurable (#675)

Co-authored-by: Sebastian Stammler <[email protected]>

Author: joshklop

core/chain_makers.go

@@ -421,6 +421,14 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 			b.header.RequestsHash = &reqHash
 		}
 
+		if config.IsDAFootprintBlockLimit(b.header.Time) {
+			gasUsed, err := types.CalcGasUsedJovian(b.txs, b.header.GasUsed)
+			if err != nil {
+				panic(err)
+			}
+			b.header.GasUsed = gasUsed
+		}
+
 		body := types.Body{Transactions: b.txs, Uncles: b.uncles, Withdrawals: b.withdrawals}
 		block, err := b.engine.FinalizeAndAssemble(cm, b.header, statedb, &body, b.receipts)
 		if err != nil {

core/state_processor.go

@@ -89,11 +89,6 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 		ProcessParentBlockHash(block.ParentHash(), evm)
 	}
 
-	var (
-		daFootprint uint64
-		isJovian    = p.config.IsJovian(block.Time())
-	)
-
 	// Iterate over and process the individual transactions
 	for i, tx := range block.Transactions() {
 		msg, err := TransactionToMessage(tx, signer, header.BaseFee)
@@ -108,10 +103,6 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 		}
 		receipts = append(receipts, receipt)
 		allLogs = append(allLogs, receipt.Logs...)
-
-		if tx.Type() != types.DepositTxType && isJovian {
-			daFootprint += tx.RollupCostData().EstimatedDASize().Uint64() * params.DAFootprintGasScalar
-		}
 	}
 
 	isIsthmus := p.config.IsIsthmus(block.Time())
@@ -138,8 +129,12 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 		requests = [][]byte{}
 	}
 
-	if isJovian && *usedGas < daFootprint {
-		*usedGas = daFootprint
+	if p.config.IsDAFootprintBlockLimit(block.Time()) {
+		gasUsed, err := types.CalcGasUsedJovian(block.Transactions(), *usedGas)
+		if err != nil {
+			return nil, fmt.Errorf("failed to calculate Jovian gas used: %w", err)
+		}
+		*usedGas = gasUsed
 	}
 
 	// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)

core/types/rollup_cost.go

@@ -19,6 +19,7 @@ package types
 import (
 	"bytes"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"math/big"
 
@@ -41,6 +42,9 @@ const (
 	// array. baseFeeScalar is in the first four bytes of the segment, blobBaseFeeScalar the next
 	// four.
 	scalarSectionStart = 32 - BaseFeeScalarSlotOffset - 4
+
+	IsthmusL1AttributesLen = 176
+	JovianL1AttributesLen  = 178
 )
 
 func init() {
@@ -57,6 +61,8 @@ var (
 	EcotoneL1AttributesSelector = []byte{0x44, 0x0a, 0x5e, 0x20}
 	// IsthmusL1AttributesSelector is the selector indicating Isthmus style L1 gas attributes.
 	IsthmusL1AttributesSelector = []byte{0x09, 0x89, 0x99, 0xbe}
+	// JovianL1AttributesSelector is the selector indicating Jovian style L1 gas attributes.
+	JovianL1AttributesSelector = []byte{0x3d, 0xb6, 0xbe, 0x2b}
 
 	// L1BlockAddr is the address of the L1Block contract which stores the L1 gas attributes.
 	L1BlockAddr = common.HexToAddress("0x4200000000000000000000000000000000000015")
@@ -512,6 +518,57 @@ func extractL1GasParamsPostIsthmus(data []byte) (gasParams, error) {
 	}, nil
 }
 
+// ExtractDAFootprintGasScalar extracts the DA footprint gas scalar from the L1 attributes transaction data
+// of a Jovian-enabled block.
+func ExtractDAFootprintGasScalar(data []byte) (uint16, error) {
+	if len(data) < JovianL1AttributesLen {
+		return 0, fmt.Errorf("L1 attributes transaction data too short for DA footprint gas scalar: %d", len(data))
+	}
+	// Future forks need to be added here
+	if !bytes.Equal(data[0:4], JovianL1AttributesSelector) {
+		return 0, fmt.Errorf("L1 attributes transaction data does not have Jovian selector")
+	}
+	daFootprintGasScalar := binary.BigEndian.Uint16(data[JovianL1AttributesLen-2 : JovianL1AttributesLen])
+	return daFootprintGasScalar, nil
+}
+
+// CalcGasUsedJovian calculates the gas used for an OP Stack chain.
+// Jovian introduces a DA footprint block limit, which potentially increases the gasUsed.
+// CalcGasUsedJovian must not be called for pre-Jovian blocks.
+func CalcGasUsedJovian(txs []*Transaction, evmGasUsed uint64) (uint64, error) {
+	if len(txs) == 0 || !txs[0].IsDepositTx() {
+		return 0, errors.New("missing deposit transaction")
+	}
+
+	// First Jovian block doesn't set the DA footprint gas scalar yet and
+	// it must not have user transactions.
+	data := txs[0].Data()
+	if len(data) == IsthmusL1AttributesLen {
+		if !txs[len(txs)-1].IsDepositTx() {
+			// sufficient to check last transaction because deposits precede non-deposit txs
+			return 0, errors.New("unexpected non-deposit transactions in Jovian activation block")
+		}
+		return evmGasUsed, nil
+	} // ExtractDAFootprintGasScalar catches all invalid lengths
+
+	daFootprintGasScalar, err := ExtractDAFootprintGasScalar(data)
+	if err != nil {
+		return 0, err
+	}
+	var cumulativeDAFootprint uint64
+	for _, tx := range txs {
+		if tx.IsDepositTx() {
+			continue
+		}
+		cumulativeDAFootprint += tx.RollupCostData().EstimatedDASize().Uint64()
+	}
+	daFootprint := uint64(daFootprintGasScalar) * cumulativeDAFootprint
+	if evmGasUsed < daFootprint {
+		return daFootprint, nil
+	}
+	return evmGasUsed, nil
+}
+
 // L1Cost computes the the data availability fee for transactions in blocks prior to the Ecotone
 // upgrade. It is used by e2e tests so must remain exported.
 func L1Cost(rollupDataGas uint64, l1BaseFee, overhead, scalar *big.Int) *big.Int {
@@ -572,13 +629,13 @@ func ExtractEcotoneFeeParams(l1FeeParams []byte) (l1BaseFeeScalar, l1BlobBaseFee
 	offset := scalarSectionStart
 	l1BaseFeeScalar = new(big.Int).SetBytes(l1FeeParams[offset : offset+4])
 	l1BlobBaseFeeScalar = new(big.Int).SetBytes(l1FeeParams[offset+4 : offset+8])
-	return
+	return l1BaseFeeScalar, l1BlobBaseFeeScalar
 }
 
 func ExtractOperatorFeeParams(operatorFeeParams common.Hash) (operatorFeeScalar, operatorFeeConstant *big.Int) {
 	operatorFeeScalar = new(big.Int).SetBytes(operatorFeeParams[20:24])
 	operatorFeeConstant = new(big.Int).SetBytes(operatorFeeParams[24:32])
-	return
+	return operatorFeeScalar, operatorFeeConstant
 }
 
 func bedrockCalldataGasUsed(costData RollupCostData) (calldataGasUsed *big.Int) {

miner/miner_optimism_test.go

@@ -1,6 +1,7 @@
 package miner
 
 import (
+	"encoding/binary"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -13,6 +14,8 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const testDAFootprintGasScalar = 400
+
 // TestDAFootprintMining tests that the miner correctly limits the DA footprint of the block.
 // It builds a block via the miner from txpool
 // transactions and then imports the block into the chain, asserting that
@@ -40,7 +43,7 @@ func TestDAFootprintMining(t *testing.T) {
 			if txs[i].IsDepositTx() {
 				continue
 			}
-			daFootprint += txs[i].RollupCostData().EstimatedDASize().Uint64() * params.DAFootprintGasScalar
+			daFootprint += txs[i].RollupCostData().EstimatedDASize().Uint64() * testDAFootprintGasScalar
 		}
 		require.Less(t, txGas, block.GasUsed(), "total tx gas used must be smaller than block gas used")
 		require.Equal(t, daFootprint, block.GasUsed(), "total DA footprint used should be equal to block gas used")
@@ -79,16 +82,23 @@ func testMineAndExecute(t *testing.T, numTxs uint64, cfg *params.ChainConfig, as
 		}
 	}
 
+	parent := b.chain.CurrentBlock()
+	ts := parent.Time + 12
+	dtx := new(types.DepositTx)
+	if cfg.IsDAFootprintBlockLimit(parent.Time) {
+		dtx = jovianDepositTx(testDAFootprintGasScalar)
+	}
+
 	genParams := &generateParams{
 		parentHash:    b.chain.CurrentBlock().Hash(),
-		timestamp:     b.chain.CurrentBlock().Time + 12,
+		timestamp:     ts,
 		withdrawals:   types.Withdrawals{},
 		beaconRoot:    new(common.Hash),
 		gasLimit:      ptr(uint64(1e6)), // Small gas limit to easily fill block
-		txs:           types.Transactions{types.NewTx(&types.DepositTx{})},
+		txs:           types.Transactions{types.NewTx(dtx)},
 		eip1559Params: eip1559.EncodeHolocene1559Params(250, 6),
 	}
-	if cfg.IsJovian(b.chain.CurrentBlock().Time) {
+	if cfg.IsMinBaseFee(ts) {
 		genParams.minBaseFee = new(uint64)
 	}
 	r := w.generateWork(genParams, false)
@@ -102,6 +112,13 @@ func testMineAndExecute(t *testing.T, numTxs uint64, cfg *params.ChainConfig, as
 	require.NoError(t, err, "block import/execution failed")
 }
 
+func jovianDepositTx(daFootprintGasScalar uint16) *types.DepositTx {
+	data := make([]byte, types.JovianL1AttributesLen)
+	copy(data[0:4], types.JovianL1AttributesSelector)
+	binary.BigEndian.PutUint16(data[types.JovianL1AttributesLen-2:types.JovianL1AttributesLen], daFootprintGasScalar)
+	return &types.DepositTx{Data: data}
+}
+
 func ptr[T any](v T) *T {
 	return &v
 }