@aztec/aztec 3.0.3 → 3.9.9-nightly.20260312

package/src/cli/aztec_start_options.ts

@@ -1,5 +1,5 @@
 import { type ArchiverConfig, archiverConfigMappings } from '@aztec/archiver/config';
-import { blobSinkConfigMappings } from '@aztec/blob-sink/server/config';
+import { blobClientConfigMapping } from '@aztec/blob-client/client/config';
 import { botConfigMappings } from '@aztec/bot/config';
 import { l1ContractsConfigMappings } from '@aztec/ethereum/config';
 import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
@@ -19,7 +19,7 @@ import { proverAgentConfigMappings, proverBrokerConfigMappings } from '@aztec/pr
 import { proverNodeConfigMappings } from '@aztec/prover-node/config';
 import { allPxeConfigMappings } from '@aztec/pxe/config';
 import { sequencerClientConfigMappings } from '@aztec/sequencer-client/config';
-import { chainConfigMappings } from '@aztec/stdlib/config';
+import { chainConfigMappings, nodeRpcConfigMappings } from '@aztec/stdlib/config';
 import { telemetryClientConfigMappings } from '@aztec/telemetry-client/config';
 import { worldStateConfigMappings } from '@aztec/world-state/config';
 
@@ -105,8 +105,7 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       env: 'NETWORK',
     },
 
-    configToFlag('--auto-update', sharedNodeConfigMappings.autoUpdate),
-    configToFlag('--auto-update-url', sharedNodeConfigMappings.autoUpdateUrl),
+    configToFlag('--enable-version-check', sharedNodeConfigMappings.enableVersionCheck),
 
     configToFlag('--sync-mode', sharedNodeConfigMappings.syncMode),
     configToFlag('--snapshots-urls', sharedNodeConfigMappings.snapshotsUrls),
@@ -142,20 +141,46 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       env: 'AZTEC_ADMIN_PORT',
       parseVal: val => parseInt(val, 10),
     },
+    {
+      flag: '--admin-api-key-hash <value>',
+      description:
+        'SHA-256 hex hash of a pre-generated admin API key. When set, the node uses this hash for authentication instead of auto-generating a key.',
+      defaultValue: undefined,
+      env: 'AZTEC_ADMIN_API_KEY_HASH',
+    },
+    {
+      flag: '--disable-admin-api-key',
+      description:
+        'Disable API key authentication on the admin RPC endpoint. By default, a key is auto-generated, displayed once, and its hash is persisted.',
+      defaultValue: false,
+      env: 'AZTEC_DISABLE_ADMIN_API_KEY',
+      // undefined means the flag was passed without a value (boolean toggle), treat as true.
+      parseVal: val => val === undefined || val === 'true' || val === '1',
+    },
+    {
+      flag: '--reset-admin-api-key',
+      description:
+        'Force-generate a new admin API key, replacing any previously persisted key hash. The new key is displayed once at startup.',
+      defaultValue: false,
+      env: 'AZTEC_RESET_ADMIN_API_KEY',
+      parseVal: val => val === 'true' || val === '1',
+    },
     {
       flag: '--api-prefix <value>',
       description: 'Prefix for API routes on any service that is started',
       defaultValue: '',
       env: 'API_PREFIX',
     },
+    configToFlag('--rpcMaxBatchSize', nodeRpcConfigMappings.rpcMaxBatchSize),
+    configToFlag('--rpcMaxBodySize', nodeRpcConfigMappings.rpcMaxBodySize),
   ],
   ETHEREUM: [
     configToFlag('--l1-chain-id', l1ReaderConfigMappings.l1ChainId),
     // Do not set default for CLI: keep undefined unless provided via flag or env
     configToFlag('--l1-rpc-urls', { ...l1ReaderConfigMappings.l1RpcUrls, defaultValue: undefined }),
-    configToFlag('--l1-consensus-host-urls', blobSinkConfigMappings.l1ConsensusHostUrls),
-    configToFlag('--l1-consensus-host-api-keys', blobSinkConfigMappings.l1ConsensusHostApiKeys),
-    configToFlag('--l1-consensus-host-api-key-headers', blobSinkConfigMappings.l1ConsensusHostApiKeyHeaders),
+    configToFlag('--l1-consensus-host-urls', blobClientConfigMapping.l1ConsensusHostUrls),
+    configToFlag('--l1-consensus-host-api-keys', blobClientConfigMapping.l1ConsensusHostApiKeys),
+    configToFlag('--l1-consensus-host-api-key-headers', blobClientConfigMapping.l1ConsensusHostApiKeyHeaders),
   ],
   'L1 CONTRACTS': [
     configToFlag('--registry-address', l1ContractAddressesMapping.registryAddress),
@@ -168,7 +193,7 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
   'WORLD STATE': [
     configToFlag('--world-state-data-directory', worldStateConfigMappings.worldStateDataDirectory),
     configToFlag('--world-state-db-map-size-kb', worldStateConfigMappings.worldStateDbMapSizeKb),
-    configToFlag('--world-state-block-history', worldStateConfigMappings.worldStateBlockHistory),
+    configToFlag('--world-state-checkpoint-history', worldStateConfigMappings.worldStateCheckpointHistory),
   ],
   // We can't easily auto-generate node options as they're parts of modules defined below
   'AZTEC NODE': [
@@ -202,21 +227,13 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       'sequencer',
       omitConfigMappings(sequencerClientConfigMappings, [
         'fakeProcessingDelayPerTxMs',
+        'fakeThrowAfterProcessingTxCount',
         'skipCollectingAttestations',
         'skipInvalidateBlockAsProposer',
         'blobSinkMapSizeKb',
       ]),
     ),
   ],
