@aztec/blob-client 3.0.0-nightly.20251223 → 3.0.0-nightly.20251224

package/dest/filestore/filestore_blob_client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filestore_blob_client.d.ts","sourceRoot":"","sources":["../../src/filestore/filestore_blob_client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,QAAQ,EAA+B,MAAM,iBAAiB,CAAC;AACnF,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAG7E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D;;;GAGG;AACH,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YACmB,KAAK,EAAE,iBAAiB,GAAG,SAAS,EACpC,QAAQ,EAAE,MAAM,EACjC,MAAM,CAAC,EAAE,MAAM,EAGhB;IAED;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAIhB;;;;OAIG;IACG,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAoBhE;IAED;;;OAGG;IACH,MAAM,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAElD;IAED;;;;;OAKG;IACG,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,YAAY,UAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAmB7D;IAED;;;;OAIG;IACG,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,aAAa,EAAE,EAAE,YAAY,UAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAOnF;IAED;;OAEG;IACH,UAAU,IAAI,MAAM,CAEnB;IAED;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAIjC;IAED;;OAEG;IACH,OAAO,CAAC,UAAU;CAGnB"}
+{"version":3,"file":"filestore_blob_client.d.ts","sourceRoot":"","sources":["../../src/filestore/filestore_blob_client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,QAAQ,EAA+B,MAAM,iBAAiB,CAAC;AACnF,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAI7E;;;GAGG;AACH,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YACmB,KAAK,EAAE,iBAAiB,GAAG,SAAS,EACpC,QAAQ,EAAE,MAAM,EACjC,MAAM,CAAC,EAAE,MAAM,EAGhB;IAED;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAIhB;;;;OAIG;IACG,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAmBhE;IAED;;;OAGG;IACH,MAAM,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAElD;IAED;;;;;OAKG;IACG,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,YAAY,UAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB7D;IAED;;;;OAIG;IACG,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,YAAY,UAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjE;IAED;;OAEG;IACH,UAAU,IAAI,MAAM,CAEnB;IAED;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAIjC;IAED;;OAEG;IACH,OAAO,CAAC,UAAU;CAGnB"}

package/dest/filestore/filestore_blob_client.js

@@ -33,11 +33,7 @@ import { inboundTransform, outboundTransform } from '../encoding/index.js';
                 }
                 const data = await this.store.read(path);
                 const json = JSON.parse(inboundTransform(data).toString());
-                // We don't know the actual index when fetching from filestore - use -1 to indicate this deliberately
-                blobs.push({
-                    ...json,
-                    index: '-1'
-                });
+                blobs.push(json);
             } catch (err) {
                 this.log.warn(`Failed to read blob ${blobHashes[i]} from filestore`, err);
             }
@@ -64,20 +60,16 @@ import { inboundTransform, outboundTransform } from '../encoding/index.js';
             this.log.trace(`Blob ${versionedHash} already exists, skipping`);
             return;
         }
