@aztec/aztec 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/src/cli/cmds/utils/needs_recompile.ts

@@ -0,0 +1,98 @@
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+
+import { collectCrateDirs } from './collect_crate_dirs.js';
+
+/**
+ * Returns true if recompilation is needed: either no artifacts exist in target/ or any .nr or Nargo.toml source file
+ * (including path-based dependencies) is newer than the oldest artifact. We compare against the oldest artifact so
+ * that a source change between the oldest and newest compilation (e.g. in a multi-contract workspace) still triggers
+ * a recompile.
+ *
+ * Note: The above implies that if there is a random json file in the target dir we would be always recompiling.
+ */
+export async function needsRecompile(): Promise<boolean> {
+  const oldestArtifactMs = await getOldestArtifactModificationTime('target');
+  if (oldestArtifactMs === undefined) {
+    return true;
+  }
+
+  // Git deps are pinned to a specific tag in Nargo.toml and nargo always fetches an exact tag, so their contents never
+  // change without Nargo.toml itself changing — and Nargo.toml is already tracked as a source file. Hence we can
+  // safely ignore checking source files of git deps.
+  const crateDirs = await collectCrateDirs('.', { skipGitDeps: true });
+  return hasNewerSourceFile(crateDirs, oldestArtifactMs);
+}
+
+/**
+ * Returns the last modification time (timestamp in ms) of the oldest .json artifact in targetDir, or undefined if
+ * none exist.
+ */
+async function getOldestArtifactModificationTime(targetDir: string): Promise<number | undefined> {
+  let entries: string[];
+  try {
+    entries = (await readdir(targetDir)).filter(f => f.endsWith('.json'));
+  } catch (err: any) {
+    if (err?.code === 'ENOENT') {
+      return undefined;
+    }
+    throw err;
+  }
+
+  if (entries.length === 0) {
+    return undefined;
+  }
+
+  let oldest = Infinity;
+  for (const entry of entries) {
+    const s = await stat(join(targetDir, entry));
+    if (s.mtimeMs < oldest) {
+      oldest = s.mtimeMs;
+    }
+  }
+  return oldest;
+}
+
+/**
+ * Walks crate dirs looking for .nr and Nargo.toml files newer than thresholdMs. Short-circuits on the first match.
+ */
+async function hasNewerSourceFile(crateDirs: string[], thresholdMs: number): Promise<boolean> {
+  // Returns true if it find a new file than thresholdMs, false otherwise
+  async function walkForNewer(dir: string): Promise<boolean> {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+
+    // We iterate over the entries in the dir
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        // If the entry is a dir and it's not called `target` we recursively enter it
+        if (entry.name === 'target') {
+          continue;
+        }
+        if (await walkForNewer(fullPath)) {
+          return true;
+        }
+      } else if (entry.name === 'Nargo.toml' || entry.name.endsWith('.nr')) {
+        // The entry is a Nargo.toml file or *.nr file so we check the timestamp
+        const s = await stat(fullPath);
+        if (s.mtimeMs > thresholdMs) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  // We search through the crate dirs
+  for (const dir of crateDirs) {
+    if (await walkForNewer(dir)) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/cli/cmds/utils/spawn.ts

@@ -0,0 +1,16 @@
+import { spawn } from 'child_process';
+
+/** Spawns a command with inherited stdio and rejects on non-zero exit. */
+export function run(cmd: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit' });
+    child.on('error', reject);
+    child.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(`${cmd} exited with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}

package/src/cli/cmds/utils/warn_if_aztec_version_mismatch.ts

@@ -0,0 +1,76 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { DEV_VERSION, getPackageVersion } from '@aztec/stdlib/update-checker';
+
+import TOML from '@iarna/toml';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+import { collectCrateDirs } from './collect_crate_dirs.js';
+
+/** Returns true if the given git URL points to the AztecProtocol/aztec-nr repository. */
+function isAztecNrGitUrl(gitUrl: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(gitUrl);
+  } catch {
+    return false;
+  }
+  if (url.hostname !== 'github.com') {
+    return false;
+  }
+  const repoPath = url.pathname
+    .replace(/^\//, '')
+    .replace(/\.git$/, '')
+    .replace(/\/$/, '');
+  return repoPath === 'AztecProtocol/aztec-nr';
+}
+
+/** Warns if any aztec-nr git dependency in a crate's Nargo.toml has a tag that doesn't match the CLI version. */
+export async function warnIfAztecVersionMismatch(log: LogFn, cliVersion?: string): Promise<void> {
+  const version = cliVersion ?? getPackageVersion();
+  if (version === DEV_VERSION) {
+    return;
+  }
+
+  const expectedTag = `v${version}`;
+  const mismatches: { file: string; depName: string; tag: string }[] = [];
+
+  const crateDirs = await collectCrateDirs('.', { skipGitDeps: true });
+
+  for (const dir of crateDirs) {
+    const tomlPath = join(dir, 'Nargo.toml');
+    let content: string;
+    try {
+      content = await readFile(tomlPath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const parsed = TOML.parse(content) as Record<string, any>;
+    const deps = (parsed.dependencies as Record<string, any>) ?? {};
+
+    for (const [depName, dep] of Object.entries(deps)) {
+      // Skip non-object deps (e.g. malformed entries) and anything that isn't a tagged git dep.
+      if (!dep || typeof dep !== 'object' || typeof dep.git !== 'string' || typeof dep.tag !== 'string') {
+        continue;
+      }
+      // Only flag deps that are sourced from the aztec-nr repo.
+      if (!isAztecNrGitUrl(dep.git)) {
+        continue;
+      }
+      if (dep.tag !== expectedTag) {
+        mismatches.push({ file: tomlPath, depName, tag: dep.tag });
+      }
+    }
+  }
+
+  if (mismatches.length > 0) {
+    const details = mismatches.map(m => `  ${m.file} — ${m.depName} (${m.tag})`).join('\n');
+    log(
+      `WARNING: Aztec dependency version mismatch detected.\n` +
+        `The following aztec-nr dependencies do not match the CLI version (${expectedTag}):\n` +
+        `${details}\n\n` +
+        `See https://docs.aztec.network/errors/9 for how to update your dependencies.`,
+    );
+  }
+}

package/src/cli/util.ts

@@ -1,14 +1,10 @@
 import type { AztecNodeConfig } from '@aztec/aztec-node';
 import type { AccountManager } from '@aztec/aztec.js/wallet';
-import type { ViemClient } from '@aztec/ethereum/types';
 import type { ConfigMappingsType } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { type LogFn, createLogger } from '@aztec/foundation/log';
-import type { SharedNodeConfig } from '@aztec/node-lib/config';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import type { LogFn } from '@aztec/foundation/log';
 import type { ProverConfig } from '@aztec/stdlib/interfaces/server';
-import { getTelemetryClient } from '@aztec/telemetry-client/start';
-import type { TestWallet } from '@aztec/test-wallet/server';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import chalk from 'chalk';
 import type { Command } from 'commander';
@@ -50,6 +46,24 @@ export function isShuttingDown(): boolean {
   return shutdownPromise !== undefined;
 }
 
+/**
+ * Stops the node's subsystems (via the registered signal handlers) without exiting the process, leaving
+ * the HTTP health server listening so K8s liveness/readiness probes keep passing. Unlike {@link shutdown}
+ * this deliberately does not latch `shutdownPromise` or call `process.exit`; instead it re-arms
+ * SIGTERM/SIGINT so a later K8s pod deletion still terminates the wound-down pod with a clean exit.
+ */
+export async function softShutdown(logFn: LogFn, signalHandlers: Array<() => Promise<void>>): Promise<void> {
+  logFn('Canonical rollup upgrade detected: stopping subsystems, health server stays up.', {
+    exitCode: ExitCode.ROLLUP_UPGRADE,
+  });
+  await Promise.allSettled(signalHandlers.map(fn => fn()));
+  for (const sig of ['SIGTERM', 'SIGINT'] as const) {
+    process.removeAllListeners(sig);
+    process.once(sig, () => process.exit(ExitCode.ROLLUP_UPGRADE));
+  }
+  logFn('Subsystems stopped due to rollup upgrade. Health server remains active.');
+}
+
 export const installSignalHandlers = (logFn: LogFn, cb?: Array<() => Promise<void>>) => {
   const signals = [
     ['SIGINT', ExitCode.SIGINT],
@@ -68,41 +82,30 @@ export const installSignalHandlers = (logFn: LogFn, cb?: Array<() => Promise<voi
 /**
  * Creates logs for the initial accounts
  * @param accounts - The initial accounts
- * @param wallet - A TestWallet instance to get the registered accounts
+ * @param wallet - A EmbeddedWallet instance to get the registered accounts
  * @returns A string array containing the initial accounts details
  */
-export async function createAccountLogs(
-  accountsWithSecretKeys: {
-    /**
-     * The account object
-     */
-    account: AccountManager;
-    /**
-     * The secret key of the account
-     */
-    secretKey: Fr;
-  }[],
-  wallet: TestWallet,
-) {
+export async function createAccountLogs(accountManagers: AccountManager[], wallet: EmbeddedWallet) {
   const registeredAccounts = await wallet.getAccounts();
   const accountLogStrings = [`Initial Accounts:\n\n`];
-  for (const accountWithSecretKey of accountsWithSecretKeys) {
-    const completeAddress = await accountWithSecretKey.account.getCompleteAddress();
+  for (const accountManager of accountManagers) {
+    const account = await accountManager.getAccount();
+    const completeAddress = account.getCompleteAddress();
     if (registeredAccounts.find(a => a.item.equals(completeAddress.address))) {
       accountLogStrings.push(` Address: ${completeAddress.address.toString()}\n`);
       accountLogStrings.push(` Partial Address: ${completeAddress.partialAddress.toString()}\n`);
-      accountLogStrings.push(` Secret Key: ${accountWithSecretKey.secretKey.toString()}\n`);
-      accountLogStrings.push(
-        ` Master nullifier public key: ${completeAddress.publicKeys.masterNullifierPublicKey.toString()}\n`,
-      );
+      accountLogStrings.push(` Secret Key: ${accountManager.getSecretKey().toString()}\n`);
+      accountLogStrings.push(` Master nullifier public key hash: ${completeAddress.publicKeys.npkMHash.toString()}\n`);
+      accountLogStrings.push(` Master incoming viewing public key: ${completeAddress.publicKeys.ivpkM.toString()}\n\n`);
       accountLogStrings.push(
-        ` Master incoming viewing public key: ${completeAddress.publicKeys.masterIncomingViewingPublicKey.toString()}\n\n`,
+        ` Master outgoing viewing public key hash: ${completeAddress.publicKeys.ovpkMHash.toString()}\n\n`,
       );
+      accountLogStrings.push(` Master tagging public key hash: ${completeAddress.publicKeys.tpkMHash.toString()}\n\n`);
       accountLogStrings.push(
-        ` Master outgoing viewing public key: ${completeAddress.publicKeys.masterOutgoingViewingPublicKey.toString()}\n\n`,
+        ` Master message-signing public key hash: ${completeAddress.publicKeys.mspkMHash.toString()}\n\n`,
       );
       accountLogStrings.push(
-        ` Master tagging public key: ${completeAddress.publicKeys.masterTaggingPublicKey.toString()}\n\n`,
+        ` Master fallback public key hash: ${completeAddress.publicKeys.fbpkMHash.toString()}\n\n`,
       );
     }
   }
@@ -282,7 +285,7 @@ export async function preloadCrsDataForVerifying(
 ): Promise<void> {
   if (realProofs) {
     const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
-    await Promise.all([Crs.new(2 ** 1, undefined, log), GrumpkinCrs.new(2 ** 16 + 1, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 1, undefined, log), GrumpkinCrs.new(2 ** 16, undefined, log)]);
   }
 }
 
@@ -297,94 +300,12 @@ export async function preloadCrsDataForServerSideProving(
 ): Promise<void> {
   if (realProofs) {
     const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
-    await Promise.all([Crs.new(2 ** 25 + 1, undefined, log), GrumpkinCrs.new(2 ** 18 + 1, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 25, undefined, log), GrumpkinCrs.new(2 ** 18, undefined, log)]);
   }
 }
 
-export async function setupUpdateMonitor(
-  autoUpdateMode: SharedNodeConfig['autoUpdate'],
-  updatesLocation: URL,
-  followsCanonicalRollup: boolean,
-  publicClient: ViemClient,
-  registryContractAddress: EthAddress,
-  signalHandlers: Array<() => Promise<void>>,
-  updateNodeConfig?: (config: object) => Promise<void>,
-) {
-  const logger = createLogger('update-check');
-  const { UpdateChecker } = await import('@aztec/stdlib/update-checker');
-  const checker = await UpdateChecker.new({
-    baseURL: updatesLocation,
-    publicClient,
-    registryContractAddress,
-  });
-
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('newRollupVersion', async ({ latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
-
-    // if node follows canonical rollup then this is equivalent to a config update
-    if (!followsCanonicalRollup) {
-      return;
-    }
-
-    if (autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') {
-      logger.info(`New rollup version detected. Please restart the node`, { latestVersion, currentVersion });
-      await shutdown(logger.info, ExitCode.ROLLUP_UPGRADE, signalHandlers);
-    } else if (autoUpdateMode === 'notify') {
-      logger.warn(`New rollup detected. Please restart the node`, { latestVersion, currentVersion });
-    }
-  });
-
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('newNodeVersion', async ({ latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
-    if (autoUpdateMode === 'config-and-version') {
-      logger.info(`New node version detected. Please update and restart the node`, { latestVersion, currentVersion });
-      await shutdown(logger.info, ExitCode.VERSION_UPGRADE, signalHandlers);
-    } else if (autoUpdateMode === 'notify') {
-      logger.info(`New node version detected. Please update and restart the node`, { latestVersion, currentVersion });
-    }
-  });
-
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('updateNodeConfig', async config => {
-    if (isShuttingDown()) {
-      return;
-    }
-
-    if ((autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') && updateNodeConfig) {
-      logger.warn(`Config change detected. Updating node`, config);
-      try {
-        await updateNodeConfig(config);
-      } catch (err) {
-        logger.warn('Failed to update config', { err });
-      }
-    }
-    // don't notify on these config changes
-  });
-
-  checker.on('updatePublicTelemetryConfig', config => {
-    if (autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') {
-      logger.warn(`Public telemetry config change detected. Updating telemetry client`, config);
-      try {
-        const publicIncludeMetrics: unknown = (config as any).publicIncludeMetrics;
-        if (Array.isArray(publicIncludeMetrics) && publicIncludeMetrics.every(m => typeof m === 'string')) {
-          getTelemetryClient().setExportedPublicTelemetry(publicIncludeMetrics);
-        }
-        const publicMetricsCollectFrom: unknown = (config as any).publicMetricsCollectFrom;
-        if (Array.isArray(publicMetricsCollectFrom) && publicMetricsCollectFrom.every(m => typeof m === 'string')) {
-          getTelemetryClient().setPublicTelemetryCollectFrom(publicMetricsCollectFrom);
-        }
-      } catch (err) {
-        logger.warn('Failed to update config', { err });
-      }
-    }
-    // don't notify on these config changes
-  });
-
-  checker.start();
+export function stringifyConfig(config: object): string {
+  return Object.entries(config)
+    .map(([key, value]) => `${key}=${jsonStringify(value)}`)
+    .join(' ');
 }

package/src/deploy/bridging.ts

@@ -0,0 +1,191 @@
+/**
+ * Fee-juice bridging for the `fee-juice` deploy policy: bridge Fee Juice from L1
+ * ({@link bridgeFeeJuice}) and wait for the L1→L2 message to become available
+ * ({@link waitForL1ToL2Message}). Fee Juice only — this is not a generic L1→L2 asset bridge.
+ * Node-only (pulls in `@aztec/aztec.js/ethereum` + viem).
+ *
+ * Nothing here sends the L2 claim tx — the caller feeds the returned claim into
+ * `FeeJuicePaymentMethodWithClaim` so the claim lands inside whatever tx the recipient is already
+ * sending.
+ */
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
+import { isL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { type AztecNodeDebug, createAztecNodeDebugClient } from '@aztec/stdlib/interfaces/client';
+
+import type { Hex } from 'viem';
+import { generatePrivateKey } from 'viem/accounts';
+
+const logger = createLogger('deploy:bridging');
+
+/** Wait between availability checks in `warp` mode — each iteration also warps the clock forward. */
+const WARP_POLL_INTERVAL_MS = 1000;
+/** Wait between availability checks in `poll` mode (a real network; nothing to do but wait). */
+const POLL_INTERVAL_MS = 5_000;
+/** Throttle for the "still waiting" progress log in the poll loop. */
+const POLL_LOG_INTERVAL_MS = 30_000;
+
+/** Local vs. remote L1→L2 message advancement: warp cheats time forward, poll just waits. */
+export type BridgeTimingMode = 'warp' | 'poll';
+
+/** The claim produced by bridging: exactly the shape `FeeJuicePaymentMethodWithClaim` expects. */
+export type FeeJuiceClaim = Awaited<ReturnType<L1FeeJuicePortalManager['bridgeTokensPublic']>>;
+
+/**
+ * Decides how the L1 signer funds a bridge: mint from the fee-asset faucet handler, or transfer
+ * its existing Fee Juice. Pure — exercised directly by unit tests.
+ *
+ * - Balance covers the requested amount → transfer it (no mint, even when a faucet exists).
+ * - Balance short of the amount + faucet available → mint (the faucet path bridges the handler's
+ *   own mint amount and ignores `amount`).
+ * - Balance short + no faucet → throw, reporting the shortfall.
+ * - No `amount` requested → the faucet is required (there is nothing to size a transfer by).
+ */
+export function pickBridgeRoute(opts: { hasFaucet: boolean; l1Balance: bigint; amount?: bigint }): {
+  useFaucet: boolean;
+  amount?: bigint;
+} {
+  const { hasFaucet, l1Balance, amount } = opts;
+  if (amount === undefined) {
+    if (!hasFaucet) {
+      throw new Error('bridgeFeeJuice: `amount` is required when no fee-asset faucet is available.');
+    }
+    return { useFaucet: true };
+  }
+  if (l1Balance >= amount) {
+    return { useFaucet: false, amount };
+  }
+  if (hasFaucet) {
+    return { useFaucet: true };
+  }
+  throw new Error(
+    `L1 signer holds ${l1Balance} wei of Fee Juice but ${amount} was requested, and no fee-asset faucet is ` +
+      `available to mint the difference.`,
+  );
+}
+
+export interface BridgeFeeJuiceParams {
+  node: AztecNode;
+  l1RpcUrl: string;
+  l1ChainId: number;
+  recipient: AztecAddress;
+  /** Desired amount in wei. Optional only when a faucet exists (whose `mintAmount()` then wins). */
+  amount?: bigint;
+  /** L1 private key signing the bridge tx. When omitted, a fresh ephemeral key is generated. */
+  l1PrivateKey?: Hex;
+}
+
+/**
+ * Bridges fee juice to an L2 recipient, minting from the faucet handler or transferring the
+ * signer's balance per {@link pickBridgeRoute}. Returns the claim; the L1→L2 message it references
+ * becomes available later — see {@link waitForL1ToL2Message}.
+ */
+export async function bridgeFeeJuice(params: BridgeFeeJuiceParams): Promise<FeeJuiceClaim> {
+  const { node, l1RpcUrl, l1ChainId, recipient } = params;
+
+  const l1PrivateKey: Hex = params.l1PrivateKey ?? generatePrivateKey();
+  const chain = createEthereumChain([l1RpcUrl], l1ChainId);
+  const l1Client = createExtendedL1Client(chain.rpcUrls, l1PrivateKey, chain.chainInfo);
+  const portalManager = await L1FeeJuicePortalManager.new(node, l1Client, logger);
+
+  const tokenManager = portalManager.getTokenManager();
+  const route = pickBridgeRoute({
+    hasFaucet: tokenManager.handlerAddress !== undefined,
+    l1Balance: await tokenManager.getL1TokenBalance(l1Client.account.address),
+    amount: params.amount,
+  });
+  return await portalManager.bridgeTokensPublic(recipient, route.amount, route.useFaucet);
+}
+
+export interface WaitForClaimParams {
+  node: AztecNode;
+  messageHash: Fr;
+  /**
+   * On `warp` (local) we cheat L1+L2 time forward via the node debug API until the message shows as
+   * available; on `poll` (every other network) we just check periodically.
+   */
+  mode: BridgeTimingMode;
+  /** Timeout before giving up (default 30 min for poll, 2 min for warp). */
+  timeoutMs?: number;
+  /** Warp-only: options for reaching the node's debug API. */
+  warpOpts?: { nodeUrl?: string };
+}
+
+/** Waits until an L1→L2 message is available on the node (warping time forward in `warp` mode). */
+export async function waitForL1ToL2Message(params: WaitForClaimParams): Promise<void> {
+  const { node, messageHash, mode } = params;
+
+  if (mode === 'warp') {
+    await warpToL1ToL2Message(node, messageHash, {
+      ...params.warpOpts,
+      timeoutMs: params.timeoutMs ?? 120_000,
+    });
+    return;
+  }
+
+  const timeoutMs = params.timeoutMs ?? 30 * 60_000;
+  const startedAt = Date.now();
+  let lastLog = startedAt;
+  await retryUntil(
+    async () => {
+      if (await isL1ToL2MessageReady(node, messageHash)) {
+        return true;
+      }
+      if (Date.now() - lastLog > POLL_LOG_INTERVAL_MS) {
+        lastLog = Date.now();
+        logger.info('Still waiting for L1→L2 message to become available', {
+          messageHash: messageHash.toString(),
+          elapsedMs: Date.now() - startedAt,
+          timeoutMs,
+        });
+      }
+      return undefined;
+    },
+    `L1→L2 message ${messageHash.toString()}`,
+    timeoutMs / 1000,
+    POLL_INTERVAL_MS / 1000,
+  );
+}
+
+/**
+ * Local-network helper: advances L1 + L2 time via the node debug API until the given L1→L2 message
+ * shows up as available, warping by one L2 slot (read from the node's rollup constants) per check.
+ * An in-process node (e.g. a test fixture's `AztecNodeService`) implements the debug interface
+ * directly; a remote node is reached via its debug RPC at `nodeUrl` — `warpL2TimeAtLeastBy` needs
+ * `AztecNode & AztecNodeDebug` (it reads the current L1 timestamp via the regular API before
+ * warping), and both clients target the same URL and expose their methods as own properties on the
+ * rpc proxy, so a shallow merge is safe.
+ */
+export async function warpToL1ToL2Message(
+  node: AztecNode,
+  messageHash: Fr,
+  opts: { nodeUrl?: string; timeoutMs?: number } = {},
+): Promise<void> {
+  const nodeUrl = opts.nodeUrl ?? 'http://localhost:8080';
+  const timeoutMs = opts.timeoutMs ?? 120_000;
+
+  const fullNode =
+    typeof (node as Partial<AztecNodeDebug>).warpL2TimeAtLeastBy === 'function'
+      ? (node as AztecNode & AztecNodeDebug)
+      : (Object.assign({}, node, createAztecNodeDebugClient(nodeUrl)) as AztecNode & AztecNodeDebug);
+  const { slotDuration } = await node.getL1Constants();
+
+  await retryUntil(
+    async () => {
+      if (await isL1ToL2MessageReady(node, messageHash)) {
+        return true;
+      }
+      await fullNode.warpL2TimeAtLeastBy(slotDuration);
+      return undefined;
+    },
+    `L1→L2 message ${messageHash.toString()} (warping)`,
+    timeoutMs / 1000,
+    WARP_POLL_INTERVAL_MS / 1000,
+  );
+}