@aztec-labs/simulator 6.0.0-nightly.20260829

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

@@ -0,0 +1 @@
+{"version":3,"file":"side_effect_errors.d.ts","sourceRoot":"","sources":["../../src/public/side_effect_errors.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEjE;;;GAGG;AACH,8BAAsB,eAAgB,SAAQ,2BAA2B;IACvE,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,qBAAa,2BAA4B,SAAQ,eAAe;IAC9D,YAAY,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAGhD;CACF;AAED,qBAAa,qCAAsC,SAAQ,2BAA2B;IACpF,cAGC;CACF;AAED,qBAAa,0BAA2B,SAAQ,2BAA2B;IACzE,cAGC;CACF;AAED,qBAAa,yBAA0B,SAAQ,2BAA2B;IACxE,cAGC;CACF;AAED,qBAAa,8BAA+B,SAAQ,2BAA2B;IAC7E,cAGC;CACF;AAED,qBAAa,uBAAwB,SAAQ,eAAe;IAC1D,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;GAIG;AACH,8BAAsB,mBAAoB,SAAQ,KAAK;IACrD,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,qBAAa,oBAAqB,SAAQ,mBAAmB;IAC3D,YAAY,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAGrD;CACF;AAED,qBAAa,4BAA6B,SAAQ,oBAAoB;IACpE,YAAY,KAAK,EAAE,MAAM,EAGxB;CACF;AAED,qBAAa,iCAAkC,SAAQ,oBAAoB;IACzE,YAAY,KAAK,EAAE,MAAM,EAGxB;CACF"}

package/dest/public/side_effect_errors.js

@@ -0,0 +1,75 @@
+import { L1_TO_L2_MSG_TREE_LEAF_COUNT, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS, NOTE_HASH_TREE_LEAF_COUNT } from '@aztec-labs/constants';
+import { CheckedPublicExecutionError } from './public_errors.js';
+/**
+ * Any error that can be thrown during side effect insertion in public.
+ * Includes SideEffectLimitReachedError and NullifierCollisionError.
+ */ export class SideEffectError extends CheckedPublicExecutionError {
+    constructor(message){
+        super(message);
+        this.name = 'SideEffectInsertionError';
+    }
+}
+export class SideEffectLimitReachedError extends SideEffectError {
+    constructor(sideEffectType, limit){
+        super(`Reached the limit (${limit}) on number of '${sideEffectType}' per tx`);
+        this.name = 'SideEffectLimitReachedError';
+    }
+}
+export class MaxCallsToUniqueContractClassIdsError extends SideEffectLimitReachedError {
+    constructor(){
+        super('contract calls to unique class IDs', MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS);
+        this.name = 'MaxCallsToUniqueContractClassIdsError';
+    }
+}
+export class NullifierLimitReachedError extends SideEffectLimitReachedError {
+    constructor(){
+        super('nullifier', MAX_NULLIFIERS_PER_TX);
+        this.name = 'NullifierLimitReachedError';
+    }
+}
+export class NoteHashLimitReachedError extends SideEffectLimitReachedError {
+    constructor(){
+        super('note hash', MAX_NOTE_HASHES_PER_TX);
+        this.name = 'NoteHashLimitReachedError';
+    }
+}
+export class L2ToL1MessageLimitReachedError extends SideEffectLimitReachedError {
+    constructor(){
+        super('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
+        this.name = 'L2ToL1MessageLimitReachedError';
+    }
+}
+export class NullifierCollisionError extends SideEffectError {
+    constructor(message){
+        super(`Nullifier collision: ${message}`);
+        this.name = 'NullifierCollisionError';
+    }
+}
+/**
+ * Any error that can be thrown during side effect reads in public.
+ * Note: Thrown at state manager level and unknown by simulation, hence NOT considered
+ * CheckedPublicExecutionErrors. Currently only includes append-only tree reads.
+ */ export class SideEffectReadError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'SideEffectReadError';
+    }
+}
+export class IndexOutOfRangeError extends SideEffectReadError {
+    constructor(tree, index, limit){
+        super(`Attempting to read index ${index} of ${tree} tree with maximum ${limit} leaves`);
+        this.name = 'IndexOutOfRangeError';
+    }
+}
+export class NoteHashIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index){
+        super('note hash', index, NOTE_HASH_TREE_LEAF_COUNT);
+        this.name = 'NoteHashIndexOutOfRangeError';
+    }
+}
+export class L1ToL2MessageIndexOutOfRangeError extends IndexOutOfRangeError {
+    constructor(index){
+        super('l1 to l2 message', index, L1_TO_L2_MSG_TREE_LEAF_COUNT);
+        this.name = 'L1ToL2MessageIndexOutOfRangeError';
+    }
+}

