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

package/dest/testing/cheat_codes.d.ts

@@ -1,44 +1,37 @@
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
 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 declare class CheatCodes {
     /** Cheat codes for L1.*/
     eth: EthCheatCodes;
     /** Cheat codes for the Aztec Rollup contract on L1. */
     rollup: RollupCheatCodes;
-    /** When wired, redirects time-warps through the AutomineSequencer queue (test-only). */
-    private automine?;
-    private logger;
     constructor(
     /** Cheat codes for L1.*/
     eth: EthCheatCodes, 
     /** Cheat codes for the Aztec Rollup contract on L1. */
-    rollup: RollupCheatCodes, 
-    /** When wired, redirects time-warps through the AutomineSequencer queue (test-only). */
-    automine?: AutomineSequencer | undefined);
-    static create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider, automine?: AutomineSequencer): Promise<CheatCodes>;
+    rollup: RollupCheatCodes);
+    static create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider): Promise<CheatCodes>;
     /**
-     * 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.
      */
     warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number): Promise<void>;
     /**
-     * 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.
      */
     warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlYXRfY29kZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2NoZWF0X2NvZGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUd2RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQzFFLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxjQUFjLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUVqRjs7Ozs7R0FLRztBQUNILHFCQUFhLFVBQVU7SUFJbkIseUJBQXlCO0lBQ2xCLEdBQUcsRUFBRSxhQUFhO0lBQ3pCLHVEQUF1RDtJQUNoRCxNQUFNLEVBQUUsZ0JBQWdCO0lBQy9CLHdGQUF3RjtJQUN4RixPQUFPLENBQUMsUUFBUSxDQUFDO0lBUm5CLE9BQU8sQ0FBQyxNQUFNLENBQXVDO0lBRXJEO0lBQ0UseUJBQXlCO0lBQ2xCLEdBQUcsRUFBRSxhQUFhO0lBQ3pCLHVEQUF1RDtJQUNoRCxNQUFNLEVBQUUsZ0JBQWdCO0lBQy9CLHdGQUF3RjtJQUNoRixRQUFRLENBQUMsK0JBQW1CLEVBQ2xDO0lBRUosT0FBYSxNQUFNLENBQ2pCLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFDakIsSUFBSSxFQUFFLFNBQVMsRUFDZixZQUFZLEVBQUUsWUFBWSxFQUMxQixRQUFRLENBQUMsRUFBRSxpQkFBaUIsR0FDM0IsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQU9yQjtJQUVEOzs7Ozs7T0FNRztJQUNHLG1CQUFtQixDQUFDLElBQUksRUFBRSxTQUFTLEdBQUcsY0FBYyxFQUFFLGVBQWUsRUFBRSxNQUFNLEdBQUcsTUFBTSxpQkF5RDNGO0lBRUQ7Ozs7OztPQU1HO0lBQ0csbUJBQW1CLENBQUMsSUFBSSxFQUFFLFNBQVMsR0FBRyxjQUFjLEVBQUUsUUFBUSxFQUFFLE1BQU0sR0FBRyxNQUFNLGlCQWVwRjtDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlYXRfY29kZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2NoZWF0X2NvZGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFakY7OztHQUdHO0FBQ0gscUJBQWEsVUFBVTtJQUVuQix5QkFBeUI7SUFDbEIsR0FBRyxFQUFFLGFBQWE7SUFDekIsdURBQXVEO0lBQ2hELE1BQU0sRUFBRSxnQkFBZ0I7SUFKakM7SUFDRSx5QkFBeUI7SUFDbEIsR0FBRyxFQUFFLGFBQWE7SUFDekIsdURBQXVEO0lBQ2hELE1BQU0sRUFBRSxnQkFBZ0IsRUFDN0I7SUFFSixPQUFhLE1BQU0sQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FPdkc7SUFFRDs7Ozs7O09BTUc7SUFDSCxtQkFBbUIsQ0FBQyxJQUFJLEVBQUUsU0FBUyxHQUFHLGNBQWMsRUFBRSxlQUFlLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBRXJHO0lBRUQ7Ozs7Ozs7T0FPRztJQUNILG1CQUFtQixDQUFDLElBQUksRUFBRSxTQUFTLEdBQUcsY0FBYyxFQUFFLFFBQVEsRUFBRSxNQUFNLEdBQUcsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFOUY7Q0FDRiJ9

