@aztec/blob-client 3.0.0-nightly.20251223

package/README.md

@@ -0,0 +1,62 @@
+## Blob Client
+
+A client library for storing and retrieving blob data from various sources.
+
+## When is this used?
+
+The blob client is used by nodes to store and retrieve blob data that accompanies `propose` transactions on L1.
+
+### Why?
+
+Blob data is only available in the L1 consensus layer for a limited period (~3 weeks). The blob client provides a unified interface for:
+- Fetching blobs from L1 consensus layer (beacon nodes)
+- Storing/retrieving blobs from file stores (local files, S3, GCS)
+- Caching blobs locally for faster access
+
+### How?
+
+The blob client supports multiple blob sources:
+1. **File Store**: Local filesystem (`file://`), S3 (`s3://`), or GCS (`gs://`)
+2. **L1 Consensus**: Beacon node API for recent blobs
+3. **Archive**: Blobscan API for historical blobs
+
+### Configurations
+
+**File Store URLs** (`BLOB_FILE_STORE_URLS`):
+Comma-separated list of URLs to read blobs from. Tried in order until blobs are found.
+
+**File Store Upload URL** (`BLOB_FILE_STORE_UPLOAD_URL`):
+URL for uploading blobs to a file store.
+
+**L1 Consensus Host URLs** (`L1_CONSENSUS_HOST_URLS`):
+Beacon node URLs for fetching recent blobs directly from L1.
+
+**Archive API URL** (`BLOB_SINK_ARCHIVE_API_URL`):
+Blobscan or similar archive API for historical blob data.
+
+### Example Usage
+
+```typescript
+import { createBlobClient, createBlobClientWithFileStores } from '@aztec/blob-client/client';
+
+// Simple client with L1 consensus and archive sources
+const client = createBlobClient({
+  l1ConsensusHostUrls: ['https://beacon.example.com'],
+  archiveApiUrl: 'https://api.blobscan.com',
+});
+
+// Client with file store support
+const clientWithFileStore = await createBlobClientWithFileStores({
+  l1ChainId: 1,
+  rollupVersion: 1,
+  l1Contracts: { rollupAddress: { toString: () => '0x...' } },
+  blobFileStoreUrls: ['s3://bucket/blobs', 'file:///local/blobs'],
+  blobFileStoreUploadUrl: 's3://bucket/blobs',
+});
+
+// Fetch blobs
+const blobs = await client.getBlobSidecar(blockHash, blobHashes);
+
+// Upload blobs to file store
+await client.sendBlobsToFilestore(blobs);
+```

package/dest/archive/blobscan_archive_client.d.ts

