@aztec/aztec 0.0.0-test.1 → 0.0.1-commit.21caa21

package/dest/testing/anvil_test_watcher.js

@@ -0,0 +1,144 @@
+import { RollupCheatCodes } from '@aztec/ethereum/test';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { getAddress, getContract } from 'viem';
+/**
+ * Represents a watcher for a rollup contract.
+ *
+ * It started on a network like anvil where time traveling is allowed, and auto-mine is turned on
+ * it will periodically check if the current slot have already been filled, e.g., there was an L2
+ * block within the slot. And if so, it will time travel into the next slot.
+ */ export class AnvilTestWatcher {
+    cheatcodes;
+    dateProvider;
+    isLocalNetwork;
+    rollup;
+    rollupCheatCodes;
+    l2SlotDuration;
+    filledRunningPromise;
+    syncDateProviderPromise;
+    markingAsProvenRunningPromise;
+    logger;
+    isMarkingAsProven;
+    constructor(cheatcodes, rollupAddress, l1Client, dateProvider){
+        this.cheatcodes = cheatcodes;
+        this.dateProvider = dateProvider;
+        this.isLocalNetwork = false;
+        this.logger = createLogger(`aztecjs:utils:watcher`);
+        this.isMarkingAsProven = true;
+        this.rollup = getContract({
+            address: getAddress(rollupAddress.toString()),
+            abi: RollupAbi,
+            client: l1Client
+        });
+        this.rollupCheatCodes = new RollupCheatCodes(this.cheatcodes, {
+            rollupAddress
+        });
+        this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
+    }
+    setIsMarkingAsProven(isMarkingAsProven) {
+        this.logger.warn(`Watcher is now ${isMarkingAsProven ? 'marking' : 'not marking'} blocks as proven`);
+        this.isMarkingAsProven = isMarkingAsProven;
+    }
+    setisLocalNetwork(isLocalNetwork) {
+        this.isLocalNetwork = isLocalNetwork;
+    }
+    async start() {
+        if (this.filledRunningPromise) {
+            throw new Error('Watcher already watching for filled slot');
+        }
+        const config = await this.rollupCheatCodes.getConfig();
+        this.l2SlotDuration = config.slotDuration;
+        // If auto mining is not supported (e.g., we are on a real network), then we
+        // will simple do nothing. But if on an anvil or the like, this make sure that
+        // the local network and tests don't break because time is frozen and we never get to
+        // the next slot.
+        const isAutoMining = await this.cheatcodes.isAutoMining();
+        if (isAutoMining) {
+            this.filledRunningPromise = new RunningPromise(()=>this.warpTimeIfNeeded(), this.logger, 200);
+            this.filledRunningPromise.start();
+            this.syncDateProviderPromise = new RunningPromise(()=>this.syncDateProviderToL1IfBehind(), this.logger, 200);
+            this.syncDateProviderPromise.start();
+            this.markingAsProvenRunningPromise = new RunningPromise(()=>this.markAsProven(), this.logger, 200);
+            this.markingAsProvenRunningPromise.start();
+            this.logger.info(`Watcher started for rollup at ${this.rollup.address}`);
+        } else {
+            this.logger.info(`Watcher not started because not auto mining`);
+        }
+    }
+    async stop() {
+        await this.filledRunningPromise?.stop();
+        await this.syncDateProviderPromise?.stop();
+        await this.markingAsProvenRunningPromise?.stop();
+    }
+    async trigger() {
+        await this.filledRunningPromise?.trigger();
+        await this.syncDateProviderPromise?.trigger();
+        await this.markingAsProvenRunningPromise?.trigger();
+    }
+    async markAsProven() {
+        if (!this.isMarkingAsProven) {
+            return;
+        }
+        await this.rollupCheatCodes.markAsProven();
+    }
+    async syncDateProviderToL1IfBehind() {
+        // this doesn't apply to the local network, because we don't have a date provider in the local network
+        if (!this.dateProvider) {
+            return;
+        }
+        const l1Time = await this.cheatcodes.timestamp() * 1000;
+        const wallTime = this.dateProvider.now();
+        if (l1Time > wallTime) {
+            this.logger.warn(`L1 is ahead of wall time. Syncing wall time to L1 time`);
+            this.dateProvider.setTime(l1Time);
+        } else if (l1Time + Number(this.l2SlotDuration) * 1000 < wallTime) {
+            this.logger.warn(`L1 is more than 1 L2 slot behind wall time. Warping to wall time`);
+            await this.cheatcodes.warp(Math.ceil(wallTime / 1000));
+        }
+    }
+    async warpTimeIfNeeded() {
+        try {
+            const currentSlot = SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
+            const pendingCheckpointNumber = BigInt(await this.rollup.read.getPendingCheckpointNumber());
+            const checkpointLog = await this.rollup.read.getCheckpoint([
+                pendingCheckpointNumber
+            ]);
+            const nextSlot = SlotNumber(currentSlot + 1);
+            const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([
+                BigInt(nextSlot)
+            ]));
+            if (BigInt(currentSlot) === checkpointLog.slotNumber) {
+                // We should jump to the next slot
+                try {
+                    await this.cheatcodes.warp(nextSlotTimestamp, {
+                        resetBlockInterval: true
+                    });
+                } catch (e) {
+                    this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+                }
+                this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
+                return;
+            }
+            // If we are not in local network, we don't need to warp time
+            if (!this.isLocalNetwork) {
+                return;
+            }
+            const currentTimestamp = this.dateProvider?.now() ?? Date.now();
+            if (currentTimestamp > nextSlotTimestamp * 1000) {
+                try {
+                    await this.cheatcodes.warp(nextSlotTimestamp, {
+                        resetBlockInterval: true
+                    });
+                } catch (e) {
+                    this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+                }
+                this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
+            }
+        } catch  {
+            this.logger.error('mineIfSlotFilled failed');
+        }
+    }
+}

