@aztec/aztec 5.0.0-rc.1 → 5.0.0-rc.2

package/src/cli/cmds/start_node.ts

@@ -6,7 +6,6 @@ import {
 } from '@aztec/aztec-node';
 import { Fr } from '@aztec/aztec.js/fields';
 import { getL1Config } from '@aztec/cli/config';
-import { getPublicClient } from '@aztec/ethereum/client';
 import { getGenesisStateConfigEnvVars } from '@aztec/ethereum/config';
 import { type NetworkNames, SecretValue } from '@aztec/foundation/config';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
@@ -30,14 +29,9 @@ import {
 import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import { createAztecNode } from '../../local-network/index.js';
-import {
-  extractNamespacedOptions,
-  extractRelevantOptions,
-  preloadCrsDataForVerifying,
-  setupVersionChecker,
-} from '../util.js';
+import { extractNamespacedOptions, extractRelevantOptions, preloadCrsDataForVerifying } from '../util.js';
 import { getVersions } from '../versioning.js';
-import { computeExpectedGenesisRoot, waitForCompatibleRollup } from './standby.js';
+import { computeExpectedGenesisRoot, setupAutoShutdown, waitForCompatibleRollup } from './standby.js';
 import { startProverBroker } from './start_prover_broker.js';
 
 export async function startNode(
@@ -165,7 +159,7 @@ export async function startNode(
   // Register prover-node services if the prover node subsystem is running
   const proverNode = node.getProverNode();
   if (proverNode) {
-    services.prover = [proverNode, ProverNodeApiSchema];
+    adminServices.prover = [proverNode, ProverNodeApiSchema];
     if (!nodeConfig.proverBrokerUrl) {
       services.provingJobSource = [proverNode.getProver().getProvingJobSource(), ProvingJobConsumerSchema];
     }
@@ -184,15 +178,14 @@ export async function startNode(
     await addBot(options, signalHandlers, services, wallet, node, telemetry, undefined);
   }
 
-  if (nodeConfig.enableVersionCheck && networkName !== 'local') {
-    const cacheDir = process.env.DATA_DIRECTORY ? `${process.env.DATA_DIRECTORY}/cache` : undefined;
+  if (nodeConfig.enableAutoShutdown && networkName !== 'local' && followsCanonicalRollup) {
     try {
-      await setupVersionChecker(
-        networkName,
-        followsCanonicalRollup,
-        getPublicClient(nodeConfig!),
+      await setupAutoShutdown(
+        nodeConfig,
+        nodeConfig.registryAddress,
+        (nodeConfig.rollupVersion as number | 'canonical') ?? 'canonical',
+        { genesisArchiveRoot, vkTreeRoot: getVKTreeRoot(), protocolContractsHash },
         signalHandlers,
-        cacheDir,
       );
     } catch {
       /* no-op */

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

@@ -6,6 +6,11 @@ export interface CompiledArtifact {
   file_map: unknown;
   functions: ContractFunction[];
   bytecode?: string;
+  /**
+   * Set to true by the AVM transpiler (invoked via `bb aztec_process`) once the contract has been transpiled and its
+   * verification keys generated. Absent on raw `nargo compile` output, hence optional.
+   */
+  transpiled?: boolean;
 }
 
 export interface ContractFunction {

package/src/cli/util.ts

@@ -1,18 +1,13 @@
 import type { AztecNodeConfig } from '@aztec/aztec-node';
 import type { AccountManager } from '@aztec/aztec.js/wallet';
-import { getNetworkConfig } from '@aztec/cli/config';
-import { RegistryContract } from '@aztec/ethereum/contracts';
-import type { ViemClient } from '@aztec/ethereum/types';
-import type { ConfigMappingsType, NetworkNames } from '@aztec/foundation/config';
+import type { ConfigMappingsType } from '@aztec/foundation/config';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { type LogFn, createLogger } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 import type { ProverConfig } from '@aztec/stdlib/interfaces/server';
-import { type VersionCheck, getPackageVersion } from '@aztec/stdlib/update-checker';
 import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import chalk from 'chalk';
 import type { Command } from 'commander';
-import type { Hex } from 'viem';
 
 import { type AztecStartOption, aztecStartOptions } from './aztec_start_options.js';
 
@@ -51,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],
@@ -291,60 +304,6 @@ export async function preloadCrsDataForServerSideProving(
   }
 }
 
-export async function setupVersionChecker(
-  network: NetworkNames,
-  followsCanonicalRollup: boolean,
-  publicClient: ViemClient,
-  signalHandlers: Array<() => Promise<void>>,
-  cacheDir?: string,
-): Promise<void> {
-  const networkConfig = await getNetworkConfig(network, cacheDir);
-  if (!networkConfig) {
-    return;
-  }
-
-  const { VersionChecker } = await import('@aztec/stdlib/update-checker');
-
-  const logger = createLogger('version_check');
-  const registry = new RegistryContract(publicClient, networkConfig.registryAddress as Hex);
-
-  const checks: Array<VersionCheck> = [];
-  checks.push({
-    name: 'node',
-    currentVersion: getPackageVersion(),
-    getLatestVersion: async () => {
-      const cfg = await getNetworkConfig(network, cacheDir);
-      return cfg?.nodeVersion;
-    },
-  });
-
-  if (followsCanonicalRollup) {
-    const getLatestVersion = async () => {
-      const version = (await registry.getRollupVersions()).at(-1);
-      return version !== undefined ? String(version) : undefined;
-    };
-    const currentVersion = await getLatestVersion();
-    if (currentVersion !== undefined) {
-      checks.push({
-        name: 'rollup',
-        currentVersion,
-        getLatestVersion,
-      });
-    }
-  }
-
-  const checker = new VersionChecker(checks, 600_000, logger);
-  checker.on('newVersion', ({ name, latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
-
-    logger.warn(`New ${name} version available`, { latestVersion, currentVersion });
-  });
-  checker.start();
-  signalHandlers.push(() => checker.stop());
-}
-
 export function stringifyConfig(config: object): string {
   return Object.entries(config)
     .map(([key, value]) => `${key}=${jsonStringify(value)}`)

package/src/local-network/local-network.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S node --no-warnings
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { AztecNodeService } from '@aztec/aztec-node';
+import { createAztecNodeService } from '@aztec/aztec-node';
 import { type AztecNodeConfig, getConfigEnvVars } from '@aztec/aztec-node/config';
 import { Fr } from '@aztec/aztec.js/fields';
 import { createLogger } from '@aztec/aztec.js/log';
@@ -166,7 +166,7 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
 
   const bananaFPC = await getBananaFPCAddress(initialAccounts);
   const sponsoredFPC = await getSponsoredFPCAddress();
-  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromStringUnsafe(a));
   const fundedAddresses = [
     ...initialAccounts.map(a => a.address),
     ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
@@ -237,7 +237,7 @@ export async function createAztecNode(
     ...getConfigEnvVars(),
     ...config,
   };
-  const node = await AztecNodeService.createAndSync(
+  const node = await createAztecNodeService(
     aztecNodeConfig,
     { ...deps, proverNodeDeps: { broker: deps.proverBroker } },
     options,

package/src/testing/cheat_codes.ts

@@ -1,129 +1,48 @@
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { AutomineSequencer } from '@aztec/sequencer-client/automine';
 import type { AztecNode, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 /**
- * A class that provides utility functions for interacting with the chain.
- * @deprecated There used to be 3 kinds of cheat codes: eth, rollup and aztec. We have nuked the Aztec ones because
- * they became unused (we now have better testing tools). If you are introducing a new functionality to the cheat
- * codes, please consider whether it makes sense to just introduce new utils in your tests instead.
+ * Wrapper for Aztec Debug API.
+ * @deprecated use the AztecNode debug API directly.
  */
 export class CheatCodes {
-  private logger = createLogger('aztecjs:cheat_codes');
-
   constructor(
     /** Cheat codes for L1.*/
     public eth: EthCheatCodes,
     /** Cheat codes for the Aztec Rollup contract on L1. */
     public rollup: RollupCheatCodes,
-    /** When wired, redirects time-warps through the AutomineSequencer queue (test-only). */
-    private automine?: AutomineSequencer,
   ) {}
 
-  static async create(
-    rpcUrls: string[],
-    node: AztecNode,
-    dateProvider: DateProvider,
-    automine?: AutomineSequencer,
-  ): Promise<CheatCodes> {
+  static async create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider): Promise<CheatCodes> {
     const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
     const rollupCheatCodes = new RollupCheatCodes(
       ethCheatCodes,
       await node.getNodeInfo().then(n => n.l1ContractAddresses),
     );
-    return new CheatCodes(ethCheatCodes, rollupCheatCodes, automine);
+    return new CheatCodes(ethCheatCodes, rollupCheatCodes);
   }
 
   /**
-   * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
-   * the target timestamp. If the target timestamp falls within the current L2 slot (which already has a block),
-   * the timestamp is automatically adjusted forward to the start of the next slot so that `mineBlock()` succeeds.
-   * @param node - The Aztec node used to force an empty block to be mined.
-   * @param targetTimestamp - The target timestamp to warp to (in seconds)
+   * Warps the L1 timestamp to at least `targetTimestamp` and mines an L2 block advancing the L2 timestamp to at least
+   * the target. Forwards to the node's debug API, which serializes the warp through the automine sequencer queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param targetTimestamp - The target timestamp to warp to (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastTo(targetTimestamp)` on the node debug API directly.
    */
-  async warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number) {
-    const targetBigInt = BigInt(targetTimestamp);
-    const currentTimestamp = BigInt(await this.eth.lastBlockTimestamp());
-
-    if (targetBigInt <= currentTimestamp) {
-      throw new Error(
-        `warpL2TimeAtLeastTo: target timestamp ${targetBigInt} is not in the future (current L1 timestamp is ${currentTimestamp}).`,
-      );
-    }
-
-    // AutomineSequencer owns time control through its serial queue — delegate to keep warps atomic
-    // with respect to any in-flight build, and avoid the mineBlock-loop hack below.
-    // `warpTo` internally builds an empty L2 checkpoint, which auto-mines exactly one L1 block at
-    // the target slot boundary, so no separate `node.mineBlock()` is needed here.
-    if (this.automine) {
-      await this.automine.warpTo(Number(targetBigInt));
-      return;
-    }
-
-    const currentSlot = await this.rollup.getSlot();
-    let effectiveTargetSlot = await this.rollup.getSlotAt(targetBigInt);
-    let effectiveTimestamp = await this.rollup.getTimestampForSlot(effectiveTargetSlot);
-
-    if (effectiveTimestamp < targetBigInt || effectiveTargetSlot <= currentSlot) {
-      const adjustedSlot = SlotNumber(Math.max(effectiveTargetSlot + 1, currentSlot + 1));
-      const adjustedTimestamp = await this.rollup.getTimestampForSlot(adjustedSlot);
-      this.logger.warn(
-        `warpL2TimeAtLeastTo: target timestamp ${targetBigInt} does not align with a future L2 slot boundary. ` +
-          `Auto-adjusting to start of slot ${adjustedSlot} at timestamp ${adjustedTimestamp}.`,
-      );
-      effectiveTimestamp = adjustedTimestamp;
-      effectiveTargetSlot = adjustedSlot;
-    }
-
-    await this.eth.warp(effectiveTimestamp, { resetBlockInterval: true });
-
-    // The sequencer's polling loop may have a `work()` cycle in flight that captured pre-warp slot/timestamp values
-    // just before our warp landed. That cycle would mine an L2 block at the stale slot — the L1 sync prunes such a
-    // block from the canonical chain, but it lingers in local world state and the PXE will use it as the anchor for
-    // subsequent txs, leading to `expiration_timestamp` values that are already in the past relative to L1. Mine
-    // until we observe an L2 block at (or past) the post-warp slot, ensuring the next tx anchors to a fresh block.
-    const maxAttempts = 5;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      await node.mineBlock();
-      const blockData = await node.getBlockData('latest');
-      const blockSlot = blockData?.header.globalVariables.slotNumber;
-      if (blockSlot !== undefined && BigInt(blockSlot) >= BigInt(effectiveTargetSlot)) {
-        return;
-      }
-      this.logger.warn(
-        `warpL2TimeAtLeastTo: mined L2 block at slot ${blockSlot}, expected at least ${effectiveTargetSlot}. ` +
-          `Retrying mineBlock (attempt ${attempt}/${maxAttempts}).`,
-      );
-    }
-    throw new Error(
-      `warpL2TimeAtLeastTo: failed to mine an L2 block at or past slot ${effectiveTargetSlot} after ${maxAttempts} attempts.`,
-    );
+  warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number): Promise<void> {
+    return node.warpL2TimeAtLeastTo(Number(targetTimestamp));
   }
 
   /**
-   * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
-   * least by the duration. If the duration is too short to cross an L2 slot boundary, the warp is automatically
-   * extended to the start of the next slot so that `mineBlock()` succeeds.
-   * @param node - The Aztec node used to force an empty block to be mined.
-   * @param duration - The duration to advance time by (in seconds)
+   * Warps the L1 timestamp forward by at least `duration` seconds and mines an L2 block advancing the L2 timestamp at
+   * least by the duration. Forwards to the node's debug API, which serializes the warp through the automine sequencer
+   * queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param duration - The duration to advance time by (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastBy(duration)` on the node debug API directly.
    */
-  async warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number) {
-    if (BigInt(duration) <= 0n) {
-      throw new Error(`warpL2TimeAtLeastBy: duration must be positive, got ${duration} seconds.`);
-    }
-
-    // Advance relative to whichever clock leads. A live sequencer mines L2 blocks at slot boundaries that can run
-    // ahead of anvil's L1 timestamp, so basing the target on L1 alone would advance the L2 timestamp by less than
-    // `duration`. Anchoring to the latest L2 block timestamp when it leads guarantees the post-warp L2 block is at
-    // least `duration` ahead of the current one.
-    const currentL1Timestamp = BigInt(await this.eth.lastBlockTimestamp());
-    const latestBlockData = await node.getBlockData('latest');
-    const latestL2Timestamp = latestBlockData ? BigInt(latestBlockData.header.globalVariables.timestamp) : 0n;
-    const baseTimestamp = latestL2Timestamp > currentL1Timestamp ? latestL2Timestamp : currentL1Timestamp;
-    const targetTimestamp = baseTimestamp + BigInt(duration);
-    await this.warpL2TimeAtLeastTo(node, targetTimestamp);
+  warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number): Promise<void> {
+    return node.warpL2TimeAtLeastBy(Number(duration));
   }
 }

package/src/testing/token_allowed_setup.ts

@@ -1,19 +1,26 @@
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { buildAllowedElement } from '@aztec/p2p/msg_validators';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
 
 /**
- * Returns Token-specific allowlist entries needed for FPC-based fee payments.
- * These are test-only: FPC-based fee payment with custom tokens won't work on mainnet alpha.
+ * Returns the allowlist entries needed for FPC-based fee payments, keyed by the contract class of
+ * the `artifact` actually deployed as the fee token (defaults to canonical Token). The setup-phase
+ * validator matches these entries by class id, so a test deploying the codegen'd TestToken as its
+ * fee vehicle must pass `TestTokenContract.artifact` here -- otherwise the FPC fee calls are matched
+ * against the wrong class and rejected. Test-only: FPC fee payment with custom tokens won't work on
+ * mainnet alpha.
  */
-export async function getTokenAllowedSetupFunctions(): Promise<AllowedElement[]> {
-  const tokenClassId = (await getContractClassFromArtifact(TokenContractArtifact)).id;
+export async function getTokenAllowedSetupFunctions(
+  artifact: ContractArtifact = TokenContractArtifact,
+): Promise<AllowedElement[]> {
+  const tokenClassId = (await getContractClassFromArtifact(artifact)).id;
   const target = { classId: tokenClassId };
   return Promise.all([
-    // Token: needed for private transfers via FPC (transfer_to_public enqueues this)
-    buildAllowedElement(TokenContractArtifact, target, '_increase_public_balance', { onlySelf: true }),
-    // Token: needed for public transfers via FPC (fee_entrypoint_public enqueues this)
-    buildAllowedElement(TokenContractArtifact, target, 'transfer_in_public'),
+    // needed for private transfers via FPC (transfer_to_public enqueues this)
+    buildAllowedElement(artifact, target, '_increase_public_balance', { onlySelf: true }),
+    // needed for public transfers via FPC (fee_entrypoint_public enqueues this)
+    buildAllowedElement(artifact, target, 'transfer_in_public'),
   ]);
 }