@aztec/simulator 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/dest/public/avm/testing/utils.d.ts

@@ -0,0 +1,32 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type ContractArtifact, type FunctionAbi, type FunctionArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type ContractClassPublic, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { UInt64 } from '@aztec/stdlib/types';
+export declare const PUBLIC_DISPATCH_FN_NAME = "public_dispatch";
+export declare const DEFAULT_TIMESTAMP: UInt64;
+export declare const DEFAULT_BLOCK_NUMBER: BlockNumber;
+/**
+ * Create a new object with all the same properties as the original, except for the ones in the overrides object.
+ */
+export declare function allSameExcept(original: any, overrides: any): any;
+export declare function getFunctionSelector(functionName: string, contractArtifact: ContractArtifact): Promise<FunctionSelector>;
+export declare function getContractFunctionArtifact(functionName: string, contractArtifact: ContractArtifact): FunctionArtifact | undefined;
+export declare function getContractFunctionAbi(functionName: string, contractArtifact: ContractArtifact): FunctionAbi | undefined;
+/**
+ * Create a contract class and instance given constructor args, artifact, etc.
+ * NOTE: This is useful for testing real-ish contract class registration and instance deployment TXs (via logs)
+ * @param constructorArgs - The constructor arguments for the contract.
+ * @param deployer - The deployer of the contract.
+ * @param contractArtifact - The contract artifact for the contract.
+ * @param seed - The seed for the contract.
+ * @param originalContractClassId - The original contract class ID (if upgraded)
+ * @returns The contract class, instance, and contract address nullifier.
+ */
+export declare function createContractClassAndInstance(constructorArgs: any[], deployer: AztecAddress, contractArtifact: ContractArtifact, seed?: number, contractClassSeed?: number, originalContractClassId?: Fr): Promise<{
+    contractClass: ContractClassPublic;
+    contractInstance: ContractInstanceWithAddress;
+    contractAddressNullifier: Fr;
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wdWJsaWMvYXZtL3Rlc3RpbmcvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQ0wsS0FBSyxnQkFBZ0IsRUFDckIsS0FBSyxXQUFXLEVBQ2hCLEtBQUssZ0JBQWdCLEVBQ3JCLGdCQUFnQixFQUVqQixNQUFNLG1CQUFtQixDQUFDO0FBQzNCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEVBQ0wsS0FBSyxtQkFBbUIsRUFDeEIsS0FBSywyQkFBMkIsRUFFakMsTUFBTSx3QkFBd0IsQ0FBQztBQUloQyxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUtsRCxlQUFPLE1BQU0sdUJBQXVCLG9CQUFvQixDQUFDO0FBQ3pELGVBQU8sTUFBTSxpQkFBaUIsRUFBRSxNQUFlLENBQUM7QUFDaEQsZUFBTyxNQUFNLG9CQUFvQixhQUFrQixDQUFDO0FBRXBEOztHQUVHO0FBQ0gsd0JBQWdCLGFBQWEsQ0FBQyxRQUFRLEVBQUUsR0FBRyxFQUFFLFNBQVMsRUFBRSxHQUFHLEdBQUcsR0FBRyxDQUVoRTtBQUVELHdCQUFnQixtQkFBbUIsQ0FDakMsWUFBWSxFQUFFLE1BQU0sRUFDcEIsZ0JBQWdCLEVBQUUsZ0JBQWdCLEdBQ2pDLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUszQjtBQUVELHdCQUFnQiwyQkFBMkIsQ0FDekMsWUFBWSxFQUFFLE1BQU0sRUFDcEIsZ0JBQWdCLEVBQUUsZ0JBQWdCLEdBQ2pDLGdCQUFnQixHQUFHLFNBQVMsQ0FFOUI7QUFFRCx3QkFBZ0Isc0JBQXNCLENBQ3BDLFlBQVksRUFBRSxNQUFNLEVBQ3BCLGdCQUFnQixFQUFFLGdCQUFnQixHQUNqQyxXQUFXLEdBQUcsU0FBUyxDQUt6QjtBQUVEOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFzQiw4QkFBOEIsQ0FDbEQsZUFBZSxFQUFFLEdBQUcsRUFBRSxFQUN0QixRQUFRLEVBQUUsWUFBWSxFQUN0QixnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFDbEMsSUFBSSxTQUFJLEVBQ1IsaUJBQWlCLFNBQU8sRUFDeEIsdUJBQXVCLENBQUMsRUFBRSxFQUFFLEdBQzNCLE9BQU8sQ0FBQztJQUNULGFBQWEsRUFBRSxtQkFBbUIsQ0FBQztJQUNuQyxnQkFBZ0IsRUFBRSwyQkFBMkIsQ0FBQztJQUM5Qyx3QkFBd0IsRUFBRSxFQUFFLENBQUM7Q0FDOUIsQ0FBQyxDQStCRCJ9

package/dest/public/avm/testing/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/testing/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,gBAAgB,EAEjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAEjC,MAAM,wBAAwB,CAAC;AAIhC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAKlD,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AACzD,eAAO,MAAM,iBAAiB,EAAE,MAAe,CAAC;AAChD,eAAO,MAAM,oBAAoB,aAAkB,CAAC;AAEpD;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,GAAG,CAEhE;AAED,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAK3B;AAED,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,GACjC,gBAAgB,GAAG,SAAS,CAE9B;AAED,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,GACjC,WAAW,GAAG,SAAS,CAKzB;AAED;;;;;;;;;GASG;AACH,wBAAsB,8BAA8B,CAClD,eAAe,EAAE,GAAG,EAAE,EACtB,QAAQ,EAAE,YAAY,EACtB,gBAAgB,EAAE,gBAAgB,EAClC,IAAI,SAAI,EACR,iBAAiB,SAAO,EACxB,uBAAuB,CAAC,EAAE,EAAE,GAC3B,OAAO,CAAC;IACT,aAAa,EAAE,mBAAmB,CAAC;IACnC,gBAAgB,EAAE,2BAA2B,CAAC;IAC9C,wBAAwB,EAAE,EAAE,CAAC;CAC9B,CAAC,CA+BD"}

package/dest/public/avm/{fixtures → testing}/utils.js

@@ -4,14 +4,11 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { FunctionSelector, getAllFunctionAbis } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computeInitializationHash } from '@aztec/stdlib/contract';
-import { isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import { deriveKeys } from '@aztec/stdlib/keys';
 import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/stdlib/testing';
 import { strict as assert } from 'assert';
 import merge from 'lodash.merge';
-import { resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../../common/index.js';
-import { Field, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
 export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
 export const DEFAULT_TIMESTAMP = 99833n;
 export const DEFAULT_BLOCK_NUMBER = BlockNumber(42);
@@ -20,26 +17,6 @@ export const DEFAULT_BLOCK_NUMBER = BlockNumber(42);
  */ export function allSameExcept(original, overrides) {
     return merge({}, original, overrides);
 }
-export function randomMemoryBytes(length) {
-    return [
-        ...Array(length)
-    ].map((_)=>new Uint8(Math.floor(Math.random() * 255)));
-}
-export function randomMemoryUint32s(length) {
-    return [
-        ...Array(length)
-    ].map((_)=>new Uint32(Math.floor(Math.random() * 255)));
-}
-export function randomMemoryUint64s(length) {
-    return [
-        ...Array(length)
-    ].map((_)=>new Uint64(Math.floor(Math.random() * 255)));
-}
-export function randomMemoryFields(length) {
-    return [
-        ...Array(length)
-    ].map((_)=>new Field(Fr.random()));
-}
 export function getFunctionSelector(functionName, contractArtifact) {
     const fnArtifact = getAllFunctionAbis(contractArtifact).find((f)=>f.name === functionName);
     assert(!!fnArtifact, `Function ${functionName} not found in ${contractArtifact.name}`);
@@ -52,16 +29,6 @@ export function getContractFunctionArtifact(functionName, contractArtifact) {
 export function getContractFunctionAbi(functionName, contractArtifact) {
     return contractArtifact.functions.find((f)=>f.name === functionName) ?? contractArtifact.nonDispatchPublicFunctions.find((f)=>f.name === functionName);
 }
-export function resolveContractAssertionMessage(functionName, revertReason, output, contractArtifact) {
-    traverseCauseChain(revertReason, (cause)=>{
-        revertReason = cause;
-    });
-    const functionArtifact = getAllFunctionAbis(contractArtifact).find((f)=>f.name === functionName);
-    if (!functionArtifact || !revertReason.noirCallStack || !isNoirCallStackUnresolved(revertReason.noirCallStack)) {
-        return undefined;
-    }
-    return resolveAssertionMessageFromRevertData(output, functionArtifact);
-}
 /**
  * Create a contract class and instance given constructor args, artifact, etc.
  * NOTE: This is useful for testing real-ish contract class registration and instance deployment TXs (via logs)
@@ -90,7 +57,7 @@ export function resolveContractAssertionMessage(functionName, revertReason, outp
         immutablesHash,
         publicKeys
     });
-    const contractAddressNullifier = await siloNullifier(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), contractInstance.address.toField());
+    const contractAddressNullifier = await siloNullifier(AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), contractInstance.address.toField());
     return {
         contractClass,
         contractInstance,

package/dest/public/avm_simulator.d.ts

@@ -0,0 +1,28 @@
+import type { PublicContractsDB } from './public_db_sources.js';
+/**
+ * Identifies the contract data a single simulation reads. The AVM's contract-data lookups during a
+ * `simulate` call are answered from `contractsDB`; `forkId` and `timestamp` scope those lookups to the
+ * world-state fork being simulated against. How this reaches the AVM (in-process call, IPC callback
+ * server, ...) is the implementation's concern — callers only supply the context.
+ */
+export interface AvmContractsDBContext {
+    contractsDB: PublicContractsDB;
+    forkId: number;
+    timestamp: bigint;
+}
+/**
+ * Something that can run AVM simulations, independent of how the work is dispatched (a single external
+ * process, a pool of them, or an in-process stub). Callers hold this and never see the underlying transport.
+ */
+export interface AvmSimulator {
+    /**
+     * Run a fast simulation and return the msgpack-encoded result. `context` supplies the contracts DB whose
+     * data the simulation reads. If `signal` aborts, the simulation stops at the next cancellation checkpoint.
+     */
+    simulate(inputBuffer: Uint8Array, context: AvmContractsDBContext, signal?: AbortSignal): Promise<Uint8Array>;
+    /** Run a simulation collecting proving hints and return the msgpack-encoded result. */
+    simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    /** Release any resources held by the underlying implementation. */
+    destroy?(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZtX3NpbXVsYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B1YmxpYy9hdm1fc2ltdWxhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFaEU7Ozs7O0dBS0c7QUFDSCxNQUFNLFdBQVcscUJBQXFCO0lBQ3BDLFdBQVcsRUFBRSxpQkFBaUIsQ0FBQztJQUMvQixNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQ2YsU0FBUyxFQUFFLE1BQU0sQ0FBQztDQUNuQjtBQUVEOzs7R0FHRztBQUNILE1BQU0sV0FBVyxZQUFZO0lBQzNCOzs7T0FHRztJQUNILFFBQVEsQ0FBQyxXQUFXLEVBQUUsVUFBVSxFQUFFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLENBQUMsRUFBRSxXQUFXLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQzdHLHVGQUF1RjtJQUN2RixpQkFBaUIsQ0FBQyxXQUFXLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUNoRSxtRUFBbUU7SUFDbkUsT0FBTyxDQUFDLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0NBQzNCIn0=

package/dest/public/avm_simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_simulator.d.ts","sourceRoot":"","sources":["../../src/public/avm_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,iBAAiB,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC7G,uFAAuF;IACvF,iBAAiB,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAChE,mEAAmE;IACnE,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B"}

package/dest/public/avm_simulator.js

@@ -0,0 +1,4 @@
+/**
+ * Something that can run AVM simulations, independent of how the work is dispatched (a single external
+ * process, a pool of them, or an in-process stub). Callers hold this and never see the underlying transport.
+ */ export { };

package/dest/public/avm_simulator_pool.d.ts

@@ -0,0 +1,45 @@
+import type { AvmContractsDBContext, AvmSimulator } from './avm_simulator.js';
+export interface AvmSimulatorPoolOptions {
+    /** Maximum number of concurrent AVM processes. If not set, defaults to AVM_MAX_CONCURRENT_SIMULATIONS env var or 4. */
+    maxSize?: number;
+    /** Path to the bb-avm-sim binary. If omitted, the generated package resolves it. */
+    avmBinaryPath?: string;
+    /** IPC path for the shared WSDB server. */
+    wsdbIpcPath: string;
+    /** Optional logger function for AVM process output. */
+    logger?: (msg: string) => void;
+}
+/**
+ * The public-execution AVM backend: a lazily-grown pool of bb-avm-sim processes plus the CDB server that
+ * answers those processes' contract-data callbacks. Callers hold this as an {@link AvmSimulator}; the pool,
+ * the CDB server, its IPC path, and fork-id routing are all hidden behind that interface. Each `simulate`
+ * registers the call's contracts DB on the CDB server for the duration of the simulation (keyed by fork id
+ * so concurrent simulations on different forks don't collide) and unregisters it once the call returns.
+ */
+export declare class AvmSimulatorPool implements AvmSimulator {
+    private options;
+    private slots;
+    private available;
+    private waiters;
+    private createdCount;
+    private log;
+    private maxSize;
+    private cdbServer;
+    constructor(options: AvmSimulatorPoolOptions);
+    static spawn(options: AvmSimulatorPoolOptions): Promise<AvmSimulatorPool>;
+    [Symbol.asyncDispose](): Promise<void>;
+    simulate(inputBuffer: Uint8Array, context: AvmContractsDBContext, signal?: AbortSignal): Promise<Uint8Array>;
+    simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    /** Destroy all AVM processes in the pool and close the CDB server. */
+    destroy(): Promise<void>;
+    /**
+     * Eagerly spawn up to `count` AVM processes (capped at maxSize) and leave them available, so the
+     * first simulate() doesn't pay process spawn/connect cost. Idempotent.
+     */
+    prewarm(count?: number): Promise<void>;
+    private checkout;
+    /** Return an AVM process to the pool after use. */
+    private return;
+    private createSlot;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZtX3NpbXVsYXRvcl9wb29sLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHVibGljL2F2bV9zaW11bGF0b3JfcG9vbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUc5RSxNQUFNLFdBQVcsdUJBQXVCO0lBQ3RDLHVIQUF1SDtJQUN2SCxPQUFPLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDakIsb0ZBQW9GO0lBQ3BGLGFBQWEsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN2QiwyQ0FBMkM7SUFDM0MsV0FBVyxFQUFFLE1BQU0sQ0FBQztJQUNwQix1REFBdUQ7SUFDdkQsTUFBTSxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxLQUFLLElBQUksQ0FBQztDQUNoQztBQWFEOzs7Ozs7R0FNRztBQUNILHFCQUFhLGdCQUFpQixZQUFXLFlBQVk7SUFTdkMsT0FBTyxDQUFDLE9BQU87SUFSM0IsT0FBTyxDQUFDLEtBQUssQ0FBc0M7SUFDbkQsT0FBTyxDQUFDLFNBQVMsQ0FBZ0I7SUFDakMsT0FBTyxDQUFDLE9BQU8sQ0FBaUc7SUFDaEgsT0FBTyxDQUFDLFlBQVksQ0FBSztJQUN6QixPQUFPLENBQUMsR0FBRyxDQUFTO0lBQ3BCLE9BQU8sQ0FBQyxPQUFPLENBQVM7SUFDeEIsT0FBTyxDQUFDLFNBQVMsQ0FBZTtJQUVoQyxZQUFvQixPQUFPLEVBQUUsdUJBQXVCLEVBSW5EO0lBRUQsT0FBYSxLQUFLLENBQUMsT0FBTyxFQUFFLHVCQUF1QixHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUs5RTtJQUVLLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFM0M7SUFFSyxRQUFRLENBQUMsV0FBVyxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxDQUFDLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0Fjakg7SUFFSyxpQkFBaUIsQ0FBQyxXQUFXLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FRcEU7SUFFRCxzRUFBc0U7SUFDaEUsT0FBTyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FtQjdCO0lBRUQ7OztPQUdHO0lBQ0csT0FBTyxDQUFDLEtBQUssU0FBSSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FVdEM7WUFHYSxRQUFRO0lBZXRCLG1EQUFtRDtJQUNuRCxPQUFPLENBQUMsTUFBTTtZQVlBLFVBQVU7Q0E4QnpCIn0=

package/dest/public/avm_simulator_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_simulator_pool.d.ts","sourceRoot":"","sources":["../../src/public/avm_simulator_pool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAG9E,MAAM,WAAW,uBAAuB;IACtC,uHAAuH;IACvH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAaD;;;;;;GAMG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IASvC,OAAO,CAAC,OAAO;IAR3B,OAAO,CAAC,KAAK,CAAsC;IACnD,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,OAAO,CAAiG;IAChH,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAe;IAEhC,YAAoB,OAAO,EAAE,uBAAuB,EAInD;IAED,OAAa,KAAK,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAK9E;IAEK,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3C;IAEK,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAcjH;IAEK,iBAAiB,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAQpE;IAED,sEAAsE;IAChE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAmB7B;IAED;;;OAGG;IACG,OAAO,CAAC,KAAK,SAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAUtC;YAGa,QAAQ;IAetB,mDAAmD;IACnD,OAAO,CAAC,MAAM;YAYA,UAAU;CA8BzB"}

package/dest/public/avm_simulator_pool.js

@@ -0,0 +1,197 @@
+var _computedKey;
+import { AvmService } from '@aztec/bb-avm-sim';
+import { createLogger } from '@aztec/foundation/log';
+import { CdbIpcServer } from './cdb_ipc_server.js';
+_computedKey = Symbol.asyncDispose;
+/**
+ * The public-execution AVM backend: a lazily-grown pool of bb-avm-sim processes plus the CDB server that
+ * answers those processes' contract-data callbacks. Callers hold this as an {@link AvmSimulator}; the pool,
+ * the CDB server, its IPC path, and fork-id routing are all hidden behind that interface. Each `simulate`
+ * registers the call's contracts DB on the CDB server for the duration of the simulation (keyed by fork id
+ * so concurrent simulations on different forks don't collide) and unregisters it once the call returns.
+ */ export class AvmSimulatorPool {
+    options;
+    slots;
+    available;
+    waiters;
+    createdCount;
+    log;
+    maxSize;
+    cdbServer;
+    constructor(options){
+        this.options = options;
+        this.slots = [];
+        this.available = [];
+        this.waiters = [];
+        this.createdCount = 0;
+        this.log = createLogger('simulator:avm-pool');
+        this.maxSize = options.maxSize ?? parseInt(process.env.AVM_MAX_CONCURRENT_SIMULATIONS ?? '4', 10);
+        this.cdbServer = new CdbIpcServer();
+    }
+    static async spawn(options) {
+        const pool = new AvmSimulatorPool(options);
+        // Always start one process up front so the first simulate() doesn't pay process spawn/connect cost.
+        await pool.prewarm();
+        return pool;
+    }
+    async [_computedKey]() {
+        await this.destroy();
+    }
+    async simulate(inputBuffer, context, signal) {
+        // Register the fork's contracts DB so the C++ AVM's callbacks (which carry this fork id) route to it,
+        // and unregister once the simulation returns — registration is only needed while the call is running.
+        this.cdbServer.registerFork(context.forkId, context.contractsDB, context.timestamp);
+        try {
+            const simulator = await this.checkout();
+            try {
+                return await simulator.simulate(inputBuffer, signal);
+            } finally{
+                this.return(simulator);
+            }
+        } finally{
+            this.cdbServer.unregisterFork(context.forkId);
+        }
+    }
+    async simulateWithHints(inputBuffer) {
+        // The hinted path makes no contract-data callbacks, so no CDB registration is needed.
+        const simulator = await this.checkout();
+        try {
+            return await simulator.simulateWithHints(inputBuffer);
+        } finally{
+            this.return(simulator);
+        }
+    }
+    /** Destroy all AVM processes in the pool and close the CDB server. */ async destroy() {
+        for (const waiter of this.waiters){
+            waiter.reject(new Error('AVM simulator pool destroyed'));
+        }
+        this.waiters = [];
+        const destroyPromises = [];
+        for (const slot of this.slots){
+            if (slot) {
+                destroyPromises.push(slot.destroy());
+            }
+        }
+        await Promise.all(destroyPromises);
+        this.slots = [];
+        this.available = [];
+        this.createdCount = 0;
+        await this.cdbServer.close();
+        this.log.info('AVM simulator pool destroyed');
+    }
+    /**
+   * Eagerly spawn up to `count` AVM processes (capped at maxSize) and leave them available, so the
+   * first simulate() doesn't pay process spawn/connect cost. Idempotent.
+   */ async prewarm(count = 1) {
+        const target = Math.min(count, this.maxSize);
+        const created = [];
+        while(this.createdCount < target){
+            created.push(await this.createSlot());
+        }
+        // Hand the freshly-spawned processes back to the pool so checkout() reuses them.
+        for (const simulator of created){
+            this.return(simulator);
+        }
+    }
+    /** Check out an AVM process from the pool, blocking until one is free. Caller must return() it when done. */ async checkout() {
+        const idx = this.available.pop();
+        if (idx !== undefined && this.slots[idx]) {
+            return this.slots[idx];
+        }
+        if (this.createdCount < this.maxSize || idx !== undefined && !this.slots[idx]) {
+            return await this.createSlot(idx);
+        }
+        return new Promise((resolve, reject)=>{
+            this.waiters.push({
+                resolve,
+                reject
+            });
+        });
+    }
+    /** Return an AVM process to the pool after use. */ return(simulator) {
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter.resolve(simulator);
+        } else {
+            const idx = this.slots.indexOf(simulator);
+            if (idx >= 0) {
+                this.available.push(idx);
+            }
+        }
+    }
+    async createSlot(reuseIdx) {
+        const reuse = reuseIdx !== undefined && reuseIdx < this.slots.length;
+        // Reserve the slot count synchronously, before the async spawn, so concurrent checkouts can't all
+        // observe `createdCount < maxSize` and overshoot the pool (the count is only bumped once control has
+        // yielded on the await). Roll back the reservation if the spawn itself fails.
+        if (!reuse) {
+            this.createdCount++;
+        }
+        let simulator;
+        try {
+            simulator = await AvmSimulatorProcess.spawn({
+                binaryPath: this.options.avmBinaryPath,
+                wsdbIpcPath: this.options.wsdbIpcPath,
+                cdbIpcPath: this.cdbServer.ipcPath,
+                logger: this.options.logger
+            });
+        } catch (err) {
+            if (!reuse) {
+                this.createdCount--;
+            }
+            throw err;
+        }
+        if (reuse) {
+            this.slots[reuseIdx] = simulator;
+        } else {
+            this.slots.push(simulator);
+        }
+        this.log.debug(`Created AVM pool slot (${this.createdCount}/${this.maxSize})`);
+        return simulator;
+    }
+}
+class AvmSimulatorProcess {
+    service;
+    constructor(service){
+        this.service = service;
+    }
+    static async spawn(options) {
+        const service = await AvmService.spawn({
+            binaryPath: options.binaryPath,
+            transport: 'uds',
+            logger: options.logger,
+            extraArgs: [
+                '--wsdb',
+                options.wsdbIpcPath,
+                '--cdb',
+                options.cdbIpcPath
+            ]
+        });
+        return new AvmSimulatorProcess(service);
+    }
+    async simulate(inputBuffer, signal) {
+        // Signal the C++ process to stop at its next cancellation checkpoint when the caller aborts.
+        const onAbort = ()=>this.service.sendProcessSignal('SIGUSR1');
+        if (signal?.aborted) {
+            onAbort();
+        }
+        signal?.addEventListener('abort', onAbort, {
+            once: true
+        });
+        try {
+            return (await this.service.simulate({
+                inputs: inputBuffer
+            })).result;
+        } finally{
+            signal?.removeEventListener('abort', onAbort);
+        }
+    }
+    async simulateWithHints(inputBuffer) {
+        return (await this.service.simulateWithHints({
+            inputs: inputBuffer
+        })).result;
+    }
+    async destroy() {
+        await this.service.destroy();
+    }
+}

package/dest/public/cdb_ipc_server.d.ts

@@ -0,0 +1,40 @@
+/**
+ * UDS server for AVM CDB requests.
+ *
+ * Transport (socket, framing, per-connection response ordering) is handled by the shared
+ * `UdsIpcServer` from `@aztec/ipc-runtime`; message dispatch comes from the generated CDB
+ * server. This class only implements the generated handler interface and routes requests to
+ * PublicContractsDB instances by fork ID.
+ */
+import { type CdbAddContracts, type CdbAddContractsResponse, type CdbCommitCheckpoint, type CdbCommitCheckpointResponse, type CdbCreateCheckpoint, type CdbCreateCheckpointResponse, type CdbGetBytecodeCommitment, type CdbGetBytecodeCommitmentResponse, type CdbGetContractClass, type CdbGetContractClassResponse, type CdbGetContractInstance, type CdbGetContractInstanceResponse, type CdbGetDebugFunctionName, type CdbGetDebugFunctionNameResponse, type Handler as CdbHandler, type CdbRevertCheckpoint, type CdbRevertCheckpointResponse } from '@aztec/cdb';
+import { type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { PublicContractsDB } from './public_db_sources.js';
+/** Serializes contract instances to the AVM CDB wire shape. */
+export declare function serializeContractInstance(instance: ContractInstanceWithAddress): Record<string, unknown>;
+/** Routes AVM CDB IPC requests to registered PublicContractsDB forks. */
+export declare class CdbIpcServer implements CdbHandler {
+    readonly ipcPath: string;
+    private server;
+    private log;
+    /** Maps WSDB fork IDs to contracts DB/timestamp pairs for concurrent simulations. */
+    private forks;
+    constructor();
+    /** Register a PublicContractsDB for a given WSDB fork ID. */
+    registerFork(forkId: number, contractsDB: PublicContractsDB, timestamp: bigint): void;
+    /** Unregister a fork's contracts DB (call after simulation completes). */
+    unregisterFork(forkId: number): void;
+    /** Close the server and all active connections. */
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    /** Look up the contracts DB for a given fork ID, throwing if not registered. */
+    private getFork;
+    getContractInstance(command: CdbGetContractInstance): Promise<CdbGetContractInstanceResponse>;
+    getContractClass(command: CdbGetContractClass): Promise<CdbGetContractClassResponse>;
+    getBytecodeCommitment(command: CdbGetBytecodeCommitment): Promise<CdbGetBytecodeCommitmentResponse>;
+    getDebugFunctionName(command: CdbGetDebugFunctionName): Promise<CdbGetDebugFunctionNameResponse>;
+    addContracts(command: CdbAddContracts): Promise<CdbAddContractsResponse>;
+    createCheckpoint(command: CdbCreateCheckpoint): Promise<CdbCreateCheckpointResponse>;
+    commitCheckpoint(command: CdbCommitCheckpoint): Promise<CdbCommitCheckpointResponse>;
+    revertCheckpoint(command: CdbRevertCheckpoint): Promise<CdbRevertCheckpointResponse>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/public/cdb_ipc_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdb_ipc_server.d.ts","sourceRoot":"","sources":["../../src/public/cdb_ipc_server.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,gCAAgC,EACrC,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,EAC3B,KAAK,8BAA8B,EACnC,KAAK,uBAAuB,EAC5B,KAAK,+BAA+B,EACpC,KAAK,OAAO,IAAI,UAAU,EAC1B,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAEjC,MAAM,YAAY,CAAC;AAMpB,OAAO,EAA0B,KAAK,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAOlG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAWhE,+DAA+D;AAC/D,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,2BAA2B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoBxG;AAiBD,yEAAyE;AACzE,qBAAa,YAAa,YAAW,UAAU;IAC7C,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,GAAG,CAAS;IACpB,qFAAqF;IACrF,OAAO,CAAC,KAAK,CAAmE;IAEhF,cAUC;IAED,6DAA6D;IAC7D,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAEpF;IAED,0EAA0E;IAC1E,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEnC;IAED,mDAAmD;IAC7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAG3B;IAEK,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3C;IAED,gFAAgF;IAChF,OAAO,CAAC,OAAO;IAWT,mBAAmB,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAKlG;IAEK,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAKzF;IAEK,qBAAqB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,gCAAgC,CAAC,CAKxG;IAEK,oBAAoB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,+BAA+B,CAAC,CAOrG;IAED,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAOvE;IAED,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAInF;IAED,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAInF;IAED,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAInF;CACF"}

package/dest/public/cdb_ipc_server.js

@@ -0,0 +1,153 @@
+/**
+ * UDS server for AVM CDB requests.
+ *
+ * Transport (socket, framing, per-connection response ordering) is handled by the shared
+ * `UdsIpcServer` from `@aztec/ipc-runtime`; message dispatch comes from the generated CDB
+ * server. This class only implements the generated handler interface and routes requests to
+ * PublicContractsDB instances by fork ID.
+ */ var _computedKey;
+import { handleRequest } from '@aztec/cdb';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { UdsIpcServer } from '@aztec/ipc-runtime';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ContractDeploymentData } from '@aztec/stdlib/contract';
+import { Decoder, Encoder } from 'msgpackr';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { threadId } from 'node:worker_threads';
+const encoder = new Encoder({
+    useRecords: false
+});
+const decoder = new Decoder({
+    useRecords: false
+});
+let instanceCounter = 0;
+function toFieldBuffer(field) {
+    return field.toBuffer();
+}
+/** Serializes contract instances to the AVM CDB wire shape. */ export function serializeContractInstance(instance) {
+    return {
+        salt: toFieldBuffer(instance.salt),
+        deployer: toFieldBuffer(instance.deployer),
+        currentContractClassId: toFieldBuffer(instance.currentContractClassId),
+        originalContractClassId: toFieldBuffer(instance.originalContractClassId),
+        initializationHash: toFieldBuffer(instance.initializationHash),
+        immutablesHash: toFieldBuffer(instance.immutablesHash),
+        publicKeys: {
+            npkMHash: toFieldBuffer(instance.publicKeys.npkMHash),
+            ivpkM: {
+                x: toFieldBuffer(instance.publicKeys.ivpkM.x),
+                y: toFieldBuffer(instance.publicKeys.ivpkM.y)
+            },
+            ovpkMHash: toFieldBuffer(instance.publicKeys.ovpkMHash),
+            tpkMHash: toFieldBuffer(instance.publicKeys.tpkMHash),
+            mspkMHash: toFieldBuffer(instance.publicKeys.mspkMHash),
+            fbpkMHash: toFieldBuffer(instance.publicKeys.fbpkMHash)
+        }
+    };
+}
+/** Serializes contract classes to the AVM CDB wire shape. */ function serializeContractClass(contractClass) {
+    return {
+        id: toFieldBuffer(contractClass.id),
+        artifactHash: toFieldBuffer(contractClass.artifactHash),
+        privateFunctionsRoot: toFieldBuffer(contractClass.privateFunctionsRoot),
+        packedBytecode: contractClass.packedBytecode
+    };
+}
+_computedKey = Symbol.asyncDispose;
+/** Routes AVM CDB IPC requests to registered PublicContractsDB forks. */ export class CdbIpcServer {
+    ipcPath;
+    server;
+    log;
+    /** Maps WSDB fork IDs to contracts DB/timestamp pairs for concurrent simulations. */ forks = new Map();
+    constructor(){
+        this.log = createLogger('cdb-ipc-server');
+        this.ipcPath = path.join(os.tmpdir(), `cdb-ts-${process.pid}-${threadId}-${instanceCounter++}.sock`);
+        // Listen asynchronously; the C++ AVM retries connecting until the socket is up.
+        this.server = UdsIpcServer.listen(this.ipcPath, (_clientId, request)=>handleRequest(this, request));
+        this.server.then(()=>this.log.debug(`CDB IPC server listening on ${this.ipcPath}`), (err)=>this.log.error(`CDB IPC server failed to listen on ${this.ipcPath}`, {
+                err
+            }));
+    }
+    /** Register a PublicContractsDB for a given WSDB fork ID. */ registerFork(forkId, contractsDB, timestamp) {
+        this.forks.set(forkId, {
+            db: contractsDB,
+            timestamp
+        });
+    }
+    /** Unregister a fork's contracts DB (call after simulation completes). */ unregisterFork(forkId) {
+        this.forks.delete(forkId);
+    }
+    /** Close the server and all active connections. */ async close() {
+        const server = await this.server.catch(()=>undefined);
+        await server?.close();
+    }
+    async [_computedKey]() {
+        await this.close();
+    }
+    /** Look up the contracts DB for a given fork ID, throwing if not registered. */ getFork(forkId) {
+        const fork = this.forks.get(forkId);
+        if (!fork) {
+            const registered = Array.from(this.forks.keys()).sort((a, b)=>a - b);
+            throw new Error(`CDB server: no contracts DB registered for forkId ${forkId} (registered=[${registered.join(',')}])`);
+        }
+        return fork;
+    }
+    async getContractInstance(command) {
+        const { db, timestamp } = this.getFork(command.forkId);
+        const address = AztecAddress.fromBuffer(Buffer.from(command.address));
+        const instance = await db.getContractInstance(address, timestamp);
+        return {
+            instance: instance ? encoder.encode(serializeContractInstance(instance)) : null
+        };
+    }
+    async getContractClass(command) {
+        const { db } = this.getFork(command.forkId);
+        const classId = Fr.fromBuffer(Buffer.from(command.classId));
+        const contractClass = await db.getContractClass(classId);
+        return {
+            contractClass: contractClass ? encoder.encode(serializeContractClass(contractClass)) : null
+        };
+    }
+    async getBytecodeCommitment(command) {
+        const { db } = this.getFork(command.forkId);
+        const classId = Fr.fromBuffer(Buffer.from(command.classId));
+        const commitment = await db.getBytecodeCommitment(classId);
+        return {
+            commitment: commitment ? toFieldBuffer(commitment) : null
+        };
+    }
+    async getDebugFunctionName(command) {
+        const { db } = this.getFork(command.forkId);
+        const address = AztecAddress.fromBuffer(Buffer.from(command.address));
+        const selectorField = Fr.fromBuffer(Buffer.from(command.selector));
+        const selector = FunctionSelector.fromFieldOrUndefined(selectorField);
+        const name = selector ? await db.getDebugFunctionName(address, selector) : undefined;
+        return {
+            name: name ?? null
+        };
+    }
+    addContracts(command) {
+        const { db } = this.getFork(command.forkId);
+        const contractDeploymentData = ContractDeploymentData.fromPlainObject(decoder.decode(command.contractDeploymentData));
+        db.addContractsFromLogs(contractDeploymentData);
+        return Promise.resolve({});
+    }
+    createCheckpoint(command) {
+        const { db } = this.getFork(command.forkId);
+        db.createCheckpoint();
+        return Promise.resolve({});
+    }
+    commitCheckpoint(command) {
+        const { db } = this.getFork(command.forkId);
+        db.commitCheckpoint();
+        return Promise.resolve({});
+    }
+    revertCheckpoint(command) {
+        const { db } = this.getFork(command.forkId);
+        db.revertCheckpoint();
+        return Promise.resolve({});
+    }
+}

package/dest/public/fixtures/amm_test.js

@@ -11,8 +11,8 @@ const INITIAL_TOKEN_BALANCE = 1_000_000_000n;
  * You do NOT need permission to remove this test!
  */ export async function ammTest(tester, logger, tokenArtifact, ammArtifact, expectToBeTrue) {
     const timer = new Timer();
-    const admin = AztecAddress.fromNumber(42);
-    const sender = AztecAddress.fromNumber(111);
+    const admin = AztecAddress.fromNumberUnsafe(42);
+    const sender = AztecAddress.fromNumberUnsafe(111);
     logger.debug(`Deploying tokens`);
     const token0 = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue, /*seed=*/ 0);
     const token1 = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue, /*seed=*/ 1);

package/dest/public/fixtures/bulk_test.js

@@ -3,7 +3,7 @@ import { Timer } from '@aztec/foundation/timer';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 export async function bulkTest(tester, logger, avmTestContractArtifact) {
     const timer = new Timer();
-    const deployer = AztecAddress.fromNumber(42);
+    const deployer = AztecAddress.fromNumberUnsafe(42);
     const avmTestContract = await tester.registerAndDeployContract(/*constructorArgs=*/ [], deployer, avmTestContractArtifact);
     // Needed since we invoke the Fee Juice Contract in the bulk test.registerFeeJuiceContract
     await tester.registerFeeJuiceContract();
@@ -136,7 +136,7 @@ export async function bulkTest(tester, logger, avmTestContractArtifact) {
 }
 export async function megaBulkTest(tester, logger, avmTestContractArtifact) {
     const timer = new Timer();
-    const deployer = AztecAddress.fromNumber(42);
+    const deployer = AztecAddress.fromNumberUnsafe(42);
     const avmTestContract = await tester.registerAndDeployContract(/*constructorArgs=*/ [], deployer, avmTestContractArtifact);
     // Needed since we invoke the Fee Juice Contract in the bulk test.registerFeeJuiceContract
     await tester.registerFeeJuiceContract();

package/dest/public/fixtures/custom_bytecode_tester.d.ts

@@ -31,4 +31,4 @@ export declare function executeCustomBytecode(contract: ContractInstanceWithAddr
  * @returns The execution result
  */
 export declare function deployAndExecuteCustomBytecode(bytecode: Buffer, tester: PublicTxSimulationTester, txLabel?: string, contractName?: string, deployer?: AztecAddress, calldata?: any[]): Promise<PublicTxResult>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tX2J5dGVjb2RlX3Rlc3Rlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9maXh0dXJlcy9jdXN0b21fYnl0ZWNvZGVfdGVzdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTFFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRTVFOzs7Ozs7O0dBT0c7QUFDSCx3QkFBc0Isb0JBQW9CLENBQ3hDLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLE1BQU0sRUFBRSx3QkFBd0IsRUFDaEMsWUFBWSxHQUFFLE1BQWlDLEVBQy9DLFFBQVEsR0FBRSxZQUEwQyxHQUNuRCxPQUFPLENBQUMsMkJBQTJCLENBQUMsQ0FpQnRDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFzQixxQkFBcUIsQ0FDekMsUUFBUSxFQUFFLDJCQUEyQixFQUNyQyxNQUFNLEVBQUUsd0JBQXdCLEVBQ2hDLE9BQU8sR0FBRSxNQUE2QixFQUN0QyxRQUFRLEdBQUUsR0FBRyxFQUFPLEdBQ25CLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FRekI7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBc0IsOEJBQThCLENBQ2xELFFBQVEsRUFBRSxNQUFNLEVBQ2hCLE1BQU0sRUFBRSx3QkFBd0IsRUFDaEMsT0FBTyxHQUFFLE1BQTZCLEVBQ3RDLFlBQVksR0FBRSxNQUFpQyxFQUMvQyxRQUFRLEdBQUUsWUFBMEMsRUFDcEQsUUFBUSxHQUFFLEdBQUcsRUFBTyxHQUNuQixPQUFPLENBQUMsY0FBYyxDQUFDLENBR3pCIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tX2J5dGVjb2RlX3Rlc3Rlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9maXh0dXJlcy9jdXN0b21fYnl0ZWNvZGVfdGVzdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTFFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRTVFOzs7Ozs7O0dBT0c7QUFDSCx3QkFBc0Isb0JBQW9CLENBQ3hDLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLE1BQU0sRUFBRSx3QkFBd0IsRUFDaEMsWUFBWSxHQUFFLE1BQWlDLEVBQy9DLFFBQVEsR0FBRSxZQUFnRCxHQUN6RCxPQUFPLENBQUMsMkJBQTJCLENBQUMsQ0FpQnRDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFzQixxQkFBcUIsQ0FDekMsUUFBUSxFQUFFLDJCQUEyQixFQUNyQyxNQUFNLEVBQUUsd0JBQXdCLEVBQ2hDLE9BQU8sR0FBRSxNQUE2QixFQUN0QyxRQUFRLEdBQUUsR0FBRyxFQUFPLEdBQ25CLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FRekI7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBc0IsOEJBQThCLENBQ2xELFFBQVEsRUFBRSxNQUFNLEVBQ2hCLE1BQU0sRUFBRSx3QkFBd0IsRUFDaEMsT0FBTyxHQUFFLE1BQTZCLEVBQ3RDLFlBQVksR0FBRSxNQUFpQyxFQUMvQyxRQUFRLEdBQUUsWUFBZ0QsRUFDMUQsUUFBUSxHQUFFLEdBQUcsRUFBTyxHQUNuQixPQUFPLENBQUMsY0FBYyxDQUFDLENBR3pCIn0=