Merge branch 'master' into custom-da

Author: Tristan-Wilson

arbnode/dataposter/data_poster.go

@@ -763,27 +763,6 @@ func (p *DataPoster) PostTransaction(ctx context.Context, dataCreatedAt time.Tim
 	return p.postTransaction(ctx, lockedState, dataCreatedAt, nonce, meta, to, calldata, gasLimit, value, kzgBlobs, accessList)
 }
 
-// shouldEnableCellProofs determines whether to use cell proofs based on the config and L1 state.
-// Returns true if cell proofs should be used, false otherwise.
-func (p *DataPoster) shouldEnableCellProofs(ctx context.Context) (bool, error) {
-	config := p.config().EnableCellProofs
-
-	switch config {
-	case "force-enable":
-		return true, nil
-	case "force-disable":
-		return false, nil
-	case "", "auto":
-		// Auto-detect based on L1 Osaka fork activation
-		if p.parentChain == nil {
-			return false, fmt.Errorf("cannot auto-detect cell proof support: parent chain not configured")
-		}
-		return p.parentChain.SupportsCellProofs(ctx, nil)
-	default:
-		return false, fmt.Errorf("invalid enable-cell-proofs config value: %q (valid values: \"\", \"auto\", \"force-enable\", \"force-disable\")", config)
-	}
-}
-
 func (p *DataPoster) postTransaction(ctx context.Context, s *state.LockedInternalState, dataCreatedAt time.Time, nonce uint64, meta []byte, to common.Address, calldata []byte, gasLimit uint64, value *big.Int, kzgBlobs []kzg4844.Blob, accessList types.AccessList) (*types.Transaction, error) {
 	if p.config().DisableNewTx {
 		return nil, fmt.Errorf("posting new transaction is disabled")
@@ -832,11 +811,7 @@ func (p *DataPoster) postTransaction(ctx context.Context, s *state.LockedInterna
 		if err != nil {
 			return nil, fmt.Errorf("failed to compute KZG commitments: %w", err)
 		}
-		enableCellProofs, err := p.shouldEnableCellProofs(ctx)
-		if err != nil {
-			return nil, fmt.Errorf("failed to determine cell proof support: %w", err)
-		}
-		proofs, version, err := blobs.ComputeProofs(kzgBlobs, commitments, enableCellProofs)
+		proofs, version, err := blobs.ComputeProofs(kzgBlobs, commitments)
 		if err != nil {
 			return nil, fmt.Errorf("failed to compute KZG proofs: %w", err)
 		}
@@ -1314,7 +1289,6 @@ type DataPosterConfig struct {
 	MaxFeeBidMultipleBips  arbmath.UBips     `koanf:"max-fee-bid-multiple-bips" reload:"hot"`
 	NonceRbfSoftConfs      uint64            `koanf:"nonce-rbf-soft-confs" reload:"hot"`
 	Post4844Blobs          bool              `koanf:"post-4844-blobs" reload:"hot"`
-	EnableCellProofs       string            `koanf:"enable-cell-proofs" reload:"hot"`
 	AllocateMempoolBalance bool              `koanf:"allocate-mempool-balance" reload:"hot"`
 	UseDBStorage           bool              `koanf:"use-db-storage"`
 	UseNoOpStorage         bool              `koanf:"use-noop-storage"`
@@ -1373,12 +1347,6 @@ type DangerousConfig struct {
 
 // Validate checks that the DataPosterConfig is valid.
 func (c *DataPosterConfig) Validate() error {
-	switch c.EnableCellProofs {
-	case "", "auto", "force-enable", "force-disable":
-		// Valid values
-	default:
-		return fmt.Errorf("invalid enable-cell-proofs value %q (valid: \"\", \"auto\", \"force-enable\", \"force-disable\")", c.EnableCellProofs)
-	}
 	if len(c.ReplacementTimes) == 0 {
 		return fmt.Errorf("replacement-times must have at least one value")
 	}
@@ -1439,7 +1407,6 @@ func DataPosterConfigAddOptions(prefix string, f *pflag.FlagSet, defaultDataPost
 		f.DurationSlice(prefix+".blob-tx-replacement-times", defaultDataPosterConfig.BlobTxReplacementTimes, "comma-separated list of durations since first posting a blob transaction to attempt a replace-by-fee")
 		f.Float64(prefix+".min-blob-tx-tip-cap-gwei", defaultDataPosterConfig.MinBlobTxTipCapGwei, "the minimum tip cap to post EIP-4844 blob carrying transactions at")
 		f.Float64(prefix+".max-blob-tx-tip-cap-gwei", defaultDataPosterConfig.MaxBlobTxTipCapGwei, "the maximum tip cap to post EIP-4844 blob carrying transactions at")
-		f.String(prefix+".enable-cell-proofs", defaultDataPosterConfig.EnableCellProofs, "enable cell proofs in blob transactions for Fusaka compatibility. Valid values: \"\" or \"auto\" (auto-detect based on L1 Osaka fork), \"force-enable\", \"force-disable\"")
 	}
 
 	// We intentionally don't expose an option to configure Post4844Blobs.
@@ -1475,7 +1442,6 @@ var DefaultDataPosterConfig = DataPosterConfig{
 	MaxFeeBidMultipleBips:  arbmath.OneInUBips * 10,
 	NonceRbfSoftConfs:      1,
 	Post4844Blobs:          false,
-	EnableCellProofs:       "", // empty string = auto-detect based on L1 Osaka fork
 	AllocateMempoolBalance: true,
 	UseDBStorage:           true,
 	UseNoOpStorage:         false,
@@ -1497,7 +1463,6 @@ var DefaultDataPosterConfigForValidator = func() DataPosterConfig {
 	config.BlobTxReplacementTimes = nil
 	config.MinBlobTxTipCapGwei = 0
 	config.MaxBlobTxTipCapGwei = 0
-	config.EnableCellProofs = ""
 	return config
 }()
 
@@ -1517,7 +1482,6 @@ var TestDataPosterConfig = DataPosterConfig{
 	MaxFeeBidMultipleBips:  arbmath.OneInUBips * 10,
 	NonceRbfSoftConfs:      1,
 	Post4844Blobs:          false,
-	EnableCellProofs:       "", // empty string = auto-detect based on L1 Osaka fork
 	AllocateMempoolBalance: true,
 	UseDBStorage:           false,
 	UseNoOpStorage:         false,

arbnode/delayed.go

@@ -155,7 +155,7 @@ func (m *DelayedInboxMessage) AfterInboxAcc() common.Hash {
 	return crypto.Keccak256Hash(m.BeforeInboxAcc[:], hash)
 }
 
-func (b *DelayedBridge) LookupMessagesInRange(ctx context.Context, from, to *big.Int, batchFetcher arbostypes.FallibleBatchFetcher) ([]*DelayedInboxMessage, error) {
+func (b *DelayedBridge) LookupMessagesInRange(ctx context.Context, from, to *big.Int, batchFetcher arbostypes.FallibleBatchFetcherWithParentBlock) ([]*DelayedInboxMessage, error) {
 	query := ethereum.FilterQuery{
 		BlockHash: nil,
 		FromBlock: from,
@@ -184,7 +184,7 @@ func (l sortableMessageList) Less(i, j int) bool {
 	return bytes.Compare(l[i].Message.Header.RequestId.Bytes(), l[j].Message.Header.RequestId.Bytes()) < 0
 }
 
-func (b *DelayedBridge) logsToDeliveredMessages(ctx context.Context, logs []types.Log, batchFetcher arbostypes.FallibleBatchFetcher) ([]*DelayedInboxMessage, error) {
+func (b *DelayedBridge) logsToDeliveredMessages(ctx context.Context, logs []types.Log, batchFetcher arbostypes.FallibleBatchFetcherWithParentBlock) ([]*DelayedInboxMessage, error) {
 	if len(logs) == 0 {
 		return nil, nil
 	}
@@ -258,7 +258,7 @@ func (b *DelayedBridge) logsToDeliveredMessages(ctx context.Context, logs []type
 			},
 			ParentChainBlockNumber: parsedLog.Raw.BlockNumber,
 		}
-		err := msg.Message.FillInBatchGasFields(batchFetcher)
+		err := msg.Message.FillInBatchGasFieldsWithParentBlock(batchFetcher, msg.ParentChainBlockNumber)
 		if err != nil {
 			return nil, err
 		}

arbnode/delayed_sequencer.go

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

arbnode/inbox_reader.go

@@ -473,15 +473,16 @@ func (r *InboxReader) run(ctx context.Context, hadError bool) error {
 			if err != nil {
 				return err
 			}
-			delayedMessages, err := r.delayedBridge.LookupMessagesInRange(ctx, from, to, func(batchNum uint64) ([]byte, error) {
+			delayedMessages, err := r.delayedBridge.LookupMessagesInRange(ctx, from, to, func(batchNum uint64, parentChainBlockNumber uint64) ([]byte, error) {
 				if len(sequencerBatches) > 0 && batchNum >= sequencerBatches[0].SequenceNumber {
 					idx := batchNum - sequencerBatches[0].SequenceNumber
 					if idx < uint64(len(sequencerBatches)) {
 						return sequencerBatches[idx].Serialize(ctx, r.l1Reader.Client())
 					}
 					log.Warn("missing mentioned batch in L1 message lookup", "batch", batchNum)
 				}
-				data, _, err := r.GetSequencerMessageBytes(ctx, batchNum)
+				// Here we pass in the local parentChainBlockNumber as LookupMessagesInRange fetches parentChainBlockNumber from the logs
+				data, _, err := r.GetSequencerMessageBytesForParentBlock(ctx, batchNum, parentChainBlockNumber)
 				return data, err
 			})
 			if err != nil {
@@ -681,7 +682,11 @@ func (r *InboxReader) GetSequencerMessageBytes(ctx context.Context, seqNum uint6
 	if err != nil {
 		return nil, common.Hash{}, err
 	}
-	blockNum := arbmath.UintToBig(metadata.ParentChainBlock)
+	return r.GetSequencerMessageBytesForParentBlock(ctx, seqNum, metadata.ParentChainBlock)
+}
+
+func (r *InboxReader) GetSequencerMessageBytesForParentBlock(ctx context.Context, seqNum uint64, parentChainBlock uint64) ([]byte, common.Hash, error) {
+	blockNum := arbmath.UintToBig(parentChainBlock)
 	seqBatches, err := r.sequencerInbox.LookupBatchesInRange(ctx, blockNum, blockNum)
 	if err != nil {
 		return nil, common.Hash{}, err
@@ -694,7 +699,7 @@ func (r *InboxReader) GetSequencerMessageBytes(ctx context.Context, seqNum uint6
 		}
 		seenBatches = append(seenBatches, batch.SequenceNumber)
 	}
-	return nil, common.Hash{}, fmt.Errorf("sequencer batch %v not found in L1 block %v (found batches %v)", seqNum, metadata.ParentChainBlock, seenBatches)
+	return nil, common.Hash{}, fmt.Errorf("sequencer batch %v not found in L1 block %v (found batches %v)", seqNum, parentChainBlock, seenBatches)
 }
 
 func (r *InboxReader) GetLastReadBatchCount() uint64 {

arbnode/inbox_tracker.go

@@ -359,15 +359,15 @@ func (t *InboxTracker) legacyGetDelayedMessageAndAccumulator(ctx context.Context
 }
 
 func (t *InboxTracker) GetDelayedMessageAccumulatorAndParentChainBlockNumber(ctx context.Context, seqNum uint64) (*arbostypes.L1IncomingMessage, common.Hash, uint64, error) {
-	msg, acc, blockNum, err := t.getRawDelayedMessageAccumulatorAndParentChainBlockNumber(ctx, seqNum)
+	msg, acc, parentChainBlockNumber, err := t.getRawDelayedMessageAccumulatorAndParentChainBlockNumber(ctx, seqNum)
 	if err != nil {
-		return msg, acc, blockNum, err
+		return msg, acc, parentChainBlockNumber, err
 	}
 	err = msg.FillInBatchGasFields(func(batchNum uint64) ([]byte, error) {
-		data, _, err := t.txStreamer.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
+		data, _, err := t.txStreamer.inboxReader.GetSequencerMessageBytesForParentBlock(ctx, batchNum, parentChainBlockNumber)
 		return data, err
 	})
-	return msg, acc, blockNum, err
+	return msg, acc, parentChainBlockNumber, err
 }
 
 // does not return message, so does not need to fill in batchGasFields

arbnode/maintenance.go

@@ -122,6 +122,7 @@ func (mr *MaintenanceRunner) MaybeRunMaintenance(ctx context.Context) time.Durat
 
 func (mr *MaintenanceRunner) waitMaintenanceToComplete(ctx context.Context) {
 	ticker := time.NewTicker(1 * time.Second)
+	defer ticker.Stop()
 	for {
 		select {
 		case <-ctx.Done():

arbnode/parent/parent.go

@@ -110,27 +110,3 @@ func (p *ParentChain) BlobFeePerByte(ctx context.Context, h *types.Header) (*big
 	}
 	return eip4844.CalcBlobFee(pCfg, header), nil
 }
-
-// SupportsCellProofs returns whether the parent chain has activated the Osaka fork
-// (Fusaka), which introduced cell proofs for blobs.
-// Passing in a nil header will use the time from the latest header.
-func (p *ParentChain) SupportsCellProofs(ctx context.Context, h *types.Header) (bool, error) {
-	header := h
-	if h == nil {
-		lh, err := p.L1Reader.LastHeader(ctx)
-		if err != nil {
-			return false, err
-		}
-		header = lh
-	}
-	pCfg, err := p.chainConfig()
-	if err != nil {
-		return false, err
-	}
-	if pCfg.IsArbitrum() {
-		// Arbitrum does not support blob transactions, so this should not have been called.
-		return false, nil
-	}
-	// arbosVersion 0 because we're checking L1 (not L2 Arbitrum)
-	return pCfg.IsOsaka(pCfg.LondonBlock, header.Time, 0), nil
-}

arbnode/transaction_streamer.go

@@ -492,12 +492,37 @@ func (s *TransactionStreamer) GetMessage(msgIdx arbutil.MessageIndex) (*arbostyp
 		return nil, err
 	}
 
+	ctx, err := s.GetContextSafe()
+	if err != nil {
+		return nil, err
+	}
+
+	var parentChainBlockNumber *uint64
+	if message.DelayedMessagesRead != 0 && s.inboxReader != nil && s.inboxReader.tracker != nil {
+		_, _, localParentChainBlockNumber, err := s.inboxReader.tracker.getRawDelayedMessageAccumulatorAndParentChainBlockNumber(ctx, message.DelayedMessagesRead-1)
+		if err != nil {
+			log.Warn("Failed to fetch parent chain block number for delayed message. Will fall back to BatchMetadata", "idx", message.DelayedMessagesRead-1)
+		} else {
+			parentChainBlockNumber = &localParentChainBlockNumber
+		}
+	}
+
 	err = message.Message.FillInBatchGasFields(func(batchNum uint64) ([]byte, error) {
 		ctx, err := s.GetContextSafe()
 		if err != nil {
 			return nil, err
 		}
-		data, _, err := s.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
+
+		var data []byte
+		if parentChainBlockNumber != nil {
+			data, _, err = s.inboxReader.GetSequencerMessageBytesForParentBlock(ctx, batchNum, *parentChainBlockNumber)
+		} else {
+			data, _, err = s.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
+		}
+		if err != nil {
+			return nil, err
+		}
+
 		return data, err
 	})
 	if err != nil {

arbos/arbostypes/incomingmessage.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/offchainlabs/nitro/arbos/util"
@@ -176,6 +177,10 @@ func LegacyCostForStats(stats *BatchDataStats) uint64 {
 }
 
 func (msg *L1IncomingMessage) FillInBatchGasFields(batchFetcher FallibleBatchFetcher) error {
+	return msg.FillInBatchGasFieldsWithParentBlock(FromFallibleBatchFetcher(batchFetcher), msg.Header.BlockNumber)
+}
+
+func (msg *L1IncomingMessage) FillInBatchGasFieldsWithParentBlock(batchFetcher FallibleBatchFetcherWithParentBlock, parentChainBlockNumber uint64) error {
 	if batchFetcher == nil || msg.Header.Kind != L1MessageType_BatchPostingReport {
 		return nil
 	}
@@ -187,16 +192,21 @@ func (msg *L1IncomingMessage) FillInBatchGasFields(batchFetcher FallibleBatchFet
 		if err != nil {
 			return fmt.Errorf("failed to parse batch posting report: %w", err)
 		}
-		batchData, err := batchFetcher(batchNum)
+		batchData, err := batchFetcher(batchNum, parentChainBlockNumber)
 		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)
+			if msg.LegacyBatchGasCost == nil {
+				return fmt.Errorf("failed to fetch batch mentioned by batch posting report: %w", err)
+			}
+			log.Warn("Failed reading batch data for filling message - leaving BatchDataStats empty")
+		} else {
+			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)
 		}
-		msg.BatchDataStats = GetDataStats(batchData)
 	}
+
 	legacyCost := LegacyCostForStats(msg.BatchDataStats)
 	msg.LegacyBatchGasCost = &legacyCost
 	return nil
@@ -271,8 +281,17 @@ func ParseIncomingL1Message(rd io.Reader, batchFetcher FallibleBatchFetcher) (*L
 	return msg, nil
 }
 
+type FallibleBatchFetcherWithParentBlock func(batchNum uint64, parentChainBlock uint64) ([]byte, error)
+
 type FallibleBatchFetcher func(batchNum uint64) ([]byte, error)
 
+// Wraps FallibleBatchFetcher into FallibleBatchFetcherWithParentBlock to ignore parentChainBlock
+func FromFallibleBatchFetcher(f FallibleBatchFetcher) FallibleBatchFetcherWithParentBlock {
+	return func(batchNum uint64, _ uint64) ([]byte, error) {
+		return f(batchNum)
+	}
+}
+
 type ParsedInitMessage struct {
 	ChainId          *big.Int
 	InitialL1BaseFee *big.Int

arbos/constraints/single_dimensional.go arbos/l2pricing/gas_constraint.goarbos/constraints/single_dimensional.go renamed to arbos/l2pricing/gas_constraint.go

@@ -1,8 +1,7 @@
 // Copyright 2025, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE.md
 
-// The constraints package tracks the multi-dimensional gas usage to apply constraint-based pricing.
-package constraints
+package l2pricing
 
 import "github.com/offchainlabs/nitro/arbos/storage"