Removing blob index

Author: mrzeszutko

yarn-project/archiver/src/archiver/archiver.test.ts

@@ -1,6 +1,5 @@
 import type { BlobClientInterface } from '@aztec/blob-client/client';
-import { BlobWithIndex } from '@aztec/blob-client/types';
-import { getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
+import { type Blob, getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
 import { makeRandomBlob } from '@aztec/blob-lib/testing';
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import type { EpochCache, EpochCommitteeInfo } from '@aztec/epoch-cache';
@@ -199,7 +198,7 @@ describe('Archiver', () => {
   // REFACTOR: we should have a single method that creates all these artifacts, as well as the l2 proposed event
   let allRollupTxs: Map<`0x${string}`, Transaction>;
   let allVersionedBlobHashes: Map<`0x${string}`, `0x${string}`[]>;
-  let allBlobs: Map<`0x${string}`, BlobWithIndex[]>;
+  let allBlobs: Map<`0x${string}`, Blob[]>;
 
   let logger: Logger;
 
@@ -1207,8 +1206,8 @@ describe('Archiver', () => {
 
     mockRollup.read.status.mockResolvedValue([0n, GENESIS_ROOT, 1n, checkpoint.archive.root.toString(), GENESIS_ROOT]);
 
-    const randomBlob = new BlobWithIndex(makeRandomBlob(3), 0);
-    const randomBlobHash = randomBlob.blob.getEthVersionedBlobHash();
+    const randomBlob = makeRandomBlob(3);
+    const randomBlobHash = randomBlob.getEthVersionedBlobHash();
 
     makeCheckpointProposedEvent(70n, checkpoint.number, checkpoint.archive.root.toString(), [
       `0x${randomBlobHash.toString()}`,
@@ -2023,7 +2022,7 @@ describe('Archiver', () => {
    */
   const makeBlobsFromCheckpoint = (checkpoint: Checkpoint) => {
     const blobFields = checkpoint.toBlobFields();
-    const blobs = getBlobsPerL1Block(blobFields).map((blob, index) => new BlobWithIndex(blob, index));
+    const blobs = getBlobsPerL1Block(blobFields);
     allBlobs.set(checkpoint.archive.root.toString(), blobs);
     return blobs;
   };

yarn-project/archiver/src/archiver/l1/data_retrieval.ts

@@ -331,15 +331,15 @@ export async function getCheckpointBlobDataFromBlobs(
   logger: Logger,
   isHistoricalSync: boolean,
 ): Promise<CheckpointBlobData> {
-  const blobBodies = await blobClient.getBlobSidecar(blockHash, blobHashes, undefined, { isHistoricalSync });
+  const blobBodies = await blobClient.getBlobSidecar(blockHash, blobHashes, { isHistoricalSync });
   if (blobBodies.length === 0) {
     throw new NoBlobBodiesFoundError(checkpointNumber);
   }
 
   let checkpointBlobData: CheckpointBlobData;
   try {
     // Attempt to decode the checkpoint blob data.
-    checkpointBlobData = decodeCheckpointBlobDataFromBlobs(blobBodies.map(b => b.blob));
+    checkpointBlobData = decodeCheckpointBlobDataFromBlobs(blobBodies);
   } catch (err: any) {
     if (err instanceof BlobDeserializationError) {
       logger.fatal(err.message);

yarn-project/blob-client/package.json

@@ -7,7 +7,6 @@
     "./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": [

yarn-project/blob-client/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,
+        })),
+      ),
     ),
 );
 

yarn-project/blob-client/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
   });
 }

yarn-project/blob-client/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>;
 }

yarn-project/blob-client/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());
     }