@aztec/blob-client 0.0.1-commit.3469e52 → 0.0.1-commit.35158ae7e

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

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/client/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,0EAA0E;IAC1E,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACtD,qEAAqE;IACrE,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACtG,6EAA6E;IAC7E,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,oFAAoF;IACpF,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,0DAA0D;IAC1D,IAAI,CAAC,IAAI,IAAI,CAAC;IACd,iEAAiE;IACjE,SAAS,IAAI,OAAO,CAAC;CACtB"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/client/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAmB;IAClC,0EAA0E;IAC1E,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACtD,qEAAqE;IACrE,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACtG,6EAA6E;IAC7E,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,oFAAoF;IACpF,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,0DAA0D;IAC1D,IAAI,CAAC,IAAI,IAAI,CAAC;IACd,iEAAiE;IACjE,SAAS,IAAI,OAAO,CAAC;CACtB"}

package/dest/client/tests.js

@@ -17,7 +17,7 @@ import { makeRandomBlob } from '@aztec/blob-lib/testing';
         await cleanup();
     });
     it('should send and retrieve blobs by hash', async ()=>{
-        const blob = makeRandomBlob(5);
+        const blob = await makeRandomBlob(5);
         const blobHash = blob.getEthVersionedBlobHash();
         await client.sendBlobsToFilestore([
             blob
@@ -29,9 +29,9 @@ import { makeRandomBlob } from '@aztec/blob-lib/testing';
         expect(retrievedBlobs[0]).toEqual(blob);
     });
     it('should handle multiple blobs', async ()=>{
-        const blobs = Array.from({
+        const blobs = await Promise.all(Array.from({
             length: 3
-        }, ()=>makeRandomBlob(7));
+        }, ()=>makeRandomBlob(7)));
         const blobHashes = blobs.map((blob)=>blob.getEthVersionedBlobHash());
         await client.sendBlobsToFilestore(blobs);
         const retrievedBlobs = await client.getBlobSidecar(blockId, blobHashes);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/blob-client",
-  "version": "0.0.1-commit.3469e52",
+  "version": "0.0.1-commit.35158ae7e",
   "type": "module",
   "bin": "./dest/client/bin/index.js",
   "exports": {
@@ -56,12 +56,12 @@
     ]
   },
   "dependencies": {
-    "@aztec/blob-lib": "0.0.1-commit.3469e52",
-    "@aztec/ethereum": "0.0.1-commit.3469e52",
-    "@aztec/foundation": "0.0.1-commit.3469e52",
-    "@aztec/kv-store": "0.0.1-commit.3469e52",
-    "@aztec/stdlib": "0.0.1-commit.3469e52",
-    "@aztec/telemetry-client": "0.0.1-commit.3469e52",
+    "@aztec/blob-lib": "0.0.1-commit.35158ae7e",
+    "@aztec/ethereum": "0.0.1-commit.35158ae7e",
+    "@aztec/foundation": "0.0.1-commit.35158ae7e",
+    "@aztec/kv-store": "0.0.1-commit.35158ae7e",
+    "@aztec/stdlib": "0.0.1-commit.35158ae7e",
+    "@aztec/telemetry-client": "0.0.1-commit.35158ae7e",
     "express": "^4.21.2",
     "snappy": "^7.2.2",
     "source-map-support": "^0.5.21",

package/src/archive/instrumentation.ts

@@ -1,4 +1,10 @@
-import { Attributes, Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/telemetry-client';
+import {
+  Attributes,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  createUpDownCounterWithDefault,
+} from '@aztec/telemetry-client';
 
 export class BlobArchiveClientInstrumentation {
   private blockRequestCounter: UpDownCounter;
@@ -11,11 +17,23 @@ export class BlobArchiveClientInstrumentation {
     name: string,
   ) {
     const meter = client.getMeter(name);
-    this.blockRequestCounter = meter.createUpDownCounter(Metrics.BLOB_SINK_ARCHIVE_BLOCK_REQUEST_COUNT);
+    const requestAttrs = {
+      [Attributes.HTTP_RESPONSE_STATUS_CODE]: [200, 404],
+      [Attributes.HTTP_REQUEST_HOST]: [httpHost],
+    };
+    this.blockRequestCounter = createUpDownCounterWithDefault(
+      meter,
+      Metrics.BLOB_SINK_ARCHIVE_BLOCK_REQUEST_COUNT,
+      requestAttrs,
+    );
 
-    this.blobRequestCounter = meter.createUpDownCounter(Metrics.BLOB_SINK_ARCHIVE_BLOB_REQUEST_COUNT);
+    this.blobRequestCounter = createUpDownCounterWithDefault(
+      meter,
+      Metrics.BLOB_SINK_ARCHIVE_BLOB_REQUEST_COUNT,
+      requestAttrs,
+    );
 
-    this.retrievedBlobs = meter.createUpDownCounter(Metrics.BLOB_SINK_ARCHIVE_BLOB_COUNT);
+    this.retrievedBlobs = createUpDownCounterWithDefault(meter, Metrics.BLOB_SINK_ARCHIVE_BLOB_COUNT);
   }
 
   incRequest(type: 'blocks' | 'blobs', status: number) {

package/src/blobstore/blob_store_test_suite.ts

@@ -13,7 +13,7 @@ export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
   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 blob = await Blob.fromFields(testFields);
     const blobHash = blob.getEthVersionedBlobHash();
 
     // Store the blob
@@ -29,8 +29,8 @@ export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
 
   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 blob1 = await Blob.fromFields([Fr.random(), Fr.random()]);
+    const blob2 = await Blob.fromFields([Fr.random(), Fr.random(), Fr.random()]);
 
     const blobHash1 = blob1.getEthVersionedBlobHash();
     const blobHash2 = blob2.getEthVersionedBlobHash();
@@ -57,9 +57,9 @@ export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
 
   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()]);
+    const blob1 = await Blob.fromFields([Fr.random()]);
+    const blob2 = await Blob.fromFields([Fr.random()]);
+    const blob3 = await Blob.fromFields([Fr.random()]);
 
     await blobStore.addBlobs([blob1, blob2, blob3]);
 
@@ -75,7 +75,7 @@ export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
   });
 
   it('should handle duplicate blob hashes in request', async () => {
-    const blob = Blob.fromFields([Fr.random()]);
+    const blob = await Blob.fromFields([Fr.random()]);
     const blobHash = blob.getEthVersionedBlobHash();
 
     await blobStore.addBlobs([blob]);
@@ -91,8 +91,8 @@ export function describeBlobStore(getBlobStore: () => Promise<BlobStore>) {
   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);
+    const blob1 = await Blob.fromFields(fields);
+    const blob2 = await Blob.fromFields(fields);
 
     const blobHash = blob1.getEthVersionedBlobHash();
 

package/src/client/config.ts

@@ -3,6 +3,7 @@ import {
   SecretValue,
   booleanConfigHelper,
   getConfigFromMappings,
+  optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
 
 import { type BlobArchiveApiConfig, blobArchiveApiConfigMappings } from '../archive/config.js';
@@ -55,6 +56,9 @@ export interface BlobClientConfig extends BlobArchiveApiConfig {
    * Interval in minutes for uploading healthcheck file to file store (default: 60 = 1 hour)
    */
   blobHealthcheckUploadIntervalMinutes?: number;
+
+  /** Timeout for HTTP requests to the L1 RPC node in ms. */
+  l1HttpTimeoutMS?: number;
 }
 
 export const blobClientConfigMapping: ConfigMappingsType<BlobClientConfig> = {
@@ -108,6 +112,11 @@ export const blobClientConfigMapping: ConfigMappingsType<BlobClientConfig> = {
     description: 'Interval in minutes for uploading healthcheck file to file store (default: 60 = 1 hour)',
     parseEnv: (val: string | undefined) => (val ? +val : undefined),
   },
+  l1HttpTimeoutMS: {
+    env: 'ETHEREUM_HTTP_TIMEOUT_MS',
+    description: 'Timeout for HTTP requests to the L1 RPC node in ms.',
+    ...optionalNumberConfigHelper(),
+  },
   ...blobArchiveApiConfigMappings,
 };
 

package/src/client/http.ts

@@ -1,10 +1,11 @@
 import { Blob, type BlobJson, computeEthVersionedBlobHash } from '@aztec/blob-lib';
+import { makeL1HttpTransport } from '@aztec/ethereum/client';
 import { shuffle } from '@aztec/foundation/array';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { type RpcBlock, createPublicClient, fallback, http } from 'viem';
+import { type RpcBlock, createPublicClient } from 'viem';
 
 import { createBlobArchiveClient } from '../archive/factory.js';
 import type { BlobArchiveClient } from '../archive/interface.js';
@@ -24,6 +25,11 @@ export class HttpBlobClient implements BlobClientInterface {
   private disabled = false;
   private healthcheckUploadIntervalId?: NodeJS.Timeout;
 
+  /** Cached beacon genesis time (seconds since Unix epoch). Fetched once at startup. */
+  private beaconGenesisTime?: bigint;
+  /** Cached beacon slot duration in seconds. Fetched once at startup. */
+  private beaconSecondsPerSlot?: number;
+
   constructor(
     config?: BlobClientConfig,
     private readonly opts: {
@@ -89,44 +95,68 @@ export class HttpBlobClient implements BlobClientInterface {
     const archiveUrl = this.archiveClient?.getBaseUrl();
     this.log.info(`Testing configured blob sources`, { l1ConsensusHostUrls, archiveUrl });
 
-    let successfulSourceCount = 0;
+    let consensusSuperNodes = 0;
+    let consensusNonSuperNodes = 0;
+    let archiveSources = 0;
+    let blobSinks = 0;
 
     if (l1ConsensusHostUrls && l1ConsensusHostUrls.length > 0) {
       for (let l1ConsensusHostIndex = 0; l1ConsensusHostIndex < l1ConsensusHostUrls.length; l1ConsensusHostIndex++) {
         const l1ConsensusHostUrl = l1ConsensusHostUrls[l1ConsensusHostIndex];
         try {
           const { url, ...options } = getBeaconNodeFetchOptions(
-            `${l1ConsensusHostUrl}/eth/v1/beacon/headers`,
+            `${l1ConsensusHostUrl}/eth/v1/beacon/headers/head`,
             this.config,
             l1ConsensusHostIndex,
           );
           const res = await this.fetch(url, options);
-          if (res.ok) {
-            this.log.info(`L1 consensus host is reachable`, { l1ConsensusHostUrl });
-            successfulSourceCount++;
-          } else {
+          if (!res.ok) {
             this.log.error(`Failure reaching L1 consensus host: ${res.statusText} (${res.status})`, {
               l1ConsensusHostUrl,
             });
+            continue;
+          }
+
+          this.log.info(`L1 consensus host is reachable`, { l1ConsensusHostUrl });
+
+          // Check if the host serves blob sidecars (supernode/semi-supernode).
+          // Post-Fusaka (PeerDAS), non-supernode beacon nodes no longer serve the
+          // blob sidecar endpoint. A 200 response (even with an empty data array
+          // for a slot with no blobs) means the node supports serving blob sidecars.
+          const body = await res.json();
+          const headSlot = body?.data?.header?.message?.slot;
+          if (headSlot) {
+            const { url: blobUrl, ...blobOptions } = getBeaconNodeFetchOptions(
+              `${l1ConsensusHostUrl}/eth/v1/beacon/blobs/${headSlot}`,
+              this.config,
+              l1ConsensusHostIndex,
+            );
+            const blobRes = await this.fetch(blobUrl, blobOptions);
+            if (blobRes.ok) {
+              this.log.info(`L1 consensus host serves blob sidecars (supernode)`, { l1ConsensusHostUrl });
+              consensusSuperNodes++;
+            } else {
+              this.log.info(`L1 consensus host does not serve blob sidecars`, { l1ConsensusHostUrl });
+              consensusNonSuperNodes++;
+            }
+          } else {
+            this.log.info(`L1 consensus host is reachable but could not determine head slot`, { l1ConsensusHostUrl });
+            consensusNonSuperNodes++;
           }
         } catch (err) {
           this.log.error(`Error reaching L1 consensus host`, err, { l1ConsensusHostUrl });
         }
       }
-    } else {
-      this.log.warn('No L1 consensus host urls configured');
     }
 
     if (this.archiveClient) {
       try {
         const latest = await this.archiveClient.getLatestBlock();
         this.log.info(`Archive client is reachable and synced to L1 block ${latest.number}`, { latest, archiveUrl });
-        successfulSourceCount++;
+        archiveSources++;
       } catch (err) {
         this.log.error(`Error reaching archive client`, err, { archiveUrl });
       }
-    } else {
-      this.log.warn('No archive client configured');
     }
 
     if (this.fileStoreClients.length > 0) {
@@ -135,7 +165,7 @@ export class HttpBlobClient implements BlobClientInterface {
           const accessible = await fileStoreClient.testConnection();
           if (accessible) {
             this.log.info(`FileStore is reachable`, { url: fileStoreClient.getBaseUrl() });
-            successfulSourceCount++;
+            blobSinks++;
           } else {
             this.log.warn(`FileStore is not accessible`, { url: fileStoreClient.getBaseUrl() });
           }
@@ -145,12 +175,24 @@ export class HttpBlobClient implements BlobClientInterface {
       }
     }
 
+    // Emit a single summary after validating all sources
+    const successfulSourceCount = consensusSuperNodes + archiveSources + blobSinks;
+
+    let summary = `Blob client running with consensusSuperNodes=${consensusSuperNodes} archiveSources=${archiveSources} blobSinks=${blobSinks}`;
+    if (consensusNonSuperNodes > 0) {
+      summary += `. ${consensusNonSuperNodes} consensus client(s) ignored because they are not running in supernode or semi-supernode mode`;
+    }
+
     if (successfulSourceCount === 0) {
       if (this.config.blobAllowEmptySources) {
-        this.log.warn('No blob sources are reachable');
+        this.log.warn(summary);
       } else {
-        throw new Error('No blob sources are reachable');
+        throw new Error(summary);
       }
+    } else if (consensusSuperNodes === 0) {
+      this.log.warn(summary);
+    } else {
+      this.log.info(summary);
     }
   }
 
@@ -215,8 +257,8 @@ export class HttpBlobClient implements BlobClientInterface {
     const getFilledBlobs = (): Blob[] => resultBlobs.filter((b): b is Blob => b !== undefined);
 
     // Helper to fill in results from fetched blobs
-    const fillResults = (fetchedBlobs: BlobJson[]): Blob[] => {
-      const blobs = processFetchedBlobs(fetchedBlobs, blobHashes, this.log);
+    const fillResults = async (fetchedBlobs: BlobJson[]): Promise<Blob[]> => {
+      const blobs = await processFetchedBlobs(fetchedBlobs, blobHashes, this.log);
       // Fill in any missing positions with matching blobs
       for (let i = 0; i < blobHashes.length; i++) {
         if (resultBlobs[i] === undefined) {
@@ -251,7 +293,7 @@ export class HttpBlobClient implements BlobClientInterface {
       // The beacon api can query by slot number, so we get that first
       const consensusCtx = { l1ConsensusHostUrls, ...ctx };
       this.log.trace(`Attempting to get slot number for block hash`, consensusCtx);
-      const slotNumber = await this.getSlotNumber(blockHash);
+      const slotNumber = await this.getSlotNumber(blockHash, opts?.parentBeaconBlockRoot, opts?.l1BlockTimestamp);
       this.log.debug(`Got slot number ${slotNumber} from consensus host for querying blobs`, consensusCtx);
 
       if (slotNumber) {
@@ -268,8 +310,13 @@ export class HttpBlobClient implements BlobClientInterface {
             l1ConsensusHostUrl,
             ...ctx,
           });
-          const blobs = await this.getBlobsFromHost(l1ConsensusHostUrl, slotNumber, l1ConsensusHostIndex);
-          const result = fillResults(blobs);
+          const blobs = await this.getBlobsFromHost(
+            l1ConsensusHostUrl,
+            slotNumber,
+            l1ConsensusHostIndex,
+            getMissingBlobHashes(),
+          );
+          const result = await fillResults(blobs);
           this.log.debug(
             `Got ${blobs.length} blobs from consensus host (total: ${result.length}/${blobHashes.length})`,
             { slotNumber, l1ConsensusHostUrl, ...ctx },
@@ -312,7 +359,7 @@ export class HttpBlobClient implements BlobClientInterface {
         this.log.debug('No blobs found from archive client', archiveCtx);
       } else {
         this.log.trace(`Got ${allBlobs.length} blobs from archive client before filtering`, archiveCtx);
-        const result = fillResults(allBlobs);
+        const result = await fillResults(allBlobs);
         this.log.debug(
           `Got ${allBlobs.length} blobs from archive client (total: ${result.length}/${blobHashes.length})`,
           archiveCtx,
@@ -345,7 +392,7 @@ export class HttpBlobClient implements BlobClientInterface {
    */
   private async tryFileStores(
     getMissingBlobHashes: () => Buffer[],
-    fillResults: (blobs: BlobJson[]) => Blob[],
+    fillResults: (blobs: BlobJson[]) => Promise<Blob[]>,
     ctx: { blockHash: string; blobHashes: string[] },
   ): Promise<void> {
     // Shuffle clients for load distribution
@@ -366,7 +413,7 @@ export class HttpBlobClient implements BlobClientInterface {
         });
         const blobs = await client.getBlobsByHashes(blobHashStrings);
         if (blobs.length > 0) {
-          const result = fillResults(blobs);
+          const result = await fillResults(blobs);
           this.log.debug(
             `Got ${blobs.length} blobs from filestore (total: ${result.length}/${ctx.blobHashes.length})`,
             {
@@ -387,19 +434,20 @@ export class HttpBlobClient implements BlobClientInterface {
     blobHashes: Buffer[] = [],
     l1ConsensusHostIndex?: number,
   ): Promise<Blob[]> {
-    const blobs = await this.getBlobsFromHost(hostUrl, blockHashOrSlot, l1ConsensusHostIndex);
-    return processFetchedBlobs(blobs, blobHashes, this.log).filter((b): b is Blob => b !== undefined);
+    const blobs = await this.getBlobsFromHost(hostUrl, blockHashOrSlot, l1ConsensusHostIndex, blobHashes);
+    return (await processFetchedBlobs(blobs, blobHashes, this.log)).filter((b): b is Blob => b !== undefined);
   }
 
   public async getBlobsFromHost(
     hostUrl: string,
     blockHashOrSlot: string | number,
     l1ConsensusHostIndex?: number,
+    blobHashes?: Buffer[],
   ): Promise<BlobJson[]> {
     try {
-      let res = await this.fetchBlobSidecars(hostUrl, blockHashOrSlot, l1ConsensusHostIndex);
+      let res = await this.fetchBlobSidecars(hostUrl, blockHashOrSlot, l1ConsensusHostIndex, blobHashes);
       if (res.ok) {
-        return parseBlobJsonsFromResponse(await res.json(), this.log);
+        return await parseBlobJsonsFromResponse(await res.json(), this.log);
       }
 
       if (res.status === 404 && typeof blockHashOrSlot === 'number') {
@@ -414,9 +462,9 @@ export class HttpBlobClient implements BlobClientInterface {
         let currentSlot = blockHashOrSlot + 1;
         while (res.status === 404 && maxRetries > 0 && latestSlot !== undefined && currentSlot <= latestSlot) {
           this.log.debug(`Trying slot ${currentSlot}`);
-          res = await this.fetchBlobSidecars(hostUrl, currentSlot, l1ConsensusHostIndex);
+          res = await this.fetchBlobSidecars(hostUrl, currentSlot, l1ConsensusHostIndex, blobHashes);
           if (res.ok) {
-            return parseBlobJsonsFromResponse(await res.json(), this.log);
+            return await parseBlobJsonsFromResponse(await res.json(), this.log);
           }
           currentSlot++;
           maxRetries--;
@@ -439,8 +487,17 @@ export class HttpBlobClient implements BlobClientInterface {
     hostUrl: string,
     blockHashOrSlot: string | number,
     l1ConsensusHostIndex?: number,
+    blobHashes?: Buffer[],
   ): Promise<Response> {
-    const baseUrl = `${hostUrl}/eth/v1/beacon/blob_sidecars/${blockHashOrSlot}`;
+    let baseUrl = `${hostUrl}/eth/v1/beacon/blobs/${blockHashOrSlot}`;
+
+    if (blobHashes && blobHashes.length > 0) {
+      const params = new URLSearchParams();
+      for (const hash of blobHashes) {
+        params.append('versioned_hashes', `0x${hash.toString('hex')}`);
+      }
+      baseUrl += `?${params.toString()}`;
+    }
 
     const { url, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
     this.log.debug(`Fetching blob sidecar for ${blockHashOrSlot}`, { url, ...options });
@@ -482,34 +539,50 @@ export class HttpBlobClient implements BlobClientInterface {
    * @param blockHash - The block hash
    * @returns The slot number
    */
-  private async getSlotNumber(blockHash: `0x${string}`): Promise<number | undefined> {
+  private async getSlotNumber(
+    blockHash: `0x${string}`,
+    parentBeaconBlockRoot?: string,
+    l1BlockTimestamp?: bigint,
+  ): Promise<number | undefined> {
     const { l1ConsensusHostUrls, l1RpcUrls } = this.config;
     if (!l1ConsensusHostUrls || l1ConsensusHostUrls.length === 0) {
       this.log.debug('No consensus host url configured');
       return undefined;
     }
 
-    if (!l1RpcUrls || l1RpcUrls.length === 0) {
-      this.log.debug('No execution host url configured');
-      return undefined;
+    // Primary path: compute slot from timestamp if genesis config is cached (no network call needed)
+    if (
+      l1BlockTimestamp !== undefined &&
+      this.beaconGenesisTime !== undefined &&
+      this.beaconSecondsPerSlot !== undefined
+    ) {
+      const slot = Number((l1BlockTimestamp - this.beaconGenesisTime) / BigInt(this.beaconSecondsPerSlot));
+      this.log.debug(`Computed slot ${slot} from L1 block timestamp`, { l1BlockTimestamp });
+      return slot;
     }
 
-    // Ping execution node to get the parentBeaconBlockRoot for this block
-    let parentBeaconBlockRoot: string | undefined;
-    const client = createPublicClient({
-      transport: fallback(l1RpcUrls.map(url => http(url, { batch: false }))),
-    });
-    try {
-      const res: RpcBlock = await client.request({
-        method: 'eth_getBlockByHash',
-        params: [blockHash, /*tx flag*/ false],
+    if (!parentBeaconBlockRoot) {
+      // parentBeaconBlockRoot not provided by caller — fetch it from the execution RPC
+      if (!l1RpcUrls || l1RpcUrls.length === 0) {
+        this.log.debug('No execution host url configured');
+        return undefined;
+      }
+
+      const client = createPublicClient({
+        transport: makeL1HttpTransport(l1RpcUrls, { timeout: this.config.l1HttpTimeoutMS }),
       });
+      try {
+        const res: RpcBlock = await client.request({
+          method: 'eth_getBlockByHash',
+          params: [blockHash, /*tx flag*/ false],
+        });
 
-      if (res.parentBeaconBlockRoot) {
-        parentBeaconBlockRoot = res.parentBeaconBlockRoot;
+        if (res.parentBeaconBlockRoot) {
+          parentBeaconBlockRoot = res.parentBeaconBlockRoot;
+        }
+      } catch (err) {
+        this.log.error(`Error getting parent beacon block root`, err);
       }
-    } catch (err) {
-      this.log.error(`Error getting parent beacon block root`, err);
     }
 
     if (!parentBeaconBlockRoot) {
@@ -555,9 +628,12 @@ export class HttpBlobClient implements BlobClientInterface {
 
   /**
    * Start the blob client.
-   * Uploads the initial healthcheck file (awaited) and starts periodic uploads.
+   * Fetches and caches beacon genesis config for timestamp-based slot resolution,
+   * then uploads the initial healthcheck file (awaited) and starts periodic uploads.
    */
   public async start(): Promise<void> {
+    await this.fetchBeaconConfig();
+
     if (!this.fileStoreUploadClient) {
       return;
     }
@@ -582,6 +658,53 @@ export class HttpBlobClient implements BlobClientInterface {
     }, intervalMs);
   }
 
+  /**
+   * Fetches and caches beacon genesis time and slot duration from the first available consensus host.
+   * These static values enable timestamp-based slot resolution, eliminating the per-fetch headers call.
+   * Logs a warning and leaves fields undefined if all hosts fail, callers fall back gracefully.
+   */
+  private async fetchBeaconConfig(): Promise<void> {
+    const { l1ConsensusHostUrls } = this.config;
+    if (!l1ConsensusHostUrls || l1ConsensusHostUrls.length === 0) {
+      return;
+    }
+
+    for (let i = 0; i < l1ConsensusHostUrls.length; i++) {
+      try {
+        const { url: genesisUrl, ...genesisOptions } = getBeaconNodeFetchOptions(
+          `${l1ConsensusHostUrls[i]}/eth/v1/config/genesis`,
+          this.config,
+          i,
+        );
+        const { url: specUrl, ...specOptions } = getBeaconNodeFetchOptions(
+          `${l1ConsensusHostUrls[i]}/eth/v1/config/spec`,
+          this.config,
+          i,
+        );
+
+        const [genesisRes, specRes] = await Promise.all([
+          this.fetch(genesisUrl, genesisOptions),
+          this.fetch(specUrl, specOptions),
+        ]);
+
+        if (genesisRes.ok && specRes.ok) {
+          const genesis = await genesisRes.json();
+          const spec = await specRes.json();
+          this.beaconGenesisTime = BigInt(genesis.data.genesisTime);
+          this.beaconSecondsPerSlot = parseInt(spec.data.secondsPerSlot);
+          this.log.debug(`Fetched beacon genesis config`, {
+            genesisTime: this.beaconGenesisTime,
+            secondsPerSlot: this.beaconSecondsPerSlot,
+          });
+          return;
+        }
+      } catch (err) {
+        this.log.warn(`Failed to fetch beacon config from host ${l1ConsensusHostUrls[i]}`, err);
+      }
+    }
+    this.log.warn('Could not fetch beacon genesis config from any consensus host — will use headers call fallback');
+  }
+
   /**
    * Stop the blob client, clearing any periodic tasks.
    */
@@ -593,10 +716,9 @@ export class HttpBlobClient implements BlobClientInterface {
   }
 }
 
-function parseBlobJsonsFromResponse(response: any, logger: Logger): BlobJson[] {
+async function parseBlobJsonsFromResponse(response: any, logger: Logger): Promise<BlobJson[]> {
   try {
-    const blobs = response.data.map(parseBlobJson);
-    return blobs;
+    return await Promise.all((response.data as string[]).map(parseBlobJson));
   } catch (err) {
     logger.error(`Error parsing blob json from response`, err);
     return [];
@@ -607,16 +729,19 @@ function parseBlobJsonsFromResponse(response: any, logger: Logger): BlobJson[] {
 // 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 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);
+async function parseBlobJson(rawHex: string): Promise<BlobJson> {
+  const blobBuffer = Buffer.from(rawHex.slice(2), 'hex');
+  const blob = await Blob.fromBlobBuffer(blobBuffer);
   return blob.toJSON();
 }
 
 // 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): (Blob | undefined)[] {
+async function processFetchedBlobs(
+  blobs: BlobJson[],
+  blobHashes: Buffer[],
+  logger: Logger,
+): Promise<(Blob | undefined)[]> {
   const requestedBlobHashes = new Set<string>(blobHashes.map(bufferToHex));
   const hashToBlob = new Map<string, Blob>();
   for (const blobJson of blobs) {
@@ -626,7 +751,7 @@ function processFetchedBlobs(blobs: BlobJson[], blobHashes: Buffer[], logger: Lo
     }
 
     try {
-      const blob = Blob.fromJson(blobJson);
+      const blob = await 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.

package/src/client/interface.ts

@@ -11,6 +11,17 @@ export interface GetBlobSidecarOptions {
    * - Near tip: FileStore first with no retries (data should exist), L1 consensus second (freshest data), then FileStore with retries, then archive (eg. blobscan)
    */
   isHistoricalSync?: boolean;
+  /**
+   * The parent beacon block root for the L1 block containing the blobs.
+   * If provided, skips the eth_getBlockByHash execution RPC call inside getSlotNumber.
+   */
+  parentBeaconBlockRoot?: string;
+  /**
+   * The timestamp of the L1 execution block containing the blobs.
+   * When provided alongside a cached beacon genesis config (fetched at startup), allows computing
+   * the beacon slot directly via timestamp math, skipping the beacon headers network call entirely.
+   */
+  l1BlockTimestamp?: bigint;
 }
 
 export interface BlobClientInterface {

package/src/client/tests.ts

@@ -28,7 +28,7 @@ export function runBlobClientTests(
   });
 
   it('should send and retrieve blobs by hash', async () => {
-    const blob = makeRandomBlob(5);
+    const blob = await makeRandomBlob(5);
     const blobHash = blob.getEthVersionedBlobHash();
 
     await client.sendBlobsToFilestore([blob]);
@@ -39,7 +39,7 @@ export function runBlobClientTests(
   });
 
   it('should handle multiple blobs', async () => {
-    const blobs = Array.from({ length: 3 }, () => makeRandomBlob(7));
+    const blobs = await Promise.all(Array.from({ length: 3 }, () => makeRandomBlob(7)));
     const blobHashes = blobs.map(blob => blob.getEthVersionedBlobHash());
 
     await client.sendBlobsToFilestore(blobs);