perf(fiber-da): skip flatten allocation on single-item Submit; honor ctx

Three changes in fiber_client.go::Submit, all hot-path correctness/
efficiency wins surfaced while debugging Fibre throughput:

1. Single-item fast path that bypasses flattenBlobs.
   For data blobs, limitBatchBySize already caps each Submit call at
   one item (each block's data already saturates MaxBlobBytes). The
   flatten step was therefore allocating MaxBlobSize bytes and
   memcpy'ing the entire payload solely to prepend the 8-byte
   count/length prefix used by splitBlobs. At 128 MiB blocks that's
   ~128 MB held in two places at once during every Upload. The fast
   path passes data[0] straight through and saves the full copy.

   Wire-format caveat: a retriever (full-node syncer or light client)
   downloading a blob written via this fast path can't decode it —
   splitBlobs always expects the prefix. The right fix is to pair
   this with a per-item Upload model so flatten falls away entirely;
   tracked as a TODO in the source pointing at the concurrent-uploads
   work where that lands naturally.

2. Honor caller's ctx in Upload.
   The previous context.Background() kept Uploads alive past node
   shutdown and was the proximate cause of the "payment promise
   already processed" warnings — a stale Upload would settle on-chain
   after ev-node had already moved on. Threading the caller's ctx
   makes shutdown promptly cancel in-flight Uploads.

3. Correct SubmittedCount on error.
   On a full-Upload failure the result reported len(data)-1 as
   submitted, which both reads weirdly for len==1 (uint64 underflow
   risk in any future arithmetic) and lies to submitToDA's
   prefix-of-success retry advance. Reset to 0 on error.

No behaviour change for the multi-item retrieve path (flatten still
runs when len > 1). Validated via go build / go vet.

Author: Wondertan

block/internal/da/fiber_client.go

@@ -87,9 +87,30 @@ func (c *fiberDAClient) Submit(ctx context.Context, data [][]byte, _ float64, na
 		}
 	}
 
-	flat := flattenBlobs(data)
+	// Single-item fast path: avoid the MaxBlobSize-sized allocation +
+	// memcpy that flattenBlobs would do just to wrap one item in the
+	// 8-byte count/length prefix. With per-item caps already saturating
+	// MaxBlobBytes for data blobs, this is the steady-state path.
+	//
+	// TODO: wire-format compat — splitBlobs always expects the prefix,
+	// so any retriever (full node syncer, light client) downloading a
+	// blob written via this fast path will fail to decode. Address
+	// alongside the concurrent-uploads change by switching to a
+	// per-item Upload model where flatten is no longer needed.
+	var blob []byte
+	if len(data) == 1 {
+		blob = data[0]
+	} else {
+		blob = flattenBlobs(data)
+	}
 
-	result, err := c.fiber.Upload(context.Background(), namespace[len(namespace)-10:], flat)
+	// Honor the caller's context so Upload returns promptly on
+	// shutdown / parent cancellation. The previous context.Background()
+	// kept Uploads alive past node shutdown and contributed to the
+	// "payment promise already processed" warnings we saw in early
+	// runs (a stale Upload would settle after the node had stopped
+	// tracking it).
+	result, err := c.fiber.Upload(ctx, namespace[len(namespace)-10:], blob)
 	if err != nil {
 		code := datypes.StatusError
 		switch {
@@ -103,9 +124,12 @@ func (c *fiberDAClient) Submit(ctx context.Context, data [][]byte, _ float64, na
 
 		return datypes.ResultSubmit{
 			BaseResult: datypes.BaseResult{
-				Code:           code,
-				Message:        fmt.Sprintf("fiber upload failed for blob: %v", err),
-				SubmittedCount: uint64(len(data) - 1),
+				Code: code,
+				Message: fmt.Sprintf("fiber upload failed for blob: %v", err),
+				// On error nothing settled — the previous len(data)-1
+				// reported all-but-one as submitted on full failure,
+				// which lied to the caller's retry/postSubmit logic.
+				SubmittedCount: 0,
 				BlobSize:       blobSize,
 				Timestamp:      time.Now(),
 			},