Fix L1 cost function (ethereum#61)

The gas price oracle calculates L1 data costs using an unsigned transaction. However, `op-geth` was calculating L1 data costs using a _signed_ transaction, which included an additional 68 unnecessary bytes (1088 gas) in the cost.

This PR removes those extra bytes as part of the Regolith hardfork.

Co-authored-by: protolambda <proto@protolambda.com>

accounts/abi/bind/backends/simulated.go

@@ -903,10 +903,11 @@ func (m callMsg) Gas() uint64                  { return m.CallMsg.Gas }
 func (m callMsg) Value() *big.Int              { return m.CallMsg.Value }
 func (m callMsg) Data() []byte                 { return m.CallMsg.Data }
 func (m callMsg) AccessList() types.AccessList { return m.CallMsg.AccessList }
-func (m callMsg) IsSystemTx() bool             { return false }
-func (m callMsg) IsDepositTx() bool            { return false }
-func (m callMsg) Mint() *big.Int               { return nil }
-func (m callMsg) RollupDataGas() uint64        { return 0 }
+
+func (m callMsg) IsSystemTx() bool                   { return false }
+func (m callMsg) IsDepositTx() bool                  { return false }
+func (m callMsg) Mint() *big.Int                     { return nil }
+func (m callMsg) RollupDataGas() types.RollupGasData { return types.RollupGasData{} }
 
 // filterBackend implements filters.Backend to support filtering for logs without
 // taking bloom-bits acceleration structures into account.

core/blockchain.go

@@ -2035,7 +2035,7 @@ func (bc *BlockChain) recoverAncestors(block *types.Block) (common.Hash, error)
 // the processing of a block. These logs are later announced as deleted or reborn.
 func (bc *BlockChain) collectLogs(b *types.Block, removed bool) []*types.Log {
 	receipts := rawdb.ReadRawReceipts(bc.db, b.Hash(), b.NumberU64())
-	receipts.DeriveFields(bc.chainConfig, b.Hash(), b.NumberU64(), b.Transactions())
+	receipts.DeriveFields(bc.chainConfig, b.Hash(), b.NumberU64(), b.Time(), b.Transactions())
 
 	var logs []*types.Log
 	for _, receipt := range receipts {

core/rawdb/accessors_chain.go

@@ -636,7 +636,12 @@ func ReadReceipts(db ethdb.Reader, hash common.Hash, number uint64, config *para
 		log.Error("Missing body but have receipt", "hash", hash, "number", number)
 		return nil
 	}
-	if err := receipts.DeriveFields(config, hash, number, body.Transactions); err != nil {
+	header := ReadHeader(db, hash, number)
+	if header == nil {
+		log.Error("Missing header but have receipt", "hash", hash, "number", number)
+		return nil
+	}
+	if err := receipts.DeriveFields(config, hash, number, header.Time, body.Transactions); err != nil {
 		log.Error("Failed to derive block receipts fields", "hash", hash, "number", number, "err", err)
 		return nil
 	}

core/rawdb/accessors_chain_test.go

@@ -347,6 +347,9 @@ func TestBlockReceiptStorage(t *testing.T) {
 	tx1 := types.NewTransaction(1, common.HexToAddress("0x1"), big.NewInt(1), 1, big.NewInt(1), nil)
 	tx2 := types.NewTransaction(2, common.HexToAddress("0x2"), big.NewInt(2), 2, big.NewInt(2), nil)
 
+	header := &types.Header{
+		Number: big.NewInt(0),
+	}
 	body := &types.Body{Transactions: types.Transactions{tx1, tx2}}
 
 	// Create the two receipts to manage afterwards
@@ -378,13 +381,16 @@ func TestBlockReceiptStorage(t *testing.T) {
 	receipts := []*types.Receipt{receipt1, receipt2}
 
 	// Check that no receipt entries are in a pristine database
-	hash := common.BytesToHash([]byte{0x03, 0x14})
+	hash := header.Hash()
 	if rs := ReadReceipts(db, hash, 0, params.TestChainConfig); len(rs) != 0 {
 		t.Fatalf("non existent receipts returned: %v", rs)
 	}
 	// Insert the body that corresponds to the receipts
 	WriteBody(db, hash, 0, body)
 
+	// Insert the header that corresponds to the receipts
+	WriteHeader(db, header)
+
 	// Insert the receipt slice into the database and check presence
 	WriteReceipts(db, hash, 0, receipts)
 	if rs := ReadReceipts(db, hash, 0, params.TestChainConfig); len(rs) == 0 {

core/state_transition.go

@@ -79,10 +79,10 @@ type Message interface {
 	Gas() uint64
 	Value() *big.Int
 
-	IsSystemTx() bool      // IsSystemTx indicates the message, if also a deposit, does not emit gas usage.
-	IsDepositTx() bool     // IsDepositTx indicates the message is force-included and can persist a mint.
-	Mint() *big.Int        // Mint is the amount to mint before EVM processing, or nil if there is no minting.
-	RollupDataGas() uint64 // RollupDataGas indicates the rollup cost of the message, 0 if not a rollup or no cost.
+	IsSystemTx() bool                   // IsSystemTx indicates the message, if also a deposit, does not emit gas usage.
+	IsDepositTx() bool                  // IsDepositTx indicates the message is force-included and can persist a mint.
+	Mint() *big.Int                     // Mint is the amount to mint before EVM processing, or nil if there is no minting.
+	RollupDataGas() types.RollupGasData // RollupDataGas indicates the rollup cost of the message, 0 if not a rollup or no cost.
 
 	Nonce() uint64
 	IsFake() bool
@@ -224,7 +224,7 @@ func (st *StateTransition) buyGas() error {
 	mgval = mgval.Mul(mgval, st.gasPrice)
 	var l1Cost *big.Int
 	if st.evm.Context.L1CostFunc != nil {
-		l1Cost = st.evm.Context.L1CostFunc(st.evm.Context.BlockNumber.Uint64(), st.msg)
+		l1Cost = st.evm.Context.L1CostFunc(st.evm.Context.BlockNumber.Uint64(), st.evm.Context.Time, st.msg)
 	}
 	if l1Cost != nil {
 		mgval = mgval.Add(mgval, l1Cost)
@@ -474,7 +474,7 @@ func (st *StateTransition) innerTransitionDb() (*ExecutionResult, error) {
 	// Note optimismConfig will not be nil if rules.IsOptimismBedrock is true
 	if optimismConfig := st.evm.ChainConfig().Optimism; optimismConfig != nil && rules.IsOptimismBedrock {
 		st.state.AddBalance(params.OptimismBaseFeeRecipient, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.evm.Context.BaseFee))
-		if cost := st.evm.Context.L1CostFunc(st.evm.Context.BlockNumber.Uint64(), st.msg); cost != nil {
+		if cost := st.evm.Context.L1CostFunc(st.evm.Context.BlockNumber.Uint64(), st.evm.Context.Time, st.msg); cost != nil {
 			st.state.AddBalance(params.OptimismL1FeeRecipient, cost)
 		}
 	}

core/txpool/txpool.go

@@ -1326,7 +1326,7 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 
 	costFn := types.NewL1CostFunc(pool.chainconfig, statedb)
 	pool.l1CostFn = func(message types.RollupMessage) *big.Int {
-		return costFn(newHead.Number.Uint64(), message)
+		return costFn(newHead.Number.Uint64(), newHead.Time, message)
 	}
 
 	// Inject any transactions discarded due to reorgs

core/types/receipt.go

@@ -473,7 +473,7 @@ func (rs Receipts) EncodeIndex(i int, w *bytes.Buffer) {
 
 // DeriveFields fills the receipts with their computed fields based on consensus
 // data and contextual infos like containing block and transactions.
-func (rs Receipts) DeriveFields(config *params.ChainConfig, hash common.Hash, number uint64, txs Transactions) error {
+func (rs Receipts) DeriveFields(config *params.ChainConfig, hash common.Hash, number uint64, time uint64, txs Transactions) error {
 	signer := MakeSigner(config, new(big.Int).SetUint64(number))
 
 	logIndex := uint(0)
@@ -526,9 +526,10 @@ func (rs Receipts) DeriveFields(config *params.ChainConfig, hash common.Hash, nu
 			feeScalar := new(big.Float).Quo(fscalar, fdivisor)
 			for i := 0; i < len(rs); i++ {
 				if !txs[i].IsDepositTx() {
+					gas := txs[i].RollupDataGas().DataGas(time, config)
 					rs[i].L1GasPrice = l1Basefee
-					rs[i].L1GasUsed = new(big.Int).SetUint64(txs[i].RollupDataGas())
-					rs[i].L1Fee = L1Cost(txs[i].RollupDataGas(), l1Basefee, overhead, scalar)
+					rs[i].L1GasUsed = new(big.Int).SetUint64(gas)
+					rs[i].L1Fee = L1Cost(gas, l1Basefee, overhead, scalar)
 					rs[i].FeeScalar = feeScalar
 				}
 			}

core/types/receipt_test.go

@@ -223,7 +223,7 @@ func TestDeriveFields(t *testing.T) {
 	hash := common.BytesToHash([]byte{0x03, 0x14})
 
 	clearComputedFieldsOnReceipts(t, receipts)
-	if err := receipts.DeriveFields(params.TestChainConfig, hash, number.Uint64(), txs); err != nil {
+	if err := receipts.DeriveFields(params.TestChainConfig, hash, number.Uint64(), 0, txs); err != nil {
 		t.Fatalf("DeriveFields(...) = %v, want <nil>", err)
 	}
 	// Iterate over all the computed fields and check that they're correct

core/types/rollup_l1_cost.go

@@ -23,8 +23,22 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
+type RollupGasData struct {
+	Zeroes, Ones uint64
+}
+
+func (r RollupGasData) DataGas(time uint64, cfg *params.ChainConfig) (gas uint64) {
+	gas = r.Zeroes * params.TxDataZeroGas
+	if cfg.IsRegolith(time) {
+		gas += r.Ones * params.TxDataNonZeroGasEIP2028
+	} else {
+		gas += (r.Ones + 68) * params.TxDataNonZeroGasEIP2028
+	}
+	return gas
+}
+
 type RollupMessage interface {
-	RollupDataGas() uint64
+	RollupDataGas() RollupGasData
 	IsDepositTx() bool
 }
 
@@ -34,7 +48,7 @@ type StateGetter interface {
 
 // L1CostFunc is used in the state transition to determine the cost of a rollup message.
 // Returns nil if there is no cost.
-type L1CostFunc func(blockNum uint64, msg RollupMessage) *big.Int
+type L1CostFunc func(blockNum uint64, blockTime uint64, msg RollupMessage) *big.Int
 
 var (
 	L1BaseFeeSlot = common.BigToHash(big.NewInt(1))
@@ -50,8 +64,8 @@ var L1BlockAddr = common.HexToAddress("0x420000000000000000000000000000000000001
 func NewL1CostFunc(config *params.ChainConfig, statedb StateGetter) L1CostFunc {
 	cacheBlockNum := ^uint64(0)
 	var l1BaseFee, overhead, scalar *big.Int
-	return func(blockNum uint64, msg RollupMessage) *big.Int {
-		rollupDataGas := msg.RollupDataGas() // Only fake txs for RPC view-calls are 0.
+	return func(blockNum uint64, blockTime uint64, msg RollupMessage) *big.Int {
+		rollupDataGas := msg.RollupDataGas().DataGas(blockTime, config) // Only fake txs for RPC view-calls are 0.
 		if config.Optimism == nil || msg.IsDepositTx() || rollupDataGas == 0 {
 			return nil
 		}

core/types/rollup_l1_cost_test.go

@@ -0,0 +1,30 @@
+package types
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRollupGasData(t *testing.T) {
+	for i := 0; i < 100; i++ {
+		zeroes := rand.Uint64()
+		ones := rand.Uint64()
+
+		r := RollupGasData{
+			Zeroes: zeroes,
+			Ones:   ones,
+		}
+		time := uint64(1)
+		cfg := &params.ChainConfig{
+			RegolithTime: &time,
+		}
+		gasPreRegolith := r.DataGas(0, cfg)
+		gasPostRegolith := r.DataGas(1, cfg)
+
+		require.Equal(t, r.Zeroes*params.TxDataZeroGas+(r.Ones+68)*params.TxDataNonZeroGasEIP2028, gasPreRegolith)
+		require.Equal(t, r.Zeroes*params.TxDataZeroGas+r.Ones*params.TxDataNonZeroGasEIP2028, gasPostRegolith)
+	}
+}

core/types/transaction.go

@@ -29,7 +29,6 @@ import (
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
@@ -59,7 +58,7 @@ type Transaction struct {
 	size atomic.Value
 	from atomic.Value
 
-	// cache how much gas the tx takes on L1 for its share of rollup data
+	// cache of RollupGasData details to compute the gas the tx takes on L1 for its share of rollup data
 	rollupGas atomic.Value
 }
 
@@ -347,31 +346,27 @@ func (tx *Transaction) Cost() *big.Int {
 }
 
 // RollupDataGas is the amount of gas it takes to confirm the tx on L1 as a rollup
-func (tx *Transaction) RollupDataGas() uint64 {
+func (tx *Transaction) RollupDataGas() RollupGasData {
 	if tx.Type() == DepositTxType {
-		return 0
+		return RollupGasData{}
 	}
 	if v := tx.rollupGas.Load(); v != nil {
-		return v.(uint64)
+		return v.(RollupGasData)
 	}
 	data, err := tx.MarshalBinary()
 	if err != nil { // Silent error, invalid txs will not be marshalled/unmarshalled for batch submission anyway.
 		log.Error("failed to encode tx for L1 cost computation", "err", err)
 	}
-	var zeroes uint64
-	var ones uint64
+	var out RollupGasData
 	for _, byt := range data {
 		if byt == 0 {
-			zeroes++
+			out.Zeroes++
 		} else {
-			ones++
+			out.Ones++
 		}
 	}
-	zeroesGas := zeroes * params.TxDataZeroGas
-	onesGas := (ones + 68) * params.TxDataNonZeroGasEIP2028
-	total := zeroesGas + onesGas
-	tx.rollupGas.Store(total)
-	return total
+	tx.rollupGas.Store(out)
+	return out
 }
 
 // RawSignatureValues returns the V, R, S signature values of the transaction.
@@ -685,7 +680,7 @@ type Message struct {
 	isSystemTx  bool
 	isDepositTx bool
 	mint        *big.Int
-	l1CostGas   uint64
+	l1CostGas   RollupGasData
 }
 
 func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice, gasFeeCap, gasTipCap *big.Int, data []byte, accessList AccessList, isFake bool) Message {
@@ -705,7 +700,7 @@ func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *b
 		isSystemTx:  false,
 		isDepositTx: false,
 		mint:        nil,
-		l1CostGas:   0,
+		l1CostGas:   RollupGasData{},
 	}
 }
 
@@ -748,10 +743,11 @@ func (m Message) Nonce() uint64          { return m.nonce }
 func (m Message) Data() []byte           { return m.data }
 func (m Message) AccessList() AccessList { return m.accessList }
 func (m Message) IsFake() bool           { return m.isFake }
-func (m Message) IsSystemTx() bool       { return m.isSystemTx }
-func (m Message) IsDepositTx() bool      { return m.isDepositTx }
-func (m Message) Mint() *big.Int         { return m.mint }
-func (m Message) RollupDataGas() uint64  { return m.l1CostGas }
+
+func (m Message) IsSystemTx() bool             { return m.isSystemTx }
+func (m Message) IsDepositTx() bool            { return m.isDepositTx }
+func (m Message) Mint() *big.Int               { return m.mint }
+func (m Message) RollupDataGas() RollupGasData { return m.l1CostGas }
 
 // copyAddressPtr copies an address.
 func copyAddressPtr(a *common.Address) *common.Address {

light/odr_util.go

@@ -175,7 +175,7 @@ func GetBlockReceipts(ctx context.Context, odr OdrBackend, hash common.Hash, num
 		genesis := rawdb.ReadCanonicalHash(odr.Database(), 0)
 		config := rawdb.ReadChainConfig(odr.Database(), genesis)
 
-		if err := receipts.DeriveFields(config, block.Hash(), block.NumberU64(), block.Transactions()); err != nil {
+		if err := receipts.DeriveFields(config, block.Hash(), block.NumberU64(), block.Time(), block.Transactions()); err != nil {
 			return nil, err
 		}
 		rawdb.WriteReceipts(odr.Database(), hash, number, receipts)