@aztec/blob-client 0.0.1-commit.f504929 → 0.0.1-commit.f650c0a5c

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);
             }

package/package.json

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

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,15 @@ 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;
+
+  /** 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> = {
@@ -108,6 +118,21 @@ 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(),
+  },
+  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,8 +76,15 @@ 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),
+    createReadOnlyFileStoreBlobClients(config.blobFileStoreUrls, fileStoreMetadata, log, httpOptions),
     createWritableFileStoreBlobClient(config.blobFileStoreUploadUrl, fileStoreMetadata, log),
   ]);
 

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';
@@ -29,6 +30,9 @@ export class HttpBlobClient implements BlobClientInterface {
   /** 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: {
@@ -94,44 +98,75 @@ 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;
+
+    const detectedSuperNodes = new Set<number>();
 
     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 });
+              detectedSuperNodes.add(l1ConsensusHostIndex);
+              consensusSuperNodes++;
+            } else {
+              this.log.info(`L1 consensus host does not serve blob sidecars, skipping for blob fetching`, {
+                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');
     }
 
+    this.superNodeHostIndexes = detectedSuperNodes;
+
     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) {
@@ -140,7 +175,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() });
           }
@@ -150,12 +185,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);
     }
   }
 
@@ -181,18 +228,15 @@ export class HttpBlobClient implements BlobClientInterface {
   }
 
   /**
-   * 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
+   * Get the blob sidecar.
    *
-   * 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
    */
   public async getBlobSidecar(
@@ -205,12 +249,11 @@ 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))
@@ -239,84 +282,60 @@ export class HttpBlobClient implements BlobClientInterface {
       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: number | undefined;
+    let slotResolved = false;
+    const getSlotNumber = async (): Promise<number | undefined> => {
+      if (!slotResolved) {
+        slotNumber = await this.resolveSlotNumber(blockHash, opts);
+        slotResolved = true;
       }
-    }
+      return slotNumber;
+    };
 
-    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, opts?.parentBeaconBlockRoot, opts?.l1BlockTimestamp);
-      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;
-          }
+    // 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);
 
-          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,
-            getMissingBlobHashes(),
-          );
-          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);
-          }
-        }
-      }
-    }
+    const preferFilestores = this.config.blobPreferFilestores ?? false;
+    const [trySourceA, trySourceB] = preferFilestores ? [tryFilestores, tryConsensus] : [tryConsensus, tryFilestores];
 
-    // 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
-      }
+    // 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();
+          }
+          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, // failSilently — expected during eventual consistency
+      );
+      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);
@@ -338,7 +357,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,
+          l1ConsensusHostUrls: this.config.l1ConsensusHostUrls,
           archiveUrl: this.archiveClient?.getBaseUrl(),
           fileStoreUrls: this.fileStoreClients.map(c => c.getBaseUrl()),
         },
@@ -347,6 +366,71 @@ 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
@@ -462,16 +546,17 @@ export class HttpBlobClient implements BlobClientInterface {
       baseUrl += `?${params.toString()}`;
     }
 
-    const { url, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
-    this.log.debug(`Fetching blob sidecar for ${blockHashOrSlot}`, { url, ...options });
-    return this.fetch(url, options);
+    const { url, logSafeUrl, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
+    this.log.debug(`Fetching blob sidecar for ${blockHashOrSlot}`, { url: logSafeUrl, ...options });
+    // No retry here — this is called inside the main retry loop in getBlobSidecar
+    return fetch(url, options);
   }
 
   private async getLatestSlotNumber(hostUrl: string, l1ConsensusHostIndex?: number): Promise<number | undefined> {
     try {
       const baseUrl = `${hostUrl}/eth/v1/beacon/headers/head`;
-      const { url, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
-      this.log.debug(`Fetching latest slot number`, { url, ...options });
+      const { url, logSafeUrl, ...options } = getBeaconNodeFetchOptions(baseUrl, this.config, l1ConsensusHostIndex);
+      this.log.debug(`Fetching latest slot number`, { url: logSafeUrl, ...options });
       const res = await this.fetch(url, options);
       if (res.ok) {
         const body = await res.json();
@@ -532,7 +617,7 @@ export class HttpBlobClient implements BlobClientInterface {
       }
 
       const client = createPublicClient({
-        transport: fallback(l1RpcUrls.map(url => http(url, { batch: false }))),
+        transport: makeL1HttpTransport(l1RpcUrls, { timeout: this.config.l1HttpTimeoutMS }),
       });
       try {
         const res: RpcBlock = await client.request({
@@ -734,12 +819,16 @@ function getBeaconNodeFetchOptions(url: string, config: BlobClientConfig, l1Cons
     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: {

package/src/client/interface.ts

@@ -6,9 +6,7 @@ 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;
   /**