-        // index=-1 is deliberate as we don't know the actual blob index in most cases when the filestores are used (blobs are saved in the filestores before we ever fetch them from L1)
-        const json = blob.toJson(-1);
+        const json = blob.toJSON();
         await this.store.save(this.blobPath(versionedHash), outboundTransform(Buffer.from(JSON.stringify(json))));
         this.log.debug(`Saved blob ${versionedHash} to filestore`);
     }
     /**
    * Save multiple blobs to the store in parallel.
-   * @param blobs - The blobs to save (either Blob[] or BlobWithIndex[])
+   * @param blobs - The blobs to save
    * @param skipIfExists - Skip saving if blob already exists (default: true)
    */ async saveBlobs(blobs, skipIfExists = true) {
-        await Promise.all(blobs.map((b)=>{
-            const blob = 'blob' in b ? b.blob : b;
-            return this.saveBlob(blob, skipIfExists);
-        }));
+        await Promise.all(blobs.map((blob)=>this.saveBlob(blob, skipIfExists)));
     }
     /**
    * Get the base URL/path of the filestore.

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@aztec/blob-client",
-  "version": "3.0.0-nightly.20251223",
+  "version": "3.0.0-nightly.20251224",
   "type": "module",
   "bin": "./dest/client/bin/index.js",
   "exports": {
     "./client": "./dest/client/index.js",
     "./client/config": "./dest/client/config.js",
     "./encoding": "./dest/encoding/index.js",
-    "./types": "./dest/types/index.js",
     "./filestore": "./dest/filestore/index.js"
   },
   "inherits": [
@@ -57,12 +56,12 @@
     ]
   },
   "dependencies": {
-    "@aztec/blob-lib": "3.0.0-nightly.20251223",
-    "@aztec/ethereum": "3.0.0-nightly.20251223",
-    "@aztec/foundation": "3.0.0-nightly.20251223",
-    "@aztec/kv-store": "3.0.0-nightly.20251223",
-    "@aztec/stdlib": "3.0.0-nightly.20251223",
-    "@aztec/telemetry-client": "3.0.0-nightly.20251223",
+    "@aztec/blob-lib": "3.0.0-nightly.20251224",
+    "@aztec/ethereum": "3.0.0-nightly.20251224",
+    "@aztec/foundation": "3.0.0-nightly.20251224",
+    "@aztec/kv-store": "3.0.0-nightly.20251224",
+    "@aztec/stdlib": "3.0.0-nightly.20251224",
+    "@aztec/telemetry-client": "3.0.0-nightly.20251224",
     "express": "^4.21.2",
     "snappy": "^7.2.2",
     "source-map-support": "^0.5.21",

package/src/archive/blobscan_archive_client.ts

@@ -25,22 +25,20 @@ export const BlobscanBlockResponseSchema = zodFor<BlobJson[]>()(
               commitment: z.string(),
               proof: z.string(),
               size: z.number().int(),
-              index: z.number().int().optional(), // This is the index within the tx, not within the block!
+              index: z.number().int().optional(), // Unused, kept for schema compatibility with blobscan API
             }),
           ),
         }),
       ),
     })
     .transform(data =>
-      data.transactions
-        .flatMap(tx =>
-          tx.blobs.map(blob => ({
-            blob: blob.data,
-            // eslint-disable-next-line camelcase
-            kzg_commitment: blob.commitment,
-          })),
-        )
-        .map((blob, index) => ({ ...blob, index: index.toString() })),
+      data.transactions.flatMap(tx =>
+        tx.blobs.map(blob => ({
+          blob: blob.data,
+          // eslint-disable-next-line camelcase
+          kzg_commitment: blob.commitment,
+        })),
+      ),
     ),
 );
 

package/src/blobstore/blob_store_test_suite.ts

@@ -1,7 +1,6 @@
 import { Blob } from '@aztec/blob-lib';
 import { Fr } from '@aztec/foundation/curves/bn254';
 
-import { BlobWithIndex } from '../types/index.js';
 import type { BlobStore } from './interface.js';
 
 export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
@@ -15,39 +14,36 @@ export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
     // Create a test blob with random fields
     const testFields = [Fr.random(), Fr.random(), Fr.random()];
     const blob = Blob.fromFields(testFields);
-    const blobWithIndex = new BlobWithIndex(blob, 0);
     const blobHash = blob.getEthVersionedBlobHash();
 
     // Store the blob
-    await blobStore.addBlobs([blobWithIndex]);
+    await blobStore.addBlobs([blob]);
 
     // Retrieve the blob by hash
     const retrievedBlobs = await blobStore.getBlobsByHashes([blobHash]);
 
     // Verify the blob was retrieved and matches
     expect(retrievedBlobs.length).toBe(1);
-    expect(retrievedBlobs[0].blob).toEqual(blob);
+    expect(retrievedBlobs[0]).toEqual(blob);
   });
 
   it('should handle multiple blobs stored and retrieved by their hashes', async () => {
     // Create two different blobs
     const blob1 = Blob.fromFields([Fr.random(), Fr.random()]);
     const blob2 = Blob.fromFields([Fr.random(), Fr.random(), Fr.random()]);
-    const blobWithIndex1 = new BlobWithIndex(blob1, 0);
-    const blobWithIndex2 = new BlobWithIndex(blob2, 1);
 
     const blobHash1 = blob1.getEthVersionedBlobHash();
     const blobHash2 = blob2.getEthVersionedBlobHash();
 
     // Store both blobs
-    await blobStore.addBlobs([blobWithIndex1, blobWithIndex2]);
+    await blobStore.addBlobs([blob1, blob2]);
 
     // Retrieve and verify both blobs
     const retrievedBlobs = await blobStore.getBlobsByHashes([blobHash1, blobHash2]);
 
     expect(retrievedBlobs.length).toBe(2);
-    expect(retrievedBlobs[0].blob).toEqual(blob1);
-    expect(retrievedBlobs[1].blob).toEqual(blob2);
+    expect(retrievedBlobs[0]).toEqual(blob1);
+    expect(retrievedBlobs[1]).toEqual(blob2);
   });
 
   it('should return empty array for non-existent blob hash', async () => {
@@ -59,31 +55,13 @@ export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
     expect(retrievedBlobs).toEqual([]);
   });
 
-  it('should handle storing blobs with different indices', async () => {
-    // Create blobs with different indices
-    const blob1 = Blob.fromFields([Fr.random()]);
-    const blob2 = Blob.fromFields([Fr.random()]);
-    const blobWithIndex1 = new BlobWithIndex(blob1, 0);
-    const blobWithIndex2 = new BlobWithIndex(blob2, 1);
-
-    await blobStore.addBlobs([blobWithIndex1, blobWithIndex2]);
-
-    const blobHash1 = blob1.getEthVersionedBlobHash();
-    const blobHash2 = blob2.getEthVersionedBlobHash();
-
-    const retrievedBlobs = await blobStore.getBlobsByHashes([blobHash1, blobHash2]);
-
-    expect(retrievedBlobs[0].index).toBe(0);
-    expect(retrievedBlobs[1].index).toBe(1);
-  });
-
   it('should handle retrieving subset of stored blobs', async () => {
     // Store multiple blobs
     const blob1 = Blob.fromFields([Fr.random()]);
     const blob2 = Blob.fromFields([Fr.random()]);
     const blob3 = Blob.fromFields([Fr.random()]);
 
-    await blobStore.addBlobs([new BlobWithIndex(blob1, 0), new BlobWithIndex(blob2, 1), new BlobWithIndex(blob3, 2)]);
+    await blobStore.addBlobs([blob1, blob2, blob3]);
 
     // Retrieve only some of them
     const blobHash1 = blob1.getEthVersionedBlobHash();
@@ -92,23 +70,22 @@ export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
     const retrievedBlobs = await blobStore.getBlobsByHashes([blobHash1, blobHash3]);
 
     expect(retrievedBlobs.length).toBe(2);
-    expect(retrievedBlobs[0].blob).toEqual(blob1);
-    expect(retrievedBlobs[1].blob).toEqual(blob3);
+    expect(retrievedBlobs[0]).toEqual(blob1);
+    expect(retrievedBlobs[1]).toEqual(blob3);
   });
 
   it('should handle duplicate blob hashes in request', async () => {
     const blob = Blob.fromFields([Fr.random()]);
-    const blobWithIndex = new BlobWithIndex(blob, 0);
     const blobHash = blob.getEthVersionedBlobHash();
 
-    await blobStore.addBlobs([blobWithIndex]);
+    await blobStore.addBlobs([blob]);
 
     // Request the same blob hash multiple times
     const retrievedBlobs = await blobStore.getBlobsByHashes([blobHash, blobHash]);
 
     // Implementation may return duplicates or deduplicate - both are valid
     expect(retrievedBlobs.length).toBeGreaterThanOrEqual(1);
-    expect(retrievedBlobs[0].blob).toEqual(blob);
+    expect(retrievedBlobs[0]).toEqual(blob);
   });
 
   it('should overwrite blob when storing with same hash', async () => {
@@ -117,21 +94,17 @@ export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
     const blob1 = Blob.fromFields(fields);
     const blob2 = Blob.fromFields(fields);
 
-    // Store with different indices
-    const blobWithIndex1 = new BlobWithIndex(blob1, 0);
-    const blobWithIndex2 = new BlobWithIndex(blob2, 5);
-
     const blobHash = blob1.getEthVersionedBlobHash();
 
     // Store first blob
-    await blobStore.addBlobs([blobWithIndex1]);
+    await blobStore.addBlobs([blob1]);
 
-    // Overwrite with second blob (same hash, different index)
-    await blobStore.addBlobs([blobWithIndex2]);
+    // Overwrite with second blob (same hash)
+    await blobStore.addBlobs([blob2]);
 
-    // Retrieve and verify it's the second blob (with index 5)
+    // Retrieve and verify it exists
     const retrievedBlobs = await blobStore.getBlobsByHashes([blobHash]);
     expect(retrievedBlobs.length).toBe(1);
-    expect(retrievedBlobs[0].index).toBe(5);
+    expect(retrievedBlobs[0]).toEqual(blob1); // Same content
   });
 }

package/src/blobstore/interface.ts

@@ -1,12 +1,12 @@
-import type { BlobWithIndex } from '../types/index.js';
+import type { Blob } from '@aztec/blob-lib';
 
 export interface BlobStore {
   /**
    * Get blobs by their hashes
    */
