Merge pull request #4113 from OffchainLabs/post-fusaka-blob-ports

v3.9.x post fusaka blob backports

Author: joshuacolvin0

arbnode/dataposter/data_poster.go

@@ -775,29 +775,7 @@ func (p *DataPoster) PostTransaction(ctx context.Context, dataCreatedAt time.Tim
 	return p.postTransactionWithMutex(ctx, 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) postTransactionWithMutex(ctx context.Context, 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")
 	}
@@ -845,11 +823,7 @@ func (p *DataPoster) postTransactionWithMutex(ctx context.Context, dataCreatedAt
 		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)
 		}
@@ -1354,7 +1328,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"`
@@ -1413,12 +1386,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")
 	}
@@ -1479,7 +1446,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.
@@ -1515,7 +1481,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,
@@ -1537,7 +1502,6 @@ var DefaultDataPosterConfigForValidator = func() DataPosterConfig {
 	config.BlobTxReplacementTimes = nil
 	config.MinBlobTxTipCapGwei = 0
 	config.MaxBlobTxTipCapGwei = 0
-	config.EnableCellProofs = ""
 	return config
 }()
 
@@ -1557,7 +1521,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/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
-}

cmd/blobtool/blobtool.go

@@ -1,7 +1,7 @@
 // Copyright 2025, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE.md
 
