Gas floor (#3618)

* update contracts for internal batch posting report fields

* batch-gas-cost: check for floor-gas-cost in arbos-50

* replace calldataprice with parentGasFloorPerToken

* internal_tx: use floorGasPerToken

* update acts and support legacy feed

* contracts: revert to version on master

* precompiles: updates for parent-gas-floor

* internal_tx: add per-batch-gas even if using floor

* eth-config: update forkid

* Add a test for gas floor

* Enable delayed sequencer, satisfy finality requirements

* internal_tx: use a constant instead of PerBatchGasCost

* update gas floor price test

* incomingmessage: fix comments

* Remove leftover comment

Author: tsahee

arbnode/delayed.go

@@ -258,7 +258,7 @@ func (b *DelayedBridge) logsToDeliveredMessages(ctx context.Context, logs []type
 			},
 			ParentChainBlockNumber: parsedLog.Raw.BlockNumber,
 		}
-		err := msg.Message.FillInBatchGasCost(batchFetcher)
+		err := msg.Message.FillInBatchGasFields(batchFetcher)
 		if err != nil {
 			return nil, err
 		}

arbnode/delayed_sequencer.go

@@ -174,7 +174,7 @@ func (d *DelayedSequencer) sequenceWithoutLockout(ctx context.Context, lastBlock
 			}
 		}
 		lastDelayedAcc = acc