-  'BLOB SINK': [
-    {
-      flag: '--blob-sink',
-      description: 'Starts Aztec Blob Sink with options',
-      defaultValue: undefined,
-      env: undefined,
-    },
-    ...getOptions('blobSink', blobSinkConfigMappings),
-  ],
   'PROVER NODE': [
     {
       flag: '--prover-node',
@@ -228,12 +245,8 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       'proverNode',
       omitConfigMappings(proverNodeConfigMappings, [
         // filter out options passed separately
-        ...getKeys(archiverConfigMappings),
         ...getKeys(proverBrokerConfigMappings),
         ...getKeys(proverAgentConfigMappings),
-        ...getKeys(p2pConfigMappings),
-        ...getKeys(worldStateConfigMappings),
-        ...getKeys(sharedNodeConfigMappings),
       ]),
     ),
   ],

package/src/cli/cli.ts

@@ -31,63 +31,18 @@ export function injectAztecCommands(program: Command, userLog: LogFn, debugLogge
 
   program.configureHelp({ sortSubcommands: true });
 
-  program.addHelpText(
-    'after',
-    `
-
-  Additional commands:
-
-    init [folder] [options]: creates a new Noir project
-      Options:
-        --name <name>       Name of the package
-        --contract          Use a contract template (default)
-        --lib               Use a library template
-        --bin               Use a binary template
-      Examples:
-        $ aztec init                    # creates a contract project in current directory
-        $ aztec init --lib              # creates a library project
-
-    new <path> [options]: creates a new Noir project in a new directory
-      Options:
-        --name <name>       Name of the package
-        --contract          Use a contract template (default)
-        --lib               Use a library template
-        --bin               Use a binary template
-      Examples:
-        $ aztec new my-project          # creates a contract project in ./my-project
-        $ aztec new my-lib --lib        # creates a library project in ./my-lib
-
-    compile [options]: compiles Aztec Noir contracts
-      Compiles contracts with nargo compile and then postprocesses them to generate Aztec-specific artifacts including:
-        - Transpiled contract artifacts
-        - Verification keys
-      The compiled contracts will be placed in the target/ directory by default.
-      Supports standard nargo compile options.
-
-    fmt [options]: formats Noir code using nargo fmt
-      Example:
-        $ aztec fmt                     # formats all Noir files in the project
-
-    check [options]: type-checks Noir code without compiling using nargo check
-      Example:
-        $ aztec check                   # checks all Noir files in the project
-
-    test [options]: starts a dockerized TXE node via
-      $ aztec start --txe
-    then runs
-      $ aztec test --silence-warnings --oracle-resolver=<TXE_ADDRESS> [options]
-
-    lsp: starts the Nargo Language Server Protocol server
-      Runs nargo lsp in a Docker container for IDE integration with Noir.
-      This command is typically used by IDE extensions and not called directly by users.
-      Example:
-        $ aztec lsp                     # starts the LSP server
-
-    preload-crs: Downloads and caches the Common Reference String (CRS) data required for zero-knowledge proofs.
-      Example:
-        $ aztec preload-crs             # preloads CRS data
+  if (process.env.AZTEC_SHELL_WRAPPER) {
+    program.addHelpText(
+      'after',
+      `
+Additional commands:
+
+  init [folder] [options]  creates a new Aztec Noir project.
+  new <path> [options]     creates a new Aztec Noir project in a new directory.
+  test [options]           starts a TXE and runs "nargo test" using it as the oracle resolver.
     `,
-  );
+    );
+  }
 
   program
     .command('preload-crs')

package/src/cli/cmds/compile.ts

@@ -0,0 +1,80 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import { execFileSync } from 'child_process';
+import type { Command } from 'commander';
+import { readFile, writeFile } from 'fs/promises';
+
+import { readArtifactFiles } from './utils/artifacts.js';
+import { run } from './utils/spawn.js';
+
+/** Returns paths to contract artifacts in the target directory. */
+async function collectContractArtifacts(): Promise<string[]> {
+  let files;
+  try {
+    files = await readArtifactFiles('target');
+  } catch (err: any) {
+    if (err?.message?.includes('does not exist')) {
+      return [];
+    }
+    throw err;
+  }
+  return files.filter(f => Array.isArray(f.content.functions)).map(f => f.filePath);
+}
+
+/** Strips the `__aztec_nr_internals__` prefix from function names in contract artifacts. */
+async function stripInternalPrefixes(artifactPaths: string[]): Promise<void> {
+  for (const path of artifactPaths) {
+    const artifact = JSON.parse(await readFile(path, 'utf-8'));
+    for (const fn of artifact.functions) {
+      if (typeof fn.name === 'string') {
+        fn.name = fn.name.replace(/^__aztec_nr_internals__/, '');
+      }
+    }
+    await writeFile(path, JSON.stringify(artifact, null, 2) + '\n');
+  }
+}
+
+/** Compiles Aztec Noir contracts and postprocesses artifacts. */
+async function compileAztecContract(nargoArgs: string[], log: LogFn): Promise<void> {
+  const nargo = process.env.NARGO ?? 'nargo';
+  const bb = process.env.BB ?? 'bb';
+
+  await run(nargo, ['compile', ...nargoArgs]);
+
+  const artifacts = await collectContractArtifacts();
+
+  if (artifacts.length > 0) {
+    log('Postprocessing contracts...');
+    const bbArgs = artifacts.flatMap(a => ['-i', a]);
+    await run(bb, ['aztec_process', ...bbArgs]);
+
+    // TODO: This should be part of bb aztec_process!
+    await stripInternalPrefixes(artifacts);
+  }
+
+  log('Compilation complete!');
+}
+
+export function injectCompileCommand(program: Command, log: LogFn): Command {
+  program
+    .command('compile')
+    .argument('[nargo-args...]')
+    .passThroughOptions()
+    .allowUnknownOption()
+    .description(
+      'Compile Aztec Noir contracts using nargo and postprocess them to generate transpiled artifacts and verification keys. All options are forwarded to nargo compile.',
+    )
+    .addHelpText('after', () => {
+      // Show nargo's own compile options so users see all available flags in one place.
+      const nargo = process.env.NARGO ?? 'nargo';
+      try {
+        const output = execFileSync(nargo, ['compile', '--help'], { encoding: 'utf-8' });
+        return `\nUnderlying nargo compile options:\n\n${output}`;
+      } catch {
+        return '\n(Run "nargo compile --help" to see available nargo options)';
+      }
+    })
+    .action((nargoArgs: string[]) => compileAztecContract(nargoArgs, log));
+
+  return program;
+}

package/src/cli/cmds/migrate_ha_db.ts

@@ -0,0 +1,43 @@
+import { runMigrations } from '@aztec/validator-ha-signer/migrations';
+
+import type { Command } from 'commander';
+
+export function injectMigrateCommand(program: Command, log: (msg: string) => void): Command {
+  const migrateCommand = program.command('migrate-ha-db').description('Run validator-ha-signer database migrations');
+
+  migrateCommand
+    .command('up')
+    .description('Apply pending migrations')
+    .requiredOption('--database-url <string>', 'PostgreSQL connection string', process.env.DATABASE_URL)
+    .option('--verbose', 'Enable verbose output', false)
+    .action(async options => {
+      const migrations = await runMigrations(options.databaseUrl, {
+        direction: 'up',
+        verbose: options.verbose,
+      });
+      if (migrations.length > 0) {
+        log(`Applied migrations: ${migrations.join(', ')}`);
+      } else {
+        log('No migrations to apply - schema is up to date');
+      }
+    });
+
+  migrateCommand
+    .command('down')
+    .description('Rollback the last migration')
+    .requiredOption('--database-url <string>', 'PostgreSQL connection string', process.env.DATABASE_URL)
+    .option('--verbose', 'Enable verbose output', false)
+    .action(async options => {
+      const migrations = await runMigrations(options.databaseUrl, {
+        direction: 'down',
+        verbose: options.verbose,
+      });
+      if (migrations.length > 0) {
+        log(`Rolled back migrations: ${migrations.join(', ')}`);
+      } else {
+        log('No migrations to rollback');
+      }
+    });
+
+  return program;
+}

package/src/cli/cmds/profile.ts

@@ -0,0 +1,25 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import type { Command } from 'commander';
+
+import { profileFlamegraph } from './profile_flamegraph.js';
+import { profileGates } from './profile_gates.js';
+
+export function injectProfileCommand(program: Command, log: LogFn): Command {
+  const profile = program.command('profile').description('Profile compiled Aztec artifacts.');
+
+  profile
+    .command('gates')
+    .argument('[target-dir]', 'Path to the compiled artifacts directory', './target')
+    .description('Display gate counts for all compiled Aztec artifacts in a target directory.')
+    .action((targetDir: string) => profileGates(targetDir, log));
+
+  profile
+    .command('flamegraph')
+    .argument('<contract-artifact>', 'Path to the compiled contract artifact JSON')
+    .argument('<function>', 'Name of the contract function to profile')
+    .description('Generate a gate count flamegraph SVG for a contract function.')
+    .action((artifactPath: string, functionName: string) => profileFlamegraph(artifactPath, functionName, log));
+
+  return program;
+}

package/src/cli/cmds/profile_flamegraph.ts

@@ -0,0 +1,63 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import { readFile, rename, rm, writeFile } from 'fs/promises';
+import { basename, dirname, join } from 'path';
+
+import { makeFunctionArtifact } from './profile_utils.js';
+import type { CompiledArtifact } from './utils/artifacts.js';
+import { run } from './utils/spawn.js';
+
+/** Generates a gate count flamegraph SVG for a single contract function. */
+export async function profileFlamegraph(artifactPath: string, functionName: string, log: LogFn): Promise<void> {
+  const raw = await readFile(artifactPath, 'utf-8');
+  const artifact: CompiledArtifact = JSON.parse(raw);
+
+  if (!Array.isArray(artifact.functions)) {
+    throw new Error(`${artifactPath} does not appear to be a contract artifact (no functions array)`);
+  }
+
+  const func = artifact.functions.find(f => f.name === functionName);
+  if (!func) {
+    const available = artifact.functions.map(f => f.name).join(', ');
+    throw new Error(`Function "${functionName}" not found in artifact. Available: ${available}`);
+  }
+  if (func.is_unconstrained) {
+    throw new Error(`Function "${functionName}" is unconstrained and cannot be profiled`);
+  }
+
+  const outputDir = dirname(artifactPath);
+  const contractName = basename(artifactPath, '.json');
+  const functionArtifact = join(outputDir, `${contractName}-${functionName}.json`);
+
+  try {
+    await writeFile(functionArtifact, makeFunctionArtifact(artifact, func));
+
+    const profiler = process.env.PROFILER_PATH ?? 'noir-profiler';
+    const bb = process.env.BB ?? 'bb';
+
+    await run(profiler, [
+      'gates',
+      '--artifact-path',
+      functionArtifact,
+      '--backend-path',
+      bb,
+      '--backend-gates-command',
+      'gates',
+      '--output',
+      outputDir,
+      '--scheme',
+      'chonk',
+      '--include_gates_per_opcode',
+    ]);
+
+    // noir-profiler names the SVG using the internal function name which
+    // retains the __aztec_nr_internals__ prefix in the bytecode metadata.
+    const srcSvg = join(outputDir, `__aztec_nr_internals__${functionName}_gates.svg`);
+    const destSvg = join(outputDir, `${contractName}-${functionName}-flamegraph.svg`);
+    await rename(srcSvg, destSvg);
+
+    log(`Flamegraph written to ${destSvg}`);
+  } finally {
+    await rm(functionArtifact, { force: true });
+  }
+}

package/src/cli/cmds/profile_gates.ts

@@ -0,0 +1,67 @@
+import { asyncPool } from '@aztec/foundation/async-pool';
+import type { LogFn } from '@aztec/foundation/log';
+
+import { execFile as execFileCb } from 'child_process';
+import { rm } from 'fs/promises';
+import { promisify } from 'util';
+
+import { MAX_CONCURRENT, discoverArtifacts } from './profile_utils.js';
+
+const execFile = promisify(execFileCb);
+
+interface GateCountResult {
+  name: string;
+  gateCount: number;
+}
+
+/** Parses circuit_size from bb gates JSON output: { "functions": [{ "circuit_size": N }] } */
+function parseGateCount(stdout: string): number {
+  const parsed = JSON.parse(stdout);
+  const size = parsed?.functions?.[0]?.circuit_size;
+  if (typeof size !== 'number') {
+    throw new Error('Failed to parse circuit_size from bb gates output');
+  }
+  return size;
+}
+
+/** Runs bb gates on a single artifact file and returns the gate count. */
+async function getGateCount(bb: string, artifactPath: string): Promise<number> {
+  const { stdout } = await execFile(bb, ['gates', '--scheme', 'chonk', '-b', artifactPath]);
+  return parseGateCount(stdout);
+}
+
+/** Profiles all compiled artifacts in a target directory and prints gate counts. */
+export async function profileGates(targetDir: string, log: LogFn): Promise<void> {
+  const bb = process.env.BB ?? 'bb';
+  const { artifacts, tmpDir } = await discoverArtifacts(targetDir);
+
+  if (artifacts.length === 0) {
+    log('No artifacts found in target directory.');
+    return;
+  }
+
+  try {
+    const results: GateCountResult[] = await asyncPool(MAX_CONCURRENT, artifacts, async artifact => ({
+      name: artifact.name,
+      gateCount: await getGateCount(bb, artifact.filePath),
+    }));
+    results.sort((a, b) => a.name.localeCompare(b.name));
+
+    if (results.length === 0) {
+      log('No constrained circuits found.');
+      return;
+    }
+
+    const maxNameLen = Math.max(...results.map(r => r.name.length));
+    log('');
+    log('Gate counts:');
+    log('-'.repeat(maxNameLen + 16));
+    for (const { name, gateCount } of results) {
+      log(`${name.padEnd(maxNameLen)}  ${gateCount.toLocaleString().padStart(12)}`);
+    }
+    log('-'.repeat(maxNameLen + 16));
+    log(`Total: ${results.length} circuit(s)`);
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+}

package/src/cli/cmds/profile_utils.ts

@@ -0,0 +1,58 @@
+import { mkdtemp, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import type { CompiledArtifact, ContractFunction } from './utils/artifacts.js';
+import { readArtifactFiles } from './utils/artifacts.js';
+
+export const MAX_CONCURRENT = 4;
+
+export interface DiscoveredArtifact {
+  name: string;
+  filePath: string;
+  type: 'contract-function' | 'program';
+}
+
+/**
+ * Reads a target directory and returns a list of discovered artifacts with temp files
+ * created for contract functions. Caller must clean up tmpDir when done.
+ */
+export async function discoverArtifacts(
+  targetDir: string,
+): Promise<{ artifacts: DiscoveredArtifact[]; tmpDir: string }> {
+  const files = await readArtifactFiles(targetDir);
+  const tmpDir = await mkdtemp(join(tmpdir(), 'aztec-profile-'));
+  const artifacts: DiscoveredArtifact[] = [];
+
+  for (const file of files) {
+    if (Array.isArray(file.content.functions)) {
+      for (const func of file.content.functions) {
+        if (!func.bytecode || func.is_unconstrained) {
+          continue;
+        }
+        const name = `${file.name}::${func.name}`;
+        const tmpPath = join(tmpDir, `${file.name}-${func.name}.json`);
+        await writeFile(tmpPath, makeFunctionArtifact(file.content, func));
+        artifacts.push({ name, filePath: tmpPath, type: 'contract-function' });
+      }
+    } else if (file.content.bytecode) {
+      artifacts.push({ name: file.name, filePath: file.filePath, type: 'program' });
+    }
+  }
+
+  return { artifacts, tmpDir };
+}
+
+/** Extracts a contract function as a standalone program artifact JSON string. */
+export function makeFunctionArtifact(artifact: CompiledArtifact, func: ContractFunction) {
+  /* eslint-disable camelcase */
+  return JSON.stringify({
+    noir_version: artifact.noir_version,
+    hash: 0,
+    abi: func.abi,
+    bytecode: func.bytecode,
+    debug_symbols: func.debug_symbols,
+    file_map: artifact.file_map,
+  });
+  /* eslint-enable camelcase */
+}

package/src/cli/cmds/standby.ts

@@ -0,0 +1,111 @@
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { Fr } from '@aztec/aztec.js/fields';
+import { getSponsoredFPCAddress } from '@aztec/cli/cli-utils';
+import { getPublicClient } from '@aztec/ethereum/client';
+import type { GenesisStateConfig } from '@aztec/ethereum/config';
+import { RegistryContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import type { LogFn } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import Koa from 'koa';
+
+const ROLLUP_POLL_INTERVAL_S = 60;
+
+/**
+ * Computes the expected genesis archive root from the genesis state config.
+ * Reads test accounts and sponsored FPC addresses as specified, then computes
+ * the genesis values including the archive root and prefilled public data.
+ */
+export async function computeExpectedGenesisRoot(config: GenesisStateConfig, userLog: LogFn) {
+  const testAccounts = config.testAccounts ? (await getInitialTestAccountsData()).map(a => a.address) : [];
+  const sponsoredFPCAccounts = config.sponsoredFPC ? [await getSponsoredFPCAddress()] : [];
+  const prefundAddresses = (config.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const initialFundedAccounts = testAccounts.concat(sponsoredFPCAccounts).concat(prefundAddresses);
+
+  userLog(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
+
+  const { genesisArchiveRoot, prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
+
+  userLog(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+
+  return { genesisArchiveRoot, prefilledPublicData };
+}
+
+/**
+ * Waits until the canonical rollup's genesis archive root matches the expected local genesis root.
+ * If the rollup is not yet compatible (e.g. during L1 contract upgrades), enters standby mode:
+ * starts a lightweight HTTP server for K8s liveness probes and polls every 60s until a compatible rollup appears.
+ */
+export async function waitForCompatibleRollup(
+  config: {
+    l1RpcUrls: string[];
+    l1ChainId: number;
+    l1Contracts: { registryAddress: EthAddress };
+    rollupVersion?: number;
+  },
+  expectedGenesisRoot: Fr,
+  port: number | undefined,
+  userLog: LogFn,
+): Promise<void> {
+  const publicClient = getPublicClient(config);
+  const rollupVersion: number | 'canonical' = config.rollupVersion ?? 'canonical';
+
+  const registry = new RegistryContract(publicClient, config.l1Contracts.registryAddress);
+  const rollupAddress = await registry.getRollupAddress(rollupVersion);
+  const rollup = new RollupContract(publicClient, rollupAddress.toString());
+
+  let l1GenesisRoot: Fr;
+  try {
+    l1GenesisRoot = await rollup.getGenesisArchiveTreeRoot();
+  } catch (err: any) {
+    throw new Error(
+      `Could not retrieve genesis archive root from canonical rollup at ${rollupAddress}: ${err.message}`,
+    );
+  }
+
+  if (l1GenesisRoot.equals(expectedGenesisRoot)) {
+    return;
+  }
+
+  userLog(
+    `Genesis root mismatch: expected ${expectedGenesisRoot}, got ${l1GenesisRoot} from rollup at ${rollupAddress}. ` +
+      `Entering standby mode. Will poll every ${ROLLUP_POLL_INTERVAL_S}s for a compatible rollup...`,
+  );
+
+  const standbyServer = await startHttpRpcServer({ getApp: () => new Koa(), isHealthy: () => true }, { port });
+  userLog(`Standby status server listening on port ${standbyServer.port}`);
+
+  try {
+    await retryUntil(
+      async () => {
+        const currentRollupAddress = await registry.getRollupAddress(rollupVersion);
+        const currentRollup = new RollupContract(publicClient, currentRollupAddress.toString());
+
+        let currentGenesisRoot: Fr;
+        try {
+          currentGenesisRoot = await currentRollup.getGenesisArchiveTreeRoot();
+        } catch {
+          userLog(`Failed to fetch genesis root from rollup at ${currentRollupAddress}. Retrying...`);
+          return undefined;
+        }
+
+        if (currentGenesisRoot.equals(expectedGenesisRoot)) {
+          userLog(`Compatible rollup found at ${currentRollupAddress}. Exiting standby mode.`);
+          return true;
+        }
+
+        userLog(`Still waiting. Rollup at ${currentRollupAddress} has genesis root ${currentGenesisRoot}.`);
+        return undefined;
+      },
+      'compatible rollup',
+      0,
+      ROLLUP_POLL_INTERVAL_S,
+    );
+  } finally {
+    await new Promise<void>((resolve, reject) => standbyServer.close(err => (err ? reject(err) : resolve())));
+  }
+}