package/dest/public/test_executor_metrics.d.ts

@@ -0,0 +1,56 @@
+import { type LoggerBindings } from '@aztec-labs/foundation/log';
+import type { RevertCode } from '@aztec-labs/stdlib/avm';
+import type { GasUsed } from '@aztec-labs/stdlib/gas';
+import type { ExecutorMetricsInterface } from './executor_metrics_interface.js';
+export interface PublicEnqueuedCallMetrics {
+    fnName: string;
+    durationMs: number;
+    manaUsed: number;
+    totalInstructionsExecuted: number;
+    reverted: boolean;
+}
+export interface PublicTxMetrics {
+    totalDurationMs: number;
+    manaUsed: number | undefined;
+    totalInstructionsExecuted: number;
+    nonRevertiblePrivateInsertionsUs: number | undefined;
+    revertiblePrivateInsertionsUs: number | undefined;
+    enqueuedCalls: PublicEnqueuedCallMetrics[];
+    revertedCode: RevertCode | undefined;
+    proverSimulationStepMs: number | undefined;
+    proverProvingStepMs: number | undefined;
+    proverTraceGenerationStepMs: number | undefined;
+    traceGenerationInteractionsMs: number | undefined;
+    traceGenerationTracesMs: number | undefined;
+    provingSumcheckMs: number | undefined;
+    provingPcsMs: number | undefined;
+    provingLogDerivativeInverseMs: number | undefined;
+    provingLogDerivativeInverseCommitmentsMs: number | undefined;
+    provingWireCommitmentsMs: number | undefined;
+}
+export declare enum PublicTxMetricsFilter {
+    ALL = 0,
+    TOTALS = 1,
+    DURATIONS = 2,
+    INSTRUCTIONS = 3,
+    PROVING = 4
+}
+export declare class TestExecutorMetrics implements ExecutorMetricsInterface {
+    #private;
+    private logger;
+    private txMetrics;
+    private currentTxLabel;
+    private txTimer;
+    constructor(bindings?: LoggerBindings);
+    startRecordingTxSimulation(txLabel: string): void;
+    stopRecordingTxSimulation(txLabel: string, gasUsed?: GasUsed, revertedCode?: RevertCode, stats?: Record<string, string>): void;
+    recordEnqueuedCallSimulation(fnName: string, durationMs: number, manaUsed: number, totalInstructionsExecuted: number): void;
+    recordEnqueuedCallSimulationFailure(fnName: string, durationMs: number, manaUsed: number, totalInstructionsExecuted: number): void;
+    recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible'): void;
+    recordProverMetrics(txLabel: string, metrics: Partial<PublicTxMetrics>): void;
+    prettyPrint(filter?: PublicTxMetricsFilter): void;
+    toPrettyString(filter?: PublicTxMetricsFilter): string;
+    toJSON(indent?: number): string;
+    toGithubActionBenchmarkJSON(indent?: number): string;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdF9leGVjdXRvcl9tZXRyaWNzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHVibGljL3Rlc3RfZXhlY3V0b3JfbWV0cmljcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWUsS0FBSyxjQUFjLEVBQWdCLE1BQU0sNEJBQTRCLENBQUM7QUFFNUYsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFHdEQsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUVoRixNQUFNLFdBQVcseUJBQXlCO0lBQ3hDLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFDZixVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25CLFFBQVEsRUFBRSxNQUFNLENBQUM7SUFDakIseUJBQXlCLEVBQUUsTUFBTSxDQUFDO0lBQ2xDLFFBQVEsRUFBRSxPQUFPLENBQUM7Q0FDbkI7QUFFRCxNQUFNLFdBQVcsZUFBZTtJQUU5QixlQUFlLEVBQUUsTUFBTSxDQUFDO0lBQ3hCLFFBQVEsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQzdCLHlCQUF5QixFQUFFLE1BQU0sQ0FBQztJQUNsQyxnQ0FBZ0MsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQ3JELDZCQUE2QixFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDbEQsYUFBYSxFQUFFLHlCQUF5QixFQUFFLENBQUM7SUFDM0MsWUFBWSxFQUFFLFVBQVUsR0FBRyxTQUFTLENBQUM7SUFFckMsc0JBQXNCLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUMzQyxtQkFBbUIsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQ3hDLDJCQUEyQixFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFFaEQsNkJBQTZCLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUNsRCx1QkFBdUIsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQzVDLGlCQUFpQixFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDdEMsWUFBWSxFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDakMsNkJBQTZCLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUNsRCx3Q0FBd0MsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQzdELHdCQUF3QixFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7Q0FDOUM7QUFXRCxvQkFBWSxxQkFBcUI7SUFDL0IsR0FBRyxJQUFBO0lBQ0gsTUFBTSxJQUFBO0lBQ04sU0FBUyxJQUFBO0lBQ1QsWUFBWSxJQUFBO0lBQ1osT0FBTyxJQUFBO0NBQ1I7QUEyQkQscUJBQWEsbUJBQW9CLFlBQVcsd0JBQXdCOztJQUNsRSxPQUFPLENBQUMsTUFBTSxDQUFTO0lBRXZCLE9BQU8sQ0FBQyxTQUFTLENBQTJDO0lBQzVELE9BQU8sQ0FBQyxjQUFjLENBQXFCO0lBQzNDLE9BQU8sQ0FBQyxPQUFPLENBQW9CO0lBRW5DLFlBQVksUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUVwQztJQUVELDBCQUEwQixDQUFDLE9BQU8sRUFBRSxNQUFNLFFBTXpDO0lBRUQseUJBQXlCLENBQ3ZCLE9BQU8sRUFBRSxNQUFNLEVBQ2YsT0FBTyxDQUFDLEVBQUUsT0FBTyxFQUNqQixZQUFZLENBQUMsRUFBRSxVQUFVLEVBQ3pCLEtBQUssQ0FBQyxFQUFFLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLFFBZ0IvQjtJQUVELDRCQUE0QixDQUMxQixNQUFNLEVBQUUsTUFBTSxFQUNkLFVBQVUsRUFBRSxNQUFNLEVBQ2xCLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLHlCQUF5QixFQUFFLE1BQU0sUUFHbEM7SUFFRCxtQ0FBbUMsQ0FDakMsTUFBTSxFQUFFLE1BQU0sRUFDZCxVQUFVLEVBQUUsTUFBTSxFQUNsQixRQUFRLEVBQUUsTUFBTSxFQUNoQix5QkFBeUIsRUFBRSxNQUFNLFFBR2xDO0lBb0JELDZCQUE2QixDQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLFlBQVksR0FBRyxnQkFBZ0IsUUFnQnRGO0lBRUQsbUJBQW1CLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDLGVBQWUsQ0FBQyxRQVVyRTtJQUVELFdBQVcsQ0FBQyxNQUFNLEdBQUUscUJBQWlELFFBRXBFO0lBRUQsY0FBYyxDQUFDLE1BQU0sR0FBRSxxQkFBaUQsVUErRXZFO0lBMEJELE1BQU0sQ0FBQyxNQUFNLFNBQUksVUFFaEI7SUFFRCwyQkFBMkIsQ0FBQyxNQUFNLFNBQUksVUE0RnJDO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"test_executor_metrics.d.ts","sourceRoot":"","sources":["../../src/public/test_executor_metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,4BAA4B,CAAC;AAE5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAGtD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAEhF,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,yBAAyB,EAAE,MAAM,CAAC;IAClC,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAE9B,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC;IAClC,gCAAgC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrD,6BAA6B,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,aAAa,EAAE,yBAAyB,EAAE,CAAC;IAC3C,YAAY,EAAE,UAAU,GAAG,SAAS,CAAC;IAErC,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,mBAAmB,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,2BAA2B,EAAE,MAAM,GAAG,SAAS,CAAC;IAEhD,6BAA6B,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,uBAAuB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,6BAA6B,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,wCAAwC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7D,wBAAwB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9C;AAWD,oBAAY,qBAAqB;IAC/B,GAAG,IAAA;IACH,MAAM,IAAA;IACN,SAAS,IAAA;IACT,YAAY,IAAA;IACZ,OAAO,IAAA;CACR;AA2BD,qBAAa,mBAAoB,YAAW,wBAAwB;;IAClE,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,SAAS,CAA2C;IAC5D,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,OAAO,CAAoB;IAEnC,YAAY,QAAQ,CAAC,EAAE,cAAc,EAEpC;IAED,0BAA0B,CAAC,OAAO,EAAE,MAAM,QAMzC;IAED,yBAAyB,CACvB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,OAAO,EACjB,YAAY,CAAC,EAAE,UAAU,EACzB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,QAgB/B;IAED,4BAA4B,CAC1B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,yBAAyB,EAAE,MAAM,QAGlC;IAED,mCAAmC,CACjC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,yBAAyB,EAAE,MAAM,QAGlC;IAoBD,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,gBAAgB,QAgBtF;IAED,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,QAUrE;IAED,WAAW,CAAC,MAAM,GAAE,qBAAiD,QAEpE;IAED,cAAc,CAAC,MAAM,GAAE,qBAAiD,UA+EvE;IA0BD,MAAM,CAAC,MAAM,SAAI,UAEhB;IAED,2BAA2B,CAAC,MAAM,SAAI,UA4FrC;CACF"}

package/dest/public/test_executor_metrics.js

@@ -0,0 +1,305 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { Timer } from '@aztec-labs/foundation/timer';
+import { strict as assert } from 'assert';
+const NUM_SPACES = 4;
+const H1 = '# ';
+const H2 = '\n## ';
+const INDENT = ' '.repeat(NUM_SPACES);
+const INDENT0 = '- ';
+const INDENT1 = INDENT + '- ';
+const INDENT2 = INDENT + INDENT + '- ';
+const H_LINE = '\n---------------------------------------------------------------------';
+export var PublicTxMetricsFilter = /*#__PURE__*/ function(PublicTxMetricsFilter) {
+    PublicTxMetricsFilter[PublicTxMetricsFilter["ALL"] = 0] = "ALL";
+    PublicTxMetricsFilter[PublicTxMetricsFilter["TOTALS"] = 1] = "TOTALS";
+    PublicTxMetricsFilter[PublicTxMetricsFilter["DURATIONS"] = 2] = "DURATIONS";
+    PublicTxMetricsFilter[PublicTxMetricsFilter["INSTRUCTIONS"] = 3] = "INSTRUCTIONS";
+    PublicTxMetricsFilter[PublicTxMetricsFilter["PROVING"] = 4] = "PROVING";
+    return PublicTxMetricsFilter;
+}({});
+function createEmptyTxMetrics() {
+    return {
+        // TS simulation
+        totalDurationMs: 0,
+        manaUsed: 0,
+        totalInstructionsExecuted: 0,
+        nonRevertiblePrivateInsertionsUs: undefined,
+        revertiblePrivateInsertionsUs: undefined,
+        enqueuedCalls: [],
+        revertedCode: undefined,
+        // Proving
+        proverSimulationStepMs: undefined,
+        proverProvingStepMs: undefined,
+        proverTraceGenerationStepMs: undefined,
+        // Proving (detail)
+        traceGenerationInteractionsMs: undefined,
+        traceGenerationTracesMs: undefined,
+        provingSumcheckMs: undefined,
+        provingPcsMs: undefined,
+        provingLogDerivativeInverseMs: undefined,
+        provingLogDerivativeInverseCommitmentsMs: undefined,
+        provingWireCommitmentsMs: undefined
+    };
+}
+export class TestExecutorMetrics {
+    logger;
+    // tx label -> tx metrics
+    txMetrics = new Map();
+    currentTxLabel;
+    txTimer;
+    constructor(bindings){
+        this.logger = createLogger(`simulator:test_executor_metrics`, bindings);
+    }
+    startRecordingTxSimulation(txLabel) {
+        assert(!this.currentTxLabel, 'Cannot start recording tx simulation when another is live');
+        assert(!this.txMetrics.has(txLabel), 'Cannot start recording metrics for tx with duplicate label');
+        this.txMetrics.set(txLabel, createEmptyTxMetrics());
+        this.currentTxLabel = txLabel;
+        this.txTimer = new Timer();
+    }
+    stopRecordingTxSimulation(txLabel, gasUsed, revertedCode, stats) {
+        assert(this.currentTxLabel === txLabel, 'Cannot stop recording metrics for tx when another is live');
+        const txMetrics = this.txMetrics.get(txLabel);
+        // total duration of tx
+        txMetrics.totalDurationMs = this.txTimer.ms();
+        this.logger.debug(`Public TX simulation of ${txLabel} took ${txMetrics.totalDurationMs}ms`);
+        // manaUsed and totalInstructionsExecuted are tx-level totals reported by the simulator.
+        txMetrics.manaUsed = gasUsed?.publicGas.l2Gas;
+        txMetrics.totalInstructionsExecuted = Number(stats?.['total_instructions_executed'] ?? 0);
+        txMetrics.revertedCode = revertedCode;
+        this.currentTxLabel = undefined;
+    }
+    recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructionsExecuted) {
+        this.#recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructionsExecuted, false);
+    }
+    recordEnqueuedCallSimulationFailure(fnName, durationMs, manaUsed, totalInstructionsExecuted) {
+        this.#recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructionsExecuted, true);
+    }
+    #recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructionsExecuted, reverted) {
+        assert(this.currentTxLabel, 'Cannot record enqueued call simulation when no tx is live');
+        const txMetrics = this.txMetrics.get(this.currentTxLabel);
+        txMetrics.enqueuedCalls.push({
+            fnName,
+            durationMs,
+            manaUsed,
+            totalInstructionsExecuted: totalInstructionsExecuted,
+            reverted
+        });
+    }
+    recordPrivateEffectsInsertion(durationUs, type) {
+        assert(this.currentTxLabel, 'Cannot record private effects insertion when no tx is live');
+        const txMetrics = this.txMetrics.get(this.currentTxLabel);
+        if (type === 'revertible') {
+            assert(txMetrics.revertiblePrivateInsertionsUs === undefined, 'Cannot RE-record revertible insertions of private effects');
+            txMetrics.revertiblePrivateInsertionsUs = durationUs;
+        } else {
+            assert(txMetrics.nonRevertiblePrivateInsertionsUs === undefined, 'Cannot RE-record non-revertible insertions of private effects');
+            txMetrics.nonRevertiblePrivateInsertionsUs = durationUs;
+        }
+    }
+    recordProverMetrics(txLabel, metrics) {
+        if (!this.txMetrics.has(txLabel)) {
+            this.txMetrics.set(txLabel, createEmptyTxMetrics());
+        }
+        const txMetrics = this.txMetrics.get(txLabel);
+        for (const [key, value] of Object.entries(metrics)){
+            if (key in txMetrics) {
+                txMetrics[key] = value;
+            }
+        }
+    }
+    prettyPrint(filter = 0) {
+        this.logger.info(this.toPrettyString(filter));
+    }
+    toPrettyString(filter = 0) {
+        let pretty = '';
+        //pretty += H_LINE + '\n';
+        pretty += `${H1}Public TX Simulation Metrics (${PublicTxMetricsFilter[filter]})\n`;
+        for (const [txLabel, txMetrics] of this.txMetrics.entries()){
+            //pretty += H_LINE + '\n';
+            pretty += `${H2}TX Label: ${txLabel}\n`;
+            if (filter == 2 || filter === 1 || filter === 0) {
+                pretty += `${INDENT0}Total duration: ${fmtNum(txMetrics.totalDurationMs, 'ms')}\n`;
+            }
+            if (filter === 1 || filter === 0) {
+                const manaUsed = txMetrics.manaUsed || 0;
+                pretty += `${INDENT0}Total mana used: ${fmtNum(manaUsed)}\n`;
+                const manaPerSecond = Math.round(manaUsed * 1000 / txMetrics.totalDurationMs);
+                pretty += `${INDENT0}Mana per second: ${fmtNum(manaPerSecond)}\n`;
+            }
+            if (filter === 3 || filter === 1 || filter === 0) {
+                pretty += `${INDENT0}Total instructions executed: ${fmtNum(txMetrics.totalInstructionsExecuted)}\n`;
+            }
+            if (filter === 2 || filter === 0) {
+                pretty += `${INDENT0}Private insertions:\n`;
+                pretty += `${INDENT1}Non-revertible: ${fmtNum(txMetrics.nonRevertiblePrivateInsertionsUs / 1_000, 'ms')}\n`;
+                pretty += `${INDENT1}Revertible: ${fmtNum(txMetrics.revertiblePrivateInsertionsUs / 1_000, 'ms')}\n`;
+            }
+            if (filter === 4 || filter === 0) {
+                let provingPretty = '';
+                if (txMetrics.proverSimulationStepMs !== undefined) {
+                    provingPretty += `${INDENT1}Simulation (all): ${fmtNum(txMetrics.proverSimulationStepMs, 'ms')}\n`;
+                }
+                if (txMetrics.proverProvingStepMs !== undefined) {
+                    provingPretty += `${INDENT1}Proving (all): ${fmtNum(txMetrics.proverProvingStepMs, 'ms')}\n`;
+                }
+                if (txMetrics.proverTraceGenerationStepMs !== undefined) {
+                    provingPretty += `${INDENT1}Trace generation (all): ${fmtNum(txMetrics.proverTraceGenerationStepMs, 'ms')}\n`;
+                }
+                if (txMetrics.traceGenerationInteractionsMs !== undefined) {
+                    provingPretty += `${INDENT1}Trace generation interactions: ${fmtNum(txMetrics.traceGenerationInteractionsMs, 'ms')}\n`;
+                }
+                if (txMetrics.traceGenerationTracesMs !== undefined) {
+                    provingPretty += `${INDENT1}Trace generation traces: ${fmtNum(txMetrics.traceGenerationTracesMs, 'ms')}\n`;
+                }
+                if (txMetrics.provingSumcheckMs !== undefined) {
+                    provingPretty += `${INDENT1}Sumcheck: ${fmtNum(txMetrics.provingSumcheckMs, 'ms')}\n`;
+                }
+                if (txMetrics.provingPcsMs !== undefined) {
+                    provingPretty += `${INDENT1}PCS: ${fmtNum(txMetrics.provingPcsMs, 'ms')}\n`;
+                }
+                if (txMetrics.provingLogDerivativeInverseMs !== undefined) {
+                    provingPretty += `${INDENT1}Log derivative inverse: ${fmtNum(txMetrics.provingLogDerivativeInverseMs, 'ms')}\n`;
+                }
+                if (txMetrics.provingLogDerivativeInverseCommitmentsMs !== undefined) {
+                    provingPretty += `${INDENT1}Log derivative inverse commitments: ${fmtNum(txMetrics.provingLogDerivativeInverseCommitmentsMs, 'ms')}\n`;
+                }
+                if (txMetrics.provingWireCommitmentsMs !== undefined) {
+                    provingPretty += `${INDENT1}Wire commitments: ${fmtNum(txMetrics.provingWireCommitmentsMs, 'ms')}\n`;
+                }
+                if (provingPretty.length > 0) {
+                    pretty += `${INDENT0}Proving:\n${provingPretty}`;
+                }
+            }
+            if (filter !== 1) {
+                // totals exclude enqueued calls
+                pretty += this.#enqueuedCallsToPrettyString(txMetrics, filter);
+            }
+            if (txMetrics.revertedCode !== undefined && !txMetrics.revertedCode.isOK()) {
+                pretty += `${INDENT0}Reverted code: ${txMetrics.revertedCode?.getDescription()}\n`;
+            }
+            pretty += H_LINE + '\n';
+        }
+        return pretty;
+    }
+    #enqueuedCallsToPrettyString(txMetrics, filter) {
+        let pretty = '';
+        pretty += `${INDENT0}Enqueued public calls:\n`;
+        for (const enqueuedCall of txMetrics.enqueuedCalls){
+            pretty += `${INDENT1}**Fn: ${enqueuedCall.fnName}**\n`;
+            if (filter === 2 || filter === 0) {
+                pretty += `${INDENT2}Duration: ${fmtNum(enqueuedCall.durationMs, 'ms')}\n`;
+            }
+            if (filter === 0) {
+                pretty += `${INDENT2}Mana used: ${fmtNum(enqueuedCall.manaUsed)}\n`;
+                const manaPerSecond = Math.round(enqueuedCall.manaUsed * 1000 / enqueuedCall.durationMs);
+                pretty += `${INDENT2}Mana per second: ${fmtNum(manaPerSecond)}\n`;
+            }
+            if (filter === 3 || filter === 0) {
+                pretty += `${INDENT2}Instructions executed: ${fmtNum(enqueuedCall.totalInstructionsExecuted)}\n`;
+            }
+            if (enqueuedCall.reverted) {
+                pretty += `${INDENT2}Reverted!\n`;
+            }
+        }
+        return pretty;
+    }
+    toJSON(indent = 2) {
+        return JSON.stringify(Object.fromEntries(this.txMetrics.entries()), null, indent);
+    }
+    toGithubActionBenchmarkJSON(indent = 2) {
+        const metricsInfo = {
+            totalInstructionsExecuted: {
+                name: 'totalInstructionsExecuted',
+                unit: '#instructions',
+                category: 3
+            },
+            totalDurationMs: {
+                name: 'totalDurationMs',
+                unit: 'ms',
+                category: 2
+            },
+            manaUsed: {
+                name: 'manaUsed',
+                unit: 'mana',
+                category: 1
+            },
+            nonRevertiblePrivateInsertionsUs: {
+                name: 'nonRevertiblePrivateInsertionsUs',
+                unit: 'us',
+                category: 2
+            },
+            revertiblePrivateInsertionsUs: {
+                name: 'revertiblePrivateInsertionsUs',
+                unit: 'us',
+                category: 2
+            },
+            proverSimulationStepMs: {
+                name: 'proverSimulationStepMs',
+                unit: 'ms',
+                category: 4
+            },
+            proverProvingStepMs: {
+                name: 'proverProvingStepMs',
+                unit: 'ms',
+                category: 4
+            },
+            proverTraceGenerationStepMs: {
+                name: 'proverTraceGenerationStepMs',
+                unit: 'ms',
+                category: 4
+            },
+            traceGenerationInteractionsMs: {
+                name: 'traceGenerationInteractionsMs',
+                unit: 'ms',
+                category: 4
+            },
+            traceGenerationTracesMs: {
+                name: 'traceGenerationTracesMs',
+                unit: 'ms',
+                category: 4
+            },
+            provingSumcheckMs: {
+                name: 'provingSumcheckMs',
+                unit: 'ms',
+                category: 4
+            },
+            provingPcsMs: {
+                name: 'provingPcsMs',
+                unit: 'ms',
+                category: 4
+            },
+            provingLogDerivativeInverseMs: {
+                name: 'provingLogDerivativeInverseMs',
+                unit: 'ms',
+                category: 4
+            },
+            provingLogDerivativeInverseCommitmentsMs: {
+                name: 'provingLogDerivativeInverseCommitmentsMs',
+                unit: 'ms',
+                category: 4
+            },
+            provingWireCommitmentsMs: {
+                name: 'provingWireCommitmentsMs',
+                unit: 'ms',
+                category: 4
+            }
+        };
+        const data = [];
+        for (const [txLabel, txMetrics] of this.txMetrics.entries()){
+            for (const [key, value] of Object.entries(txMetrics)){
+                if (value !== undefined && key in metricsInfo) {
+                    data.push({
+                        name: `${txLabel}/${metricsInfo[key].name}`,
+                        value: value,
+                        unit: metricsInfo[key].unit
+                    });
+                }
+            }
+        }
+        return JSON.stringify(data, null, indent);
+    }
+}
+function fmtNum(num, unit) {
+    return `\`${num.toLocaleString()}${unit ? ` ${unit}` : ''}\``;
+}

