@aztec/node-lib 0.0.1-fake-c83136db25

package/src/actions/create-backups.ts

@@ -0,0 +1,41 @@
+import type { Archiver } from '@aztec/archiver';
+import type { Logger } from '@aztec/foundation/log';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { SnapshotDataUrls } from '@aztec/stdlib/snapshots';
+
+import { existsSync } from 'fs';
+import { join } from 'path/posix';
+
+export async function createBackups(
+  backupDir: string,
+  archiver: Archiver,
+  worldState: WorldStateSynchronizer,
+  log: Logger,
+) {
+  try {
+    log.info(`Pausing archiver and world state sync to start snapshot upload`);
+    await archiver.stop();
+    await worldState.stopSync();
+
+    log.info(`Creating backups of lmdb environments to ${backupDir}`);
+    const [archiverPath, worldStatePaths] = await Promise.all([
+      archiver.backupTo(join(backupDir, 'archiver')),
+      worldState.backupTo(join(backupDir, 'world-state')),
+    ]);
+    const paths: SnapshotDataUrls = { ...worldStatePaths, archiver: archiverPath };
+
+    const missing = Object.entries(paths).filter(([_key, path]) => !path || !existsSync(path));
+    if (missing.length > 0) {
+      throw new Error(`Missing backup files: ${missing.map(([key, path]) => `${path} (${key})`).join(', ')}`);
+    }
+
+    log.info(`Data stores backed up to ${backupDir}`, { paths });
+    return paths;
+  } catch (err) {
+    throw new Error(`Error creating backups for snapshot upload: ${err}`);
+  } finally {
+    log.info(`Resuming archiver and world state sync`);
+    worldState.resumeSync();
+    archiver.resume();
+  }
+}

package/src/actions/index.ts

@@ -0,0 +1,4 @@
+export * from './snapshot-sync.js';
+export * from './upload-snapshot.js';
+export * from './create-backups.js';
+export * from './build-snapshot-metadata.js';

package/src/actions/snapshot-sync.ts