package/dest/testing/cheat_codes.d.ts

@@ -0,0 +1,41 @@
+import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { SequencerClient } from '@aztec/sequencer-client';
+import type { AztecNode } 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.
+ */
+export declare class CheatCodes {
+    eth: EthCheatCodes;
+    rollup: RollupCheatCodes;
+    constructor(
+    /** Cheat codes for L1.*/
+    eth: EthCheatCodes, 
+    /** Cheat codes for the Aztec Rollup contract on L1. */
+    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. L2 timestamp is not advanced exactly to the target timestamp because it is determined
+     * by the slot number, which advances in fixed intervals.
+     * This is useful for testing time-dependent contract behavior.
+     * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+     * @param node - The Aztec node used to query if a new block has been mined.
+     * @param targetTimestamp - The target timestamp to warp to (in seconds)
+     */
+    warpL2TimeAtLeastTo(sequencerClient: SequencerClient, node: AztecNode, 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. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
+     * number, which advances in fixed intervals.
+     * This is useful for testing time-dependent contract behavior.
+     * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+     * @param node - The Aztec node used to query if a new block has been mined.
+     * @param duration - The duration to advance time by (in seconds)
+     */
+    warpL2TimeAtLeastBy(sequencerClient: SequencerClient, node: AztecNode, duration: bigint | number): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlYXRfY29kZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2NoZWF0X2NvZGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV2RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUMvRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUVqRTs7Ozs7R0FLRztBQUNILHFCQUFhLFVBQVU7SUFHWixHQUFHLEVBQUUsYUFBYTtJQUVsQixNQUFNLEVBQUUsZ0JBQWdCO0lBSmpDO0lBQ0UseUJBQXlCO0lBQ2xCLEdBQUcsRUFBRSxhQUFhO0lBQ3pCLHVEQUF1RDtJQUNoRCxNQUFNLEVBQUUsZ0JBQWdCLEVBQzdCO0lBRUosT0FBYSxNQUFNLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLENBT3ZHO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDRyxtQkFBbUIsQ0FBQyxlQUFlLEVBQUUsZUFBZSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsZUFBZSxFQUFFLE1BQU0sR0FBRyxNQUFNLGlCQXVCNUc7SUFFRDs7Ozs7Ozs7T0FRRztJQUNHLG1CQUFtQixDQUFDLGVBQWUsRUFBRSxlQUFlLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxRQUFRLEVBQUUsTUFBTSxHQUFHLE1BQU0saUJBSXJHO0NBQ0YifQ==

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

@@ -0,0 +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;AAEvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE;;;;;GAKG;AACH,qBAAa,UAAU;IAGZ,GAAG,EAAE,aAAa;IAElB,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;;;;;;;;OAQG;IACG,mBAAmB,CAAC,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,iBAuB5G;IAED;;;;;;;;OAQG;IACG,mBAAmB,CAAC,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,iBAIrG;CACF"}

package/dest/testing/cheat_codes.js

@@ -0,0 +1,62 @@
+import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import { retryUntil } from '@aztec/foundation/retry';
+/**
+ * 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.
+ */ export class CheatCodes {
+    eth;
+    rollup;
+    constructor(/** Cheat codes for L1.*/ eth, /** Cheat codes for the Aztec Rollup contract on L1. */ rollup){
+        this.eth = eth;
+        this.rollup = rollup;
+    }
+    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);
+    }
+    /**
+   * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
+   * the target timestamp. L2 timestamp is not advanced exactly to the target timestamp because it is determined
+   * by the slot number, which advances in fixed intervals.
+   * This is useful for testing time-dependent contract behavior.
+   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+   * @param node - The Aztec node used to query if a new block has been mined.
+   * @param targetTimestamp - The target timestamp to warp to (in seconds)
+   */ async warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp) {
+        const currentL2BlockNumber = await node.getBlockNumber();
+        // We warp the L1 timestamp
+        await this.eth.warp(targetTimestamp, {
+            resetBlockInterval: true
+        });
+        // Wait until an L2 block is mined
+        const sequencer = sequencerClient.getSequencer();
+        const minTxsPerBlock = sequencer.getConfig().minTxsPerBlock;
+        sequencer.updateConfig({
+            minTxsPerBlock: 0
+        });
+        await retryUntil(async ()=>{
+            const newL2BlockNumber = await node.getBlockNumber();
+            return newL2BlockNumber > currentL2BlockNumber;
+        }, 'new block after warping L2 time', 36, 1);
+        // Restore original minTxsPerBlock
+        sequencer.updateConfig({
+            minTxsPerBlock
+        });
+    }
+    /**
+   * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
+   * least by the duration. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
+   * number, which advances in fixed intervals.
+   * This is useful for testing time-dependent contract behavior.
+   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+   * @param node - The Aztec node used to query if a new block has been mined.
+   * @param duration - The duration to advance time by (in seconds)
+   */ async warpL2TimeAtLeastBy(sequencerClient, node, duration) {
+        const currentTimestamp = await this.eth.timestamp();
+        const targetTimestamp = BigInt(currentTimestamp) + BigInt(duration);
+        await this.warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp);
+    }
+}