package/dest/public/unique_class_ids.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A class manage a de-duplicated set of class IDs that errors if you try to add a duplicate.
+ * Useful for bytecode retrieval hints to avoid duplicates in parent trace & grandparent trace....
+ */
+export declare class UniqueClassIds {
+    private readonly parent?;
+    private readonly classIds;
+    constructor(parent?: UniqueClassIds | undefined);
+    /**
+     * Create a fork that references this one as its parent
+     */
+    fork(): UniqueClassIds;
+    /**
+     * Check for a class ID here or in parent's (recursively).
+     *
+     * @param classId - the contract class ID (as a string) to check
+     * @returns boolean: whether the class ID is here
+     */
+    has(classId: string): boolean;
+    /**
+     * Get the total number of classIds
+     */
+    size(): number;
+    /**
+     * Add a class ID (if not already present) to the set.
+     *
+     * @param classId - the contract class ID (as a string)
+     */
+    add(classId: string): void;
+    /**
+     * Merge in another set of unique class IDs into this one, but fail on duplicates.
+     *
+     * @param incoming: other unique class IDs
+     */
+    acceptAndMerge(incoming: UniqueClassIds): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pcXVlX2NsYXNzX2lkcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B1YmxpYy91bmlxdWVfY2xhc3NfaWRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7R0FHRztBQUNILHFCQUFhLGNBQWM7SUFHYixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQztJQUZwQyxPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBMEI7SUFFbkQsWUFBNkIsTUFBTSxDQUFDLDRCQUFnQixFQUFJO0lBRXhEOztPQUVHO0lBQ0ksSUFBSSxtQkFFVjtJQUVEOzs7OztPQUtHO0lBQ0ksR0FBRyxDQUFDLE9BQU8sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQVNuQztJQUVEOztPQUVHO0lBQ0ksSUFBSSxJQUFJLE1BQU0sQ0FFcEI7SUFFRDs7OztPQUlHO0lBQ0ksR0FBRyxDQUFDLE9BQU8sRUFBRSxNQUFNLFFBU3pCO0lBRUQ7Ozs7T0FJRztJQUNJLGNBQWMsQ0FBQyxRQUFRLEVBQUUsY0FBYyxRQWE3QztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"unique_class_ids.d.ts","sourceRoot":"","sources":["../../src/public/unique_class_ids.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,qBAAa,cAAc;IAGb,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAFpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;IAEnD,YAA6B,MAAM,CAAC,4BAAgB,EAAI;IAExD;;OAEG;IACI,IAAI,mBAEV;IAED;;;;;OAKG;IACI,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CASnC;IAED;;OAEG;IACI,IAAI,IAAI,MAAM,CAEpB;IAED;;;;OAIG;IACI,GAAG,CAAC,OAAO,EAAE,MAAM,QASzB;IAED;;;;OAIG;IACI,cAAc,CAAC,QAAQ,EAAE,cAAc,QAa7C;CACF"}

package/dest/public/unique_class_ids.js

@@ -0,0 +1,61 @@
+import { MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS } from '@aztec-labs/constants';
+import { strict as assert } from 'assert';
+/**
+ * A class manage a de-duplicated set of class IDs that errors if you try to add a duplicate.
+ * Useful for bytecode retrieval hints to avoid duplicates in parent trace & grandparent trace....
+ */ export class UniqueClassIds {
+    parent;
+    classIds;
+    constructor(parent){
+        this.parent = parent;
+        this.classIds = new Set();
+    }
+    /**
+   * Create a fork that references this one as its parent
+   */ fork() {
+        return new UniqueClassIds(/*parent=*/ this);
+    }
+    /**
+   * Check for a class ID here or in parent's (recursively).
+   *
+   * @param classId - the contract class ID (as a string) to check
+   * @returns boolean: whether the class ID is here
+   */ has(classId) {
+        // First try check this' classIds
+        let here = this.classIds.has(classId);
+        // Then try parent's
+        if (!here && this.parent) {
+            // Note: this will recurse to grandparent/etc until we reach top or find it
+            here = this.parent.has(classId);
+        }
+        return here;
+    }
+    /**
+   * Get the total number of classIds
+   */ size() {
+        return this.classIds.size + (this.parent ? this.parent.size() : 0);
+    }
+    /**
+   * Add a class ID (if not already present) to the set.
+   *
+   * @param classId - the contract class ID (as a string)
+   */ add(classId) {
+        assert(!this.has(classId), `Bug! Tried to add duplicate classId ${classId} to set of unique classIds.`);
+        if (!this.has(classId)) {
+            this.classIds.add(classId);
+            assert(this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS, `Bug! Surpassed limit (${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}) of unique contract class IDs used for bytecode retrievals.`);
+        }
+    }
+    /**
+   * Merge in another set of unique class IDs into this one, but fail on duplicates.
+   *
+   * @param incoming: other unique class IDs
+   */ acceptAndMerge(incoming) {
+        for (const classId of incoming.classIds.keys()){
+            assert(!this.has(classId), `Bug! Cannot merge classId ${classId} into set of unique classIds as it already exists.`);
+            this.classIds.add(classId);
+        }
+        // since set() has an assertion, and size() always checks parent, this should be impossible
+        assert(this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS, `Bug! Merging unique class Ids should never exceed the limit of ${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}.`);
+    }
+}

package/dest/public/utils.d.ts

@@ -0,0 +1,3 @@
+import { PublicCallRequestWithCalldata, type Tx, TxExecutionPhase } from '@aztec-labs/stdlib/tx';
+export declare function getCallRequestsWithCalldataByPhase(tx: Tx, phase: TxExecutionPhase): PublicCallRequestWithCalldata[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLDZCQUE2QixFQUFFLEtBQUssRUFBRSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFakcsd0JBQWdCLGtDQUFrQyxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLGdCQUFnQixHQUFHLDZCQUE2QixFQUFFLENBYW5IIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/public/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEjG,wBAAgB,kCAAkC,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,gBAAgB,GAAG,6BAA6B,EAAE,CAanH"}

package/dest/public/utils.js

@@ -0,0 +1,18 @@
+import { TxExecutionPhase } from '@aztec-labs/stdlib/tx';
+export function getCallRequestsWithCalldataByPhase(tx, phase) {
+    switch(phase){
+        case TxExecutionPhase.SETUP:
+            return tx.getNonRevertiblePublicCallRequestsWithCalldata();
+        case TxExecutionPhase.APP_LOGIC:
+            return tx.getRevertiblePublicCallRequestsWithCalldata();
+        case TxExecutionPhase.TEARDOWN:
+            {
+                const request = tx.getTeardownPublicCallRequestWithCalldata();
+                return request ? [
+                    request
+                ] : [];
+            }
+        default:
+            throw new Error(`Unknown phase: ${phase}`);
+    }
+}

package/dest/server.d.ts

@@ -0,0 +1,7 @@
+export * from './public/index.js';
+export * from './private/acvm/index.js';
+export { WASMSimulatorWithBlobs } from './private/acvm_wasm_with_blobs.js';
+export { NativeACVMSimulator } from './private/acvm_native.js';
+export { type CircuitSimulator, type DecodedError } from './private/circuit_simulator.js';
+export * from './common/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvc2VydmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUMzRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSxLQUFLLFlBQVksRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzFGLGNBQWMsbUJBQW1CLENBQUMifQ==

package/dest/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC1F,cAAc,mBAAmB,CAAC"}

package/dest/server.js

@@ -0,0 +1,5 @@
+export * from './public/index.js';
+export * from './private/acvm/index.js';
+export { WASMSimulatorWithBlobs } from './private/acvm_wasm_with_blobs.js';
+export { NativeACVMSimulator } from './private/acvm_native.js';
+export * from './common/index.js';