-  getBlobsByHashes: (blobHashes: Buffer[]) => Promise<BlobWithIndex[]>;
+  getBlobsByHashes: (blobHashes: Buffer[]) => Promise<Blob[]>;
   /**
    * Add blobs to the store, indexed by their hashes
    */
-  addBlobs: (blobs: BlobWithIndex[]) => Promise<void>;
+  addBlobs: (blobs: Blob[]) => Promise<void>;
 }

package/src/blobstore/memory_blob_store.ts

@@ -1,28 +1,28 @@
+import { Blob } from '@aztec/blob-lib';
 import { bufferToHex } from '@aztec/foundation/string';
 
-import { BlobWithIndex } from '../types/index.js';
 import type { BlobStore } from './interface.js';
 
 export class MemoryBlobStore implements BlobStore {
   private blobs: Map<string, Buffer> = new Map();
 
-  public getBlobsByHashes(blobHashes: Buffer[]): Promise<BlobWithIndex[]> {
-    const results: BlobWithIndex[] = [];
+  public getBlobsByHashes(blobHashes: Buffer[]): Promise<Blob[]> {
+    const results: Blob[] = [];
 
     for (const blobHash of blobHashes) {
       const key = bufferToHex(blobHash);
       const blobBuffer = this.blobs.get(key);
       if (blobBuffer) {
-        results.push(BlobWithIndex.fromBuffer(blobBuffer));
+        results.push(Blob.fromBuffer(blobBuffer));
       }
     }
 
     return Promise.resolve(results);
   }
 
-  public addBlobs(blobs: BlobWithIndex[]): Promise<void> {
+  public addBlobs(blobs: Blob[]): Promise<void> {
     for (const blob of blobs) {
-      const blobHash = blob.blob.getEthVersionedBlobHash();
+      const blobHash = blob.getEthVersionedBlobHash();
       const key = bufferToHex(blobHash);
       this.blobs.set(key, blob.toBuffer());
     }

package/src/client/http.ts

@@ -9,7 +9,6 @@ import { type RpcBlock, createPublicClient, fallback, http } from 'viem';
 import { createBlobArchiveClient } from '../archive/factory.js';
 import type { BlobArchiveClient } from '../archive/interface.js';
 import type { FileStoreBlobClient } from '../filestore/filestore_blob_client.js';
-import { BlobWithIndex } from '../types/blob_with_index.js';
 import { type BlobClientConfig, getBlobClientConfigFromEnv } from './config.js';
 import type { BlobClientInterface, GetBlobSidecarOptions } from './interface.js';
 
@@ -31,7 +30,7 @@ export class HttpBlobClient implements BlobClientInterface {
       fileStoreClients?: FileStoreBlobClient[];
       fileStoreUploadClient?: FileStoreBlobClient;
       /** Callback fired when blobs are successfully fetched from any source */
-      onBlobsFetched?: (blobs: BlobWithIndex[]) => void;
+      onBlobsFetched?: (blobs: Blob[]) => void;
     } = {},
   ) {
     this.config = config ?? getBlobClientConfigFromEnv();
@@ -62,7 +61,7 @@ export class HttpBlobClient implements BlobClientInterface {
    * Upload fetched blobs to filestore (fire-and-forget).
    * Called automatically when blobs are fetched from any source.
    */
-  private uploadBlobsToFileStore(blobs: BlobWithIndex[]): void {
+  private uploadBlobsToFileStore(blobs: Blob[]): void {
     if (!this.fileStoreUploadClient) {
       return;
     }
@@ -186,16 +185,14 @@ export class HttpBlobClient implements BlobClientInterface {
    *
    * @param blockHash - The block hash
    * @param blobHashes - The blob hashes to fetch
-   * @param indices - The indices of the blobs to get
    * @param opts - Options including isHistoricalSync flag
    * @returns The blobs
    */
   public async getBlobSidecar(
     blockHash: `0x${string}`,
     blobHashes: Buffer[],
-    indices?: number[],
     opts?: GetBlobSidecarOptions,
-  ): Promise<BlobWithIndex[]> {
+  ): Promise<Blob[]> {
     if (this.disabled) {
       this.log.warn('Blob storage is disabled, returning empty blob sidecar');
       return [];
@@ -204,7 +201,7 @@ export class HttpBlobClient implements BlobClientInterface {
     const isHistoricalSync = opts?.isHistoricalSync ?? false;
     // Accumulate blobs across sources, preserving order and handling duplicates
     // resultBlobs[i] will contain the blob for blobHashes[i], or undefined if not yet found
-    const resultBlobs: (BlobWithIndex | undefined)[] = new Array(blobHashes.length).fill(undefined);
+    const resultBlobs: (Blob | undefined)[] = new Array(blobHashes.length).fill(undefined);
 
     // Helper to get  missing blob hashes that we still need to fetch
     const getMissingBlobHashes = (): Buffer[] =>
@@ -213,10 +210,10 @@ export class HttpBlobClient implements BlobClientInterface {
         .filter((bh): bh is Buffer => bh !== undefined);
 
     // Return the result, ignoring any undefined ones
-    const getFilledBlobs = (): BlobWithIndex[] => resultBlobs.filter((b): b is BlobWithIndex => b !== undefined);
+    const getFilledBlobs = (): Blob[] => resultBlobs.filter((b): b is Blob => b !== undefined);
 
     // Helper to fill in results from fetched blobs
-    const fillResults = (fetchedBlobs: BlobJson[]): BlobWithIndex[] => {
+    const fillResults = (fetchedBlobs: BlobJson[]): Blob[] => {
       const blobs = processFetchedBlobs(fetchedBlobs, blobHashes, this.log);
       // Fill in any missing positions with matching blobs
       for (let i = 0; i < blobHashes.length; i++) {
@@ -228,7 +225,7 @@ export class HttpBlobClient implements BlobClientInterface {
     };
 
     // Fire callback when returning blobs (fire-and-forget)
-    const returnWithCallback = (blobs: BlobWithIndex[]): BlobWithIndex[] => {
+    const returnWithCallback = (blobs: Blob[]): Blob[] => {
       if (blobs.length > 0 && this.opts.onBlobsFetched) {
         void Promise.resolve().then(() => this.opts.onBlobsFetched!(blobs));
       }
@@ -237,7 +234,7 @@ export class HttpBlobClient implements BlobClientInterface {
 
     const { l1ConsensusHostUrls } = this.config;
 
-    const ctx = { blockHash, blobHashes: blobHashes.map(bufferToHex), indices };
+    const ctx = { blockHash, blobHashes: blobHashes.map(bufferToHex) };
 
     // Try filestore (quick, no retries) - useful for both historical and near-tip sync
     if (this.fileStoreClients.length > 0 && getMissingBlobHashes().length > 0) {
@@ -269,7 +266,7 @@ export class HttpBlobClient implements BlobClientInterface {
             l1ConsensusHostUrl,
             ...ctx,
           });
-          const blobs = await this.getBlobsFromHost(l1ConsensusHostUrl, slotNumber, indices, l1ConsensusHostIndex);
+          const blobs = await this.getBlobsFromHost(l1ConsensusHostUrl, slotNumber, l1ConsensusHostIndex);
           const result = fillResults(blobs);
           this.log.debug(
             `Got ${blobs.length} blobs from consensus host (total: ${result.length}/${blobHashes.length})`,
@@ -346,8 +343,8 @@ export class HttpBlobClient implements BlobClientInterface {
    */
   private async tryFileStores(
     getMissingBlobHashes: () => Buffer[],
-    fillResults: (blobs: BlobJson[]) => BlobWithIndex[],
-    ctx: { blockHash: string; blobHashes: string[]; indices?: number[] },
+    fillResults: (blobs: BlobJson[]) => Blob[],
+    ctx: { blockHash: string; blobHashes: string[] },
   ): Promise<void> {
     // Shuffle clients for load distribution
     const shuffledClients = [...this.fileStoreClients];
@@ -386,21 +383,19 @@ export class HttpBlobClient implements BlobClientInterface {
     hostUrl: string,
     blockHashOrSlot: string | number,
     blobHashes: Buffer[] = [],
-    indices: number[] = [],
     l1ConsensusHostIndex?: number,
-  ): Promise<BlobWithIndex[]> {
-    const blobs = await this.getBlobsFromHost(hostUrl, blockHashOrSlot, indices, l1ConsensusHostIndex);
-    return processFetchedBlobs(blobs, blobHashes, this.log).filter((b): b is BlobWithIndex => b !== undefined);
+  ): Promise<Blob[]> {
+    const blobs = await this.getBlobsFromHost(hostUrl, blockHashOrSlot, l1ConsensusHostIndex);
+    return processFetchedBlobs(blobs, blobHashes, this.log).filter((b): b is Blob => b !== undefined);
   }
 
   public async getBlobsFromHost(
     hostUrl: string,
     blockHashOrSlot: string | number,
-    indices: number[] = [],
     l1ConsensusHostIndex?: number,
   ): Promise<BlobJson[]> {
     try {
-      let res = await this.fetchBlobSidecars(hostUrl, blockHashOrSlot, indices, l1ConsensusHostIndex);
+      let res = await this.fetchBlobSidecars(hostUrl, blockHashOrSlot, l1ConsensusHostIndex);
       if (res.ok) {
         return parseBlobJsonsFromResponse(await res.json(), this.log);
       }
@@ -416,8 +411,8 @@ export class HttpBlobClient implements BlobClientInterface {
         let maxRetries = 10;
         let currentSlot = blockHashOrSlot + 1;
         while (res.status === 404 && maxRetries > 0 && latestSlot !== undefined && currentSlot <= latestSlot) {
-          this.log.debug(`Trying slot ${currentSlot} for blob indices ${indices.join(', ')}`);
-          res = await this.fetchBlobSidecars(hostUrl, currentSlot, indices, l1ConsensusHostIndex);
+          this.log.debug(`Trying slot ${currentSlot}`);
+          res = await this.fetchBlobSidecars(hostUrl, currentSlot, l1ConsensusHostIndex);
           if (res.ok) {
             return parseBlobJsonsFromResponse(await res.json(), this.log);
           }
@@ -441,13 +436,9 @@ export class HttpBlobClient implements BlobClientInterface {
   private fetchBlobSidecars(
     hostUrl: string,
     blockHashOrSlot: string | number,
-    indices: number[],
     l1ConsensusHostIndex?: number,
   ): Promise<Response> {
-    let baseUrl = `${hostUrl}/eth/v1/beacon/blob_sidecars/${blockHashOrSlot}`;
-    if (indices.length > 0) {
-      baseUrl += `?indices=${indices.join(',')}`;
-    }
+    const baseUrl = `${hostUrl}/eth/v1/beacon/blob_sidecars/${blockHashOrSlot}`;
 
     const { url, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
     this.log.debug(`Fetching blob sidecar for ${blockHashOrSlot}`, { url, ...options });
@@ -549,6 +540,11 @@ export class HttpBlobClient implements BlobClientInterface {
 
     return undefined;
   }
+
+  /** @internal - exposed for testing */
+  public getArchiveClient(): BlobArchiveClient | undefined {
+    return this.archiveClient;
+  }
 }
 
 function parseBlobJsonsFromResponse(response: any, logger: Logger): BlobJson[] {
@@ -564,28 +560,28 @@ function parseBlobJsonsFromResponse(response: any, logger: Logger): BlobJson[] {
 // Blobs will be in this form when requested from the blob client, or from the beacon chain via `getBlobSidecars`:
 // https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlobSidecars
 // Here we attempt to parse the response data to Buffer, and check the lengths (via Blob's constructor), to avoid
-// throwing an error down the line when calling BlobWithIndex.fromJson().
+// throwing an error down the line when calling Blob.fromJson().
 function parseBlobJson(data: any): BlobJson {
   const blobBuffer = Buffer.from(data.blob.slice(2), 'hex');
   const commitmentBuffer = Buffer.from(data.kzg_commitment.slice(2), 'hex');
   const blob = new Blob(blobBuffer, commitmentBuffer);
-  return blob.toJson(parseInt(data.index));
+  return blob.toJSON();
 }
 
-// Returns an array that maps each blob hash to the corresponding blob with index, or undefined if the blob is not found
+// Returns an array that maps each blob hash to the corresponding blob, or undefined if the blob is not found
 // or the data does not match the commitment.
-function processFetchedBlobs(blobs: BlobJson[], blobHashes: Buffer[], logger: Logger): (BlobWithIndex | undefined)[] {
+function processFetchedBlobs(blobs: BlobJson[], blobHashes: Buffer[], logger: Logger): (Blob | undefined)[] {
   const requestedBlobHashes = new Set<string>(blobHashes.map(bufferToHex));
-  const hashToBlob = new Map<string, BlobWithIndex>();
-  for (const blob of blobs) {
-    const hashHex = bufferToHex(computeEthVersionedBlobHash(hexToBuffer(blob.kzg_commitment)));
+  const hashToBlob = new Map<string, Blob>();
+  for (const blobJson of blobs) {
+    const hashHex = bufferToHex(computeEthVersionedBlobHash(hexToBuffer(blobJson.kzg_commitment)));
     if (!requestedBlobHashes.has(hashHex) || hashToBlob.has(hashHex)) {
       continue;
     }
 
     try {
-      const blobWithIndex = BlobWithIndex.fromJson(blob);
-      hashToBlob.set(hashHex, blobWithIndex);
+      const blob = Blob.fromJson(blobJson);
+      hashToBlob.set(hashHex, blob);
     } catch (err) {
       // If the above throws, it's likely that the blob commitment does not match the hash of the blob data.
       logger.error(`Error converting blob from json`, err);

package/src/client/interface.ts

@@ -1,7 +1,5 @@
 import type { Blob } from '@aztec/blob-lib';
 
-import type { BlobWithIndex } from '../types/blob_with_index.js';
-
 /**
  * Options for getBlobSidecar method.
  */
@@ -18,13 +16,8 @@ export interface GetBlobSidecarOptions {
 export interface BlobClientInterface {
   /** Sends the given blobs to the filestore, to be indexed by blob hash. */
   sendBlobsToFilestore(blobs: Blob[]): Promise<boolean>;
-  /** Fetches the given blob sidecars by block, hash, and indices. */
-  getBlobSidecar(
-    blockId: string,
-    blobHashes?: Buffer[],
-    indices?: number[],
-    opts?: GetBlobSidecarOptions,
-  ): Promise<BlobWithIndex[]>;
+  /** Fetches the given blob sidecars by block hash and blob hashes. */
+  getBlobSidecar(blockId: string, blobHashes?: Buffer[], opts?: GetBlobSidecarOptions): Promise<Blob[]>;
   /** Tests all configured blob sources and logs whether they are reachable or not. */
   testSources(): Promise<void>;
 }

package/src/client/local.ts

@@ -1,7 +1,6 @@
 import type { Blob } from '@aztec/blob-lib';
 
 import type { BlobStore } from '../blobstore/index.js';
-import { BlobWithIndex } from '../types/blob_with_index.js';
 import type { BlobClientInterface, GetBlobSidecarOptions } from './interface.js';
 
 export class LocalBlobClient implements BlobClientInterface {
@@ -16,17 +15,11 @@ export class LocalBlobClient implements BlobClientInterface {
   }
 
   public async sendBlobsToFilestore(blobs: Blob[]): Promise<boolean> {
-    const blobsWithIndex = blobs.map((blob, index) => new BlobWithIndex(blob, index));
-    await this.blobStore.addBlobs(blobsWithIndex);
+    await this.blobStore.addBlobs(blobs);
     return true;
   }
 
-  public getBlobSidecar(
-    _blockId: string,
-    blobHashes: Buffer[],
-    _indices?: number[],
-    _opts?: GetBlobSidecarOptions,
-  ): Promise<BlobWithIndex[]> {
+  public getBlobSidecar(_blockId: string, blobHashes: Buffer[], _opts?: GetBlobSidecarOptions): Promise<Blob[]> {
     return this.blobStore.getBlobsByHashes(blobHashes);
   }
 }

package/src/client/tests.ts

@@ -35,7 +35,7 @@ export function runBlobClientTests(
 
     const retrievedBlobs = await client.getBlobSidecar(blockId, [blobHash]);
     expect(retrievedBlobs).toHaveLength(1);
-    expect(retrievedBlobs[0].blob).toEqual(blob);
+    expect(retrievedBlobs[0]).toEqual(blob);
   });
 
   it('should handle multiple blobs', async () => {
@@ -48,7 +48,7 @@ export function runBlobClientTests(
     expect(retrievedBlobs.length).toBe(3);
 
     for (let i = 0; i < blobs.length; i++) {
-      expect(retrievedBlobs[i].blob).toEqual(blobs[i]);
+      expect(retrievedBlobs[i]).toEqual(blobs[i]);
     }
   });
 
@@ -59,20 +59,4 @@ export function runBlobClientTests(
     const retrievedBlobs = await client.getBlobSidecar(blockId, [nonExistentHash]);
     expect(retrievedBlobs).toEqual([]);
   });
-
-  it('should preserve blob indices', async () => {
-    const blobs = Array.from({ length: 3 }, () => makeRandomBlob(7));
-    const blobHashes = blobs.map(blob => blob.getEthVersionedBlobHash());
-
-    await client.sendBlobsToFilestore(blobs);
-
-    const retrievedBlobs = await client.getBlobSidecar(blockId, blobHashes);
-    expect(retrievedBlobs.length).toBe(blobs.length);
-
-    // Indices should be assigned sequentially based on the order they were sent
-    for (let i = 0; i < blobs.length; i++) {
-      expect(retrievedBlobs[i].blob).toEqual(blobs[i]);
-      expect(retrievedBlobs[i].index).toBe(i);
-    }
-  });
 }

package/src/filestore/filestore_blob_client.ts

@@ -3,7 +3,6 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { FileStore, ReadOnlyFileStore } from '@aztec/stdlib/file-store';
 
 import { inboundTransform, outboundTransform } from '../encoding/index.js';
-import { BlobWithIndex } from '../types/blob_with_index.js';
 
 /**
  * A blob client that uses a FileStore (S3/GCS/local) as the data source.
@@ -45,8 +44,7 @@ export class FileStoreBlobClient {
 
         const data = await this.store.read(path);
         const json = JSON.parse(inboundTransform(data).toString()) as BlobJson;
-        // We don't know the actual index when fetching from filestore - use -1 to indicate this deliberately
-        blobs.push({ ...json, index: '-1' });
+        blobs.push(json);
       } catch (err) {
         this.log.warn(`Failed to read blob ${blobHashes[i]} from filestore`, err);
       }
@@ -81,8 +79,7 @@ export class FileStoreBlobClient {
       return;
     }
 
-    // index=-1 is deliberate as we don't know the actual blob index in most cases when the filestores are used (blobs are saved in the filestores before we ever fetch them from L1)
-    const json = blob.toJson(-1);
+    const json = blob.toJSON();
     await (this.store as FileStore).save(
       this.blobPath(versionedHash),
       outboundTransform(Buffer.from(JSON.stringify(json))),
@@ -92,16 +89,11 @@ export class FileStoreBlobClient {
 
   /**
    * Save multiple blobs to the store in parallel.
-   * @param blobs - The blobs to save (either Blob[] or BlobWithIndex[])
+   * @param blobs - The blobs to save
    * @param skipIfExists - Skip saving if blob already exists (default: true)
    */
-  async saveBlobs(blobs: Blob[] | BlobWithIndex[], skipIfExists = true): Promise<void> {
-    await Promise.all(
-      blobs.map(b => {
-        const blob = 'blob' in b ? b.blob : b;
-        return this.saveBlob(blob, skipIfExists);
-      }),
-    );
+  async saveBlobs(blobs: Blob[], skipIfExists = true): Promise<void> {
+    await Promise.all(blobs.map(blob => this.saveBlob(blob, skipIfExists)));
   }
 
   /**