package/dest/testing/index.d.ts

@@ -0,0 +1,4 @@
+export { AnvilTestWatcher } from './anvil_test_watcher.js';
+export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+export { CheatCodes } from './cheat_codes.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzNELE9BQU8sRUFBRSxhQUFhLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dest/testing/index.js

@@ -0,0 +1,3 @@
+export { AnvilTestWatcher } from './anvil_test_watcher.js';
+export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+export { CheatCodes } from './cheat_codes.js';

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@aztec/aztec",
-  "version": "0.0.0-test.1",
+  "version": "0.0.1-commit.21caa21",
   "type": "module",
   "exports": {
-    ".": "./dest/index.js"
+    ".": "./dest/index.js",
+    "./testing": "./dest/testing/index.js"
   },
-  "bin": "./dest/bin/index.js",
+  "bin": "./scripts/aztec.sh",
   "typedocOptions": {
     "entryPoints": [
       "./src/index.ts"
@@ -14,14 +15,12 @@
     "tsconfig": "./tsconfig.json"
   },
   "scripts": {
-    "build": "yarn clean && tsc -b",
+    "build": "yarn clean && tsgo -b",
     "start": "node --no-warnings ./dest/bin",
     "start:debug": "node --inspect=0.0.0.0:9221 --no-warnings ./dest/bin",
-    "start:sandbox": "ETHEREUM_HOSTS=http://0.0.0.0:8545/ && yarn start start --sandbox",
+    "start:local-network": "ETHEREUM_HOSTS=http://0.0.0.0:8545/ && yarn start start --local-network",
     "clean": "rm -rf ./dest .tsbuildinfo",
-    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
-    "build:dev": "tsc -b --watch",
+    "build:dev": "tsgo -b --watch",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
     "run:example:token": "LOG_LEVEL='verbose' node ./dest/examples/token.js"
   },
@@ -29,55 +28,60 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/accounts": "0.0.0-test.1",
-    "@aztec/archiver": "0.0.0-test.1",
-    "@aztec/aztec-faucet": "0.0.0-test.1",
-    "@aztec/aztec-node": "0.0.0-test.1",
-    "@aztec/aztec.js": "0.0.0-test.1",
-    "@aztec/bb-prover": "0.0.0-test.1",
-    "@aztec/blob-sink": "0.0.0-test.1",
-    "@aztec/bot": "0.0.0-test.1",
-    "@aztec/builder": "0.0.0-test.1",
-    "@aztec/cli": "0.0.0-test.1",
-    "@aztec/cli-wallet": "0.0.0-test.1",
-    "@aztec/constants": "0.0.0-test.1",
-    "@aztec/entrypoints": "0.0.0-test.1",
-    "@aztec/ethereum": "0.0.0-test.1",
-    "@aztec/foundation": "0.0.0-test.1",
-    "@aztec/kv-store": "0.0.0-test.1",
-    "@aztec/noir-contracts.js": "0.0.0-test.1",
-    "@aztec/noir-protocol-circuits-types": "0.0.0-test.1",
-    "@aztec/p2p": "0.0.0-test.1",
-    "@aztec/p2p-bootstrap": "0.0.0-test.1",
-    "@aztec/protocol-contracts": "0.0.0-test.1",
-    "@aztec/prover-client": "0.0.0-test.1",
-    "@aztec/prover-node": "0.0.0-test.1",
-    "@aztec/pxe": "0.0.0-test.1",
-    "@aztec/stdlib": "0.0.0-test.1",
-    "@aztec/telemetry-client": "0.0.0-test.1",
-    "@aztec/txe": "0.0.0-test.1",
-    "@aztec/world-state": "0.0.0-test.1",
+    "@aztec/accounts": "0.0.1-commit.21caa21",
+    "@aztec/archiver": "0.0.1-commit.21caa21",
+    "@aztec/aztec-faucet": "0.0.1-commit.21caa21",
+    "@aztec/aztec-node": "0.0.1-commit.21caa21",
+    "@aztec/aztec.js": "0.0.1-commit.21caa21",
+    "@aztec/bb-prover": "0.0.1-commit.21caa21",
+    "@aztec/bb.js": "0.0.1-commit.21caa21",
+    "@aztec/blob-sink": "0.0.1-commit.21caa21",
+    "@aztec/bot": "0.0.1-commit.21caa21",
+    "@aztec/builder": "0.0.1-commit.21caa21",
+    "@aztec/cli": "0.0.1-commit.21caa21",
+    "@aztec/constants": "0.0.1-commit.21caa21",
+    "@aztec/entrypoints": "0.0.1-commit.21caa21",
+    "@aztec/ethereum": "0.0.1-commit.21caa21",
+    "@aztec/foundation": "0.0.1-commit.21caa21",
+    "@aztec/kv-store": "0.0.1-commit.21caa21",
+    "@aztec/l1-artifacts": "0.0.1-commit.21caa21",
+    "@aztec/node-lib": "0.0.1-commit.21caa21",
+    "@aztec/noir-contracts.js": "0.0.1-commit.21caa21",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.21caa21",
+    "@aztec/p2p": "0.0.1-commit.21caa21",
+    "@aztec/p2p-bootstrap": "0.0.1-commit.21caa21",
+    "@aztec/protocol-contracts": "0.0.1-commit.21caa21",
+    "@aztec/prover-client": "0.0.1-commit.21caa21",
+    "@aztec/prover-node": "0.0.1-commit.21caa21",
+    "@aztec/pxe": "0.0.1-commit.21caa21",
+    "@aztec/stdlib": "0.0.1-commit.21caa21",
+    "@aztec/telemetry-client": "0.0.1-commit.21caa21",
+    "@aztec/test-wallet": "0.0.1-commit.21caa21",
+    "@aztec/txe": "0.0.1-commit.21caa21",
+    "@aztec/world-state": "0.0.1-commit.21caa21",
     "@types/chalk": "^2.2.0",
     "abitype": "^0.8.11",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
-    "koa": "^2.14.2",
-    "koa-router": "^12.0.0",
-    "viem": "2.22.8"
+    "koa": "^2.16.1",
+    "koa-router": "^13.1.1",
+    "viem": "npm:@aztec/viem@2.38.2"
   },
   "files": [
     "dest",
+    "scripts",
     "src",
     "!*.test.*"
   ],
   "types": "./dest/index.d.ts",
   "devDependencies": {
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
-    "@types/koa": "^2.13.6",
-    "jest": "^29.5.0",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/koa": "^2.15.0",
+    "@typescript/native-preview": "7.0.0-dev.20251126.1",
+    "jest": "^30.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "jest": {
     "moduleNameMapper": {
@@ -110,9 +114,13 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ]
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/scripts/aztec.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(dirname "$(realpath "$0")")"
+
+function aztec {
+  node --no-warnings $script_dir/../dest/bin/index.js "$@"
+}
+
+cmd=${1:-}
+[ -n "$cmd" ] && shift
+
+export AZTEC_SHELL_WRAPPER=1
+
+case $cmd in
+  test)
+    export LOG_LEVEL="${LOG_LEVEL:-info}"
+    aztec start --txe --port 8081 &
+    server_pid=$!
+    trap 'kill $server_pid &>/dev/null || true' EXIT
+    while ! nc -z 127.0.0.1 8081 &>/dev/null; do sleep 0.2; done
+    export NARGO_FOREIGN_CALL_TIMEOUT=300000
+    nargo test --silence-warnings --pedantic-solving --oracle-resolver http://127.0.0.1:8081 "$@"
+    ;;
+  start)
+    if [ "${1:-}" == "--local-network" ]; then
+      # TODO: Can these just be set in TS?
+      export ARCHIVER_POLLING_INTERVAL_MS=500
+      export P2P_BLOCK_CHECK_INTERVAL_MS=500
+      export SEQ_TX_POLLING_INTERVAL_MS=500
+      export WS_BLOCK_CHECK_INTERVAL_MS=500
+      export ARCHIVER_VIEM_POLLING_INTERVAL_MS=500
+      export TEST_ACCOUNTS=${TEST_ACCOUNTS:-true}
+      export LOG_LEVEL=${LOG_LEVEL:-info;silent:sequencer;verbose:debug_log}
+      export DEPLOY_AZTEC_CONTRACTS_SALT=${DEPLOY_AZTEC_CONTRACTS_SALT:-$RANDOM}
+
+      ANVIL_PORT=${ANVIL_PORT:-8545}
+
+      export L1_CHAIN_ID=${L1_CHAIN_ID:-31337}
+      export ETHEREUM_HOSTS=${ETHEREUM_HOSTS:-"http://127.0.0.1:${ANVIL_PORT}"}
+
+      anvil --version
+      anvil --silent &
+      anvil_pid=$!
+      trap 'kill $anvil_pid &>/dev/null' EXIT
+    fi
+
+    aztec start "$@"
+    ;;
+  compile|new|init|flamegraph)
+    $script_dir/${cmd}.sh "$@"
+    ;;
+  fmt|check|lsp)
+    # TODO: These should be removed, just use nargo directly.
+    nargo $cmd "$@"
+    ;;
+  *)
+    aztec $cmd "$@"
+    ;;
+esac