@@ -0,0 +1,147 @@
+import type { BlobJson } from '@aztec/blob-lib/types';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { z } from 'zod';
+import type { BlobArchiveClient } from './interface.js';
+export declare const BlobscanBlockResponseSchema: z.ZodEffects<z.ZodObject<{
+    hash: z.ZodString;
+    slot: z.ZodNumber;
+    number: z.ZodNumber;
+    transactions: z.ZodArray<z.ZodObject<{
+        hash: z.ZodString;
+        blobs: z.ZodArray<z.ZodObject<{
+            versionedHash: z.ZodString;
+            data: z.ZodString;
+            commitment: z.ZodString;
+            proof: z.ZodString;
+            size: z.ZodNumber;
+            index: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            versionedHash: string;
+            data: string;
+            commitment: string;
+            proof: string;
+            size: number;
+            index?: number | undefined;
+        }, {
+            versionedHash: string;
+            data: string;
+            commitment: string;
+            proof: string;
+            size: number;
+            index?: number | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        hash: string;
+        blobs: {
+            versionedHash: string;
+            data: string;
+            commitment: string;
+            proof: string;
+            size: number;
+            index?: number | undefined;
+        }[];
+    }, {
+        hash: string;
+        blobs: {
+            versionedHash: string;
+            data: string;
+            commitment: string;
+            proof: string;
+            size: number;
+            index?: number | undefined;
+        }[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    hash: string;
+    slot: number;
+    number: number;
+    transactions: {
+        hash: string;
+        blobs: {
+            versionedHash: string;
+            data: string;
+            commitment: string;
+            proof: string;
+            size: number;
+            index?: number | undefined;
+        }[];
+    }[];
+}, {
+    hash: string;
+    slot: number;
+    number: number;
+    transactions: {
+        hash: string;
+        blobs: {
+            versionedHash: string;
+            data: string;
+            commitment: string;
+            proof: string;
+            size: number;
+            index?: number | undefined;
+        }[];
+    }[];
+}>, {
+    blob: string;
+    kzg_commitment: string;
+    index: string;
+}[], {
+    hash: string;
+    slot: number;
+    number: number;
+    transactions: {
+        hash: string;
+        blobs: {
+            versionedHash: string;
+            data: string;
+            commitment: string;
+            proof: string;
+            size: number;
+            index?: number | undefined;
+        }[];
+    }[];
+}>;
+export declare const BlobscanBlocksResponseSchema: z.ZodObject<{
+    blocks: z.ZodArray<z.ZodObject<{
+        hash: z.ZodString;
+        slot: z.ZodNumber;
+        number: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        hash: string;
+        slot: number;
+        number: number;
+    }, {
+        hash: string;
+        slot: number;
+        number: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    blocks: {
+        hash: string;
+        slot: number;
+        number: number;
+    }[];
+}, {
+    blocks: {
+        hash: string;
+        slot: number;
+        number: number;
+    }[];
+}>;
+export declare class BlobscanArchiveClient implements BlobArchiveClient {
+    private readonly logger;
+    private readonly fetchOpts;
+    private readonly fetch;
+    private readonly baseUrl;
+    private instrumentation;
+    constructor(baseUrl: string, telemetry?: TelemetryClient);
+    getLatestBlock(): Promise<{
+        hash: string;
+        number: number;
+        slot: number;
+    }>;
+    getBaseUrl(): string;
+    getBlobsFromBlock(blockId: string): Promise<BlobJson[] | undefined>;
+    getBlobData(id: string): Promise<Buffer | undefined>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvYnNjYW5fYXJjaGl2ZV9jbGllbnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcmNoaXZlL2Jsb2JzY2FuX2FyY2hpdmVfY2xpZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBSXRELE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0IsTUFBTSx5QkFBeUIsQ0FBQztBQUVuRixPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBR3hCLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFeEQsZUFBTyxNQUFNLDJCQUEyQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFpQ3ZDLENBQUM7QUFHRixlQUFPLE1BQU0sNEJBQTRCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztFQVF2QyxDQUFDO0FBRUgscUJBQWEscUJBQXNCLFlBQVcsaUJBQWlCO0lBQzdELE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUF1RDtJQUM5RSxPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBK0M7SUFDekUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBU3BCO0lBRUYsT0FBTyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQU07SUFFOUIsT0FBTyxDQUFDLGVBQWUsQ0FBbUM7SUFFMUQsWUFBWSxPQUFPLEVBQUUsTUFBTSxFQUFFLFNBQVMsR0FBRSxlQUFzQyxFQVU3RTtJQUVZLGNBQWMsSUFBSSxPQUFPLENBQUM7UUFBRSxJQUFJLEVBQUUsTUFBTSxDQUFDO1FBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQztRQUFDLElBQUksRUFBRSxNQUFNLENBQUE7S0FBRSxDQUFDLENBMkJyRjtJQUVNLFVBQVUsSUFBSSxNQUFNLENBRTFCO0lBRVksaUJBQWlCLENBQUMsT0FBTyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsUUFBUSxFQUFFLEdBQUcsU0FBUyxDQUFDLENBNEIvRTtJQUVZLFdBQVcsQ0FBQyxFQUFFLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBMEJoRTtDQUNGIn0=

package/dest/archive/blobscan_archive_client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobscan_archive_client.d.ts","sourceRoot":"","sources":["../../src/archive/blobscan_archive_client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItD,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCvC,CAAC;AAGF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;EAQvC,CAAC;AAEH,qBAAa,qBAAsB,YAAW,iBAAiB;IAC7D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuD;IAC9E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+C;IACzE,OAAO,CAAC,QAAQ,CAAC,KAAK,CASpB;IAEF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAM;IAE9B,OAAO,CAAC,eAAe,CAAmC;IAE1D,YAAY,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,eAAsC,EAU7E;IAEY,cAAc,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CA2BrF;IAEM,UAAU,IAAI,MAAM,CAE1B;IAEY,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,GAAG,SAAS,CAAC,CA4B/E;IAEY,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA0BhE;CACF"}

package/dest/archive/blobscan_archive_client.js

@@ -0,0 +1,141 @@
+import { createLogger } from '@aztec/foundation/log';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { z } from 'zod';
+import { BlobArchiveClientInstrumentation } from './instrumentation.js';
+export const BlobscanBlockResponseSchema = zodFor()(z.object({
+    hash: z.string(),
+    slot: z.number().int(),
+    number: z.number().int(),
+    transactions: z.array(z.object({
+        hash: z.string(),
+        blobs: z.array(z.object({
+            versionedHash: z.string(),
+            data: z.string(),
+            commitment: z.string(),
+            proof: z.string(),
+            size: z.number().int(),
+            index: z.number().int().optional()
+        }))
+    }))
+}).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()
+        }))));
+// Response from https://api.blobscan.com/blocks?sort=desc&type=canonical
+export const BlobscanBlocksResponseSchema = z.object({
+    blocks: z.array(z.object({
+        hash: z.string(),
+        slot: z.number().int(),
+        number: z.number().int()
+    }))
+});
+export class BlobscanArchiveClient {
+    logger = createLogger('blob-client:blobscan-archive-client');
+    fetchOpts = {
+        headers: {
+            accept: 'application/json'
+        }
+    };
+    fetch = async (...args)=>{
+        return await retry(()=>fetch(...args), // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        `Fetching ${args[0]}`, makeBackoff([
+            1,
+            1,
+            3
+        ]), this.logger, /*failSilently=*/ false);
+    };
+    baseUrl;
+    instrumentation;
+    constructor(baseUrl, telemetry = getTelemetryClient()){
+        this.baseUrl = new URL(baseUrl);
+        if (this.baseUrl.protocol !== 'https:') {
+            throw new TypeError('BaseURL must be secure: ' + baseUrl);
+        }
+        this.instrumentation = new BlobArchiveClientInstrumentation(telemetry, this.baseUrl.origin, 'BlobscanArchiveClient');
+    }
+    async getLatestBlock() {
+        const url = new URL('blocks', this.baseUrl);
+        url.searchParams.set('sort', 'desc');
+        url.searchParams.set('type', 'canonical');
+        url.searchParams.set('p', '1');
+        url.searchParams.set('ps', '1');
+        this.logger.trace(`Fetching latest block from ${url.href}`);
+        const response = await this.fetch(url, this.fetchOpts);
+        if (response.status !== 200) {
+            throw new Error(`Failed to fetch latest block: ${response.statusText} (${response.status})`, {
+                cause: {
+                    httpResponse: {
+                        status: response.status,
+                        body: await response.text().catch(()=>'Failed to read response body')
+                    }
+                }
+            });
+        }
+        const parsed = await response.json().then((data)=>BlobscanBlocksResponseSchema.parse(data));
+        if (parsed.blocks.length === 0) {
+            throw new Error(`No blocks found at ${this.baseUrl}`);
+        }
+        return parsed.blocks[0];
+    }
+    getBaseUrl() {
+        return this.baseUrl.href;
+    }
+    async getBlobsFromBlock(blockId) {
+        const url = new URL(`blocks/${blockId}`, this.baseUrl);
+        url.searchParams.set('type', 'canonical');
+        url.searchParams.set('expand', 'blob,blob_data');
+        this.logger.trace(`Fetching blobs for block ${blockId} from ${url.href}`);
+        const response = await this.fetch(url, this.fetchOpts);
+        this.instrumentation.incRequest('blocks', response.status);
+        if (response.status === 404) {
+            this.logger.debug(`No blobs found for block ${blockId} at ${this.baseUrl}`);
+            return undefined;
+        } else if (response.status !== 200) {
+            throw new Error(`Failed to fetch blobs for block ${blockId}: ${response.statusText} (${response.status})`, {
+                cause: {
+                    httpResponse: {
+                        status: response.status,
+                        body: await response.text().catch(()=>'Failed to read response body')
+                    }
+                }
+            });
+        } else {
+            const result = await response.json().then((data)=>BlobscanBlockResponseSchema.parse(data));
+            this.logger.debug(`Fetched ${result.length} blobs for block ${blockId} from ${this.baseUrl}`);
+            this.instrumentation.incRetrievedBlobs(result.length);
+            return result;
+        }
+    }
+    async getBlobData(id) {
+        const url = new URL(`blobs/${id}/data`, this.baseUrl);
+        const response = await this.fetch(url, this.fetchOpts);
+        this.instrumentation.incRequest('blobs', response.status);
+        if (response.status === 404) {
+            return undefined;
+        } else if (response.status !== 200) {
+            throw new Error(`Failed to fetch blob data for blob ${id}: ${response.statusText} (${response.status})`, {
+                cause: {
+                    httpResponse: {
+                        status: response.status,
+                        body: await response.text().catch((err)=>{
+                            this.logger.warn('Failed to read response body', err);
+                            return '';
+                        })
+                    }
+                }
+            });
+        } else {
+            return await response.json().then((data)=>{
+                const blob = schemas.BufferHex.parse(data);
+                this.instrumentation.incRetrievedBlobs(1);
+                return blob;
+            });
+        }
+    }
+}

