@aztec/node-lib 3.0.0-canary.a9708bd → 3.0.0-devnet.3

package/dest/stores/l1_tx_store.js

@@ -0,0 +1,264 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+/**
+ * Store for persisting L1 transaction states across all L1TxUtils instances.
+ * Each state is stored individually with a unique ID, and blobs are stored separately.
+ * @remarks This class lives in this package instead of `ethereum` because it depends on `kv-store`.
+ */ export class L1TxStore {
+    store;
+    log;
+    static SCHEMA_VERSION = 2;
+    states;
+    blobs;
+    stateIdCounter;
+    constructor(store, log = createLogger('l1-tx-utils:store')){
+        this.store = store;
+        this.log = log;
+        this.states = store.openMap('l1_tx_states');
+        this.blobs = store.openMap('l1_tx_blobs');
+        this.stateIdCounter = store.openMap('l1_tx_state_id_counter');
+    }
+    /**
+   * Gets the next available state ID for an account.
+   */ consumeNextStateId(account) {
+        return this.store.transactionAsync(async ()=>{
+            const currentId = await this.stateIdCounter.getAsync(account) ?? 0;
+            const nextId = currentId + 1;
+            await this.stateIdCounter.set(account, nextId);
+            return nextId;
+        });
+    }
+    /**
+   * Creates a storage key for state/blob data.
+   */ makeKey(account, stateId) {
+        return `${account}-${stateId.toString().padStart(10, '0')}`;
+    }
+    /**
+   * Saves a single transaction state for a specific account.
+   * Blobs are not stored here, use saveBlobs instead.
+   * @param account - The sender account address
+   * @param state - Transaction state to save
+   */ async saveState(account, state) {
+        const key = this.makeKey(account, state.id);
+        const serializable = this.serializeState(state);
+        await this.states.set(key, jsonStringify(serializable));
+        this.log.debug(`Saved tx state ${state.id} for account ${account} with nonce ${state.nonce}`);
+        return state;
+    }
+    /**
+   * Saves blobs for a given state.
+   * @param account - The sender account address
+   * @param stateId - The state ID
+   * @param blobInputs - Blob inputs to save
+   */ async saveBlobs(account, stateId, blobInputs) {
+        if (!blobInputs) {
+            return;
+        }
+        const key = this.makeKey(account, stateId);
+        const blobData = this.serializeBlobInputs(blobInputs);
+        await this.blobs.set(key, jsonStringify(blobData));
+        this.log.debug(`Saved blobs for state ${stateId} of account ${account}`);
+    }
+    /**
+   * Loads all transaction states for a specific account.
+   * @param account - The sender account address
+   * @returns Array of transaction states with their IDs
+   */ async loadStates(account) {
+        const states = [];
+        const prefix = `${account}-`;
+        for await (const [key, stateJson] of this.states.entriesAsync({
+            start: prefix,
+            end: `${prefix}Z`
+        })){
+            const [keyAccount, stateIdStr] = key.split('-');
+            if (keyAccount !== account) {
+                throw new Error(`Mismatched account in key: expected ${account} but got ${keyAccount}`);
+            }
+            const stateId = parseInt(stateIdStr, 10);
+            try {
+                const serialized = JSON.parse(stateJson);
+                // Load blobs if they exist
+                let blobInputs;
+                if (serialized.hasBlobInputs) {
+                    const blobJson = await this.blobs.getAsync(key);
+                    if (blobJson) {
+                        blobInputs = this.deserializeBlobInputs(JSON.parse(blobJson), serialized.blobMetadata);
+                    }
+                }
+                const state = this.deserializeState(serialized, blobInputs);
+                states.push({
+                    ...state,
+                    id: stateId
+                });
+            } catch (err) {
+                this.log.error(`Failed to deserialize state ${key}`, err);
+            }
+        }
+        // Sort by ID
+        states.sort((a, b)=>a.id - b.id);
+        this.log.debug(`Loaded ${states.length} tx states for account ${account}`);
+        return states;
+    }
+    /**
+   * Loads a single state by ID.
+   * @param account - The sender account address
+   * @param stateId - The state ID
+   * @returns The transaction state or undefined if not found
+   */ async loadState(account, stateId) {
+        const key = this.makeKey(account, stateId);
+        const stateJson = await this.states.getAsync(key);
+        if (!stateJson) {
+            return undefined;
+        }
+        try {
+            const serialized = JSON.parse(stateJson);
+            // Load blobs if they exist
+            let blobInputs;
+            if (serialized.hasBlobInputs) {
+                const blobJson = await this.blobs.getAsync(key);
+                if (blobJson) {
+                    blobInputs = this.deserializeBlobInputs(JSON.parse(blobJson), serialized.blobMetadata);
+                }
+            }
+            const state = this.deserializeState(serialized, blobInputs);
+            return {
+                ...state,
+                id: stateId
+            };
+        } catch (err) {
+            this.log.error(`Failed to deserialize state ${key}`, err);
+            return undefined;
+        }
+    }
+    /**
+   * Deletes a specific state and its associated blobs.
+   * @param account - The sender account address
+   * @param stateId - The state ID to delete
+   */ async deleteState(account, stateId) {
+        const key = this.makeKey(account, stateId);
+        await this.states.delete(key);
+        await this.blobs.delete(key);
+        this.log.debug(`Deleted state ${stateId} for account ${account}`);
+    }
+    /**
+   * Clears all transaction states for a specific account.
+   * @param account - The sender account address
+   */ async clearStates(account) {
+        const states = await this.loadStates(account);
+        for (const state of states){
+            await this.deleteState(account, state.id);
+        }
+        await this.stateIdCounter.delete(account);
+        this.log.info(`Cleared all tx states for account ${account}`);
+    }
+    /**
+   * Gets all accounts that have stored states.
+   * @returns Array of account addresses
+   */ async getAllAccounts() {
+        const accounts = new Set();
+        for await (const [key] of this.states.entriesAsync()){
+            const account = key.substring(0, key.lastIndexOf('-'));
+            accounts.add(account);
+        }
+        return Array.from(accounts);
+    }
+    /**
+   * Closes the store.
+   */ async close() {
+        await this.store.close();
+        this.log.info('Closed L1 tx state store');
+    }
+    /**
+   * Serializes an L1TxState for storage.
+   */ serializeState(state) {
+        const txConfigOverrides = {
+            ...state.txConfigOverrides,
+            gasLimit: state.txConfigOverrides.gasLimit?.toString(),
+            txTimeoutAt: state.txConfigOverrides.txTimeoutAt?.getTime()
+        };
+        return {
+            id: state.id,
+            txHashes: state.txHashes,
+            cancelTxHashes: state.cancelTxHashes,
+            gasLimit: state.gasLimit.toString(),
+            gasPrice: {
+                maxFeePerGas: state.gasPrice.maxFeePerGas.toString(),
+                maxPriorityFeePerGas: state.gasPrice.maxPriorityFeePerGas.toString(),
+                maxFeePerBlobGas: state.gasPrice.maxFeePerBlobGas?.toString()
+            },
+            txConfigOverrides,
+            request: {
+                ...state.request,
+                value: state.request.value?.toString()
+            },
+            status: state.status,
+            nonce: state.nonce,
+            sentAt: state.sentAtL1Ts.getTime(),
+            lastSentAt: state.lastSentAtL1Ts.getTime(),
+            receipt: state.receipt,
+            hasBlobInputs: state.blobInputs !== undefined,
+            blobMetadata: state.blobInputs?.maxFeePerBlobGas ? {
+                maxFeePerBlobGas: state.blobInputs.maxFeePerBlobGas.toString()
+            } : undefined
+        };
+    }
+    /**
+   * Deserializes a stored state back to L1TxState.
+   */ deserializeState(stored, blobInputs) {
+        const txConfigOverrides = {
+            ...stored.txConfigOverrides,
+            gasLimit: stored.txConfigOverrides.gasLimit !== undefined ? BigInt(stored.txConfigOverrides.gasLimit) : undefined,
+            txTimeoutAt: stored.txConfigOverrides.txTimeoutAt !== undefined ? new Date(stored.txConfigOverrides.txTimeoutAt) : undefined
+        };
+        const receipt = stored.receipt ? {
+            ...stored.receipt,
+            blockNumber: BigInt(stored.receipt.blockNumber),
+            cumulativeGasUsed: BigInt(stored.receipt.cumulativeGasUsed),
+            effectiveGasPrice: BigInt(stored.receipt.effectiveGasPrice),
+            gasUsed: BigInt(stored.receipt.gasUsed)
+        } : undefined;
+        return {
+            id: stored.id,
+            txHashes: stored.txHashes,
+            cancelTxHashes: stored.cancelTxHashes,
+            gasLimit: BigInt(stored.gasLimit),
+            gasPrice: {
+                maxFeePerGas: BigInt(stored.gasPrice.maxFeePerGas),
+                maxPriorityFeePerGas: BigInt(stored.gasPrice.maxPriorityFeePerGas),
+                maxFeePerBlobGas: stored.gasPrice.maxFeePerBlobGas ? BigInt(stored.gasPrice.maxFeePerBlobGas) : undefined
+            },
+            txConfigOverrides,
+            request: {
+                to: stored.request.to,
+                data: stored.request.data,
+                value: stored.request.value ? BigInt(stored.request.value) : undefined
+            },
+            status: stored.status,
+            nonce: stored.nonce,
+            sentAtL1Ts: new Date(stored.sentAt),
+            lastSentAtL1Ts: new Date(stored.lastSentAt),
+            receipt,
+            blobInputs
+        };
+    }
+    /**
+   * Serializes blob inputs for separate storage.
+   */ serializeBlobInputs(blobInputs) {
+        return {
+            blobs: blobInputs.blobs.map((b)=>Buffer.from(b).toString('base64')),
+            kzg: jsonStringify(blobInputs.kzg)
+        };
+    }
+    /**
+   * Deserializes blob inputs from storage, combining blob data with metadata.
+   */ deserializeBlobInputs(stored, metadata) {
+        const blobInputs = {
+            blobs: stored.blobs.map((b)=>new Uint8Array(Buffer.from(b, 'base64'))),
+            kzg: JSON.parse(stored.kzg)
+        };
+        if (metadata?.maxFeePerBlobGas) {
+            blobInputs.maxFeePerBlobGas = BigInt(metadata.maxFeePerBlobGas);
+        }
+        return blobInputs;
+    }
+}

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@aztec/node-lib",
-  "version": "3.0.0-canary.a9708bd",
+  "version": "3.0.0-devnet.3",
   "type": "module",
   "exports": {
     "./actions": "./dest/actions/index.js",
-    "./config": "./dest/config/index.js"
+    "./config": "./dest/config/index.js",
+    "./factories": "./dest/factories/index.js",
+    "./metrics": "./dest/metrics/index.js",
+    "./stores": "./dest/stores/index.js"
   },
   "inherits": [
     "../package.common.json"
@@ -54,27 +57,28 @@
     ]
   },
   "dependencies": {
-    "@aztec/archiver": "3.0.0-canary.a9708bd",
-    "@aztec/bb-prover": "3.0.0-canary.a9708bd",
-    "@aztec/blob-sink": "3.0.0-canary.a9708bd",
-    "@aztec/constants": "3.0.0-canary.a9708bd",
-    "@aztec/epoch-cache": "3.0.0-canary.a9708bd",
-    "@aztec/ethereum": "3.0.0-canary.a9708bd",
-    "@aztec/foundation": "3.0.0-canary.a9708bd",
-    "@aztec/kv-store": "3.0.0-canary.a9708bd",
-    "@aztec/merkle-tree": "3.0.0-canary.a9708bd",
-    "@aztec/p2p": "3.0.0-canary.a9708bd",
-    "@aztec/protocol-contracts": "3.0.0-canary.a9708bd",
-    "@aztec/prover-client": "3.0.0-canary.a9708bd",
-    "@aztec/sequencer-client": "3.0.0-canary.a9708bd",
-    "@aztec/simulator": "3.0.0-canary.a9708bd",
-    "@aztec/stdlib": "3.0.0-canary.a9708bd",
-    "@aztec/telemetry-client": "3.0.0-canary.a9708bd",
-    "@aztec/validator-client": "3.0.0-canary.a9708bd",
-    "@aztec/world-state": "3.0.0-canary.a9708bd",
+    "@aztec/archiver": "3.0.0-devnet.3",
+    "@aztec/bb-prover": "3.0.0-devnet.3",
+    "@aztec/blob-sink": "3.0.0-devnet.3",
+    "@aztec/constants": "3.0.0-devnet.3",
+    "@aztec/epoch-cache": "3.0.0-devnet.3",
+    "@aztec/ethereum": "3.0.0-devnet.3",
+    "@aztec/foundation": "3.0.0-devnet.3",
+    "@aztec/kv-store": "3.0.0-devnet.3",
+    "@aztec/merkle-tree": "3.0.0-devnet.3",
+    "@aztec/p2p": "3.0.0-devnet.3",
+    "@aztec/protocol-contracts": "3.0.0-devnet.3",
+    "@aztec/prover-client": "3.0.0-devnet.3",
+    "@aztec/sequencer-client": "3.0.0-devnet.3",
+    "@aztec/simulator": "3.0.0-devnet.3",
+    "@aztec/stdlib": "3.0.0-devnet.3",
+    "@aztec/telemetry-client": "3.0.0-devnet.3",
+    "@aztec/validator-client": "3.0.0-devnet.3",
+    "@aztec/world-state": "3.0.0-devnet.3",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
+    "@aztec/blob-lib": "3.0.0-devnet.3",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/actions/snapshot-sync.ts

@@ -26,11 +26,12 @@ import type { SharedNodeConfig } from '../config/index.js';
 // Half day worth of L1 blocks
 const MIN_L1_BLOCKS_TO_TRIGGER_REPLACE = 86400 / 2 / 12;
 
-type SnapshotSyncConfig = Pick<SharedNodeConfig, 'syncMode' | 'snapshotsUrl'> &
+type SnapshotSyncConfig = Pick<SharedNodeConfig, 'syncMode'> &
   Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> &
   Pick<ArchiverConfig, 'archiverStoreMapSizeKb' | 'maxLogs'> &
   Required<DataStoreConfig> &
   EthereumClientConfig & {
+    snapshotsUrls?: string[];
     minL1BlocksToTriggerReplace?: number;
   };
 
@@ -39,14 +40,14 @@ type SnapshotSyncConfig = Pick<SharedNodeConfig, 'syncMode' | 'snapshotsUrl'> &
  * Behaviour depends on syncing mode.
  */
 export async function trySnapshotSync(config: SnapshotSyncConfig, log: Logger) {
-  const { syncMode, snapshotsUrl, dataDirectory, l1ChainId, rollupVersion, l1Contracts } = config;
+  const { syncMode, snapshotsUrls, dataDirectory, l1ChainId, rollupVersion, l1Contracts } = config;
   if (syncMode === 'full') {
     log.debug('Snapshot sync is disabled. Running full sync.', { syncMode: syncMode });
     return false;
   }
 
-  if (!snapshotsUrl) {
-    log.verbose('Snapshot sync is disabled. No snapshots URL provided.');
+  if (!snapshotsUrls || snapshotsUrls.length === 0) {
+    log.verbose('Snapshot sync is disabled. No snapshots URLs provided.');
     return false;
   }
 
@@ -55,15 +56,7 @@ export async function trySnapshotSync(config: SnapshotSyncConfig, log: Logger) {
     return false;
   }
 
-  let fileStore: ReadOnlyFileStore;
-  try {
-    fileStore = await createReadOnlyFileStore(snapshotsUrl, log);
-  } catch (err) {
-    log.error(`Invalid config for downloading snapshots`, err);
-    return false;
-  }
-
-  // Create an archiver store to check the current state
+  // Create an archiver store to check the current state (do this only once)
   log.verbose(`Creating temporary archiver data store`);
   const archiverStore = await createArchiverStore(config);
   let archiverL1BlockNumber: bigint | undefined;
@@ -102,65 +95,111 @@ export async function trySnapshotSync(config: SnapshotSyncConfig, log: Logger) {
     rollupVersion,
     rollupAddress: l1Contracts.rollupAddress,
   };
-  let snapshot: SnapshotMetadata | undefined;
-  try {
-    snapshot = await getLatestSnapshotMetadata(indexMetadata, fileStore);
-  } catch (err) {
-    log.error(`Failed to get latest snapshot metadata. Skipping snapshot sync.`, err, {
-      ...indexMetadata,
-      snapshotsUrl,
-    });
-    return false;
-  }
 
-  if (!snapshot) {
-    log.verbose(`No snapshot found. Skipping snapshot sync.`, { ...indexMetadata, snapshotsUrl });
-    return false;
-  }
+  // Fetch latest snapshot from each URL
+  type SnapshotCandidate = { snapshot: SnapshotMetadata; url: string; fileStore: ReadOnlyFileStore };
+  const snapshotCandidates: SnapshotCandidate[] = [];
 
-  if (snapshot.schemaVersions.archiver !== ARCHIVER_DB_VERSION) {
-    log.warn(
-      `Skipping snapshot sync as last snapshot has schema version ${snapshot.schemaVersions.archiver} but expected ${ARCHIVER_DB_VERSION}.`,
-      snapshot,
-    );
-    return false;
-  }
+  for (const snapshotsUrl of snapshotsUrls) {
+    let fileStore: ReadOnlyFileStore;
+    try {
+      fileStore = await createReadOnlyFileStore(snapshotsUrl, log);
+    } catch (err) {
+      log.error(`Invalid config for downloading snapshots from ${snapshotsUrl}`, err);
+      continue;
+    }
 
-  if (snapshot.schemaVersions.worldState !== WORLD_STATE_DB_VERSION) {
-    log.warn(
-      `Skipping snapshot sync as last snapshot has world state schema version ${snapshot.schemaVersions.worldState} but we expected ${WORLD_STATE_DB_VERSION}.`,
-      snapshot,
-    );
-    return false;
+    let snapshot: SnapshotMetadata | undefined;
+    try {
+      snapshot = await getLatestSnapshotMetadata(indexMetadata, fileStore);
+    } catch (err) {
+      log.error(`Failed to get latest snapshot metadata from ${snapshotsUrl}. Skipping this URL.`, err, {
+        ...indexMetadata,
+        snapshotsUrl,
+      });
+      continue;
+    }
+
+    if (!snapshot) {
+      log.verbose(`No snapshot found at ${snapshotsUrl}. Skipping this URL.`, { ...indexMetadata, snapshotsUrl });
+      continue;
+    }
+
+    if (snapshot.schemaVersions.archiver !== ARCHIVER_DB_VERSION) {
+      log.warn(
+        `Skipping snapshot from ${snapshotsUrl} as it has schema version ${snapshot.schemaVersions.archiver} but expected ${ARCHIVER_DB_VERSION}.`,
+        snapshot,
+      );
+      continue;
+    }
+
+    if (snapshot.schemaVersions.worldState !== WORLD_STATE_DB_VERSION) {
+      log.warn(
+        `Skipping snapshot from ${snapshotsUrl} as it has world state schema version ${snapshot.schemaVersions.worldState} but we expected ${WORLD_STATE_DB_VERSION}.`,
+        snapshot,
+      );
+      continue;
+    }
+
+    if (archiverL1BlockNumber && snapshot.l1BlockNumber < archiverL1BlockNumber) {
+      log.verbose(
+        `Skipping snapshot from ${snapshotsUrl} since local archiver is at L1 block ${archiverL1BlockNumber} which is further than snapshot at ${snapshot.l1BlockNumber}`,
+        { snapshot, archiverL1BlockNumber, snapshotsUrl },
+      );
+      continue;
+    }
+
+    if (archiverL1BlockNumber && snapshot.l1BlockNumber - Number(archiverL1BlockNumber) < minL1BlocksToTriggerReplace) {
+      log.verbose(
+        `Skipping snapshot from ${snapshotsUrl} as archiver is less than ${
+          snapshot.l1BlockNumber - Number(archiverL1BlockNumber)
+        } L1 blocks behind this snapshot.`,
+        { snapshot, archiverL1BlockNumber, snapshotsUrl },
+      );
+      continue;
+    }
+
+    snapshotCandidates.push({ snapshot, url: snapshotsUrl, fileStore });
   }
 
-  if (archiverL1BlockNumber && snapshot.l1BlockNumber < archiverL1BlockNumber) {
-    log.verbose(
-      `Skipping snapshot sync since local archiver is at L1 block ${archiverL1BlockNumber} which is further than last snapshot at ${snapshot.l1BlockNumber}`,
-      { snapshot, archiverL1BlockNumber },
-    );
+  if (snapshotCandidates.length === 0) {
+    log.verbose(`No valid snapshots found from any URL. Skipping snapshot sync.`, { ...indexMetadata, snapshotsUrls });
     return false;
   }
 
-  if (archiverL1BlockNumber && snapshot.l1BlockNumber - Number(archiverL1BlockNumber) < minL1BlocksToTriggerReplace) {
-    log.verbose(
-      `Skipping snapshot sync as archiver is less than ${
-        snapshot.l1BlockNumber - Number(archiverL1BlockNumber)
-      } L1 blocks behind latest snapshot.`,
-      { snapshot, archiverL1BlockNumber },
-    );
-    return false;
+  // Sort candidates by L1 block number (highest first)
+  snapshotCandidates.sort((a, b) => b.snapshot.l1BlockNumber - a.snapshot.l1BlockNumber);
+
+  // Try each candidate in order until one succeeds
+  for (const { snapshot, url } of snapshotCandidates) {
+    const { l1BlockNumber, l2BlockNumber } = snapshot;
+    log.info(`Attempting to sync from snapshot at L1 block ${l1BlockNumber} L2 block ${l2BlockNumber}`, {
+      snapshot,
+      snapshotsUrl: url,
+    });
+
+    try {
+      await snapshotSync(snapshot, log, {
+        dataDirectory: config.dataDirectory!,
+        rollupAddress: config.l1Contracts.rollupAddress,
+        snapshotsUrl: url,
+      });
+      log.info(`Snapshot synced to L1 block ${l1BlockNumber} L2 block ${l2BlockNumber}`, {
+        snapshot,
+        snapshotsUrl: url,
+      });
+      return true;
+    } catch (err) {
+      log.error(`Failed to download snapshot from ${url}. Trying next candidate.`, err, {
+        snapshot,
+        snapshotsUrl: url,
+      });
+      continue;
+    }
   }
 
-  const { l1BlockNumber, l2BlockNumber } = snapshot;
-  log.info(`Syncing from snapshot at L1 block ${l1BlockNumber} L2 block ${l2BlockNumber}`, { snapshot, snapshotsUrl });
-  await snapshotSync(snapshot, log, {
-    dataDirectory: config.dataDirectory!,
-    rollupAddress: config.l1Contracts.rollupAddress,
-    snapshotsUrl,
-  });
-  log.info(`Snapshot synced to L1 block ${l1BlockNumber} L2 block ${l2BlockNumber}`, { snapshot });
-  return true;
+  log.error(`Failed to download snapshot from all URLs.`, { snapshotsUrls });
+  return false;
 }
 
 /**

package/src/config/index.ts

@@ -7,8 +7,8 @@ export type SharedNodeConfig = {
   sponsoredFPC: boolean;
   /** Sync mode: full to always sync via L1, snapshot to download a snapshot if there is no local data, force-snapshot to download even if there is local data. */
   syncMode: 'full' | 'snapshot' | 'force-snapshot';
-  /** Base URL for snapshots index. Index file will be searched at `SNAPSHOTS_BASE_URL/aztec-L1_CHAIN_ID-VERSION-ROLLUP_ADDRESS/index.json` */
-  snapshotsUrl?: string;
+  /** Base URLs for snapshots index. Index file will be searched at `SNAPSHOTS_BASE_URL/aztec-L1_CHAIN_ID-VERSION-ROLLUP_ADDRESS/index.json` */
+  snapshotsUrls?: string[];
 
   /** Auto update mode: disabled - to completely ignore remote signals to update the node. enabled - to respect the signals (potentially shutting this node down). log - check for updates but log a warning instead of applying them*/
   autoUpdate?: 'disabled' | 'notify' | 'config' | 'config-and-version';
@@ -36,9 +36,16 @@ export const sharedNodeConfigMappings: ConfigMappingsType<SharedNodeConfig> = {
       'Set sync mode to `full` to always sync via L1, `snapshot` to download a snapshot if there is no local data, `force-snapshot` to download even if there is local data.',
     defaultValue: 'snapshot',
   },
-  snapshotsUrl: {
-    env: 'SYNC_SNAPSHOTS_URL',
-    description: 'Base URL for snapshots index.',
+  snapshotsUrls: {
+    env: 'SYNC_SNAPSHOTS_URLS',
+    description: 'Base URLs for snapshots index, comma-separated.',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(url => url.trim())
+        .filter(url => url.length > 0),
+    fallback: ['SYNC_SNAPSHOTS_URL'],
+    defaultValue: [],
   },
   autoUpdate: {
     env: 'AUTO_UPDATE',

package/src/factories/index.ts

@@ -0,0 +1 @@
+export * from './l1_tx_utils.js';