-// This is a command line tool for testing beacon/blobs and blob_sidecars endpoints.
+// This is a command line tool for testing beacon/blobs endpoint.
 package main
 
 import (
@@ -42,20 +42,16 @@ func main() {
 }
 
 type FetchConfig struct {
-	BeaconURL         string   `koanf:"beacon-url"`
-	Slot              uint64   `koanf:"slot"`
-	VersionedHashes   []string `koanf:"versioned-hashes"`
-	UseLegacyEndpoint bool     `koanf:"use-legacy-endpoint"`
-	CompareEndpoints  bool     `koanf:"compare-endpoints"`
+	BeaconURL       string   `koanf:"beacon-url"`
+	Slot            uint64   `koanf:"slot"`
+	VersionedHashes []string `koanf:"versioned-hashes"`
 }
 
 func parseFetchConfig(args []string) (*FetchConfig, error) {
 	f := flag.NewFlagSet("blobtool fetch", flag.ContinueOnError)
 	f.String("beacon-url", "", "Beacon Chain RPC URL. For example with --beacon-url=http://localhost, an RPC call will be made to http://localhost/eth/v1/beacon/blobs")
 	f.Uint64("slot", 0, "Beacon chain slot number to fetch blobs from")
 	f.StringSlice("versioned-hashes", []string{}, "Comma-separated list of versioned hashes to fetch (optional - fetches all if not provided)")
-	f.Bool("use-legacy-endpoint", false, "Use the legacy blob_sidecars endpoint")
-	f.Bool("compare-endpoints", false, "Fetch using both endpoints and compare results")
 
 	k, err := confighelpers.BeginCommonParse(f, args)
 	if err != nil {
@@ -94,20 +90,8 @@ func fetchBlobs(args []string) error {
 		versionedHashes[i] = common.HexToHash(hashStr)
 	}
 
-	if config.UseLegacyEndpoint && len(versionedHashes) == 0 {
-		return fmt.Errorf("--versioned-hashes is required when using --use-legacy-endpoint")
-	}
-
-	if config.CompareEndpoints {
-		if len(versionedHashes) == 0 {
-			return fmt.Errorf("--versioned-hashes is required when using --compare-endpoints")
-		}
-		return compareEndpoints(ctx, config, versionedHashes)
-	}
-
 	blobClientConfig := headerreader.BlobClientConfig{
-		BeaconUrl:         config.BeaconURL,
-		UseLegacyEndpoint: config.UseLegacyEndpoint,
+		BeaconUrl: config.BeaconURL,
 	}
 
 	blobClient, err := headerreader.NewBlobClient(blobClientConfig, nil)
@@ -119,15 +103,10 @@ func fetchBlobs(args []string) error {
 		return fmt.Errorf("failed to initialize blob client: %w", err)
 	}
 
-	endpointType := "new blobs"
-	if config.UseLegacyEndpoint {
-		endpointType = "legacy blob_sidecars"
-	}
-
 	if len(versionedHashes) > 0 {
-		fmt.Printf("Fetching %d blobs for slot %d using %s endpoint...\n", len(versionedHashes), config.Slot, endpointType)
+		fmt.Printf("Fetching %d blobs for slot %d...\n", len(versionedHashes), config.Slot)
 	} else {
-		fmt.Printf("Fetching all blobs for slot %d using %s endpoint...\n", config.Slot, endpointType)
+		fmt.Printf("Fetching all blobs for slot %d...\n", config.Slot)
 	}
 
 	startTime := time.Now()
@@ -153,82 +132,3 @@ func fetchBlobs(args []string) error {
 
 	return nil
 }
-
-func compareEndpoints(ctx context.Context, config *FetchConfig, versionedHashes []common.Hash) error {
-	fmt.Println("Comparing legacy blob_sidecars and new blobs endpoints...")
-	fmt.Println()
-
-	legacyConfig := headerreader.BlobClientConfig{
-		BeaconUrl:         config.BeaconURL,
-		UseLegacyEndpoint: true,
-	}
-	legacyClient, err := headerreader.NewBlobClient(legacyConfig, nil)
-	if err != nil {
-		return fmt.Errorf("failed to create legacy blob client: %w", err)
-	}
-	if err := legacyClient.Initialize(ctx); err != nil {
-		return fmt.Errorf("failed to initialize legacy blob client: %w", err)
-	}
-
-	fmt.Println("Fetching with legacy blob_sidecars endpoint...")
-	legacyStart := time.Now()
-	legacyBlobs, err := legacyClient.GetBlobsBySlot(ctx, config.Slot, versionedHashes)
-	legacyDuration := time.Since(legacyStart)
-	if err != nil {
-		return fmt.Errorf("failed to fetch blobs with legacy endpoint: %w", err)
-	}
-	fmt.Printf("✓ Legacy endpoint: fetched %d blobs in %v\n", len(legacyBlobs), legacyDuration)
-	fmt.Println()
-
-	newConfig := headerreader.BlobClientConfig{
-		BeaconUrl:         config.BeaconURL,
-		UseLegacyEndpoint: false,
-	}
-	newClient, err := headerreader.NewBlobClient(newConfig, nil)
-	if err != nil {
-		return fmt.Errorf("failed to create new blob client: %w", err)
-	}
-	if err := newClient.Initialize(ctx); err != nil {
-		return fmt.Errorf("failed to initialize new blob client: %w", err)
-	}
-
-	fmt.Println("Fetching with new blobs endpoint...")
-	newStart := time.Now()
-	newBlobs, err := newClient.GetBlobsBySlot(ctx, config.Slot, versionedHashes)
-	newDuration := time.Since(newStart)
-	if err != nil {
-		return fmt.Errorf("failed to fetch blobs with new endpoint: %w", err)
-	}
-	fmt.Printf("✓ New endpoint: fetched %d blobs in %v\n", len(newBlobs), newDuration)
-	fmt.Println()
-
-	if len(legacyBlobs) != len(newBlobs) {
-		return fmt.Errorf("blob count mismatch: legacy=%d, new=%d", len(legacyBlobs), len(newBlobs))
-	}
-
-	fmt.Println("Comparing blob data...")
-	for i := range legacyBlobs {
-		if legacyBlobs[i] != newBlobs[i] {
-			return fmt.Errorf("blob %d data mismatch", i)
-		}
-		_, hashes, err := blobs.ComputeCommitmentsAndHashes([]kzg4844.Blob{legacyBlobs[i]})
-		if err != nil {
-			return fmt.Errorf("failed to compute hash for blob %d: %w", i, err)
-		}
-		fmt.Printf("  Blob %d: ✓ identical (%s)\n", i, hashes[0].Hex())
-	}
-
-	fmt.Println()
-	fmt.Printf("Performance comparison:\n")
-	fmt.Printf("  Legacy endpoint: %v\n", legacyDuration)
-	fmt.Printf("  New endpoint:    %v\n", newDuration)
-	if newDuration < legacyDuration {
-		improvement := float64(legacyDuration-newDuration) / float64(legacyDuration) * 100
-		fmt.Printf("  New endpoint is %.1f%% faster\n", improvement)
-	} else {
-		slower := float64(newDuration-legacyDuration) / float64(legacyDuration) * 100
-		fmt.Printf("  New endpoint is %.1f%% slower\n", slower)
-	}
-
-	return nil
-}

util/blobs/blobs.go

@@ -128,36 +128,21 @@ func ComputeCommitmentsAndHashes(blobs []kzg4844.Blob) ([]kzg4844.Commitment, []
 	return commitments, versionedHashes, nil
 }
 
-// ComputeProofs computes either legacy blob proofs (Version0) or cell proofs (Version1)
-// based on the enableCellProofs flag. Returns proofs, version byte, and error.
-func ComputeProofs(blobs []kzg4844.Blob, commitments []kzg4844.Commitment, enableCellProofs bool) ([]kzg4844.Proof, byte, error) {
+// ComputeProofs computes cell proofs for the given blobs.
+// Each blob generates CellProofsPerBlob (128) proofs.
+// Returns proofs, version byte (always 1), and error.
+func ComputeProofs(blobs []kzg4844.Blob, commitments []kzg4844.Commitment) ([]kzg4844.Proof, byte, error) {
 	if len(blobs) != len(commitments) {
 		return nil, 0, fmt.Errorf("ComputeProofs got %v blobs but %v commitments", len(blobs), len(commitments))
 	}
 
-	if enableCellProofs {
-		// Version1: Use cell proofs for Fusaka compatibility
-		// Each blob generates CellProofsPerBlob (128) proofs
-		proofs := make([]kzg4844.Proof, 0, len(blobs)*kzg4844.CellProofsPerBlob)
-		for i := range blobs {
-			cellProofs, err := kzg4844.ComputeCellProofs(&blobs[i])
-			if err != nil {
-				return nil, 0, fmt.Errorf("failed to compute cell proofs for blob %d: %w", i, err)
-			}
-			proofs = append(proofs, cellProofs...)
-		}
-		return proofs, 1, nil // BlobSidecarVersion1
-	}
-
-	// Version0: Use legacy blob proofs (pre-Fusaka)
-	// Each blob generates 1 proof
-	proofs := make([]kzg4844.Proof, len(blobs))
+	proofs := make([]kzg4844.Proof, 0, len(blobs)*kzg4844.CellProofsPerBlob)
 	for i := range blobs {
-		var err error
-		proofs[i], err = kzg4844.ComputeBlobProof(&blobs[i], commitments[i])
+		cellProofs, err := kzg4844.ComputeCellProofs(&blobs[i])
 		if err != nil {
-			return nil, 0, fmt.Errorf("failed to compute blob proof for blob %d: %w", i, err)
+			return nil, 0, fmt.Errorf("failed to compute cell proofs for blob %d: %w", i, err)
 		}
+		proofs = append(proofs, cellProofs...)
 	}
-	return proofs, 0, nil // BlobSidecarVersion0
+	return proofs, 1, nil
 }