[DNM] feat(da): support fiber (not via c-node)

apps/evm/cmd/run.go

@@ -131,7 +131,10 @@ var RunCmd = &cobra.Command{
 			}()
 		}
 
-		return rollcmd.StartNode(logger, cmd, executor, sequencer, nodeKey, datastore, nodeConfig, genesis, node.NodeOptions{})
+		// nil fiberClient: the EVM app doesn't wire Fibre DA. See
+		// tools/celestia-node-fiber for the adapter; testapp/cmd/run.go
+		// has the same TODO note for matching context.
+		return rollcmd.StartNode(logger, cmd, executor, sequencer, nodeKey, datastore, nodeConfig, genesis, node.NodeOptions{}, nil)
 	},
 }
 

apps/grpc/cmd/run.go

@@ -86,8 +86,10 @@ The execution client must implement the Evolve execution gRPC interface.`,
 			return err
 		}
 
-		// Start the node
-		return rollcmd.StartNode(logger, cmd, executor, sequencer, nodeKey, datastore, nodeConfig, genesis, node.NodeOptions{})
+		// Start the node. nil fiberClient: the gRPC app doesn't wire
+		// Fibre DA. See tools/celestia-node-fiber for the adapter;
+		// testapp/cmd/run.go has the same TODO note for context.
+		return rollcmd.StartNode(logger, cmd, executor, sequencer, nodeKey, datastore, nodeConfig, genesis, node.NodeOptions{}, nil)
 	},
 }
 

apps/testapp/cmd/run.go

@@ -97,7 +97,12 @@ var RunCmd = &cobra.Command{
 			return err
 		}
 
-		return cmd.StartNode(logger, command, executor, sequencer, nodeKey, datastore, nodeConfig, genesis, node.NodeOptions{})
+		// nil fiberClient: testapp doesn't yet wire Fibre DA. To enable
+		// fiber support here, build a *cnfiber.Adapter from
+		// nodeConfig.DA.Fiber and pass it as the last argument. The
+		// adapter wiring lives in tools/celestia-node-fiber; see the
+		// fiber-bench tool's run.go for a working caller.
+		return cmd.StartNode(logger, command, executor, sequencer, nodeKey, datastore, nodeConfig, genesis, node.NodeOptions{}, nil)
 	},
 }
 

block/internal/cache/manager.go

@@ -25,8 +25,24 @@ const (
 	// DataDAIncludedPrefix is the store key prefix for data DA inclusion tracking.
 	DataDAIncludedPrefix = "cache/data-da-included/"
 
-	// DefaultTxCacheRetention is the default time to keep transaction hashes in cache.
-	DefaultTxCacheRetention = 24 * time.Hour
+	// DefaultTxCacheRetention is how long tx hashes stay in the
+	// seen-tx cache before CleanupOldTxs evicts them.
+	//
+	// HACK(fiber-throughput): dropped from 24h to 30s while we chase
+	// throughput, but the previous default was itself wrong: 24h is
+	// retention × tps in memory, so any rollup with meaningful TPS
+	// would OOM (we hit ~16 GB in under a minute at ~1.5M tx/s).
+	// What this should be properly:
+	//   - Bounded by entry count, not wall time. The dedup window
+	//     should be "the last N txs we saw", LRU-evicted, so cache
+	//     memory is fixed regardless of throughput.
+	//   - Or expressed in DA blocks: "drop hashes once their txs
+	//     would have been retried out of the mempool", which is a
+	//     property of mempool TTL × DA block time, not 24 hours.
+	//   - 30s is a fine measurement default and a reasonable upper
+	//     bound for pretty much any rollup; pick the right number
+	//     when the cache structure itself is reworked.
+	DefaultTxCacheRetention = 30 * time.Second
 )
 
 // CacheManager provides thread-safe cache operations for tracking seen blocks

block/internal/common/consts.go

@@ -2,19 +2,54 @@ package common
 
 import "strconv"
 
-// defaultMaxBlobSizeStr holds the string representation of the default blob
-// size limit. Override at link time via:
+// defaultMaxBlobSizeStr holds the string representation of the default
+// blob size limit. Anchored to Fibre's actual cap: protocol MaxBlobSize
+// (1 << 27 = 128 MiB) minus the 5-byte Fibre blob header (1 byte
+// version + 4 byte data size). See celestia-app/v9/fibre/blob.go
+// (blobHeaderLen) and fibre/protocol_params.go (MaxBlobSize).
 //
-//	go build -ldflags "-X github.com/evstack/ev-node/block/internal/common.defaultMaxBlobSizeStr=125829120"
-var defaultMaxBlobSizeStr = "5242880" // 5 MB
+// HACK(fiber-throughput): this default is correct for fiber-enabled
+// deployments but WRONG for the legacy JSON-RPC blob client path —
+// the bridge / chain rejects blobs above its own (much smaller) cap,
+// so a non-fiber node started against this default would fail to
+// submit. The right shape is per-backend: fiber's cap is one number,
+// blob-RPC's cap is another, and DefaultMaxBlobSize shouldn't be a
+// single global. Restructure into config when the throughput-cleanup
+// TODO lands; until then, non-fiber callers should override via
+// ldflag or local config.
+//
+// MUST be a string literal: Go's `-ldflags "-X ..."` only takes effect
+// on variables initialized to a string constant, NOT a function call.
+// A previous version used strconv.FormatUint here, which compiled but
+// silently ignored ldflag overrides.
+//
+// Override at link time via:
+//
+//	go build -ldflags "-X github.com/evstack/ev-node/block/internal/common.defaultMaxBlobSizeStr=33554432"
+var defaultMaxBlobSizeStr = "134217723" // 1 << 27 - 5 = 128 MiB - 5 B
 
 // DefaultMaxBlobSize is the max blob size limit used for blob submission.
+//
+// TODO(throughput-cleanup): this single value is currently plugged in
+// at two semantically different limits and the conflation has caused
+// real bugs (a packed block marshals larger than its raw-tx total, so
+// using MaxBlobSize as both input cap and output cap let blocks blow
+// past the DA cap). Split into two:
+//
+//   MaxBlobSize       — chain-side ceiling on a marshaled DA blob
+//   MaxBlockTxBytes() — derived raw-tx budget = MaxBlobSize - per-block
+//                       marshal overhead. Used by RetrieveBatch /
+//                       FilterTxs.
+//
+// Once that derivation exists, drop the ad-hoc 2% reservation in
+// executing/executor.go::RetrieveBatch and the duplicate cap in
+// submitting/da_submitter.go::defaultRetryPolicy.
 var DefaultMaxBlobSize uint64
 
 func init() {
 	v, err := strconv.ParseUint(defaultMaxBlobSizeStr, 10, 64)
 	if err != nil || v == 0 {
-		DefaultMaxBlobSize = 5 * 1024 * 1024 // 5 MB fallback
+		DefaultMaxBlobSize = 134217723
 		return
 	}
 	DefaultMaxBlobSize = v

block/internal/da/fiber/types.go

@@ -0,0 +1,69 @@
+// Package fiber defines the Fiber DA backend interface and shared types.
+//
+// # Design Assumptions
+//
+//   - The sequencer trusts the encoder to eventually confirm blob inclusion.
+//     Upload returns after the blob is uploaded and the PFF transaction is
+//     broadcast, NOT after on-chain confirmation. This keeps the sequencer's
+//     write path fast (~2s per 128 MB blob).
+//
+//   - Callers are expected to batch/buffer their data into blobs sized for the
+//     protocol maximum (128 MiB - 5 byte header = 134,217,723 bytes).
+//     The interface accepts arbitrary sizes but the implementation may batch
+//     or reject oversized blobs.
+//
+//   - Confirmation/finality is intentionally omitted from the initial API.
+//     The sequencer does not need it; the read path (Listen + Download) is
+//     sufficient for full nodes. A Status or Confirm RPC can be added later
+//     if needed without breaking existing callers.
+//
+//   - Blob ordering is encoded in the blob data itself by the caller.
+//     The interface does not impose or guarantee ordering.
+//
+//   - The interface is the same whether the encoder runs in-process or as an
+//     external gRPC service. For in-process use, call the mock or real
+//     implementation directly; for external use, connect via gRPC.
+package fiber
+
+import (
+	"context"
+	"time"
+)
+
+// BlobID uniquely identifies an uploaded blob (version byte + 32-byte commitment).
+type BlobID []byte
+
+// UploadResult is returned by Upload after the blob is accepted.
+type UploadResult struct {
+	BlobID    BlobID
+	ExpiresAt time.Time
+}
+
+// BlobEvent is delivered via Listen when a blob is confirmed on-chain.
+type BlobEvent struct {
+	BlobID   BlobID
+	Height   uint64
+	DataSize uint64
+}
+
+// DA is the interface for interacting with the Fiber data availability layer.
+type DA interface {
+	// Upload submits a blob under the given namespace to the DA network.
+	// Returns after the blob is uploaded and the payment transaction is broadcast.
+	// Does NOT wait for on-chain confirmation (see package doc for rationale).
+	Upload(ctx context.Context, namespace []byte, data []byte) (UploadResult, error)
+
+	// Download retrieves and reconstructs a blob by its ID.
+	// Returns the original data that was passed to Upload.
+	Download(ctx context.Context, blobID BlobID) ([]byte, error)
+
+	// Listen streams confirmed blob events for the given namespace,
+	// starting at fromHeight.
+	//
+	// fromHeight == 0 starts the stream from the current chain head; any
+	// positive value replays events from that block forward so a
+	// subscriber can resume after a restart without missing blobs (the
+	// DA backend is expected to block, not error, on future heights).
+	// The returned channel is closed when ctx is cancelled.
+	Listen(ctx context.Context, namespace []byte, fromHeight uint64) (<-chan BlobEvent, error)
+}