@aztec/blob-client 0.0.1-commit.9ef841308 → 0.0.1-commit.a89ec08

package/src/client/config.ts

@@ -59,12 +59,6 @@ export interface BlobClientConfig extends BlobArchiveApiConfig {
 
   /** Timeout for HTTP requests to the L1 RPC node in ms. */
   l1HttpTimeoutMS?: number;
-
-  /** Whether to prefer filestores over consensus clients when fetching blobs. Default: false (consensus first). */
-  blobPreferFilestores?: boolean;
-
-  /** Timeout in ms for HTTP requests to the blob file store. Default: 10000 (10s). */
-  blobFileStoreTimeoutMs?: number;
 }
 
 export const blobClientConfigMapping: ConfigMappingsType<BlobClientConfig> = {
@@ -123,16 +117,6 @@ export const blobClientConfigMapping: ConfigMappingsType<BlobClientConfig> = {
     description: 'Timeout for HTTP requests to the L1 RPC node in ms.',
     ...optionalNumberConfigHelper(),
   },
-  blobPreferFilestores: {
-    env: 'BLOB_PREFER_FILESTORES',
-    description: 'Whether to prefer filestores over consensus clients when fetching blobs. Default: false.',
-    ...booleanConfigHelper(false),
-  },
-  blobFileStoreTimeoutMs: {
-    env: 'BLOB_FILE_STORE_TIMEOUT_MS',
-    description: 'Timeout in ms for HTTP requests to the blob file store. Default: 10000 (10s).',
-    ...optionalNumberConfigHelper(),
-  },
   ...blobArchiveApiConfigMappings,
 };
 

package/src/client/factory.ts

@@ -76,15 +76,8 @@ export async function createBlobClientWithFileStores(
     rollupAddress: config.l1Contracts.rollupAddress.toString(),
   };
 
-  // Disable internal retries for blob file stores — retry logic is handled by HttpBlobClient.
-  // Set a configurable timeout (default 10s) to avoid hanging on slow stores.
-  const httpOptions = {
-    retryBackoff: [] as number[],
-    timeoutMs: config.blobFileStoreTimeoutMs ?? 10_000,
-  };
-
   const [fileStoreClients, fileStoreUploadClient] = await Promise.all([
-    createReadOnlyFileStoreBlobClients(config.blobFileStoreUrls, fileStoreMetadata, log, httpOptions),
+    createReadOnlyFileStoreBlobClients(config.blobFileStoreUrls, fileStoreMetadata, log),
     createWritableFileStoreBlobClient(config.blobFileStoreUploadUrl, fileStoreMetadata, log),
   ]);
 

package/src/client/http.ts

@@ -25,14 +25,6 @@ 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;
-
-  /** Indexes of consensus hosts that serve blob sidecars (supernodes). Populated by testSources(). */
-  private superNodeHostIndexes?: Set<number>;
-
   constructor(
     config?: BlobClientConfig,
     private readonly opts: {
@@ -103,8 +95,6 @@ export class HttpBlobClient implements BlobClientInterface {
     let archiveSources = 0;
     let blobSinks = 0;
 
-    const detectedSuperNodes = new Set<number>();
-
     if (l1ConsensusHostUrls && l1ConsensusHostUrls.length > 0) {
       for (let l1ConsensusHostIndex = 0; l1ConsensusHostIndex < l1ConsensusHostUrls.length; l1ConsensusHostIndex++) {
         const l1ConsensusHostUrl = l1ConsensusHostUrls[l1ConsensusHostIndex];
@@ -139,12 +129,9 @@ export class HttpBlobClient implements BlobClientInterface {
             const blobRes = await this.fetch(blobUrl, blobOptions);
             if (blobRes.ok) {
               this.log.info(`L1 consensus host serves blob sidecars (supernode)`, { l1ConsensusHostUrl });
-              detectedSuperNodes.add(l1ConsensusHostIndex);
               consensusSuperNodes++;
             } else {
-              this.log.info(`L1 consensus host does not serve blob sidecars, skipping for blob fetching`, {
-                l1ConsensusHostUrl,
-              });
+              this.log.info(`L1 consensus host does not serve blob sidecars`, { l1ConsensusHostUrl });
               consensusNonSuperNodes++;
             }
           } else {
@@ -157,8 +144,6 @@ export class HttpBlobClient implements BlobClientInterface {
       }
     }
 
-    this.superNodeHostIndexes = detectedSuperNodes;
-
     if (this.archiveClient) {
       try {
         const latest = await this.archiveClient.getLatestBlock();
@@ -228,15 +213,18 @@ export class HttpBlobClient implements BlobClientInterface {
   }
 
   /**
-   * Get the blob sidecar.
+   * Get the blob sidecar
    *
-   * Alternates between two primary sources (consensus and filestore) in a retry loop,
-   * then falls back to archive if blobs are still missing. The order of the primary
-   * sources is configurable via `blobPreferFilestores`.
+   * If requesting from the blob client, we send the blobkHash
+   * If requesting from the beacon node, we send the slot number
+   *
+   * Source ordering depends on sync state:
+   * - Historical sync: blob client → FileStore → L1 consensus → Archive
+   * - Near tip sync: blob client → FileStore → L1 consensus → FileStore (with retries) → Archive (eg blobscan)
    *
    * @param blockHash - The block hash
    * @param blobHashes - The blob hashes to fetch
-   * @param opts - Options for slot resolution
+   * @param opts - Options including isHistoricalSync flag
    * @returns The blobs
    */
   public async getBlobSidecar(
@@ -249,11 +237,12 @@ export class HttpBlobClient implements BlobClientInterface {
       return [];
     }
 
+    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: (Blob | undefined)[] = new Array(blobHashes.length).fill(undefined);
 
-    // Helper to get missing blob hashes that we still need to fetch
+    // Helper to get  missing blob hashes that we still need to fetch
     const getMissingBlobHashes = (): Buffer[] =>
       blobHashes
         .map((bh, i) => (resultBlobs[i] === undefined ? bh : undefined))
@@ -282,60 +271,79 @@ export class HttpBlobClient implements BlobClientInterface {
       return blobs;
     };
 
+    const { l1ConsensusHostUrls } = this.config;
+
     const ctx = { blockHash, blobHashes: blobHashes.map(bufferToHex) };
 
-    // Lazily resolve the slot number — only resolved when consensus hosts are actually tried.
-    let slotNumber: number | undefined;
-    let slotResolved = false;
-    const getSlotNumber = async (): Promise<number | undefined> => {
-      if (!slotResolved) {
-        slotNumber = await this.resolveSlotNumber(blockHash, opts);
-        slotResolved = true;
+    // Try filestore (quick, no retries) - useful for both historical and near-tip sync
+    if (this.fileStoreClients.length > 0 && getMissingBlobHashes().length > 0) {
+      await this.tryFileStores(getMissingBlobHashes, fillResults, ctx);
+      if (getMissingBlobHashes().length === 0) {
+        return returnWithCallback(getFilledBlobs());
       }
-      return slotNumber;
-    };
-
-    // Build the two source-try functions. The order depends on the config.
-    const tryConsensus = () => this.tryConsensusHosts(getSlotNumber, getMissingBlobHashes, fillResults, ctx);
-    const tryFilestores = () => this.tryFileStores(getMissingBlobHashes, fillResults, ctx);
-
-    const preferFilestores = this.config.blobPreferFilestores ?? false;
-    const [trySourceA, trySourceB] = preferFilestores ? [tryFilestores, tryConsensus] : [tryConsensus, tryFilestores];
-
-    // Historical sync: blobs should already exist, use shorter backoff for transient errors.
-    // Near-tip sync: blobs may still be uploading, use longer backoff for eventual consistency.
-    const isHistoricalSync = opts?.isHistoricalSync ?? false;
-    const backoff = isHistoricalSync ? [1, 1] : [1, 1, 1, 2, 2];
+    }
 
-    // Retry loop: alternate between the two primary sources with backoff.
-    try {
-      await retry(
-        async () => {
-          if (getMissingBlobHashes().length > 0) {
-            await trySourceA();
+    const missingAfterSink = getMissingBlobHashes();
+    if (missingAfterSink.length > 0 && l1ConsensusHostUrls && l1ConsensusHostUrls.length > 0) {
+      // 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);
+      this.log.debug(`Got slot number ${slotNumber} from consensus host for querying blobs`, consensusCtx);
+
+      if (slotNumber) {
+        let l1ConsensusHostUrl: string;
+        for (let l1ConsensusHostIndex = 0; l1ConsensusHostIndex < l1ConsensusHostUrls.length; l1ConsensusHostIndex++) {
+          const missingHashes = getMissingBlobHashes();
+          if (missingHashes.length === 0) {
+            break;
           }
-          if (getMissingBlobHashes().length > 0) {
-            await trySourceB();
-          }
-          if (getMissingBlobHashes().length > 0) {
-            throw new Error('Still missing blobs after trying all primary sources');
+
+          l1ConsensusHostUrl = l1ConsensusHostUrls[l1ConsensusHostIndex];
+          this.log.trace(`Attempting to get ${missingHashes.length} blobs from consensus host`, {
+            slotNumber,
+            l1ConsensusHostUrl,
+            ...ctx,
+          });
+          const blobs = await this.getBlobsFromHost(l1ConsensusHostUrl, slotNumber, l1ConsensusHostIndex);
+          const result = await fillResults(blobs);
+          this.log.debug(
+            `Got ${blobs.length} blobs from consensus host (total: ${result.length}/${blobHashes.length})`,
+            { slotNumber, l1ConsensusHostUrl, ...ctx },
+          );
+          if (result.length === blobHashes.length) {
+            return returnWithCallback(result);
           }
-        },
-        'blob retrieval',
-        makeBackoff(backoff),
-        this.log,
-        true, // failSilently — expected during eventual consistency
-      );
-      return returnWithCallback(getFilledBlobs());
-    } catch {
-      // Exhausted retries, continue to archive fallback
+        }
+      }
     }
 
-    // Archive fallback
-    const missingAfterPrimary = getMissingBlobHashes();
-    if (missingAfterPrimary.length > 0 && this.archiveClient) {
+    // For near-tip sync, retry filestores with backoff (eventual consistency)
+    // This handles the case where blobs are still being uploaded by other validators
+    if (!isHistoricalSync && this.fileStoreClients.length > 0 && getMissingBlobHashes().length > 0) {
+      try {
+        await retry(
+          async () => {
+            await this.tryFileStores(getMissingBlobHashes, fillResults, ctx);
+            if (getMissingBlobHashes().length > 0) {
+              throw new Error('Still missing blobs from filestores');
+            }
+          },
+          'filestore blob retrieval',
+          makeBackoff([1, 1, 2]),
+          this.log,
+          true, // failSilently - expected to fail during eventual consistency
+        );
+        return returnWithCallback(getFilledBlobs());
+      } catch {
+        // Exhausted retries, continue to archive fallback
+      }
+    }
+
+    const missingAfterConsensus = getMissingBlobHashes();
+    if (missingAfterConsensus.length > 0 && this.archiveClient) {
       const archiveCtx = { archiveUrl: this.archiveClient.getBaseUrl(), ...ctx };
-      this.log.trace(`Attempting to get ${missingAfterPrimary.length} blobs from archive`, archiveCtx);
+      this.log.trace(`Attempting to get ${missingAfterConsensus.length} blobs from archive`, archiveCtx);
       const allBlobs = await this.archiveClient.getBlobsFromBlock(blockHash);
       if (!allBlobs) {
         this.log.debug('No blobs found from archive client', archiveCtx);
@@ -357,7 +365,7 @@ export class HttpBlobClient implements BlobClientInterface {
       this.log.warn(
         `Failed to fetch all blobs for ${blockHash} from all blob sources (got ${result.length}/${blobHashes.length})`,
         {
-          l1ConsensusHostUrls: this.config.l1ConsensusHostUrls,
+          l1ConsensusHostUrls,
           archiveUrl: this.archiveClient?.getBaseUrl(),
           fileStoreUrls: this.fileStoreClients.map(c => c.getBaseUrl()),
         },
@@ -366,71 +374,6 @@ export class HttpBlobClient implements BlobClientInterface {
     return returnWithCallback(result);
   }
 
-  /** Resolves the beacon slot number for the given block hash. Returns undefined if no consensus hosts. */
-  private resolveSlotNumber(
-    blockHash: `0x${string}`,
-    opts?: GetBlobSidecarOptions,
-  ): Promise<number | undefined> | undefined {
-    const { l1ConsensusHostUrls } = this.config;
-    if (!l1ConsensusHostUrls || l1ConsensusHostUrls.length === 0) {
-      return undefined;
-    }
-    // If no supernodes, no point resolving the slot
-    if (this.superNodeHostIndexes && this.superNodeHostIndexes.size === 0) {
-      return undefined;
-    }
-    return this.getSlotNumber(blockHash, opts?.parentBeaconBlockRoot, opts?.l1BlockTimestamp);
-  }
-
-  /**
-   * Try all supernode consensus hosts for blob sidecars.
-   * Skips hosts that were detected as non-supernodes during testSources().
-   */
-  private async tryConsensusHosts(
-    getSlotNumber: () => Promise<number | undefined>,
-    getMissingBlobHashes: () => Buffer[],
-    fillResults: (blobs: BlobJson[]) => Promise<Blob[]>,
-    ctx: { blockHash: string; blobHashes: string[] },
-  ): Promise<void> {
-    const { l1ConsensusHostUrls } = this.config;
-    if (!l1ConsensusHostUrls || l1ConsensusHostUrls.length === 0) {
-      return;
-    }
-
-    const slotNumber = await getSlotNumber();
-    if (!slotNumber) {
-      return;
-    }
-
-    for (let l1ConsensusHostIndex = 0; l1ConsensusHostIndex < l1ConsensusHostUrls.length; l1ConsensusHostIndex++) {
-      const missingHashes = getMissingBlobHashes();
-      if (missingHashes.length === 0) {
-        break;
-      }
-
-      // Skip non-supernode hosts if we've already detected supernodes
-      if (this.superNodeHostIndexes && !this.superNodeHostIndexes.has(l1ConsensusHostIndex)) {
-        this.log.trace(`Skipping non-supernode consensus host`, {
-          l1ConsensusHostUrl: l1ConsensusHostUrls[l1ConsensusHostIndex],
-        });
-        continue;
-      }
-
-      const l1ConsensusHostUrl = l1ConsensusHostUrls[l1ConsensusHostIndex];
-      this.log.trace(`Attempting to get ${missingHashes.length} blobs from consensus host`, {
-        slotNumber,
-        l1ConsensusHostUrl,
-        ...ctx,
-      });
-      const blobs = await this.getBlobsFromHost(l1ConsensusHostUrl, slotNumber, l1ConsensusHostIndex, missingHashes);
-      const result = await fillResults(blobs);
-      this.log.debug(
-        `Got ${blobs.length} blobs from consensus host (total: ${result.length}/${ctx.blobHashes.length})`,
-        { slotNumber, l1ConsensusHostUrl, ...ctx },
-      );
-    }
-  }
-
   /**
    * Try all filestores once (shuffled for load distribution).
    * @param getMissingBlobHashes - Function to get remaining blob hashes to fetch
@@ -481,7 +424,7 @@ export class HttpBlobClient implements BlobClientInterface {
     blobHashes: Buffer[] = [],
     l1ConsensusHostIndex?: number,
   ): Promise<Blob[]> {
-    const blobs = await this.getBlobsFromHost(hostUrl, blockHashOrSlot, l1ConsensusHostIndex, blobHashes);
+    const blobs = await this.getBlobsFromHost(hostUrl, blockHashOrSlot, l1ConsensusHostIndex);
     return (await processFetchedBlobs(blobs, blobHashes, this.log)).filter((b): b is Blob => b !== undefined);
   }
 
@@ -489,12 +432,11 @@ export class HttpBlobClient implements BlobClientInterface {
     hostUrl: string,
     blockHashOrSlot: string | number,
     l1ConsensusHostIndex?: number,
-    blobHashes?: Buffer[],
   ): Promise<BlobJson[]> {
     try {
-      let res = await this.fetchBlobSidecars(hostUrl, blockHashOrSlot, l1ConsensusHostIndex, blobHashes);
+      let res = await this.fetchBlobSidecars(hostUrl, blockHashOrSlot, l1ConsensusHostIndex);
       if (res.ok) {
-        return await parseBlobJsonsFromResponse(await res.json(), this.log);
+        return parseBlobJsonsFromResponse(await res.json(), this.log);
       }
 
       if (res.status === 404 && typeof blockHashOrSlot === 'number') {
@@ -509,9 +451,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, blobHashes);
+          res = await this.fetchBlobSidecars(hostUrl, currentSlot, l1ConsensusHostIndex);
           if (res.ok) {
-            return await parseBlobJsonsFromResponse(await res.json(), this.log);
+            return parseBlobJsonsFromResponse(await res.json(), this.log);
           }
           currentSlot++;
           maxRetries--;
@@ -534,22 +476,12 @@ export class HttpBlobClient implements BlobClientInterface {
     hostUrl: string,
     blockHashOrSlot: string | number,
     l1ConsensusHostIndex?: number,
-    blobHashes?: Buffer[],
   ): Promise<Response> {
-    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 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 });
-    // No retry here — this is called inside the main retry loop in getBlobSidecar
-    return fetch(url, options);
+    return this.fetch(url, options);
   }
 
   private async getLatestSlotNumber(hostUrl: string, l1ConsensusHostIndex?: number): Promise<number | undefined> {
@@ -587,50 +519,34 @@ export class HttpBlobClient implements BlobClientInterface {
    * @param blockHash - The block hash
    * @returns The slot number
    */
-  private async getSlotNumber(
-    blockHash: `0x${string}`,
-    parentBeaconBlockRoot?: string,
-    l1BlockTimestamp?: bigint,
-  ): Promise<number | undefined> {
+  private async getSlotNumber(blockHash: `0x${string}`): Promise<number | undefined> {
     const { l1ConsensusHostUrls, l1RpcUrls } = this.config;
     if (!l1ConsensusHostUrls || l1ConsensusHostUrls.length === 0) {
       this.log.debug('No consensus 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;
+    if (!l1RpcUrls || l1RpcUrls.length === 0) {
+      this.log.debug('No execution host url configured');
+      return undefined;
     }
 
-    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 }),
+    // Ping execution node to get the parentBeaconBlockRoot for this block
+    let parentBeaconBlockRoot: string | 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],
       });
-      try {
-        const res: RpcBlock = await client.request({
-          method: 'eth_getBlockByHash',
-          params: [blockHash, /*tx flag*/ false],
-        });
 
-        if (res.parentBeaconBlockRoot) {
-          parentBeaconBlockRoot = res.parentBeaconBlockRoot;
-        }
-      } catch (err) {
-        this.log.error(`Error getting parent beacon block root`, err);
+      if (res.parentBeaconBlockRoot) {
+        parentBeaconBlockRoot = res.parentBeaconBlockRoot;
       }
+    } catch (err) {
+      this.log.error(`Error getting parent beacon block root`, err);
     }
 
     if (!parentBeaconBlockRoot) {
@@ -676,12 +592,9 @@ export class HttpBlobClient implements BlobClientInterface {
 
   /**
    * Start the blob client.
-   * Fetches and caches beacon genesis config for timestamp-based slot resolution,
-   * then uploads the initial healthcheck file (awaited) and starts periodic uploads.
+   * Uploads the initial healthcheck file (awaited) and starts periodic uploads.
    */
   public async start(): Promise<void> {
-    await this.fetchBeaconConfig();
-
     if (!this.fileStoreUploadClient) {
       return;
     }
@@ -706,53 +619,6 @@ 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.
    */
@@ -764,9 +630,10 @@ export class HttpBlobClient implements BlobClientInterface {
   }
 }
 
-async function parseBlobJsonsFromResponse(response: any, logger: Logger): Promise<BlobJson[]> {
+function parseBlobJsonsFromResponse(response: any, logger: Logger): BlobJson[] {
   try {
-    return await Promise.all((response.data as string[]).map(parseBlobJson));
+    const blobs = response.data.map(parseBlobJson);
+    return blobs;
   } catch (err) {
     logger.error(`Error parsing blob json from response`, err);
     return [];
@@ -777,9 +644,10 @@ async function parseBlobJsonsFromResponse(response: any, logger: Logger): Promis
 // 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().
-async function parseBlobJson(rawHex: string): Promise<BlobJson> {
-  const blobBuffer = Buffer.from(rawHex.slice(2), 'hex');
-  const blob = await Blob.fromBlobBuffer(blobBuffer);
+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();
 }
 

package/src/client/interface.ts

@@ -6,20 +6,11 @@ import type { Blob } from '@aztec/blob-lib';
 export interface GetBlobSidecarOptions {
   /**
    * True if the archiver is catching up (historical sync), false if near tip.
-   * Historical sync uses a shorter retry backoff since blobs should already exist.
+   * This affects source ordering:
+   * - Historical: FileStore first (data should exist), then L1 consensus, then archive (eg. blobscan)
+   * - 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/filestore/factory.ts

@@ -1,7 +1,6 @@
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import {
   type FileStore,
-  type HttpFileStoreOptions,
   type ReadOnlyFileStore,
   createFileStore,
   createReadOnlyFileStore,
@@ -45,19 +44,16 @@ export async function createReadOnlyFileStoreBlobClient(
   storeUrl: string,
   metadata: BlobFileStoreMetadata,
   logger?: Logger,
-  httpOptions?: HttpFileStoreOptions,
 ): Promise<FileStoreBlobClient>;
 export async function createReadOnlyFileStoreBlobClient(
   storeUrl: string | undefined,
   metadata: BlobFileStoreMetadata,
   logger?: Logger,
-  httpOptions?: HttpFileStoreOptions,
 ): Promise<FileStoreBlobClient | undefined>;
 export async function createReadOnlyFileStoreBlobClient(
   storeUrl: string | undefined,
   metadata: BlobFileStoreMetadata,
   logger?: Logger,
-  httpOptions?: HttpFileStoreOptions,
 ): Promise<FileStoreBlobClient | undefined> {
   if (!storeUrl) {
     return undefined;
@@ -68,7 +64,7 @@ export async function createReadOnlyFileStoreBlobClient(
 
   log.debug(`Creating read-only filestore blob client`, { storeUrl, basePath });
 
-  const store: ReadOnlyFileStore = await createReadOnlyFileStore(storeUrl, log, httpOptions);
+  const store: ReadOnlyFileStore = await createReadOnlyFileStore(storeUrl, log);
   return new FileStoreBlobClient(store, basePath, log);
 }
 
@@ -84,7 +80,6 @@ export async function createReadOnlyFileStoreBlobClients(
   storeUrls: string[] | undefined,
   metadata: BlobFileStoreMetadata,
   logger?: Logger,
-  httpOptions?: HttpFileStoreOptions,
 ): Promise<FileStoreBlobClient[]> {
   if (!storeUrls || storeUrls.length === 0) {
     return [];
@@ -95,7 +90,7 @@ export async function createReadOnlyFileStoreBlobClients(
 
   for (const storeUrl of storeUrls) {
     try {
-      const client = await createReadOnlyFileStoreBlobClient(storeUrl, metadata, log, httpOptions);
+      const client = await createReadOnlyFileStoreBlobClient(storeUrl, metadata, log);
       if (client) {
         clients.push(client);
       }