package/dest/archive/config.d.ts

@@ -0,0 +1,7 @@
+import { type L1ReaderConfig } from '@aztec/ethereum/l1-reader';
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+export type BlobArchiveApiConfig = {
+    archiveApiUrl?: string;
+} & Partial<Pick<L1ReaderConfig, 'l1ChainId'>>;
+export declare const blobArchiveApiConfigMappings: ConfigMappingsType<BlobArchiveApiConfig>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXJjaGl2ZS9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssY0FBYyxFQUEwQixNQUFNLDJCQUEyQixDQUFDO0FBQ3hGLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUFzQixNQUFNLDBCQUEwQixDQUFDO0FBRXZGLE1BQU0sTUFBTSxvQkFBb0IsR0FBRztJQUNqQyxhQUFhLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDeEIsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLGNBQWMsRUFBRSxXQUFXLENBQUMsQ0FBQyxDQUFDO0FBRS9DLGVBQU8sTUFBTSw0QkFBNEIsRUFBRSxrQkFBa0IsQ0FBQyxvQkFBb0IsQ0FNakYsQ0FBQyJ9

package/dest/archive/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/archive/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,2BAA2B,CAAC;AACxF,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,0BAA0B,CAAC;AAEvF,MAAM,MAAM,oBAAoB,GAAG;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC;AAE/C,eAAO,MAAM,4BAA4B,EAAE,kBAAkB,CAAC,oBAAoB,CAMjF,CAAC"}