-		err = msg.FillInBatchGasCost(func(batchNum uint64) ([]byte, error) {
+		err = msg.FillInBatchGasFields(func(batchNum uint64) ([]byte, error) {
 			data, _, err := d.reader.GetSequencerMessageBytes(ctx, batchNum)
 			return data, err
 		})

arbnode/inbox_tracker.go

@@ -338,7 +338,7 @@ func (t *InboxTracker) legacyGetDelayedMessageAndAccumulator(ctx context.Context
 		return nil, common.Hash{}, err
 	}
 
-	err = msg.FillInBatchGasCost(func(batchNum uint64) ([]byte, error) {
+	err = msg.FillInBatchGasFields(func(batchNum uint64) ([]byte, error) {
 		data, _, err := t.txStreamer.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
 		return data, err
 	})
@@ -371,7 +371,7 @@ func (t *InboxTracker) GetDelayedMessageAccumulatorAndParentChainBlockNumber(ctx
 		return msg, acc, 0, err
 	}
 
-	err = msg.FillInBatchGasCost(func(batchNum uint64) ([]byte, error) {
+	err = msg.FillInBatchGasFields(func(batchNum uint64) ([]byte, error) {
 		data, _, err := t.txStreamer.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
 		return data, err
 	})

arbnode/mel/extraction/message_extraction_function.go

@@ -187,10 +187,8 @@ func extractMessagesImpl(
 					batch.SequenceNumber,
 				)
 			}
-			gas := arbostypes.ComputeBatchGasCost(serialized)
-
-			// Fill in the batch gas cost into the batch posting report.
-			batchPostReport.Message.BatchGasCost = &gas
+			// Fill in the batch gas stats into the batch posting report.
+			batchPostReport.Message.BatchDataStats = arbostypes.GetDataStats(serialized)
 		} else if !(inputState.DelayedMessagedSeen == 0 && i == 0 && delayedMessages[i] == batchPostReport) {
 			return nil, nil, nil, errors.New("encountered initialize message that is not the first delayed message and the first batch ")
 		}

arbnode/transaction_streamer.go

@@ -482,7 +482,7 @@ func (s *TransactionStreamer) GetMessage(msgIdx arbutil.MessageIndex) (*arbostyp
 		return nil, err
 	}
 
-	err = message.Message.FillInBatchGasCost(func(batchNum uint64) ([]byte, error) {
+	err = message.Message.FillInBatchGasFields(func(batchNum uint64) ([]byte, error) {
 		ctx, err := s.GetContextSafe()
 		if err != nil {
 			return nil, err
@@ -830,19 +830,22 @@ func (s *TransactionStreamer) countDuplicateMessages(
 			}
 			var duplicateMessage bool
 			if nextMessage.MessageWithMeta.Message != nil {
-				if dbMessageParsed.Message.BatchGasCost == nil || nextMessage.MessageWithMeta.Message.BatchGasCost == nil {
+				if dbMessageParsed.Message.BatchDataStats == nil || nextMessage.MessageWithMeta.Message.BatchDataStats == nil {
 					// Remove both of the batch gas costs and see if the messages still differ
 					nextMessageCopy := nextMessage.MessageWithMeta
 					nextMessageCopy.Message = new(arbostypes.L1IncomingMessage)
 					*nextMessageCopy.Message = *nextMessage.MessageWithMeta.Message
-					batchGasCostBkup := dbMessageParsed.Message.BatchGasCost
-					dbMessageParsed.Message.BatchGasCost = nil
-					nextMessageCopy.Message.BatchGasCost = nil
+					batchGasCostBkup := dbMessageParsed.Message.LegacyBatchGasCost
+					statsBkup := dbMessageParsed.Message.BatchDataStats
+					dbMessageParsed.Message.LegacyBatchGasCost = nil
+					nextMessageCopy.Message.LegacyBatchGasCost = nil
+					dbMessageParsed.Message.BatchDataStats = nil
+					nextMessageCopy.Message.BatchDataStats = nil
 					if reflect.DeepEqual(dbMessageParsed, nextMessageCopy) {
 						// Actually this isn't a reorg; only the batch gas costs differed
 						duplicateMessage = true
 						// If possible - update the message in the database to add the gas cost cache.
-						if batch != nil && nextMessage.MessageWithMeta.Message.BatchGasCost != nil {
+						if batch != nil && nextMessage.MessageWithMeta.Message.BatchDataStats != nil {
 							if *batch == nil {
 								*batch = s.db.NewBatch()
 							}
@@ -851,7 +854,8 @@ func (s *TransactionStreamer) countDuplicateMessages(
 							}
 						}
 					}
-					dbMessageParsed.Message.BatchGasCost = batchGasCostBkup
+					dbMessageParsed.Message.LegacyBatchGasCost = batchGasCostBkup
+					dbMessageParsed.Message.BatchDataStats = statsBkup
 				}
 			}
 

arbos/arbosState/arbosstate.go

@@ -391,13 +391,6 @@ func (state *ArbosState) UpgradeArbosVersion(
 			ensure(err)
 			ensure(p.UpgradeToArbosVersion(nextArbosVersion))
 			ensure(p.Save())
-			chainId, err := state.ChainId()
-			ensure(err)
-			if chainId.Cmp(chaininfo.ArbitrumOneChainConfig().ChainID) == 0 || chainId.Cmp(chaininfo.ArbitrumNovaChainConfig().ChainID) == 0 {
-				ensure(state.l1PricingState.SetCalldataPrice(big.NewInt(int64(params.TxCostFloorPerToken))))
-			} else {
-				ensure(state.l1PricingState.SetCalldataPrice(big.NewInt(int64(params.TxDataNonZeroGasEIP2028))))
-			}
 			ensure(state.l2PricingState.SetMaxPerTxGasLimit(l2pricing.InitialPerTxGasLimitV50))
 			oldBlockGasLimit, err := state.l2PricingState.PerBlockGasLimit()
 			ensure(err)

arbos/arbostypes/incomingmessage.go

@@ -55,12 +55,20 @@ func (h L1IncomingMessageHeader) SeqNum() (uint64, error) {
 	return seqNumBig.Uint64(), nil
 }
 
+type BatchDataStats struct {
+	Length   uint64 `json:"length"`
+	NonZeros uint64 `json:"nonzeros"`
+}
+
 type L1IncomingMessage struct {
 	Header *L1IncomingMessageHeader `json:"header"`
 	L2msg  []byte                   `json:"l2Msg"`
 
 	// Only used for `L1MessageType_BatchPostingReport`
-	BatchGasCost *uint64 `json:"batchGasCost,omitempty" rlp:"optional"`
+	// note: the legacy field is used in json to support older clients
+	// in rlp it's used to distinguish old from new (old will load into first arg)
+	LegacyBatchGasCost *uint64         `json:"batchGasCost,omitempty" rlp:"optional"`
+	BatchDataStats     *BatchDataStats `json:"batchDataTokens,omitempty" rlp:"optional"`
 }
 
 var EmptyTestIncomingMessage = L1IncomingMessage{
@@ -145,41 +153,52 @@ func (h *L1IncomingMessageHeader) Equals(other *L1IncomingMessageHeader) bool {
 		arbmath.BigEquals(h.L1BaseFee, other.L1BaseFee)
 }
 
-func ComputeBatchGasCost(data []byte) uint64 {
-	var gas uint64
+func GetDataStats(data []byte) *BatchDataStats {
+	nonZeros := uint64(0)
 	for _, b := range data {
-		if b == 0 {
-			gas += params.TxDataZeroGas
-		} else {
-			gas += params.TxDataNonZeroGasEIP2028
+		if b != 0 {
+			nonZeros += 1
 		}
 	}
+	return &BatchDataStats{
+		Length:   uint64(len(data)),
+		NonZeros: nonZeros,
+	}
+}
 
+func LegacyCostForStats(stats *BatchDataStats) uint64 {
+	gas := params.TxDataZeroGas*(stats.Length-stats.NonZeros) + params.TxDataNonZeroGasEIP2028*stats.NonZeros
 	// the poster also pays to keccak the batch and place it and a batch-posting report into the inbox
-	keccakWords := arbmath.WordsForBytes(uint64(len(data)))
+	keccakWords := arbmath.WordsForBytes(stats.Length)
 	gas += params.Keccak256Gas + (keccakWords * params.Keccak256WordGas)
 	gas += 2 * params.SstoreSetGasEIP2200
 	return gas
 }
 
-func (msg *L1IncomingMessage) FillInBatchGasCost(batchFetcher FallibleBatchFetcher) error {
-	if batchFetcher == nil || msg.Header.Kind != L1MessageType_BatchPostingReport || msg.BatchGasCost != nil {
+func (msg *L1IncomingMessage) FillInBatchGasFields(batchFetcher FallibleBatchFetcher) error {
+	if batchFetcher == nil || msg.Header.Kind != L1MessageType_BatchPostingReport {
 		return nil
 	}
-	_, _, batchHash, batchNum, _, _, err := ParseBatchPostingReportMessageFields(bytes.NewReader(msg.L2msg))
-	if err != nil {
-		return fmt.Errorf("failed to parse batch posting report: %w", err)
-	}
-	batchData, err := batchFetcher(batchNum)
-	if err != nil {
-		return fmt.Errorf("failed to fetch batch mentioned by batch posting report: %w", err)
+	if msg.BatchDataStats != nil && msg.LegacyBatchGasCost != nil {
+		return nil
 	}
-	gotHash := crypto.Keccak256Hash(batchData)
-	if gotHash != batchHash {
-		return fmt.Errorf("batch fetcher returned incorrect data hash %v (wanted %v for batch %v)", gotHash, batchHash, batchNum)
+	if msg.BatchDataStats == nil {
+		_, _, batchHash, batchNum, _, _, err := ParseBatchPostingReportMessageFields(bytes.NewReader(msg.L2msg))
+		if err != nil {
+			return fmt.Errorf("failed to parse batch posting report: %w", err)
+		}
+		batchData, err := batchFetcher(batchNum)
+		if err != nil {
+			return fmt.Errorf("failed to fetch batch mentioned by batch posting report: %w", err)
+		}
+		gotHash := crypto.Keccak256Hash(batchData)
+		if gotHash != batchHash {
+			return fmt.Errorf("batch fetcher returned incorrect data hash %v (wanted %v for batch %v)", gotHash, batchHash, batchNum)
+		}
+		msg.BatchDataStats = GetDataStats(batchData)
 	}
-	gas := ComputeBatchGasCost(batchData)
-	msg.BatchGasCost = &gas
+	legacyCost := LegacyCostForStats(msg.BatchDataStats)
+	msg.LegacyBatchGasCost = &legacyCost
 	return nil
 }
 
@@ -233,18 +252,19 @@ func ParseIncomingL1Message(rd io.Reader, batchFetcher FallibleBatchFetcher) (*L
 	}
 
 	msg := &L1IncomingMessage{
-		&L1IncomingMessageHeader{
+		Header: &L1IncomingMessageHeader{
 			Kind:        kind,
 			Poster:      sender,
 			BlockNumber: blockNumber,
 			Timestamp:   timestamp,
 			RequestId:   &requestId,
 			L1BaseFee:   baseFeeL1.Big(),
 		},
-		data,
-		nil,
+		L2msg:              data,
+		LegacyBatchGasCost: nil,
+		BatchDataStats:     nil,
 	}
-	err = msg.FillInBatchGasCost(batchFetcher)
+	err = msg.FillInBatchGasFields(batchFetcher)
 	if err != nil {
 		return nil, err
 	}

arbos/incomingmessage_test.go

@@ -25,9 +25,10 @@ func TestSerializeAndParseL1Message(t *testing.T) {
 		L1BaseFee:   big.NewInt(10000000000000),
 	}
 	msg := arbostypes.L1IncomingMessage{
-		Header:       &header,
-		L2msg:        []byte{3, 2, 1},
-		BatchGasCost: nil,
+		Header:             &header,
+		L2msg:              []byte{3, 2, 1},
+		LegacyBatchGasCost: nil,
+		BatchDataStats:     nil,
 	}
 	serialized, err := msg.Serialize()
 	if err != nil {

arbos/internal_tx.go

@@ -16,6 +16,7 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/offchainlabs/nitro/arbos/arbosState"
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbos/util"
 	"github.com/offchainlabs/nitro/util/arbmath"
 )
@@ -102,16 +103,49 @@ func ApplyInternalTxUpdate(tx *types.ArbitrumInternalTx, state *arbosState.Arbos
 		}
 		batchTimestamp := util.SafeMapGet[*big.Int](inputs, "batchTimestamp")
 		batchPosterAddress := util.SafeMapGet[common.Address](inputs, "batchPosterAddress")
-		batchDataGas := util.SafeMapGet[uint64](inputs, "batchDataGas")
+		batchCalldataLength := util.SafeMapGet[uint64](inputs, "batchCalldataLength")
+		batchCalldataNonZeros := util.SafeMapGet[uint64](inputs, "batchCalldataNonZeros")
+		batchLegacyGas := util.SafeMapGet[uint64](inputs, "batchLegacyGas")
+		batchExtraGas := util.SafeMapGet[uint64](inputs, "batchExtraGas")
 		l1BaseFeeWei := util.SafeMapGet[*big.Int](inputs, "l1BaseFeeWei")
 
+		var gasSpent uint64
+		if batchCalldataLength == ^uint64(0) {
+			if state.ArbOSVersion() >= params.ArbosVersion_50 {
+				return fmt.Errorf("missing batch calldata stats for arbos >= 50")
+			}
+			gasSpent = batchLegacyGas
+		} else {
+			gasSpent = arbostypes.LegacyCostForStats(&arbostypes.BatchDataStats{
+				Length:   batchCalldataLength,
+				NonZeros: batchCalldataNonZeros,
+			})
+			gasSpent = arbmath.SaturatingUAdd(gasSpent, batchExtraGas)
+			if batchLegacyGas != ^uint64(0) && batchLegacyGas != gasSpent {
+				log.Error("legacy gas doesn't fit local compute", "local", gasSpent, "legacy", batchLegacyGas, "timestamp", batchTimestamp)
+			}
+		}
+
 		l1p := state.L1PricingState()
+
 		perBatchGas, err := l1p.PerBatchGasCost()
 		if err != nil {
 			log.Warn("L1Pricing PerBatchGas failed", "err", err)
 		}
-		gasSpent := arbmath.SaturatingAdd(perBatchGas, arbmath.SaturatingCast[int64](batchDataGas))
-		weiSpent := arbmath.BigMulByUint(l1BaseFeeWei, arbmath.SaturatingUCast[uint64](gasSpent))
+		gasSpent = arbmath.SaturatingUAdd(gasSpent, arbmath.SaturatingUCast[uint64](perBatchGas))
+
+		if state.ArbOSVersion() >= params.ArbosVersion_50 {
+			gasFloorPerToken, err := l1p.ParentGasFloorPerToken()
+			if err != nil {
+				log.Warn("failed reading gasFloorPerToken", "err", err)
+			}
+			floorGasSpent := gasFloorPerToken*(batchCalldataLength+batchCalldataNonZeros*3) + params.TxGas
+			if floorGasSpent > gasSpent {
+				gasSpent = floorGasSpent
+			}
+		}
+
+		weiSpent := arbmath.BigMulByUint(l1BaseFeeWei, gasSpent)
 		err = l1p.UpdateForBatchPosterSpending(
 			evm.StateDB,
 			evm,

arbos/l1pricing/l1pricing.go

@@ -39,11 +39,11 @@ type L1PricingState struct {
 	// funds collected since update are recorded as the balance in account L1PricerFundsPoolAddress
 	unitsSinceUpdate     storage.StorageBackedUint64  // calldata units collected for since last update
 	pricePerUnit         storage.StorageBackedBigUint // current price per calldata unit
-	calldataPrice        storage.StorageBackedBigInt  // gas per non-zero calldata byte
 	lastSurplus          storage.StorageBackedBigInt  // introduced in ArbOS version 2
 	perBatchGasCost      storage.StorageBackedInt64   // introduced in ArbOS version 3
 	amortizedCostCapBips storage.StorageBackedUint64  // in basis points; introduced in ArbOS version 3
 	l1FeesAvailable      storage.StorageBackedBigUint
+	gasFloorPerToken     storage.StorageBackedUint64 // introduced in arbos version 50, default 0
 
 	ArbosVersion uint64
 }
@@ -70,7 +70,7 @@ const (
 	perBatchGasCostOffset
 	amortizedCostCapBipsOffset
 	l1FeesAvailableOffset
-	calldataPriceOffset
+	gasFloorPerTokenOffset
 )
 
 const (
@@ -129,11 +129,11 @@ func OpenL1PricingState(sto *storage.Storage, arbosVersion uint64) *L1PricingSta
 		fundsDueForRewards:   sto.OpenStorageBackedBigInt(fundsDueForRewardsOffset),
 		unitsSinceUpdate:     sto.OpenStorageBackedUint64(unitsSinceOffset),
 		pricePerUnit:         sto.OpenStorageBackedBigUint(pricePerUnitOffset),
-		calldataPrice:        sto.OpenStorageBackedBigInt(calldataPriceOffset),
 		lastSurplus:          sto.OpenStorageBackedBigInt(lastSurplusOffset),
 		perBatchGasCost:      sto.OpenStorageBackedInt64(perBatchGasCostOffset),
 		amortizedCostCapBips: sto.OpenStorageBackedUint64(amortizedCostCapBipsOffset),
 		l1FeesAvailable:      sto.OpenStorageBackedBigUint(l1FeesAvailableOffset),
+		gasFloorPerToken:     sto.OpenStorageBackedUint64(gasFloorPerTokenOffset),
 		ArbosVersion:         arbosVersion,
 	}
 }
@@ -243,15 +243,18 @@ func (ps *L1PricingState) SetPricePerUnit(price *big.Int) error {
 	return ps.pricePerUnit.SetChecked(price)
 }
 
-func (ps *L1PricingState) CalldataPrice() (*big.Int, error) {
+func (ps *L1PricingState) SetParentGasFloorPerToken(floor uint64) error {
 	if ps.ArbosVersion < params.ArbosVersion_50 {
-		return big.NewInt(int64(params.TxDataNonZeroGasEIP2028)), nil
+		return fmt.Errorf("not supported")
 	}
-	return ps.calldataPrice.Get()
+	return ps.gasFloorPerToken.Set(floor)
 }
 
-func (ps *L1PricingState) SetCalldataPrice(price *big.Int) error {
-	return ps.calldataPrice.SetChecked(price)
+func (ps *L1PricingState) ParentGasFloorPerToken() (uint64, error) {
+	if ps.ArbosVersion < params.ArbosVersion_50 {
+		return 0, nil
+	}
+	return ps.gasFloorPerToken.Get()
 }
 
 func (ps *L1PricingState) PerBatchGasCost() (int64, error) {
@@ -528,11 +531,7 @@ func (ps *L1PricingState) getPosterUnitsWithoutCache(tx *types.Transaction, post
 	if err != nil {
 		panic(fmt.Sprintf("failed to compress tx: %v", err))
 	}
-	l1CalldataPrice, err := ps.CalldataPrice()
-	if err != nil {
-		return 0
-	}
-	return am.BigMulByUint(l1CalldataPrice, l1Bytes).Uint64()
+	return am.SaturatingUMul(params.TxDataNonZeroGasEIP2028, l1Bytes)
 }
 
 // GetPosterInfo returns the poster cost and the calldata units for a transaction
@@ -555,7 +554,7 @@ func (ps *L1PricingState) GetPosterInfo(tx *types.Transaction, poster common.Add
 }
 
 // We don't have the full tx in gas estimation, so we assume it might be a bit bigger in practice.
-var estimationPaddingUnits uint64 = 16
+var estimationPaddingUnits uint64 = 16 * params.TxDataNonZeroGasEIP2028
 
 const estimationPaddingBasisPoints = 100
 
@@ -612,8 +611,7 @@ func (ps *L1PricingState) PosterDataCost(message *core.Message, poster common.Ad
 	// We'll instead make a fake tx from the message info we do have, and then pad our cost a bit to be safe.
 	tx = makeFakeTxForMessage(message)
 	units := ps.getPosterUnitsWithoutCache(tx, poster, brotliCompressionLevel)
-	l1CalldataPrice, _ := ps.CalldataPrice()
-	units = am.UintMulByBips(units+l1CalldataPrice.Uint64()*estimationPaddingUnits, am.OneInBips+estimationPaddingBasisPoints)
+	units = am.UintMulByBips(units+estimationPaddingUnits, am.OneInBips+estimationPaddingBasisPoints)
 	pricePerUnit, _ := ps.PricePerUnit()
 	return am.BigMulByUint(pricePerUnit, units), units
 }