package/scripts/compile.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+NARGO=${NARGO:-nargo}
+BB=${BB:-bb}
+
+# If help is requested, show Aztec-specific info then run nargo compile help and then exit in order to not trigger
+# transpilation
+for arg in "$@"; do
+  if [ "$arg" == "--help" ] || [ "$arg" == "-h" ]; then
+    cat << 'EOF'
+Aztec Compile - Compile Aztec Noir contracts
+
+This command compiles Aztec Noir contracts using nargo and then automatically
+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.
+
+---
+Underlying nargo compile options:
+
+EOF
+    nargo compile --help
+    exit 0
+  fi
+done
+
+# Run nargo compile.
+$NARGO compile "$@"
+
+echo "Postprocessing contract..."
+$BB aztec_process
+
+# Strip internal prefixes from all compiled contract JSONs in target directory
+# TODO: This should be part of bb aztec_process!
+for json in target/*.json; do
+  temp_file="${json}.tmp"
+  jq '.functions |= map(.name |= sub("^__aztec_nr_internals__"; ""))' "$json" > "$temp_file"
+  mv "$temp_file" "$json"
+done
+
+echo "Compilation complete!"

package/scripts/extract_function.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import fs from 'fs/promises';
+import path from 'path';
+
+// Simple script to extract a contract function as a separate Noir artifact.
+// We need to use this since the transpiling that we do on public functions make the contract artifacts
+// unreadable by noir tooling, since they are no longer following the noir artifact format.
+async function main() {
+  let [contractArtifactPath, functionName] = process.argv.slice(2);
+  if (!contractArtifactPath || !functionName) {
+    console.log('Usage: node extractFunctionAsNoirArtifact.js <contractArtifactPath> <functionName>');
+    return;
+  }
+
+  const contractArtifact = JSON.parse(await fs.readFile(contractArtifactPath, 'utf8'));
+  const func = contractArtifact.functions.find(f => f.name === functionName);
+  if (!func) {
+    console.error(`Function ${functionName} not found in ${contractArtifactPath}`);
+    return;
+  }
+
+  const artifact = {
+    noir_version: contractArtifact.noir_version,
+    hash: 0,
+    abi: func.abi,
+    bytecode: func.bytecode,
+    debug_symbols: func.debug_symbols,
+    file_map: contractArtifact.file_map,
+    expression_width: {
+      Bounded: {
+        width: 4,
+      },
+    },
+  };
+
+  const outputDir = path.dirname(contractArtifactPath);
+  const outputName = path.basename(contractArtifactPath, '.json') + `-${functionName}.json`;
+
+  const outPath = path.join(outputDir, outputName);
+
+  await fs.writeFile(outPath, JSON.stringify(artifact, null, 2));
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/flamegraph.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+set -eu
+
+# If first arg is -h or --help, print usage.
+if [ $# -lt 2 ] || [ "$1" == "-h" ] || [ "$1" == "--help" ]; then
+    cat << 'EOF'
+Aztec Flamegraph - Generate a gate count flamegraph for an aztec contract function.
+
+Usage: aztec flamegraph <contract_artifact> <function>
+
+Options:
+  -h, --help     Print help
+
+Will output an svg at <artifact_path>/<contract>-<function>-flamegraph.svg.
+You can open it in your browser to view it.
+
+EOF
+    exit 0
+fi
+
+cleanup() {
+  set +e
+  if [ -f "$function_artifact" ]; then
+    rm -f "$function_artifact"
+  fi
+}
+
+trap cleanup EXIT
+
+# Get the directory of the script
+script_dir=$(realpath $(dirname $0))
+
+PROFILER=${PROFILER_PATH:-noir-profiler}
+BB=${BB:-bb}
+
+# first console arg is contract name in camel case or path to contract artifact
+contract=$1
+
+# second console arg is the contract function
+function=$2
+
+if [ ! -f "$contract" ]; then
+  echo "Error: Contract artifact not found at: $contract"
+  exit 1
+fi
+artifact_path=$contract
+function_artifact="${artifact_path%%.json}-${function}.json"
+output_dir=$(dirname "$artifact_path")
+
+# Extract artifact for the specific function.
+node $script_dir/extract_function.js "$artifact_path" $function
+
+# Generate the flamegraph
+$PROFILER gates --artifact-path "$function_artifact" --backend-path "$BB" --backend-gates-command "gates" --output "$output_dir" --scheme chonk --include_gates_per_opcode
+
+# Save as $artifact_name-$function-flamegraph.svg
+output_file="${function_artifact%%.json}-flamegraph.svg"
+mv "$output_dir/__aztec_nr_internals__${function}_gates.svg" "$output_file"
+echo "Flamegraph generated at: $output_file"