@@ -0,0 +1,277 @@
+import { ARCHIVER_DB_VERSION, ARCHIVER_STORE_NAME, type ArchiverConfig, createArchiverStore } from '@aztec/archiver';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { type EthereumClientConfig, getPublicClient } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { tryRmDir } from '@aztec/foundation/fs';
+import type { Logger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { P2P_STORE_NAME } from '@aztec/p2p';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import { DatabaseVersionManager } from '@aztec/stdlib/database-version';
+import { type ReadOnlyFileStore, createReadOnlyFileStore } from '@aztec/stdlib/file-store';
+import {
+  type SnapshotMetadata,
+  type SnapshotsIndexMetadata,
+  downloadSnapshot,
+  getLatestSnapshotMetadata,
+  makeSnapshotPaths,
+} from '@aztec/stdlib/snapshots';
+import { NATIVE_WORLD_STATE_DBS, WORLD_STATE_DB_VERSION, WORLD_STATE_DIR } from '@aztec/world-state';
+
+import { mkdir, mkdtemp, rename } from 'fs/promises';
+import { join } from 'path';
+
+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'> &
+  Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> &
+  Pick<ArchiverConfig, 'archiverStoreMapSizeKb' | 'maxLogs'> &
+  Required<DataStoreConfig> &
+  EthereumClientConfig & {
+    snapshotsUrls?: string[];
+    minL1BlocksToTriggerReplace?: number;
+  };
+
+/**
+ * Connects to a remote snapshot index and downloads the latest snapshot if the local archiver is behind.
+ * Behaviour depends on syncing mode.
+ */
+export async function trySnapshotSync(config: SnapshotSyncConfig, log: Logger) {
+  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 (!snapshotsUrls || snapshotsUrls.length === 0) {
+    log.verbose('Snapshot sync is disabled. No snapshots URLs provided.');
+    return false;
+  }
+
+  if (!dataDirectory) {
+    log.verbose('Snapshot sync is disabled. No local data directory defined.');
+    return false;
+  }
+
+  // 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;
+  let archiverL2BlockNumber: number | undefined;
+  try {
+    [archiverL1BlockNumber, archiverL2BlockNumber] = await Promise.all([
+      archiverStore.getSynchPoint().then(s => s.blocksSynchedTo),
+      archiverStore.getSynchedL2BlockNumber(),
+    ] as const);
+  } finally {
+    log.verbose(`Closing temporary archiver data store`, { archiverL1BlockNumber, archiverL2BlockNumber });
+    await archiverStore.close();
+  }
+
+  const minL1BlocksToTriggerReplace = config.minL1BlocksToTriggerReplace ?? MIN_L1_BLOCKS_TO_TRIGGER_REPLACE;
+  if (syncMode === 'snapshot' && archiverL2BlockNumber !== undefined && archiverL2BlockNumber >= INITIAL_L2_BLOCK_NUM) {
+    log.verbose(
+      `Skipping non-forced snapshot sync as archiver is already synced to L2 block ${archiverL2BlockNumber}.`,
+    );
+    return false;
+  }
+
+  const currentL1BlockNumber = await getPublicClient(config).getBlockNumber();
+  if (archiverL1BlockNumber && currentL1BlockNumber - archiverL1BlockNumber < minL1BlocksToTriggerReplace) {
+    log.verbose(
+      `Skipping snapshot sync as archiver is less than ${
+        currentL1BlockNumber - archiverL1BlockNumber
+      } L1 blocks behind.`,
+      { archiverL1BlockNumber, currentL1BlockNumber, minL1BlocksToTriggerReplace },
+    );
+    return false;
+  }
+
+  const indexMetadata: SnapshotsIndexMetadata = {
+    l1ChainId,
+    rollupVersion,
+    rollupAddress: l1Contracts.rollupAddress,
+  };
+
+  // Fetch latest snapshot from each URL
+  type SnapshotCandidate = { snapshot: SnapshotMetadata; url: string; fileStore: ReadOnlyFileStore };
+  const snapshotCandidates: SnapshotCandidate[] = [];
+
+  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;
+    }
+
+    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 (snapshotCandidates.length === 0) {
+    log.verbose(`No valid snapshots found from any URL. Skipping snapshot sync.`, { ...indexMetadata, snapshotsUrls });
+    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;
+    }
+  }
+
+  log.error(`Failed to download snapshot from all URLs.`, { snapshotsUrls });
+  return false;
+}
+
+/**
+ * Downloads the given snapshot replacing any local data stores.
+ */
+export async function snapshotSync(
+  snapshot: Pick<SnapshotMetadata, 'dataUrls'>,
+  log: Logger,
+  config: { dataDirectory: string; rollupAddress: EthAddress; snapshotsUrl: string },
+) {
+  const { dataDirectory, rollupAddress } = config;
+  if (!dataDirectory) {
+    throw new Error(`No local data directory defined. Cannot sync snapshot.`);
+  }
+
+  const fileStore = await createReadOnlyFileStore(config.snapshotsUrl, log);
+
+  let downloadDir: string | undefined;
+
+  try {
+    // Download the snapshot to a temp location.
+    await mkdir(dataDirectory, { recursive: true });
+    downloadDir = await mkdtemp(join(dataDirectory, 'download-'));
+    const downloadPaths = makeSnapshotPaths(downloadDir);
+    log.info(`Downloading snapshot to ${downloadDir}`, { snapshot, downloadPaths });
+    await downloadSnapshot(snapshot, downloadPaths, fileStore);
+    log.info(`Snapshot downloaded at ${downloadDir}`, { snapshot, downloadPaths });
+
+    // If download was successful, clear lock and version, and move download there
+    const archiverPath = join(dataDirectory, ARCHIVER_STORE_NAME);
+    await prepareTarget(archiverPath, ARCHIVER_DB_VERSION, rollupAddress);
+    await rename(downloadPaths.archiver, join(archiverPath, 'data.mdb'));
+    log.info(`Archiver database set up from snapshot`, {
+      path: archiverPath,
+      dbVersion: ARCHIVER_DB_VERSION,
+      rollupAddress,
+    });
+
+    // Same for the world state dbs, only that we do not close them, since we assume they are not yet in use
+    const worldStateBasePath = join(dataDirectory, WORLD_STATE_DIR);
+    await prepareTarget(worldStateBasePath, WORLD_STATE_DB_VERSION, rollupAddress);
+    for (const [name, dir] of NATIVE_WORLD_STATE_DBS) {
+      const path = join(worldStateBasePath, dir);
+      await mkdir(path, { recursive: true });
+      await rename(downloadPaths[name], join(path, 'data.mdb'));
+      log.info(`World state database ${name} set up from snapshot`, {
+        path,
+        dbVersion: WORLD_STATE_DB_VERSION,
+        rollupAddress,
+      });
+    }
+
+    // And clear the p2p db altogether
+    const p2pPath = join(dataDirectory, P2P_STORE_NAME);
+    await tryRmDir(p2pPath, log);
+    log.info(`P2P database cleared`, { path: p2pPath });
+  } finally {
+    if (downloadDir) {
+      await tryRmDir(downloadDir, log);
+    }
+  }
+}
+
+/** Deletes target dir and writes the new version file. */
+async function prepareTarget(target: string, schemaVersion: number, rollupAddress: EthAddress) {
+  const noOpen = () => Promise.resolve(undefined);
+  const versionManager = new DatabaseVersionManager<undefined>({
+    schemaVersion,
+    rollupAddress,
+    dataDirectory: target,
+    onOpen: noOpen,
+  });
+  await versionManager.resetDataDirectory();
+  await versionManager.writeVersion();
+}