package/dest/archive/config.js

@@ -0,0 +1,11 @@
+import { l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
+import { pickConfigMappings } from '@aztec/foundation/config';
+export const blobArchiveApiConfigMappings = {
+    archiveApiUrl: {
+        env: 'BLOB_SINK_ARCHIVE_API_URL',
+        description: 'The URL of the archive API'
+    },
+    ...pickConfigMappings(l1ReaderConfigMappings, [
+        'l1ChainId'
+    ])
+};

package/dest/archive/factory.d.ts

@@ -0,0 +1,4 @@
+import type { BlobClientConfig } from '../client/config.js';
+import type { BlobArchiveClient } from './interface.js';
+export declare function createBlobArchiveClient(config: BlobClientConfig): BlobArchiveClient | undefined;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FyY2hpdmUvZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRTVELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFeEQsd0JBQWdCLHVCQUF1QixDQUFDLE1BQU0sRUFBRSxnQkFBZ0IsR0FBRyxpQkFBaUIsR0FBRyxTQUFTLENBTS9GIn0=

package/dest/archive/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/archive/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,gBAAgB,GAAG,iBAAiB,GAAG,SAAS,CAM/F"}

package/dest/archive/factory.js

@@ -0,0 +1,7 @@
+import { BlobscanArchiveClient } from './blobscan_archive_client.js';
+export function createBlobArchiveClient(config) {
+    if (config.archiveApiUrl) {
+        return new BlobscanArchiveClient(config.archiveApiUrl);
+    }
+    return undefined;
+}

package/dest/archive/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interface.js';
+export * from './factory.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcmNoaXZlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxjQUFjLENBQUMifQ==

package/dest/archive/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/archive/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC"}

package/dest/archive/index.js

@@ -0,0 +1,2 @@
+export * from './interface.js';
+export * from './factory.js';

package/dest/archive/instrumentation.d.ts

@@ -0,0 +1,11 @@
+import { type TelemetryClient } from '@aztec/telemetry-client';
+export declare class BlobArchiveClientInstrumentation {
+    private httpHost;
+    private blockRequestCounter;
+    private blobRequestCounter;
+    private retrievedBlobs;
+    constructor(client: TelemetryClient, httpHost: string, name: string);
+    incRequest(type: 'blocks' | 'blobs', status: number): void;
+    incRetrievedBlobs(count: number): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1bWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXJjaGl2ZS9pbnN0cnVtZW50YXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUF1QixLQUFLLGVBQWUsRUFBaUMsTUFBTSx5QkFBeUIsQ0FBQztBQUVuSCxxQkFBYSxnQ0FBZ0M7SUFPekMsT0FBTyxDQUFDLFFBQVE7SUFObEIsT0FBTyxDQUFDLG1CQUFtQixDQUFnQjtJQUMzQyxPQUFPLENBQUMsa0JBQWtCLENBQWdCO0lBQzFDLE9BQU8sQ0FBQyxjQUFjLENBQWdCO0lBRXRDLFlBQ0UsTUFBTSxFQUFFLGVBQWUsRUFDZixRQUFRLEVBQUUsTUFBTSxFQUN4QixJQUFJLEVBQUUsTUFBTSxFQWlCYjtJQUVELFVBQVUsQ0FBQyxJQUFJLEVBQUUsUUFBUSxHQUFHLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxRQU1sRDtJQUVELGlCQUFpQixDQUFDLEtBQUssRUFBRSxNQUFNLFFBRTlCO0NBQ0YifQ==

package/dest/archive/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/archive/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,eAAe,EAAiC,MAAM,yBAAyB,CAAC;AAEnH,qBAAa,gCAAgC;IAOzC,OAAO,CAAC,QAAQ;IANlB,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,OAAO,CAAC,kBAAkB,CAAgB;IAC1C,OAAO,CAAC,cAAc,CAAgB;IAEtC,YACE,MAAM,EAAE,eAAe,EACf,QAAQ,EAAE,MAAM,EACxB,IAAI,EAAE,MAAM,EAiBb;IAED,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,QAMlD;IAED,iBAAiB,CAAC,KAAK,EAAE,MAAM,QAE9B;CACF"}

package/dest/archive/instrumentation.js

@@ -0,0 +1,33 @@
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+export class BlobArchiveClientInstrumentation {
+    httpHost;
+    blockRequestCounter;
+    blobRequestCounter;
+    retrievedBlobs;
+    constructor(client, httpHost, name){
+        this.httpHost = httpHost;
+        const meter = client.getMeter(name);
+        this.blockRequestCounter = meter.createUpDownCounter(Metrics.BLOB_SINK_ARCHIVE_BLOCK_REQUEST_COUNT, {
+            description: 'Number of requests made to retrieve blocks from the blob archive',
+            valueType: ValueType.INT
+        });
+        this.blobRequestCounter = meter.createUpDownCounter(Metrics.BLOB_SINK_ARCHIVE_BLOB_REQUEST_COUNT, {
+            description: 'Number of requests made to retrieve blobs from the blob archive',
+            valueType: ValueType.INT
+        });
+        this.retrievedBlobs = meter.createUpDownCounter(Metrics.BLOB_SINK_ARCHIVE_BLOB_COUNT, {
+            description: 'Number of blobs retrieved from the blob archive',
+            valueType: ValueType.INT
+        });
+    }
+    incRequest(type, status) {
+        const counter = type === 'blocks' ? this.blockRequestCounter : this.blobRequestCounter;
+        counter.add(1, {
+            [Attributes.HTTP_RESPONSE_STATUS_CODE]: status,
+            [Attributes.HTTP_REQUEST_HOST]: this.httpHost
+        });
+    }
+    incRetrievedBlobs(count) {
+        this.retrievedBlobs.add(count);
+    }
+}

package/dest/archive/interface.d.ts

@@ -0,0 +1,13 @@
+import type { BlobJson } from '@aztec/blob-lib/types';
+/** Interface to an blob archiving service. */
+export interface BlobArchiveClient {
+    getBlobData(id: string): Promise<Buffer | undefined>;
+    getBlobsFromBlock(blockId: string): Promise<BlobJson[] | undefined>;
+    getLatestBlock(): Promise<{
+        hash: string;
+        number: number;
+        slot: number;
+    }>;
+    getBaseUrl(): string;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXJjaGl2ZS9pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFdEQsOENBQThDO0FBQzlDLE1BQU0sV0FBVyxpQkFBaUI7SUFDaEMsV0FBVyxDQUFDLEVBQUUsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FBQztJQUNyRCxpQkFBaUIsQ0FBQyxPQUFPLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxRQUFRLEVBQUUsR0FBRyxTQUFTLENBQUMsQ0FBQztJQUNwRSxjQUFjLElBQUksT0FBTyxDQUFDO1FBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQztRQUFDLE1BQU0sRUFBRSxNQUFNLENBQUM7UUFBQyxJQUFJLEVBQUUsTUFBTSxDQUFBO0tBQUUsQ0FBQyxDQUFDO0lBQzFFLFVBQVUsSUFBSSxNQUFNLENBQUM7Q0FDdEIifQ==

package/dest/archive/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/archive/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEtD,8CAA8C;AAC9C,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACrD,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,GAAG,SAAS,CAAC,CAAC;IACpE,cAAc,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1E,UAAU,IAAI,MAAM,CAAC;CACtB"}

package/dest/archive/interface.js

@@ -0,0 +1 @@
+/** Interface to an blob archiving service. */ export { };

package/dest/blobstore/blob_store_test_suite.d.ts

@@ -0,0 +1,3 @@
+import type { BlobStore } from './interface.js';
+export declare function describeBlobStore(getBlobStore: () => Promise<BlobStore>): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvYl9zdG9yZV90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYmxvYnN0b3JlL2Jsb2Jfc3RvcmVfdGVzdF9zdWl0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVoRCx3QkFBZ0IsaUJBQWlCLENBQUMsWUFBWSxFQUFFLE1BQU0sT0FBTyxDQUFDLFNBQVMsQ0FBQyxRQWtJdkUifQ==

package/dest/blobstore/blob_store_test_suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob_store_test_suite.d.ts","sourceRoot":"","sources":["../../src/blobstore/blob_store_test_suite.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,QAkIvE"}

package/dest/blobstore/blob_store_test_suite.js

@@ -0,0 +1,164 @@
+import { Blob } from '@aztec/blob-lib';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BlobWithIndex } from '../types/index.js';
+export function describeBlobStore(getBlobStore) {
+    let blobStore;
+    beforeEach(async ()=>{
+        blobStore = await getBlobStore();
+    });
+    it('should store and retrieve a blob by hash', async ()=>{
+        // 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
+        ]);
+        // 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);
+    });
+    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
+        ]);
+        // 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);
+    });
+    it('should return empty array for non-existent blob hash', async ()=>{
+        // Create a random hash that doesn't exist
+        const nonExistentHash = Buffer.alloc(32);
+        nonExistentHash.fill(0xff);
+        const retrievedBlobs = await blobStore.getBlobsByHashes([
+            nonExistentHash
+        ]);
+        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)
+        ]);
+        // Retrieve only some of them
+        const blobHash1 = blob1.getEthVersionedBlobHash();
+        const blobHash3 = blob3.getEthVersionedBlobHash();
+        const retrievedBlobs = await blobStore.getBlobsByHashes([
+            blobHash1,
+            blobHash3
+        ]);
+        expect(retrievedBlobs.length).toBe(2);
+        expect(retrievedBlobs[0].blob).toEqual(blob1);
+        expect(retrievedBlobs[1].blob).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
+        ]);
+        // 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);
+    });
+    it('should overwrite blob when storing with same hash', async ()=>{
+        // Create two blobs that will have the same hash (same content)
+        const fields = [
+            Fr.random(),
+            Fr.random()
+        ];
+        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
+        ]);
+        // Overwrite with second blob (same hash, different index)
+        await blobStore.addBlobs([
+            blobWithIndex2
+        ]);
+        // Retrieve and verify it's the second blob (with index 5)
+        const retrievedBlobs = await blobStore.getBlobsByHashes([
+            blobHash
+        ]);
+        expect(retrievedBlobs.length).toBe(1);
+        expect(retrievedBlobs[0].index).toBe(5);
+    });
+}

package/dest/blobstore/index.d.ts

@@ -0,0 +1,3 @@
+export * from './memory_blob_store.js';
+export * from './interface.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ibG9ic3RvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGdCQUFnQixDQUFDIn0=