@aztec/blob-client 0.0.1-commit.8c0b8ff → 0.0.1-commit.8cb2d04d8

package/dest/client/http.js

@@ -18,6 +18,9 @@ export class HttpBlobClient {
     fileStoreUploadClient;
     disabled;
     healthcheckUploadIntervalId;
+    /** Cached beacon genesis time (seconds since Unix epoch). Fetched once at startup. */ beaconGenesisTime;
+    /** Cached beacon slot duration in seconds. Fetched once at startup. */ beaconSecondsPerSlot;
+    /** Indexes of consensus hosts that serve blob sidecars (supernodes). Populated by testSources(). */ superNodeHostIndexes;
     constructor(config, opts = {}){
         this.opts = opts;
         this.disabled = false;
@@ -71,6 +74,7 @@ export class HttpBlobClient {
         let consensusNonSuperNodes = 0;
         let archiveSources = 0;
         let blobSinks = 0;
+        const detectedSuperNodes = new Set();
         if (l1ConsensusHostUrls && l1ConsensusHostUrls.length > 0) {
             for(let l1ConsensusHostIndex = 0; l1ConsensusHostIndex < l1ConsensusHostUrls.length; l1ConsensusHostIndex++){
                 const l1ConsensusHostUrl = l1ConsensusHostUrls[l1ConsensusHostIndex];
@@ -99,9 +103,10 @@ export class HttpBlobClient {
                             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`, {
+                            this.log.info(`L1 consensus host does not serve blob sidecars, skipping for blob fetching`, {
                                 l1ConsensusHostUrl
                             });
                             consensusNonSuperNodes++;
@@ -119,6 +124,7 @@ export class HttpBlobClient {
                 }
             }
         }
+        this.superNodeHostIndexes = detectedSuperNodes;
         if (this.archiveClient) {
             try {
                 const latest = await this.archiveClient.getLatestBlock();
@@ -191,29 +197,25 @@ export class HttpBlobClient {
         }
     }
     /**
-   * Get the blob sidecar
+   * Get the blob sidecar.
    *
-   * 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)
+   * 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`.
    *
    * @param blockHash - The block hash
    * @param blobHashes - The blob hashes to fetch
-   * @param opts - Options including isHistoricalSync flag
+   * @param opts - Options for slot resolution
    * @returns The blobs
    */ async getBlobSidecar(blockHash, blobHashes, opts) {
         if (this.disabled) {
             this.log.warn('Blob storage is disabled, returning empty blob sidecar');
             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 = 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 = ()=>blobHashes.map((bh, i)=>resultBlobs[i] === undefined ? bh : undefined).filter((bh)=>bh !== undefined);
         // Return the result, ignoring any undefined ones
         const getFilledBlobs = ()=>resultBlobs.filter((b)=>b !== undefined);
@@ -235,80 +237,69 @@ export class HttpBlobClient {
             }
             return blobs;
         };
-        const { l1ConsensusHostUrls } = this.config;
         const ctx = {
             blockHash,
             blobHashes: blobHashes.map(bufferToHex)
         };
-        // Try filestore (quick, no retries) - useful for both historical and near-tip sync
-        if (this.fileStoreClients.length > 0 && getMissingBlobHashes().length > 0) {
-            await this.tryFileStores(getMissingBlobHashes, fillResults, ctx);
-            if (getMissingBlobHashes().length === 0) {
-                return returnWithCallback(getFilledBlobs());
+        // Lazily resolve the slot number — only resolved when consensus hosts are actually tried.
+        let slotNumber;
+        let slotResolved = false;
+        const getSlotNumber = async ()=>{
+            if (!slotResolved) {
+                slotNumber = await this.resolveSlotNumber(blockHash, opts);
+                slotResolved = true;
             }
-        }
-        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;
-                for(let l1ConsensusHostIndex = 0; l1ConsensusHostIndex < l1ConsensusHostUrls.length; l1ConsensusHostIndex++){
-                    const missingHashes = getMissingBlobHashes();
-                    if (missingHashes.length === 0) {
-                        break;
-                    }
-                    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);
-                    }
+            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();
                 }
-            }
-        }
-        // 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);
-                return returnWithCallback(getFilledBlobs());
-            } catch  {
-            // Exhausted retries, continue to archive fallback
-            }
+                if (getMissingBlobHashes().length > 0) {
+                    await trySourceB();
+                }
+                if (getMissingBlobHashes().length > 0) {
+                    throw new Error('Still missing blobs after trying all primary sources');
+                }
+            }, 'blob retrieval', makeBackoff(backoff), this.log, true);
+            return returnWithCallback(getFilledBlobs());
+        } catch  {
+        // Exhausted retries, continue to archive fallback
         }
-        const missingAfterConsensus = getMissingBlobHashes();
-        if (missingAfterConsensus.length > 0 && this.archiveClient) {
+        // Archive fallback
+        const missingAfterPrimary = getMissingBlobHashes();
+        if (missingAfterPrimary.length > 0 && this.archiveClient) {
             const archiveCtx = {
                 archiveUrl: this.archiveClient.getBaseUrl(),
                 ...ctx
             };
-            this.log.trace(`Attempting to get ${missingAfterConsensus.length} blobs from archive`, archiveCtx);
+            this.log.trace(`Attempting to get ${missingAfterPrimary.length} blobs from archive`, archiveCtx);
             const allBlobs = await this.archiveClient.getBlobsFromBlock(blockHash);
             if (!allBlobs) {
                 this.log.debug('No blobs found from archive client', archiveCtx);
@@ -324,13 +315,63 @@ export class HttpBlobClient {
         const result = getFilledBlobs();
         if (result.length < blobHashes.length) {
             this.log.warn(`Failed to fetch all blobs for ${blockHash} from all blob sources (got ${result.length}/${blobHashes.length})`, {
-                l1ConsensusHostUrls,
+                l1ConsensusHostUrls: this.config.l1ConsensusHostUrls,
                 archiveUrl: this.archiveClient?.getBaseUrl(),
                 fileStoreUrls: this.fileStoreClients.map((c)=>c.getBaseUrl())
             });
         }
         return returnWithCallback(result);
     }
+    /** Resolves the beacon slot number for the given block hash. Returns undefined if no consensus hosts. */ resolveSlotNumber(blockHash, opts) {
+        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().
+   */ async tryConsensusHosts(getSlotNumber, getMissingBlobHashes, fillResults, ctx) {
+        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
@@ -369,14 +410,14 @@ export class HttpBlobClient {
         }
     }
     async getBlobSidecarFrom(hostUrl, blockHashOrSlot, blobHashes = [], l1ConsensusHostIndex) {
-        const blobs = await this.getBlobsFromHost(hostUrl, blockHashOrSlot, l1ConsensusHostIndex);
+        const blobs = await this.getBlobsFromHost(hostUrl, blockHashOrSlot, l1ConsensusHostIndex, blobHashes);
         return (await processFetchedBlobs(blobs, blobHashes, this.log)).filter((b)=>b !== undefined);
     }
-    async getBlobsFromHost(hostUrl, blockHashOrSlot, l1ConsensusHostIndex) {
+    async getBlobsFromHost(hostUrl, blockHashOrSlot, l1ConsensusHostIndex, blobHashes) {
         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') {
                 const latestSlot = await this.getLatestSlotNumber(hostUrl, l1ConsensusHostIndex);
@@ -389,9 +430,9 @@ export class HttpBlobClient {
                 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--;
@@ -408,21 +449,29 @@ export class HttpBlobClient {
             return [];
         }
     }
-    fetchBlobSidecars(hostUrl, blockHashOrSlot, l1ConsensusHostIndex) {
-        const baseUrl = `${hostUrl}/eth/v1/beacon/blob_sidecars/${blockHashOrSlot}`;
-        const { url, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
+    fetchBlobSidecars(hostUrl, blockHashOrSlot, l1ConsensusHostIndex, blobHashes) {
+        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, logSafeUrl, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
         this.log.debug(`Fetching blob sidecar for ${blockHashOrSlot}`, {
-            url,
+            url: logSafeUrl,
             ...options
         });
-        return this.fetch(url, options);
+        // No retry here — this is called inside the main retry loop in getBlobSidecar
+        return fetch(url, options);
     }
     async getLatestSlotNumber(hostUrl, l1ConsensusHostIndex) {
         try {
             const baseUrl = `${hostUrl}/eth/v1/beacon/headers/head`;
-            const { url, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
+            const { url, logSafeUrl, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
             this.log.debug(`Fetching latest slot number`, {
-                url,
+                url: logSafeUrl,
                 ...options
             });
             const res = await this.fetch(url, options);
@@ -455,36 +504,45 @@ export class HttpBlobClient {
    *
    * @param blockHash - The block hash
    * @returns The slot number
-   */ async getSlotNumber(blockHash) {
+   */ async getSlotNumber(blockHash, parentBeaconBlockRoot, l1BlockTimestamp) {
         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;
-        const client = createPublicClient({
-            transport: makeL1HttpTransport(l1RpcUrls, {
-                timeout: this.config.l1HttpTimeoutMS
-            })
-        });
-        try {
-            const res = 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
+                })
             });
-            if (res.parentBeaconBlockRoot) {
-                parentBeaconBlockRoot = res.parentBeaconBlockRoot;
+            try {
+                const res = 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);
             }
-        } catch (err) {
-            this.log.error(`Error getting parent beacon block root`, err);
         }
         if (!parentBeaconBlockRoot) {
             this.log.error(`No parent beacon block root found for block ${blockHash}`);
@@ -516,8 +574,10 @@ export class HttpBlobClient {
     }
     /**
    * 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.
    */ async start() {
+        await this.fetchBeaconConfig();
         if (!this.fileStoreUploadClient) {
             return;
         }
@@ -536,6 +596,40 @@ export class HttpBlobClient {
         }, 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.
+   */ async fetchBeaconConfig() {
+        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.
    */ stop() {
         if (this.healthcheckUploadIntervalId) {
@@ -544,10 +638,9 @@ export class HttpBlobClient {
         }
     }
 }
-function parseBlobJsonsFromResponse(response, logger) {
+async function parseBlobJsonsFromResponse(response, logger) {
     try {
-        const blobs = response.data.map(parseBlobJson);
-        return blobs;
+        return await Promise.all(response.data.map(parseBlobJson));
     } catch (err) {
         logger.error(`Error parsing blob json from response`, err);
         return [];
@@ -557,10 +650,9 @@ function parseBlobJsonsFromResponse(response, logger) {
 // 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) {
-    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) {
+    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
@@ -588,11 +680,15 @@ function getBeaconNodeFetchOptions(url, config, l1ConsensusHostIndex) {
     const l1ConsensusHostApiKey = l1ConsensusHostIndex !== undefined && l1ConsensusHostApiKeys && l1ConsensusHostApiKeys[l1ConsensusHostIndex];
     const l1ConsensusHostApiKeyHeader = l1ConsensusHostIndex !== undefined && l1ConsensusHostApiKeyHeaders && l1ConsensusHostApiKeyHeaders[l1ConsensusHostIndex];
     let formattedUrl = url;
+    let logSafeUrl = url;
     if (l1ConsensusHostApiKey && l1ConsensusHostApiKey.getValue() !== '' && !l1ConsensusHostApiKeyHeader) {
-        formattedUrl += `${formattedUrl.includes('?') ? '&' : '?'}key=${l1ConsensusHostApiKey.getValue()}`;
+        const separator = formattedUrl.includes('?') ? '&' : '?';
+        formattedUrl += `${separator}key=${l1ConsensusHostApiKey.getValue()}`;
+        logSafeUrl += `${separator}key=[REDACTED]`;
     }
     return {
         url: formattedUrl,
+        logSafeUrl,
         ...l1ConsensusHostApiKey && l1ConsensusHostApiKeyHeader && {
             headers: {
                 [l1ConsensusHostApiKeyHeader]: l1ConsensusHostApiKey.getValue()

package/dest/client/interface.d.ts

@@ -5,11 +5,20 @@ import type { Blob } from '@aztec/blob-lib';
 export interface GetBlobSidecarOptions {
     /**
      * True if the archiver is catching up (historical sync), false if near tip.
-     * 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)
+     * Historical sync uses a shorter retry backoff since blobs should already exist.
      */
     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 {
     /** Sends the given blobs to the filestore, to be indexed by blob hash. */
@@ -25,4 +34,4 @@ export interface BlobClientInterface {
     /** Returns true if this client can upload blobs to filestore. */
     canUpload(): boolean;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpZW50L2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxJQUFJLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUU1Qzs7R0FFRztBQUNILE1BQU0sV0FBVyxxQkFBcUI7SUFDcEM7Ozs7O09BS0c7SUFDSCxnQkFBZ0IsQ0FBQyxFQUFFLE9BQU8sQ0FBQztDQUM1QjtBQUVELE1BQU0sV0FBVyxtQkFBbUI7SUFDbEMsMEVBQTBFO0lBQzFFLG9CQUFvQixDQUFDLEtBQUssRUFBRSxJQUFJLEVBQUUsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDdEQscUVBQXFFO0lBQ3JFLGNBQWMsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsQ0FBQyxFQUFFLE1BQU0sRUFBRSxFQUFFLElBQUksQ0FBQyxFQUFFLHFCQUFxQixHQUFHLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ3RHLDZFQUE2RTtJQUM3RSxLQUFLLENBQUMsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDeEIsb0ZBQW9GO0lBQ3BGLFdBQVcsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDN0IsMERBQTBEO0lBQzFELElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQztJQUNkLGlFQUFpRTtJQUNqRSxTQUFTLElBQUksT0FBTyxDQUFDO0NBQ3RCIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpZW50L2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxJQUFJLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUU1Qzs7R0FFRztBQUNILE1BQU0sV0FBVyxxQkFBcUI7SUFDcEM7OztPQUdHO0lBQ0gsZ0JBQWdCLENBQUMsRUFBRSxPQUFPLENBQUM7SUFDM0I7OztPQUdHO0lBQ0gscUJBQXFCLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDL0I7Ozs7T0FJRztJQUNILGdCQUFnQixDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQzNCO0FBRUQsTUFBTSxXQUFXLG1CQUFtQjtJQUNsQywwRUFBMEU7SUFDMUUsb0JBQW9CLENBQUMsS0FBSyxFQUFFLElBQUksRUFBRSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUN0RCxxRUFBcUU7SUFDckUsY0FBYyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxDQUFDLEVBQUUsTUFBTSxFQUFFLEVBQUUsSUFBSSxDQUFDLEVBQUUscUJBQXFCLEdBQUcsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7SUFDdEcsNkVBQTZFO0lBQzdFLEtBQUssQ0FBQyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN4QixvRkFBb0Y7SUFDcEYsV0FBVyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM3QiwwREFBMEQ7SUFDMUQsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDO0lBQ2QsaUVBQWlFO0lBQ2pFLFNBQVMsSUFBSSxPQUFPLENBQUM7Q0FDdEIifQ==

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;;;OAGG;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/filestore/factory.d.ts

@@ -1,4 +1,5 @@
 import { type Logger } from '@aztec/foundation/log';
+import { type HttpFileStoreOptions } from '@aztec/stdlib/file-store';
 import { FileStoreBlobClient } from './filestore_blob_client.js';
 /**
  * Metadata required to construct the base path for blob storage.
@@ -25,8 +26,8 @@ export declare function makeBlobBasePath(metadata: BlobFileStoreMetadata): strin
  * @param logger - Optional logger
  * @returns A FileStoreBlobClient for reading blobs, or undefined if storeUrl is undefined
  */
-export declare function createReadOnlyFileStoreBlobClient(storeUrl: string, metadata: BlobFileStoreMetadata, logger?: Logger): Promise<FileStoreBlobClient>;
-export declare function createReadOnlyFileStoreBlobClient(storeUrl: string | undefined, metadata: BlobFileStoreMetadata, logger?: Logger): Promise<FileStoreBlobClient | undefined>;
+export declare function createReadOnlyFileStoreBlobClient(storeUrl: string, metadata: BlobFileStoreMetadata, logger?: Logger, httpOptions?: HttpFileStoreOptions): Promise<FileStoreBlobClient>;
+export declare function createReadOnlyFileStoreBlobClient(storeUrl: string | undefined, metadata: BlobFileStoreMetadata, logger?: Logger, httpOptions?: HttpFileStoreOptions): Promise<FileStoreBlobClient | undefined>;
 /**
  * Creates multiple read-only FileStoreBlobClients from an array of URLs.
  *
@@ -35,7 +36,7 @@ export declare function createReadOnlyFileStoreBlobClient(storeUrl: string | und
  * @param logger - Optional logger
  * @returns Array of FileStoreBlobClients (excludes any that failed to create)
  */
-export declare function createReadOnlyFileStoreBlobClients(storeUrls: string[] | undefined, metadata: BlobFileStoreMetadata, logger?: Logger): Promise<FileStoreBlobClient[]>;
+export declare function createReadOnlyFileStoreBlobClients(storeUrls: string[] | undefined, metadata: BlobFileStoreMetadata, logger?: Logger, httpOptions?: HttpFileStoreOptions): Promise<FileStoreBlobClient[]>;
 /**
  * Creates a writable FileStoreBlobClient for uploading blobs.
  * Note: https:// URLs are not supported for upload, only s3://, gs://, or file://.
@@ -47,4 +48,4 @@ export declare function createReadOnlyFileStoreBlobClients(storeUrls: string[] |
  */
 export declare function createWritableFileStoreBlobClient(storeUrl: string, metadata: BlobFileStoreMetadata, logger?: Logger): Promise<FileStoreBlobClient>;
 export declare function createWritableFileStoreBlobClient(storeUrl: string | undefined, metadata: BlobFileStoreMetadata, logger?: Logger): Promise<FileStoreBlobClient | undefined>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZpbGVzdG9yZS9mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQVFsRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUVqRTs7O0dBR0c7QUFDSCxNQUFNLFdBQVcscUJBQXFCO0lBQ3BDLHNCQUFzQjtJQUN0QixTQUFTLEVBQUUsTUFBTSxDQUFDO0lBQ2xCLHlCQUF5QjtJQUN6QixhQUFhLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLDhEQUE4RDtJQUM5RCxhQUFhLEVBQUUsTUFBTSxDQUFDO0NBQ3ZCO0FBRUQ7OztHQUdHO0FBQ0gsd0JBQWdCLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxxQkFBcUIsR0FBRyxNQUFNLENBS3hFO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFzQixpQ0FBaUMsQ0FDckQsUUFBUSxFQUFFLE1BQU0sRUFDaEIsUUFBUSxFQUFFLHFCQUFxQixFQUMvQixNQUFNLENBQUMsRUFBRSxNQUFNLEdBQ2QsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQUM7QUFDaEMsd0JBQXNCLGlDQUFpQyxDQUNyRCxRQUFRLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFDNUIsUUFBUSxFQUFFLHFCQUFxQixFQUMvQixNQUFNLENBQUMsRUFBRSxNQUFNLEdBQ2QsT0FBTyxDQUFDLG1CQUFtQixHQUFHLFNBQVMsQ0FBQyxDQUFDO0FBbUI1Qzs7Ozs7OztHQU9HO0FBQ0gsd0JBQXNCLGtDQUFrQyxDQUN0RCxTQUFTLEVBQUUsTUFBTSxFQUFFLEdBQUcsU0FBUyxFQUMvQixRQUFRLEVBQUUscUJBQXFCLEVBQy9CLE1BQU0sQ0FBQyxFQUFFLE1BQU0sR0FDZCxPQUFPLENBQUMsbUJBQW1CLEVBQUUsQ0FBQyxDQW9CaEM7QUFFRDs7Ozs7Ozs7R0FRRztBQUNILHdCQUFzQixpQ0FBaUMsQ0FDckQsUUFBUSxFQUFFLE1BQU0sRUFDaEIsUUFBUSxFQUFFLHFCQUFxQixFQUMvQixNQUFNLENBQUMsRUFBRSxNQUFNLEdBQ2QsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQUM7QUFDaEMsd0JBQXNCLGlDQUFpQyxDQUNyRCxRQUFRLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFDNUIsUUFBUSxFQUFFLHFCQUFxQixFQUMvQixNQUFNLENBQUMsRUFBRSxNQUFNLEdBQ2QsT0FBTyxDQUFDLG1CQUFtQixHQUFHLFNBQVMsQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZpbGVzdG9yZS9mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUNsRSxPQUFPLEVBRUwsS0FBSyxvQkFBb0IsRUFJMUIsTUFBTSwwQkFBMEIsQ0FBQztBQUVsQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUVqRTs7O0dBR0c7QUFDSCxNQUFNLFdBQVcscUJBQXFCO0lBQ3BDLHNCQUFzQjtJQUN0QixTQUFTLEVBQUUsTUFBTSxDQUFDO0lBQ2xCLHlCQUF5QjtJQUN6QixhQUFhLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLDhEQUE4RDtJQUM5RCxhQUFhLEVBQUUsTUFBTSxDQUFDO0NBQ3ZCO0FBRUQ7OztHQUdHO0FBQ0gsd0JBQWdCLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxxQkFBcUIsR0FBRyxNQUFNLENBS3hFO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFzQixpQ0FBaUMsQ0FDckQsUUFBUSxFQUFFLE1BQU0sRUFDaEIsUUFBUSxFQUFFLHFCQUFxQixFQUMvQixNQUFNLENBQUMsRUFBRSxNQUFNLEVBQ2YsV0FBVyxDQUFDLEVBQUUsb0JBQW9CLEdBQ2pDLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO0FBQ2hDLHdCQUFzQixpQ0FBaUMsQ0FDckQsUUFBUSxFQUFFLE1BQU0sR0FBRyxTQUFTLEVBQzVCLFFBQVEsRUFBRSxxQkFBcUIsRUFDL0IsTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUNmLFdBQVcsQ0FBQyxFQUFFLG9CQUFvQixHQUNqQyxPQUFPLENBQUMsbUJBQW1CLEdBQUcsU0FBUyxDQUFDLENBQUM7QUFvQjVDOzs7Ozs7O0dBT0c7QUFDSCx3QkFBc0Isa0NBQWtDLENBQ3RELFNBQVMsRUFBRSxNQUFNLEVBQUUsR0FBRyxTQUFTLEVBQy9CLFFBQVEsRUFBRSxxQkFBcUIsRUFDL0IsTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUNmLFdBQVcsQ0FBQyxFQUFFLG9CQUFvQixHQUNqQyxPQUFPLENBQUMsbUJBQW1CLEVBQUUsQ0FBQyxDQW9CaEM7QUFFRDs7Ozs7Ozs7R0FRRztBQUNILHdCQUFzQixpQ0FBaUMsQ0FDckQsUUFBUSxFQUFFLE1BQU0sRUFDaEIsUUFBUSxFQUFFLHFCQUFxQixFQUMvQixNQUFNLENBQUMsRUFBRSxNQUFNLEdBQ2QsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQUM7QUFDaEMsd0JBQXNCLGlDQUFpQyxDQUNyRCxRQUFRLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFDNUIsUUFBUSxFQUFFLHFCQUFxQixFQUMvQixNQUFNLENBQUMsRUFBRSxNQUFNLEdBQ2QsT0FBTyxDQUFDLG1CQUFtQixHQUFHLFNBQVMsQ0FBQyxDQUFDIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/filestore/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAQlE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,sBAAsB;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,yBAAyB;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,CAKxE;AAED;;;;;;;GAOG;AACH,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAAC;AAmB5C;;;;;;;GAOG;AACH,wBAAsB,kCAAkC,CACtD,SAAS,EAAE,MAAM,EAAE,GAAG,SAAS,EAC/B,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAoBhC;AAED;;;;;;;;GAQG;AACH,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAAC"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/filestore/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAEL,KAAK,oBAAoB,EAI1B,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,sBAAsB;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,yBAAyB;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,CAKxE;AAED;;;;;;;GAOG;AACH,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,oBAAoB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,oBAAoB,GACjC,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAAC;AAoB5C;;;;;;;GAOG;AACH,wBAAsB,kCAAkC,CACtD,SAAS,EAAE,MAAM,EAAE,GAAG,SAAS,EAC/B,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,oBAAoB,GACjC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAoBhC;AAED;;;;;;;;GAQG;AACH,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAChC,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAAC"}

package/dest/filestore/factory.js

@@ -10,7 +10,7 @@ import { FileStoreBlobClient } from './filestore_blob_client.js';
     const normalizedAddress = rollupAddress.toLowerCase().replace(/^0x/, '');
     return `aztec-${l1ChainId}-${rollupVersion}-0x${normalizedAddress}`;
 }
-export async function createReadOnlyFileStoreBlobClient(storeUrl, metadata, logger) {
+export async function createReadOnlyFileStoreBlobClient(storeUrl, metadata, logger, httpOptions) {
     if (!storeUrl) {
         return undefined;
     }
@@ -20,7 +20,7 @@ export async function createReadOnlyFileStoreBlobClient(storeUrl, metadata, logg
         storeUrl,
         basePath
     });
-    const store = await createReadOnlyFileStore(storeUrl, log);
+    const store = await createReadOnlyFileStore(storeUrl, log, httpOptions);
     return new FileStoreBlobClient(store, basePath, log);
 }
 /**
@@ -30,7 +30,7 @@ export async function createReadOnlyFileStoreBlobClient(storeUrl, metadata, logg
  * @param metadata - Chain metadata for constructing the base path
  * @param logger - Optional logger
  * @returns Array of FileStoreBlobClients (excludes any that failed to create)
- */ export async function createReadOnlyFileStoreBlobClients(storeUrls, metadata, logger) {
+ */ export async function createReadOnlyFileStoreBlobClients(storeUrls, metadata, logger, httpOptions) {
     if (!storeUrls || storeUrls.length === 0) {
         return [];
     }
@@ -38,7 +38,7 @@ export async function createReadOnlyFileStoreBlobClient(storeUrl, metadata, logg
     const clients = [];
     for (const storeUrl of storeUrls){
         try {
-            const client = await createReadOnlyFileStoreBlobClient(storeUrl, metadata, log);
+            const client = await createReadOnlyFileStoreBlobClient(storeUrl, metadata, log, httpOptions);
             if (client) {
                 clients.push(client);
             }