package/src/actions/upload-snapshot.ts

@@ -0,0 +1,50 @@
+import { ARCHIVER_DB_VERSION, type Archiver } from '@aztec/archiver';
+import { tryRmDir } from '@aztec/foundation/fs';
+import type { Logger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import { createFileStore } from '@aztec/stdlib/file-store';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { uploadSnapshotToIndex } from '@aztec/stdlib/snapshots';
+import { WORLD_STATE_DB_VERSION } from '@aztec/world-state';
+
+import { mkdtemp } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import { buildSnapshotMetadata } from './build-snapshot-metadata.js';
+import { createBackups } from './create-backups.js';
+
+export type UploadSnapshotConfig = Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> &
+  Pick<DataStoreConfig, 'dataDirectory'>;
+
+/**
+ * Pauses the archiver and world state sync, creates backups of the archiver and world state lmdb environments,
+ * and uploads them to the specified location. Location must be a URL supported by our file store (eg `gs://bucketname/path`).
+ */
+export async function uploadSnapshot(
+  location: string,
+  archiver: Archiver,
+  worldState: WorldStateSynchronizer,
+  config: UploadSnapshotConfig,
+  log: Logger,
+) {
+  const store = await createFileStore(location);
+  if (!store) {
+    throw new Error(`Failed to create file store for snapshot upload for location ${location}.`);
+  }
+
+  const backupDir = await mkdtemp(join(config.dataDirectory ?? tmpdir(), 'snapshot-'));
+
+  try {
+    const paths = await createBackups(backupDir, archiver, worldState, log);
+    const versions = { archiver: ARCHIVER_DB_VERSION, worldState: WORLD_STATE_DB_VERSION };
+    const metadata = await buildSnapshotMetadata(archiver, config);
+    log.info(`Uploading snapshot to ${location}`, { snapshot: metadata });
+    const snapshot = await uploadSnapshotToIndex(paths, versions, metadata, store);
+    log.info(`Snapshot uploaded successfully`, { snapshot });
+  } finally {
+    log.info(`Cleaning up backup dir ${backupDir}`);
+    await tryRmDir(backupDir, log);
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,64 @@
+import { type ConfigMappingsType, booleanConfigHelper } from '@aztec/foundation/config';
+
+export type SharedNodeConfig = {
+  /** Whether to populate the genesis state with initial fee juice for the test accounts */
+  testAccounts: boolean;
+  /** Whether to populate the genesis state with initial fee juice for the sponsored FPC */
+  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 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';
+  /** The base URL against which to check for updates */
+  autoUpdateUrl?: string;
+
+  /** URL of the Web3Signer instance */
+  web3SignerUrl?: string;
+};
+
+export const sharedNodeConfigMappings: ConfigMappingsType<SharedNodeConfig> = {
+  testAccounts: {
+    env: 'TEST_ACCOUNTS',
+    description: 'Whether to populate the genesis state with initial fee juice for the test accounts.',
+    ...booleanConfigHelper(),
+  },
+  sponsoredFPC: {
+    env: 'SPONSORED_FPC',
+    description: 'Whether to populate the genesis state with initial fee juice for the sponsored FPC.',
+    ...booleanConfigHelper(false),
+  },
+  syncMode: {
+    env: 'SYNC_MODE',
+    description:
+      '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',
+  },
+  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',
+    description: 'The auto update mode for this node',
+    defaultValue: 'disabled',
+  },
+  autoUpdateUrl: {
+    env: 'AUTO_UPDATE_URL',
+    description: 'Base URL to check for updates',
+  },
+  web3SignerUrl: {
+    env: 'WEB3_SIGNER_URL',
+    description: 'URL of the Web3Signer instance',
+    parseEnv: (val: string) => val.trim(),
+  },
+};

package/src/factories/index.ts

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

package/src/factories/l1_tx_utils.ts

@@ -0,0 +1,122 @@
+import {
+  createL1TxUtilsFromEthSigner as createL1TxUtilsFromEthSignerBase,
+  createL1TxUtilsFromViemWallet as createL1TxUtilsFromViemWalletBase,
+} from '@aztec/ethereum';
+import type { EthSigner, ExtendedViemWalletClient, L1TxUtilsConfig, ViemClient } from '@aztec/ethereum';
+import {
+  createL1TxUtilsWithBlobsFromEthSigner as createL1TxUtilsWithBlobsFromEthSignerBase,
+  createL1TxUtilsWithBlobsFromViemWallet as createL1TxUtilsWithBlobsFromViemWalletBase,
+} from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import { omit } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import type { TelemetryClient } from '@aztec/telemetry-client';
+
+import type { L1TxScope } from '../metrics/l1_tx_metrics.js';
+import { L1TxMetrics } from '../metrics/l1_tx_metrics.js';
+import { L1TxStore } from '../stores/l1_tx_store.js';
+
+const L1_TX_STORE_NAME = 'l1-tx-utils';
+
+/**
+ * Creates shared dependencies (logger, store, metrics) for L1TxUtils instances.
+ */
+async function createSharedDeps(
+  config: DataStoreConfig & { scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+  },
+) {
+  const logger = deps.logger ?? createLogger('l1-tx-utils');
+
+  // Note that we do NOT bind them to the rollup address, since we still need to
+  // monitor and cancel txs for previous rollups to free up our nonces.
+  const noRollupConfig = omit(config, 'l1Contracts');
+  const kvStore = await createStore(L1_TX_STORE_NAME, L1TxStore.SCHEMA_VERSION, noRollupConfig, logger);
+  const store = new L1TxStore(kvStore, logger);
+
+  const meter = deps.telemetry.getMeter('L1TxUtils');
+  const metrics = new L1TxMetrics(meter, config.scope ?? 'other', logger);
+
+  return { logger, store, metrics, dateProvider: deps.dateProvider };
+}
+
+/**
+ * Creates L1TxUtils with blobs from multiple Viem wallets, sharing store and metrics.
+ */
+export async function createL1TxUtilsWithBlobsFromViemWallet(
+  clients: ExtendedViemWalletClient[],
+  config: DataStoreConfig & Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean; scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+  },
+) {
+  const sharedDeps = await createSharedDeps(config, deps);
+
+  return clients.map(client =>
+    createL1TxUtilsWithBlobsFromViemWalletBase(client, sharedDeps, config, config.debugMaxGasLimit),
+  );
+}
+
+/**
+ * Creates L1TxUtils with blobs from multiple EthSigners, sharing store and metrics.
+ */
+export async function createL1TxUtilsWithBlobsFromEthSigner(
+  client: ViemClient,
+  signers: EthSigner[],
+  config: DataStoreConfig & Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean; scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+  },
+) {
+  const sharedDeps = await createSharedDeps(config, deps);
+
+  return signers.map(signer =>
+    createL1TxUtilsWithBlobsFromEthSignerBase(client, signer, sharedDeps, config, config.debugMaxGasLimit),
+  );
+}
+
+/**
+ * Creates L1TxUtils (without blobs) from multiple Viem wallets, sharing store and metrics.
+ */
+export async function createL1TxUtilsFromViemWalletWithStore(
+  clients: ExtendedViemWalletClient[],
+  config: DataStoreConfig & Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean; scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+    scope?: L1TxScope;
+  },
+) {
+  const sharedDeps = await createSharedDeps(config, deps);
+
+  return clients.map(client => createL1TxUtilsFromViemWalletBase(client, sharedDeps, config));
+}
+
+/**
+ * Creates L1TxUtils (without blobs) from multiple EthSigners, sharing store and metrics.
+ */
+export async function createL1TxUtilsFromEthSignerWithStore(
+  client: ViemClient,
+  signers: EthSigner[],
+  config: DataStoreConfig & Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean; scope?: L1TxScope },
+  deps: {
+    telemetry: TelemetryClient;
+    logger?: ReturnType<typeof createLogger>;
+    dateProvider?: DateProvider;
+    scope?: L1TxScope;
+  },
+) {
+  const sharedDeps = await createSharedDeps(config, deps);
+
+  return signers.map(signer => createL1TxUtilsFromEthSignerBase(client, signer, sharedDeps, config));
+}

package/src/metrics/index.ts

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