package/dest/testing/cheat_codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cheat_codes.d.ts","sourceRoot":"","sources":["../../src/testing/cheat_codes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEjF;;;;;GAKG;AACH,qBAAa,UAAU;IAInB,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;IAC/B,wFAAwF;IACxF,OAAO,CAAC,QAAQ,CAAC;IARnB,OAAO,CAAC,MAAM,CAAuC;IAErD;IACE,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;IAC/B,wFAAwF;IAChF,QAAQ,CAAC,+BAAmB,EAClC;IAEJ,OAAa,MAAM,CACjB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,SAAS,EACf,YAAY,EAAE,YAAY,EAC1B,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,OAAO,CAAC,UAAU,CAAC,CAOrB;IAED;;;;;;OAMG;IACG,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,iBAyD3F;IAED;;;;;;OAMG;IACG,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,iBAepF;CACF"}
+{"version":3,"file":"cheat_codes.d.ts","sourceRoot":"","sources":["../../src/testing/cheat_codes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEjF;;;GAGG;AACH,qBAAa,UAAU;IAEnB,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;IAJjC;IACE,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,uDAAuD;IAChD,MAAM,EAAE,gBAAgB,EAC7B;IAEJ,OAAa,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,CAOvG;IAED;;;;;;OAMG;IACH,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAErG;IAED;;;;;;;OAOG;IACH,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE9F;CACF"}

package/dest/testing/cheat_codes.js

@@ -1,96 +1,36 @@
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
 /**
- * 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 {
     eth;
     rollup;
-    automine;
-    logger;
-    constructor(/** Cheat codes for L1.*/ eth, /** Cheat codes for the Aztec Rollup contract on L1. */ rollup, /** When wired, redirects time-warps through the AutomineSequencer queue (test-only). */ automine){
+    constructor(/** Cheat codes for L1.*/ eth, /** Cheat codes for the Aztec Rollup contract on L1. */ rollup){
         this.eth = eth;
         this.rollup = rollup;
-        this.automine = automine;
-        this.logger = createLogger('aztecjs:cheat_codes');
     }
-    static async create(rpcUrls, node, dateProvider, automine) {
+    static async create(rpcUrls, node, dateProvider) {
         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)
-   */ async warpL2TimeAtLeastTo(node, targetTimestamp) {
-        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.`);
+   * 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.
+   */ warpL2TimeAtLeastTo(node, targetTimestamp) {
+        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)
-   */ async warpL2TimeAtLeastBy(node, duration) {
-        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);
+   * 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.
+   */ warpL2TimeAtLeastBy(node, duration) {
+        return node.warpL2TimeAtLeastBy(Number(duration));
     }
 }

package/dest/testing/token_allowed_setup.d.ts

@@ -1,7 +1,12 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
 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 declare function getTokenAllowedSetupFunctions(): Promise<AllowedElement[]>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5fYWxsb3dlZF9zZXR1cC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3RpbmcvdG9rZW5fYWxsb3dlZF9zZXR1cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUV0RTs7O0dBR0c7QUFDSCx3QkFBc0IsNkJBQTZCLElBQUksT0FBTyxDQUFDLGNBQWMsRUFBRSxDQUFDLENBUy9FIn0=
+export declare function getTokenAllowedSetupFunctions(artifact?: ContractArtifact): Promise<AllowedElement[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5fYWxsb3dlZF9zZXR1cC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3RpbmcvdG9rZW5fYWxsb3dlZF9zZXR1cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRTFELE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRXRFOzs7Ozs7O0dBT0c7QUFDSCx3QkFBc0IsNkJBQTZCLENBQ2pELFFBQVEsR0FBRSxnQkFBd0MsR0FDakQsT0FBTyxDQUFDLGNBQWMsRUFBRSxDQUFDLENBUzNCIn0=

package/dest/testing/token_allowed_setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token_allowed_setup.d.ts","sourceRoot":"","sources":["../../src/testing/token_allowed_setup.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE;;;GAGG;AACH,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAS/E"}
+{"version":3,"file":"token_allowed_setup.d.ts","sourceRoot":"","sources":["../../src/testing/token_allowed_setup.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE;;;;;;;GAOG;AACH,wBAAsB,6BAA6B,CACjD,QAAQ,GAAE,gBAAwC,GACjD,OAAO,CAAC,cAAc,EAAE,CAAC,CAS3B"}

package/dest/testing/token_allowed_setup.js

@@ -2,19 +2,23 @@ import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { buildAllowedElement } from '@aztec/p2p/msg_validators';
 import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 /**
- * 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.
- */ export async function getTokenAllowedSetupFunctions() {
-    const tokenClassId = (await getContractClassFromArtifact(TokenContractArtifact)).id;
+ * 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(artifact = TokenContractArtifact) {
+    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', {
+        // needed for private transfers via FPC (transfer_to_public enqueues this)
+        buildAllowedElement(artifact, 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 public transfers via FPC (fee_entrypoint_public enqueues this)
+        buildAllowedElement(artifact, target, 'transfer_in_public')
     ]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/aztec",
-  "version": "5.0.0-rc.1",
+  "version": "5.0.0-rc.2",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -28,39 +28,39 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/accounts": "5.0.0-rc.1",
-    "@aztec/archiver": "5.0.0-rc.1",
-    "@aztec/aztec-node": "5.0.0-rc.1",
-    "@aztec/aztec.js": "5.0.0-rc.1",
-    "@aztec/bb-prover": "5.0.0-rc.1",
-    "@aztec/bb.js": "5.0.0-rc.1",
-    "@aztec/blob-client": "5.0.0-rc.1",
-    "@aztec/bot": "5.0.0-rc.1",
-    "@aztec/builder": "5.0.0-rc.1",
-    "@aztec/cli": "5.0.0-rc.1",
-    "@aztec/constants": "5.0.0-rc.1",
-    "@aztec/entrypoints": "5.0.0-rc.1",
-    "@aztec/ethereum": "5.0.0-rc.1",
-    "@aztec/foundation": "5.0.0-rc.1",
-    "@aztec/kv-store": "5.0.0-rc.1",
-    "@aztec/l1-artifacts": "5.0.0-rc.1",
-    "@aztec/node-lib": "5.0.0-rc.1",
-    "@aztec/noir-contracts.js": "5.0.0-rc.1",
-    "@aztec/noir-protocol-circuits-types": "5.0.0-rc.1",
-    "@aztec/p2p": "5.0.0-rc.1",
-    "@aztec/p2p-bootstrap": "5.0.0-rc.1",
-    "@aztec/protocol-contracts": "5.0.0-rc.1",
-    "@aztec/prover-client": "5.0.0-rc.1",
-    "@aztec/prover-node": "5.0.0-rc.1",
-    "@aztec/pxe": "5.0.0-rc.1",
-    "@aztec/sequencer-client": "5.0.0-rc.1",
-    "@aztec/standard-contracts": "5.0.0-rc.1",
-    "@aztec/stdlib": "5.0.0-rc.1",
-    "@aztec/telemetry-client": "5.0.0-rc.1",
-    "@aztec/txe": "5.0.0-rc.1",
-    "@aztec/validator-ha-signer": "5.0.0-rc.1",
-    "@aztec/wallets": "5.0.0-rc.1",
-    "@aztec/world-state": "5.0.0-rc.1",
+    "@aztec/accounts": "5.0.0-rc.2",
+    "@aztec/archiver": "5.0.0-rc.2",
+    "@aztec/aztec-node": "5.0.0-rc.2",
+    "@aztec/aztec.js": "5.0.0-rc.2",
+    "@aztec/bb-prover": "5.0.0-rc.2",
+    "@aztec/bb.js": "5.0.0-rc.2",
+    "@aztec/blob-client": "5.0.0-rc.2",
+    "@aztec/bot": "5.0.0-rc.2",
+    "@aztec/builder": "5.0.0-rc.2",
+    "@aztec/cli": "5.0.0-rc.2",
+    "@aztec/constants": "5.0.0-rc.2",
+    "@aztec/entrypoints": "5.0.0-rc.2",
+    "@aztec/ethereum": "5.0.0-rc.2",
+    "@aztec/foundation": "5.0.0-rc.2",
+    "@aztec/kv-store": "5.0.0-rc.2",
+    "@aztec/l1-artifacts": "5.0.0-rc.2",
+    "@aztec/node-lib": "5.0.0-rc.2",
+    "@aztec/noir-contracts.js": "5.0.0-rc.2",
+    "@aztec/noir-protocol-circuits-types": "5.0.0-rc.2",
+    "@aztec/p2p": "5.0.0-rc.2",
+    "@aztec/p2p-bootstrap": "5.0.0-rc.2",
+    "@aztec/protocol-contracts": "5.0.0-rc.2",
+    "@aztec/prover-client": "5.0.0-rc.2",
+    "@aztec/prover-node": "5.0.0-rc.2",
+    "@aztec/pxe": "5.0.0-rc.2",
+    "@aztec/sequencer-client": "5.0.0-rc.2",
+    "@aztec/standard-contracts": "5.0.0-rc.2",
+    "@aztec/stdlib": "5.0.0-rc.2",
+    "@aztec/telemetry-client": "5.0.0-rc.2",
+    "@aztec/txe": "5.0.0-rc.2",
+    "@aztec/validator-ha-signer": "5.0.0-rc.2",
+    "@aztec/wallets": "5.0.0-rc.2",
+    "@aztec/world-state": "5.0.0-rc.2",
     "@iarna/toml": "^2.2.5",
     "@types/chalk": "^2.2.0",
     "abitype": "^0.8.11",

package/scripts/templates/counter/contract/src/main.nr

@@ -24,17 +24,17 @@ pub contract Counter {
     #[initializer]
     #[external("private")]
     fn constructor(initial_value: u128, owner: AztecAddress) {
-        // Delivers the note to the recipient onchain with provable correctness.
+        // Delivers the note to the recipient onchain.
         // Without delivery, the recipient can't find or decrypt the note.
         self.storage.counters.at(owner).add(initial_value).deliver(
-            MessageDelivery::onchain_constrained(),
+            MessageDelivery::onchain_unconstrained(),
         );
     }
 
     // Adds 1 to the owner's counter.
     #[external("private")]
     fn increment(owner: AztecAddress) {
-        self.storage.counters.at(owner).add(1).deliver(MessageDelivery::onchain_constrained());
+        self.storage.counters.at(owner).add(1).deliver(MessageDelivery::onchain_unconstrained());
     }
 
     // Returns the current value of the owner's counter.

package/src/bin/index.ts

@@ -18,6 +18,7 @@ import { Command } from 'commander';
 import { injectCompileCommand } from '../cli/cmds/compile.js';
 import { injectMigrateCommand } from '../cli/cmds/migrate_ha_db.js';
 import { injectProfileCommand } from '../cli/cmds/profile.js';
+import { injectProverCommand } from '../cli/cmds/prover.js';
 import { injectAztecCommands } from '../cli/index.js';
 
 const NETWORK_FLAG = 'network';
@@ -61,6 +62,7 @@ async function main() {
   program = injectCompileCommand(program, userLog);
   program = injectProfileCommand(program, userLog);
   program = injectMigrateCommand(program, userLog);
+  program = injectProverCommand(program, userLog);
 
   await program.parseAsync(process.argv);
 }

package/src/cli/aztec_start_options.ts

@@ -109,7 +109,7 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       env: 'NETWORK',
     },
 
-    configToFlag('--enable-version-check', sharedNodeConfigMappings.enableVersionCheck),
+    configToFlag('--enable-auto-shutdown', sharedNodeConfigMappings.enableAutoShutdown),
 
     configToFlag('--sync-mode', sharedNodeConfigMappings.syncMode),
     configToFlag('--snapshots-urls', sharedNodeConfigMappings.snapshotsUrls),

package/src/cli/cmds/compile.ts

@@ -12,8 +12,8 @@ import { needsRecompile } from './utils/needs_recompile.js';
 import { run } from './utils/spawn.js';
 import { warnIfAztecVersionMismatch } from './utils/warn_if_aztec_version_mismatch.js';
 
-/** Returns paths to contract artifacts in the target directory. */
-async function collectContractArtifacts(): Promise<string[]> {
+/** Returns contract artifacts in the target directory along with whether each has already been postprocessed. */
+async function collectContractArtifacts(): Promise<ContractArtifactInfo[]> {
   let files;
   try {
     files = await readArtifactFiles('target');
@@ -23,7 +23,9 @@ async function collectContractArtifacts(): Promise<string[]> {
     }
     throw err;
   }
-  return files.filter(f => Array.isArray(f.content.functions)).map(f => f.filePath);
+  return files
+    .filter(f => Array.isArray(f.content.functions))
+    .map(f => ({ filePath: f.filePath, transpiled: f.content.transpiled === true }));
 }
 
 /** Stamps the Aztec stack version into the contract artifacts. */
@@ -141,30 +143,34 @@ async function checkNoTestsInContracts(nargo: string, log: LogFn): Promise<void>
 async function compileAztecContract(nargoArgs: string[], log: LogFn): Promise<void> {
   await warnIfAztecVersionMismatch(log);
 
-  if (!(await needsRecompile())) {
-    log('No source changes detected, skipping compilation.');
-    return;
-  }
-
   const nargo = process.env.NARGO ?? 'nargo';
   const bb = process.env.BB ?? findBbBinary() ?? 'bb';
 
-  await run(nargo, ['compile', ...nargoArgs]);
+  const shouldRecompile = await needsRecompile();
+  if (shouldRecompile) {
+    await run(nargo, ['compile', ...nargoArgs]);
 
-  // Ensure contract crates contain no tests (tests belong in the test crate).
-  await checkNoTestsInContracts(nargo, log);
+    // Ensure contract crates contain no tests (tests belong in the test crate).
+    await checkNoTestsInContracts(nargo, log);
+  }
 
-  const artifacts = await collectContractArtifacts();
+  // Postprocess any untranspiled artifacts: those just produced by nargo above, and any left behind by a bare
+  // `nargo compile` run outside `aztec compile`.
+  const unprocessed = (await collectContractArtifacts()).filter(a => !a.transpiled).map(a => a.filePath);
 
-  if (artifacts.length > 0) {
+  if (unprocessed.length > 0) {
     log('Postprocessing contracts...');
-    const bbArgs = artifacts.flatMap(a => ['-i', a]);
+    const bbArgs = unprocessed.flatMap(a => ['-i', a]);
     await run(bb, ['aztec_process', ...bbArgs]);
 
-    await stampAztecVersion(artifacts);
+    await stampAztecVersion(unprocessed);
   }
 
-  log('Compilation complete!');
+  if (shouldRecompile || unprocessed.length > 0) {
+    log('Compilation complete!');
+  } else {
+    log('No source changes detected, skipping compilation.');
+  }
 }
 
 export function injectCompileCommand(program: Command, log: LogFn): Command {
@@ -190,3 +196,10 @@ export function injectCompileCommand(program: Command, log: LogFn): Command {
 
   return program;
 }
+
+interface ContractArtifactInfo {
+  /** Path to the artifact JSON in the target directory. */
+  filePath: string;
+  /** Whether the artifact has already been transpiled and had its verification keys generated. */
+  transpiled: boolean;
+}

package/src/cli/cmds/prover.ts

@@ -0,0 +1,42 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import type { LogFn } from '@aztec/foundation/log';
+import { createProverNodeAdminClient } from '@aztec/stdlib/interfaces/server';
+
+import { type Command, InvalidArgumentError } from 'commander';
+
+function parseEpoch(value: string): number {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new InvalidArgumentError('Epoch must be a non-negative integer.');
+  }
+  return parsed;
+}
+
+export function injectProverCommand(program: Command, log: LogFn): Command {
+  const proverCommand = program.command('prover').description('Operate a prover node via its admin JSON-RPC endpoint');
+
+  proverCommand
+    .command('start-proof')
+    .description('Schedules proving for the given epoch')
+    .requiredOption('--epoch <n>', 'Epoch number to prove', parseEpoch)
+    .requiredOption('--admin-url <url>', 'URL of the prover node admin JSON-RPC endpoint')
+    .option('--api-key <key>', 'Admin API key', process.env.AZTEC_ADMIN_API_KEY)
+    .action(async options => {
+      const client = createProverNodeAdminClient(options.adminUrl, {}, undefined, options.apiKey);
+      const jobId = await client.startProof(options.epoch);
+      log(`Started proving job ${jobId} for epoch ${options.epoch}`);
+    });
+
+  proverCommand
+    .command('get-jobs')
+    .description('Lists the prover node proving jobs')
+    .requiredOption('--admin-url <url>', 'URL of the prover node admin JSON-RPC endpoint')
+    .option('--api-key <key>', 'Admin API key', process.env.AZTEC_ADMIN_API_KEY)
+    .action(async options => {
+      const client = createProverNodeAdminClient(options.adminUrl, {}, undefined, options.apiKey);
+      const jobs = await client.getJobs();
+      log(jsonStringify(jobs, true));
+    });
+
+  return program;
+}

package/src/cli/cmds/standby.ts

@@ -6,13 +6,16 @@ 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 { type LogFn, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { VersionCheck } from '@aztec/stdlib/update-checker';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import Koa from 'koa';
 
+import { isShuttingDown, softShutdown } from '../util.js';
+
 const ROLLUP_POLL_INTERVAL_S = 60;
 
 /**
@@ -23,7 +26,7 @@ const ROLLUP_POLL_INTERVAL_S = 60;
 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 prefundAddresses = (config.prefundAddresses ?? []).map(a => AztecAddress.fromStringUnsafe(a));
   const initialFundedAccounts = testAccounts.concat(sponsoredFPCAccounts).concat(prefundAddresses);
 
   userLog(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
@@ -35,7 +38,12 @@ export async function computeExpectedGenesisRoot(config: GenesisStateConfig, use
   return { genesisArchiveRoot, genesis };
 }
 
-async function checkRollupCompatibility(
+/**
+ * Compares the rollup's on-chain protocol constants (genesis archive root, VK tree root, protocol
+ * contracts hash) against the node's expected local values. Returns a list of human-readable mismatch
+ * descriptions, empty if the rollup is compatible.
+ */
+export async function checkRollupCompatibility(
   rollup: RollupContract,
   expected: { genesisArchiveRoot: Fr; vkTreeRoot: Fr; protocolContractsHash: Fr },
 ): Promise<string[]> {
@@ -130,3 +138,47 @@ export async function waitForCompatibleRollup(
     await new Promise<void>((resolve, reject) => standbyServer.close(err => (err ? reject(err) : resolve())));
   }
 }
+
+/**
+ * Polls the canonical rollup's protocol constants every 10 minutes and soft-shuts-down the node once they
+ * diverge from the node's expected local values (i.e. an incompatible rollup has become canonical on L1).
+ * The HTTP health server is left running so K8s probes keep passing on the wound-down pod. This is the
+ * inverse of {@link waitForCompatibleRollup}; it should only be set up for nodes following the canonical
+ * rollup. Reuses the {@link checkRollupCompatibility} diff and the generic VersionChecker poll primitive.
+ */
+export async function setupAutoShutdown(
+  config: { l1RpcUrls: string[]; l1ChainId: number },
+  registryAddress: EthAddress,
+  rollupVersion: number | 'canonical',
+  expected: { genesisArchiveRoot: Fr; vkTreeRoot: Fr; protocolContractsHash: Fr },
+  signalHandlers: Array<() => Promise<void>>,
+): Promise<void> {
+  const { VersionChecker } = await import('@aztec/stdlib/update-checker');
+
+  const logger = createLogger('auto_shutdown');
+  const publicClient = getPublicClient(config);
+  const registry = new RegistryContract(publicClient, registryAddress);
+
+  const check: VersionCheck = {
+    name: 'rollup',
+    currentVersion: 'compatible',
+    getLatestVersion: async () => {
+      const rollupAddress = await registry.getRollupAddress(rollupVersion);
+      const rollup = new RollupContract(publicClient, rollupAddress.toString());
+      const mismatches = await checkRollupCompatibility(rollup, expected);
+      return mismatches.length === 0 ? 'compatible' : `incompatible: ${mismatches.join('; ')}`;
+    },
+  };
+
+  const checker = new VersionChecker([check], 600_000, logger);
+  checker.on('newVersion', ({ latestVersion }) => {
+    if (isShuttingDown()) {
+      return;
+    }
+    logger.warn('Canonical rollup is no longer compatible; auto-shutting down node', { latestVersion });
+    // softShutdown never rejects (it awaits handlers via allSettled); fire-and-forget from the listener.
+    void softShutdown(logger.info.bind(logger), signalHandlers);
+  });
+  checker.start();
+  signalHandlers.push(() => checker.stop());
+}