@aztec-labs/pxe 6.0.0-nightly.20260829

package/dest/operation_lifecycle.js

@@ -0,0 +1,68 @@
+import { allToCompletion } from '@aztec-labs/foundation/promise';
+/**
+ * Runs `fn` as the operation's work and decides its change set.
+ *
+ * On success:
+ * 1. Waits for every contributor to settle. A rejection vetoes the commit and the failure path below runs instead.
+ * 2. Commits the change set.
+ * 3. Notifies contributors of the outcome.
+ *
+ * On failure:
+ * 1. Drains contributors, logging failures instead of propagating them so the discard runs to completion and the
+ *    error that aborted the operation is not masked.
+ * 2. Aborts the change set.
+ * 3. Notifies contributors of the outcome.
+ * 4. Rethrows.
+ */ export async function runOperation(args, fn) {
+    const { stagedWriteCoordinator, contributors, changeSetId, log } = args;
+    try {
+        const result = await fn();
+        // Settling must stay outside the commit transaction: it can take arbitrarily long.
+        await allToCompletion(contributors.map((contributor)=>contributor.settle?.(changeSetId)));
+        log.verbose(`Committing operation ${changeSetId}`, {
+            changeSetId
+        });
+        await stagedWriteCoordinator.commit(changeSetId);
+        notifyOperationEnd(args, 'committed');
+        return result;
+    } catch (err) {
+        log.verbose(`Aborting operation ${changeSetId}`, {
+            changeSetId
+        });
+        await settleContributorsLoggingFailures(args);
+        try {
+            stagedWriteCoordinator.abort(changeSetId);
+        } catch (abortErr) {
+            // Nothing here can undo a failed abort, so it is logged, but the error that ended the operation is the one
+            // reported.
+            log.error(`Failed to abort operation ${changeSetId}`, abortErr, {
+                changeSetId
+            });
+        }
+        notifyOperationEnd(args, 'discarded');
+        throw err;
+    }
+}
+function notifyOperationEnd({ contributors, changeSetId, log }, outcome) {
+    for (const contributor of contributors){
+        // The change set has already been decided at this point, so a failed notification must not turn a committed
+        // operation into a rejected one, nor mask the error that caused a discard.
+        try {
+            contributor.onOperationEnd(changeSetId, outcome);
+        } catch (err) {
+            log.warn(`Contributor failed to handle the end of operation ${changeSetId}`, {
+                changeSetId,
+                outcome,
+                err
+            });
+        }
+    }
+}
+async function settleContributorsLoggingFailures({ contributors, changeSetId, log }) {
+    await allToCompletion(contributors.map((contributor)=>contributor.settle?.(changeSetId).catch((err)=>{
+            log.warn(`Contributor failed to settle while discarding operation ${changeSetId}`, {
+                changeSetId,
+                err
+            });
+        })));
+}

package/dest/operation_queue.d.ts

@@ -0,0 +1,75 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { BlockHeader } from '@aztec-labs/stdlib/tx';
+import type { BlockSynchronizer } from './block_synchronizer/index.js';
+import type { Recording } from './node/benchmarked_node.js';
+import type { CachingAztecNode } from './node/caching_aztec_node.js';
+import { type OperationContributor } from './operation_lifecycle.js';
+import type { AnchorBlockStore } from './storage/anchor_block_store/anchor_block_store.js';
+import type { ChangeSetId, StagedWriteCoordinator } from './storage/staged_write_coordinator.js';
+/** What a synced operation receives: its change set id, the anchor its sync established, and its instrumentation. */
+export type SyncedOperationContext = {
+    /**
+     * The change set the operation's writes are staged under. A synced operation runs inside exactly one change set,
+     * which is committed if it succeeds and discarded if it fails, so this ID doubles as the operation's identity:
+     * bookkeeping that must be kept or thrown away along with the operation is keyed on it, whether or not it lives in
+     * a store.
+     */
+    changeSetId: ChangeSetId;
+    /** Duration of the sync, for timing stats. */
+    syncTime: number;
+    anchorBlockHeader: BlockHeader;
+    /** Open recording of the node RPC calls made so far in this operation; `stats()` snapshots them for reporting. */
+    recording: Recording;
+    /** The operation's duration so far, including the sync. */
+    totalMs: () => number;
+};
+/**
+ * Serializes the PXE's operations, since concurrent execution is not supported: operations execute oracles that read
+ * and write the PXE stores, and concurrent runs would interfere with one another.
+ *
+ * Synced operations additionally run after a sync with the node and inside a staged-write session (see
+ * {@link StagedWriteCoordinator}): staged writes are committed if the operation succeeds and discarded if it throws.
+ */
+export declare class OperationQueue {
+    #private;
+    private readonly queue;
+    private readonly node;
+    private readonly synchronizer;
+    private readonly anchorBlockStore;
+    private readonly stagedWriteCoordinator;
+    private readonly contributors;
+    private readonly autoSync;
+    private readonly log;
+    constructor(args: OperationQueueArgs);
+    start(): void;
+    stop(): Promise<void>;
+    /**
+     * Runs an operation once no other operations are running. Returns a promise that will resolve once the operation
+     * is complete.
+     *
+     * Useful for tasks that cannot run concurrently, such as contract function simulation.
+     */
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Runs an operation (`fn`) after a sync with the node (skipped when the `autoSync` config flag is disabled, unless
+     * `forceSync` is set). If the operation succeeds, then all staged writes are committed. If it rejects, then all
+     * staged writes are discarded.
+     */
+    runSynced<T>(fn: (ctx: SyncedOperationContext) => Promise<T>, { errorContext, forceSync }?: {
+        errorContext?: () => string[];
+        forceSync?: boolean;
+    }): Promise<T>;
+}
+/** Dependencies of the {@link OperationQueue}. */
+type OperationQueueArgs = {
+    node: CachingAztecNode;
+    synchronizer: BlockSynchronizer;
+    anchorBlockStore: AnchorBlockStore;
+    stagedWriteCoordinator: StagedWriteCoordinator;
+    contributors: OperationContributor[];
+    /** Whether synced operations sync with the node before running (see {@link OperationQueue.runSynced}). */
+    autoSync: boolean;
+    log: Logger;
+};
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dest/operation_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation_queue.d.ts","sourceRoot":"","sources":["../src/operation_queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAIzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,KAAK,oBAAoB,EAAgB,MAAM,0BAA0B,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oDAAoD,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAEjG,qHAAqH;AACrH,MAAM,MAAM,sBAAsB,GAAG;IACnC;;;;;OAKG;IACH,WAAW,EAAE,WAAW,CAAC;IACzB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,WAAW,CAAC;IAC/B,kHAAkH;IAClH,SAAS,EAAE,SAAS,CAAC;IACrB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,cAAc;;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAmB;IACxC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IACpD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAyB;IAChE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IACtD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YAAY,IAAI,EAAE,kBAAkB,EAQnC;IAEM,KAAK,IAAI,IAAI,CAEnB;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAEjC;IAED;;;;;OAKG;IACI,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAS9C;IAED;;;;OAIG;IACI,SAAS,CAAC,CAAC,EAChB,EAAE,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,OAAO,CAAC,CAAC,CAAC,EAC/C,EAAE,YAAY,EAAE,SAAiB,EAAE,GAAE;QAAE,YAAY,CAAC,EAAE,MAAM,MAAM,EAAE,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAO,GAC/F,OAAO,CAAC,CAAC,CAAC,CA8BZ;CAeF;AAED,kDAAkD;AAClD,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,gBAAgB,CAAC;IACvB,YAAY,EAAE,iBAAiB,CAAC;IAChC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,0GAA0G;IAC1G,QAAQ,EAAE,OAAO,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC"}

package/dest/operation_queue.js

@@ -0,0 +1,100 @@
+import { SerialQueue } from '@aztec-labs/foundation/queue';
+import { Timer } from '@aztec-labs/foundation/timer';
+import { SimulationError } from '@aztec-labs/stdlib/errors';
+import { runOperation } from './operation_lifecycle.js';
+/**
+ * Serializes the PXE's operations, since concurrent execution is not supported: operations execute oracles that read
+ * and write the PXE stores, and concurrent runs would interfere with one another.
+ *
+ * Synced operations additionally run after a sync with the node and inside a staged-write session (see
+ * {@link StagedWriteCoordinator}): staged writes are committed if the operation succeeds and discarded if it throws.
+ */ export class OperationQueue {
+    queue = new SerialQueue();
+    node;
+    synchronizer;
+    anchorBlockStore;
+    stagedWriteCoordinator;
+    contributors;
+    autoSync;
+    log;
+    constructor(args){
+        this.node = args.node;
+        this.synchronizer = args.synchronizer;
+        this.anchorBlockStore = args.anchorBlockStore;
+        this.stagedWriteCoordinator = args.stagedWriteCoordinator;
+        this.contributors = args.contributors;
+        this.autoSync = args.autoSync;
+        this.log = args.log;
+    }
+    start() {
+        this.queue.start();
+    }
+    async stop() {
+        await this.queue.end();
+    }
+    /**
+   * Runs an operation once no other operations are running. Returns a promise that will resolve once the operation
+   * is complete.
+   *
+   * Useful for tasks that cannot run concurrently, such as contract function simulation.
+   */ run(fn) {
+        // TODO(#12636): relax the conditions under which we forbid concurrency.
+        if (this.queue.length() != 0) {
+            this.log.warn(`PXE is already processing ${this.queue.length()} operations, concurrent execution is not supported. Will run once those are complete.`);
+        }
+        return this.queue.put(fn);
+    }
+    /**
+   * Runs an operation (`fn`) after a sync with the node (skipped when the `autoSync` config flag is disabled, unless
+   * `forceSync` is set). If the operation succeeds, then all staged writes are committed. If it rejects, then all
+   * staged writes are discarded.
+   */ runSynced(fn, { errorContext, forceSync = false } = {}) {
+        return this.run(async ()=>{
+            const totalTimer = new Timer();
+            const recording = this.node.startRecording();
+            try {
+                const syncTimer = new Timer();
+                if (forceSync || this.autoSync) {
+                    await this.synchronizer.sync();
+                }
+                const syncTime = syncTimer.ms();
+                const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+                const changeSetId = this.stagedWriteCoordinator.begin();
+                this.log.verbose(`Beginning operation ${changeSetId}`, {
+                    changeSetId,
+                    syncMs: syncTime
+                });
+                const operationArgs = {
+                    stagedWriteCoordinator: this.stagedWriteCoordinator,
+                    contributors: this.contributors,
+                    changeSetId,
+                    log: this.log
+                };
+                return await runOperation(operationArgs, ()=>fn({
+                        changeSetId,
+                        syncTime,
+                        anchorBlockHeader,
+                        recording,
+                        totalMs: ()=>totalTimer.ms()
+                    }));
+            } catch (err) {
+                throw errorContext ? this.#contextualizeError(err, ...errorContext()) : err;
+            } finally{
+                recording.stop();
+            }
+        });
+    }
+    #contextualizeError(err, ...context) {
+        let contextStr = '';
+        if (context.length > 0) {
+            contextStr = `\nContext:\n${context.join('\n')}`;
+        }
+        if (err instanceof SimulationError) {
+            err.setAztecContext(contextStr);
+        } else {
+            this.log.error(err.name, err);
+            this.log.debug(contextStr);
+        }
+        return err;
+    }
+}

package/dest/oracle_version.d.ts

@@ -0,0 +1,4 @@
+export declare const ORACLE_VERSION_MAJOR = 30;
+export declare const ORACLE_VERSION_MINOR = 8;
+export declare const ORACLE_INTERFACE_HASH = "16a4ca6f5342a5b7a12fe9ec3aa88be16c40cf685f5a205a58187c2c41bb2661";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JhY2xlX3ZlcnNpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9vcmFjbGVfdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFZQSxlQUFPLE1BQU0sb0JBQW9CLEtBQUssQ0FBQztBQUN2QyxlQUFPLE1BQU0sb0JBQW9CLElBQUksQ0FBQztBQVF0QyxlQUFPLE1BQU0scUJBQXFCLHFFQUFxRSxDQUFDIn0=

package/dest/oracle_version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oracle_version.d.ts","sourceRoot":"","sources":["../src/oracle_version.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAQtC,eAAO,MAAM,qBAAqB,qEAAqE,CAAC"}

package/dest/oracle_version.js

@@ -0,0 +1,21 @@
+/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.
+/// We version the oracle interface as `major.minor` where:
+///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)
+///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)
+///
+/// The Noir counterparts are in `noir-projects/aztec-nr/aztec/src/oracle/version.nr`.
+///
+/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is called.
+/// If the major version is incompatible, an error is thrown immediately. The minor version is recorded by the PXE and
+/// used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw immediately
+/// if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency without actually
+/// using any of the new oracles then there is no reason to throw.
+export const ORACLE_VERSION_MAJOR = 30;
+export const ORACLE_VERSION_MINOR = 8;
+/// This hash is computed from `ORACLE_REGISTRY` (each oracle's name, ordered parameter names and
+/// types, and return type) and is used to detect when the oracle interface changes. When it does, you need to either:
+/// - increment `ORACLE_VERSION_MAJOR` and reset `ORACLE_VERSION_MINOR` to zero if the change is breaking, or
+/// - increment only `ORACLE_VERSION_MINOR` if the change is additive (a new oracle was added).
+///
+/// These constants must be kept in sync between this file and `noir-projects/aztec-nr/aztec/src/oracle/version.nr`.
+export const ORACLE_INTERFACE_HASH = '16a4ca6f5342a5b7a12fe9ec3aa88be16c40cf685f5a205a58187c2c41bb2661';

package/dest/private_kernel/batch_planner.d.ts

@@ -0,0 +1,47 @@
+import { PrivateKernelCircuitPublicInputs } from '@aztec-labs/stdlib/kernel';
+import type { PrivateCallExecutionResult } from '@aztec-labs/stdlib/tx';
+/**
+ * Decides how many apps from the top of the execution stack the next kernel iteration should
+ * absorb. The decision is made by keeping track of an app-by-app accumulator calling
+ * `PrivateKernelResetPrivateInputsBuilder.needsReset()` whether a reset would be required before
+ * taking each candidate.
+ *
+ * The K-batched kernels are mathematically equivalent to running K sequential `init`/`inner`
+ * iterations so a multi-app fit-check reduces to a sequence of single-app fit-checks against a rolling
+ * accumulator.
+ */
+export declare class BatchPlanner {
+    private noteHashNullifierCounterMap;
+    private splitCounter;
+    private maxBatchSize;
+    constructor(noteHashNullifierCounterMap: Map<number, number>, splitCounter: number, maxBatchSize: number);
+    /**
+     * Returns the number of apps from the top of `stack` that the next kernel iteration should
+     * batch. Always at least 1 — the caller is expected to have run any pending resets first, so
+     * the next single app must always fit.
+     *
+     * The walk mirrors `consumeNextApp`'s stack manipulation (pop top, push reversed nested
+     * children, then DFS into them) on a copy of the stack, so the planner can look ahead past
+     * the parent's children without mutating the real prover stack.
+     */
+    decideBatchSize(currentAccumulator: PrivateKernelCircuitPublicInputs, stack: PrivateCallExecutionResult[]): number;
+}
+/**
+ * Returns a new `PrivateKernelCircuitPublicInputs` representing the accumulator after one kernel
+ * iteration has absorbed `app`. Mirrors the kernel composer's accumulator-update step
+ * (`PrivateKernelCircuitOutputComposer::scope_and_propagate_from_private_call`) for the six
+ * fields that `PrivateKernelResetPrivateInputsBuilder.needsReset()` inspects:
+ *
+ * - `validationRequests.noteHashReadRequests`              (already scoped per app; appended as-is)
+ * - `validationRequests.nullifierReadRequests`             (already scoped per app; appended as-is)
+ * - `validationRequests.scopedKeyValidationRequestsAndSeparators` (scope with call's contract address)
+ * - `end.noteHashes`                                       (scope)
+ * - `end.nullifiers`                                       (scope)
+ * - `end.privateLogs`                                      (scope)
+ *
+ * Other fields on `PrivateKernelCircuitPublicInputs` (constants, fee_payer, expiration_timestamp,
+ * public_call_requests, l2_to_l1_msgs, contract_class_logs_hashes, etc.) are not read by
+ * `needsReset()` and are carried over unchanged from `acc`.
+ */
+export declare function appendApp(acc: PrivateKernelCircuitPublicInputs, app: PrivateCallExecutionResult): PrivateKernelCircuitPublicInputs;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmF0Y2hfcGxhbm5lci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ByaXZhdGVfa2VybmVsL2JhdGNoX3BsYW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUdMLGdDQUFnQyxFQUlqQyxNQUFNLDJCQUEyQixDQUFDO0FBQ25DLE9BQU8sS0FBSyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFLeEU7Ozs7Ozs7OztHQVNHO0FBQ0gscUJBQWEsWUFBWTtJQUVyQixPQUFPLENBQUMsMkJBQTJCO0lBQ25DLE9BQU8sQ0FBQyxZQUFZO0lBQ3BCLE9BQU8sQ0FBQyxZQUFZO0lBSHRCLFlBQ1UsMkJBQTJCLEVBQUUsR0FBRyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFDaEQsWUFBWSxFQUFFLE1BQU0sRUFDcEIsWUFBWSxFQUFFLE1BQU0sRUFDMUI7SUFFSjs7Ozs7Ozs7T0FRRztJQUNILGVBQWUsQ0FBQyxrQkFBa0IsRUFBRSxnQ0FBZ0MsRUFBRSxLQUFLLEVBQUUsMEJBQTBCLEVBQUUsR0FBRyxNQUFNLENBNEJqSDtDQUNGO0FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDSCx3QkFBZ0IsU0FBUyxDQUN2QixHQUFHLEVBQUUsZ0NBQWdDLEVBQ3JDLEdBQUcsRUFBRSwwQkFBMEIsR0FDOUIsZ0NBQWdDLENBK0RsQyJ9

package/dest/private_kernel/batch_planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch_planner.d.ts","sourceRoot":"","sources":["../../src/private_kernel/batch_planner.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,gCAAgC,EAIjC,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAKxE;;;;;;;;;GASG;AACH,qBAAa,YAAY;IAErB,OAAO,CAAC,2BAA2B;IACnC,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,YAAY;IAHtB,YACU,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EAC1B;IAEJ;;;;;;;;OAQG;IACH,eAAe,CAAC,kBAAkB,EAAE,gCAAgC,EAAE,KAAK,EAAE,0BAA0B,EAAE,GAAG,MAAM,CA4BjH;CACF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,gCAAgC,EACrC,GAAG,EAAE,0BAA0B,GAC9B,gCAAgC,CA+DlC"}

package/dest/private_kernel/batch_planner.js

@@ -0,0 +1,104 @@
+import { ClaimedLengthArray, PrivateAccumulatedData, PrivateKernelCircuitPublicInputs, PrivateValidationRequests, ScopedKeyValidationRequestAndSeparator, ScopedPrivateLogData } from '@aztec-labs/stdlib/kernel';
+import { VerificationKeyData } from '@aztec-labs/stdlib/vks';
+import { PrivateKernelResetPrivateInputsBuilder } from './hints/private_kernel_reset_private_inputs_builder.js';
+/**
+ * Decides how many apps from the top of the execution stack the next kernel iteration should
+ * absorb. The decision is made by keeping track of an app-by-app accumulator calling
+ * `PrivateKernelResetPrivateInputsBuilder.needsReset()` whether a reset would be required before
+ * taking each candidate.
+ *
+ * The K-batched kernels are mathematically equivalent to running K sequential `init`/`inner`
+ * iterations so a multi-app fit-check reduces to a sequence of single-app fit-checks against a rolling
+ * accumulator.
+ */ export class BatchPlanner {
+    noteHashNullifierCounterMap;
+    splitCounter;
+    maxBatchSize;
+    constructor(noteHashNullifierCounterMap, splitCounter, maxBatchSize){
+        this.noteHashNullifierCounterMap = noteHashNullifierCounterMap;
+        this.splitCounter = splitCounter;
+        this.maxBatchSize = maxBatchSize;
+    }
+    /**
+   * Returns the number of apps from the top of `stack` that the next kernel iteration should
+   * batch. Always at least 1 — the caller is expected to have run any pending resets first, so
+   * the next single app must always fit.
+   *
+   * The walk mirrors `consumeNextApp`'s stack manipulation (pop top, push reversed nested
+   * children, then DFS into them) on a copy of the stack, so the planner can look ahead past
+   * the parent's children without mutating the real prover stack.
+   */ decideBatchSize(currentAccumulator, stack) {
+        const virtualStack = [
+            ...stack
+        ];
+        let projected = currentAccumulator;
+        let chosen = 0;
+        for(let i = 0; i < this.maxBatchSize && virtualStack.length > 0; i++){
+            const probe = new PrivateKernelResetPrivateInputsBuilder({
+                publicInputs: projected,
+                verificationKey: VerificationKeyData.empty(),
+                outputWitness: new Map(),
+                bytecode: Buffer.from([])
+            }, virtualStack, this.noteHashNullifierCounterMap, this.splitCounter);
+            if (probe.needsReset()) {
+                break;
+            }
+            // Speculatively consume the top of the virtual stack the same way `consumeNextApp` does
+            // on the real stack: pop the candidate, push its reversed nested children so the next
+            // iteration's top is the next DFS app.
+            const candidate = virtualStack.pop();
+            virtualStack.push(...[
+                ...candidate.nestedExecutionResults
+            ].reverse());
+            projected = appendApp(projected, candidate);
+            chosen++;
+        }
+        return Math.max(1, chosen);
+    }
+}
+/**
+ * Returns a new `PrivateKernelCircuitPublicInputs` representing the accumulator after one kernel
+ * iteration has absorbed `app`. Mirrors the kernel composer's accumulator-update step
+ * (`PrivateKernelCircuitOutputComposer::scope_and_propagate_from_private_call`) for the six
+ * fields that `PrivateKernelResetPrivateInputsBuilder.needsReset()` inspects:
+ *
+ * - `validationRequests.noteHashReadRequests`              (already scoped per app; appended as-is)
+ * - `validationRequests.nullifierReadRequests`             (already scoped per app; appended as-is)
+ * - `validationRequests.scopedKeyValidationRequestsAndSeparators` (scope with call's contract address)
+ * - `end.noteHashes`                                       (scope)
+ * - `end.nullifiers`                                       (scope)
+ * - `end.privateLogs`                                      (scope)
+ *
+ * Other fields on `PrivateKernelCircuitPublicInputs` (constants, fee_payer, expiration_timestamp,
+ * public_call_requests, l2_to_l1_msgs, contract_class_logs_hashes, etc.) are not read by
+ * `needsReset()` and are carried over unchanged from `acc`.
+ */ export function appendApp(acc, app) {
+    const ca = app.publicInputs.callContext.contractAddress;
+    const appPi = app.publicInputs;
+    const newNoteHashReadRequests = cloneClaimedLengthArray(acc.validationRequests.noteHashReadRequests);
+    pushAll(newNoteHashReadRequests, appPi.noteHashReadRequests.getActiveItems());
+    const newNullifierReadRequests = cloneClaimedLengthArray(acc.validationRequests.nullifierReadRequests);
+    pushAll(newNullifierReadRequests, appPi.nullifierReadRequests.getActiveItems());
+    const newScopedKvrs = cloneClaimedLengthArray(acc.validationRequests.scopedKeyValidationRequestsAndSeparators);
+    pushAll(newScopedKvrs, appPi.keyValidationRequestsAndSeparators.getActiveItems().map((kvr)=>new ScopedKeyValidationRequestAndSeparator(kvr, ca)));
+    const newNoteHashes = cloneClaimedLengthArray(acc.end.noteHashes);
+    pushAll(newNoteHashes, appPi.noteHashes.getActiveItems().map((nh)=>nh.scope(ca)));
+    const newNullifiers = cloneClaimedLengthArray(acc.end.nullifiers);
+    pushAll(newNullifiers, appPi.nullifiers.getActiveItems().map((n)=>n.scope(ca)));
+    const newPrivateLogs = cloneClaimedLengthArray(acc.end.privateLogs);
+    pushAll(newPrivateLogs, appPi.privateLogs.getActiveItems().map((pl)=>new ScopedPrivateLogData(pl, ca)));
+    const validationRequests = new PrivateValidationRequests(newNoteHashReadRequests, newNullifierReadRequests, newScopedKvrs);
+    const end = new PrivateAccumulatedData(newNoteHashes, newNullifiers, acc.end.l2ToL1Msgs, newPrivateLogs, acc.end.contractClassLogsHashes, acc.end.publicCallRequests, acc.end.privateCallStack);
+    return new PrivateKernelCircuitPublicInputs(acc.constants, acc.minRevertibleSideEffectCounter, validationRequests, end, acc.publicTeardownCallRequest, acc.feePayer, acc.expirationTimestamp, acc.isPrivateOnly, acc.claimedRevertibleCounter);
+}
+function cloneClaimedLengthArray(src) {
+    return new ClaimedLengthArray([
+        ...src.array
+    ], src.claimedLength);
+}
+function pushAll(arr, items) {
+    for (const item of items){
+        arr.array[arr.claimedLength] = item;
+        arr.claimedLength++;
+    }
+}

package/dest/private_kernel/hints/compute_tx_expiration_timestamp.d.ts

@@ -0,0 +1,4 @@
+import type { PrivateKernelCircuitPublicInputs } from '@aztec-labs/stdlib/kernel';
+import type { UInt64 } from '@aztec-labs/stdlib/types';
+export declare function computeTxExpirationTimestamp(previousKernel: PrivateKernelCircuitPublicInputs, txLifetime?: number): UInt64;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHV0ZV90eF9leHBpcmF0aW9uX3RpbWVzdGFtcC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3ByaXZhdGVfa2VybmVsL2hpbnRzL2NvbXB1dGVfdHhfZXhwaXJhdGlvbl90aW1lc3RhbXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNsRixPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQXFCdkQsd0JBQWdCLDRCQUE0QixDQUMxQyxjQUFjLEVBQUUsZ0NBQWdDLEVBQ2hELFVBQVUsU0FBa0IsR0FDM0IsTUFBTSxDQStCUiJ9

package/dest/private_kernel/hints/compute_tx_expiration_timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_tx_expiration_timestamp.d.ts","sourceRoot":"","sources":["../../../src/private_kernel/hints/compute_tx_expiration_timestamp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,2BAA2B,CAAC;AAClF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAqBvD,wBAAgB,4BAA4B,CAC1C,cAAc,EAAE,gCAAgC,EAChD,UAAU,SAAkB,GAC3B,MAAM,CA+BR"}

package/dest/private_kernel/hints/compute_tx_expiration_timestamp.js

@@ -0,0 +1,41 @@
+import { MAX_TX_LIFETIME } from '@aztec-labs/constants';
+const ROUNDED_DURATIONS = [
+    3600,
+    1800,
+    1
+];
+function roundTimestamp(blockTimestamp, expirationTimestamp) {
+    return ROUNDED_DURATIONS.reduce((timestamp, duration)=>{
+        if (timestamp <= blockTimestamp) {
+            // The timestamp must be greater than the block timestamp.
+            // If it is too small, round it down again using a smaller duration.
+            const totalDuration = expirationTimestamp - blockTimestamp;
+            const roundedDuration = totalDuration - totalDuration % BigInt(duration);
+            return blockTimestamp + roundedDuration;
+        }
+        return timestamp;
+    }, 0n);
+}
+export function computeTxExpirationTimestamp(previousKernel, txLifetime = MAX_TX_LIFETIME) {
+    if (txLifetime > MAX_TX_LIFETIME) {
+        throw new Error(`Custom tx lifetime cannot be greater than the max allowed. Max allowed: ${MAX_TX_LIFETIME}. Custom value: ${txLifetime}.`);
+    }
+    const anchorBlockTimestamp = previousKernel.constants.anchorBlockHeader.globalVariables.timestamp;
+    const maxTimestamp = anchorBlockTimestamp + BigInt(txLifetime);
+    const expirationTimestamp = previousKernel.expirationTimestamp;
+    // If the expirationTimestamp set during the tx execution is greater than or equal to the max allowed duration,
+    // use the maximum allowed timestamp.
+    // Note: It shouldn't be larger than the max allowed duration, but we check for it anyway.
+    if (expirationTimestamp >= maxTimestamp) {
+        return maxTimestamp;
+    }
+    // Round it down to the nearest hour/min/second to reduce precision and avoid revealing the exact value.
+    // This makes it harder for others to infer what function calls may have been used to produce a specific timestamp.
+    const roundedTimestamp = roundTimestamp(anchorBlockTimestamp, expirationTimestamp);
+    // The tx can't be published if the timestamp is the same or less than the anchor block's timestamp.
+    // Future blocks will have a greater timestamp, so the tx would never be included.
+    if (roundedTimestamp <= anchorBlockTimestamp) {
+        throw new Error(`Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${expirationTimestamp}.`);
+    }
+    return roundedTimestamp;
+}

package/dest/private_kernel/hints/index.d.ts

@@ -0,0 +1,3 @@
+export * from './private_kernel_reset_private_inputs_builder.js';
+export * from './compute_tx_expiration_timestamp.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcml2YXRlX2tlcm5lbC9oaW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtEQUFrRCxDQUFDO0FBQ2pFLGNBQWMsc0NBQXNDLENBQUMifQ==

package/dest/private_kernel/hints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/private_kernel/hints/index.ts"],"names":[],"mappings":"AAAA,cAAc,kDAAkD,CAAC;AACjE,cAAc,sCAAsC,CAAC"}

package/dest/private_kernel/hints/index.js

@@ -0,0 +1,2 @@
+export * from './private_kernel_reset_private_inputs_builder.js';
+export * from './compute_tx_expiration_timestamp.js';

package/dest/private_kernel/hints/private_kernel_reset_private_inputs_builder.d.ts

@@ -0,0 +1,29 @@
+import { type PrivateKernelCircuitPublicInputs, PrivateKernelResetCircuitPrivateInputs, PrivateKernelResetDimensions, type PrivateKernelSimulateOutput } from '@aztec-labs/stdlib/kernel';
+import { type PrivateCallExecutionResult } from '@aztec-labs/stdlib/tx';
+import type { PrivateKernelOracle } from '../private_kernel_oracle.js';
+export declare class PrivateKernelResetPrivateInputsBuilder {
+    private previousKernelOutput;
+    private executionStack;
+    private noteHashNullifierCounterMap;
+    private splitCounter;
+    private previousKernel;
+    private nextIteration?;
+    private noteHashResetActions;
+    private nullifierResetActions;
+    private numTransientData?;
+    private transientDataSquashingHints;
+    private requestedDimensions;
+    constructor(previousKernelOutput: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>, executionStack: PrivateCallExecutionResult[], noteHashNullifierCounterMap: Map<number, number>, splitCounter: number);
+    getRequestedDimensions(): PrivateKernelResetDimensions;
+    needsReset(): boolean;
+    build(oracle: PrivateKernelOracle): Promise<PrivateKernelResetCircuitPrivateInputs>;
+    private reduceReadRequestActions;
+    private needsResetNoteHashReadRequests;
+    private needsResetNullifierReadRequests;
+    private needsResetKeyValidationRequests;
+    private needsResetTransientData;
+    private needsSiloNoteHashes;
+    private needsSiloNullifiers;
+    private needsSiloPrivateLogs;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9rZXJuZWxfcmVzZXRfcHJpdmF0ZV9pbnB1dHNfYnVpbGRlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3ByaXZhdGVfa2VybmVsL2hpbnRzL3ByaXZhdGVfa2VybmVsX3Jlc2V0X3ByaXZhdGVfaW5wdXRzX2J1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBZ0JBLE9BQU8sRUFLTCxLQUFLLGdDQUFnQyxFQUVyQyxzQ0FBc0MsRUFDdEMsNEJBQTRCLEVBRTVCLEtBQUssMkJBQTJCLEVBY2pDLE1BQU0sMkJBQTJCLENBQUM7QUFDbkMsT0FBTyxFQUFFLEtBQUssMEJBQTBCLEVBQWlCLE1BQU0sdUJBQXVCLENBQUM7QUFHdkYsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQW1DdkUscUJBQWEsc0NBQXNDO0lBZS9DLE9BQU8sQ0FBQyxvQkFBb0I7SUFDNUIsT0FBTyxDQUFDLGNBQWM7SUFDdEIsT0FBTyxDQUFDLDJCQUEyQjtJQUNuQyxPQUFPLENBQUMsWUFBWTtJQWpCdEIsT0FBTyxDQUFDLGNBQWMsQ0FBbUM7SUFFekQsT0FBTyxDQUFDLGFBQWEsQ0FBQyxDQUE2QjtJQUVuRCxPQUFPLENBQUMsb0JBQW9CLENBQXFFO0lBQ2pHLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBcUU7SUFDbEcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBQVM7SUFDbEMsT0FBTyxDQUFDLDJCQUEyQixDQUdqQztJQUNGLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBd0M7SUFFbkUsWUFDVSxvQkFBb0IsRUFBRSwyQkFBMkIsQ0FBQyxnQ0FBZ0MsQ0FBQyxFQUNuRixjQUFjLEVBQUUsMEJBQTBCLEVBQUUsRUFDNUMsMkJBQTJCLEVBQUUsR0FBRyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFDaEQsWUFBWSxFQUFFLE1BQU0sRUFJN0I7SUFFRCxzQkFBc0IsSUFBSSw0QkFBNEIsQ0FFckQ7SUFFRCxVQUFVLElBQUksT0FBTyxDQXNCcEI7SUFFSyxLQUFLLENBQUMsTUFBTSxFQUFFLG1CQUFtQixtREF1RnRDO0lBRUQsT0FBTyxDQUFDLHdCQUF3QjtJQTJCaEMsT0FBTyxDQUFDLDhCQUE4QjtJQTBFdEMsT0FBTyxDQUFDLCtCQUErQjtJQXlFdkMsT0FBTyxDQUFDLCtCQUErQjtJQWF2QyxPQUFPLENBQUMsdUJBQXVCO0lBMEYvQixPQUFPLENBQUMsbUJBQW1CO0lBaUIzQixPQUFPLENBQUMsbUJBQW1CO0lBaUIzQixPQUFPLENBQUMsb0JBQW9CO0NBcUI3QiJ9

package/dest/private_kernel/hints/private_kernel_reset_private_inputs_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_kernel_reset_private_inputs_builder.d.ts","sourceRoot":"","sources":["../../../src/private_kernel/hints/private_kernel_reset_private_inputs_builder.ts"],"names":[],"mappings":"AAgBA,OAAO,EAKL,KAAK,gCAAgC,EAErC,sCAAsC,EACtC,4BAA4B,EAE5B,KAAK,2BAA2B,EAcjC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,0BAA0B,EAAiB,MAAM,uBAAuB,CAAC;AAGvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAmCvE,qBAAa,sCAAsC;IAe/C,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,2BAA2B;IACnC,OAAO,CAAC,YAAY;IAjBtB,OAAO,CAAC,cAAc,CAAmC;IAEzD,OAAO,CAAC,aAAa,CAAC,CAA6B;IAEnD,OAAO,CAAC,oBAAoB,CAAqE;IACjG,OAAO,CAAC,qBAAqB,CAAqE;IAClG,OAAO,CAAC,gBAAgB,CAAC,CAAS;IAClC,OAAO,CAAC,2BAA2B,CAGjC;IACF,OAAO,CAAC,mBAAmB,CAAwC;IAEnE,YACU,oBAAoB,EAAE,2BAA2B,CAAC,gCAAgC,CAAC,EACnF,cAAc,EAAE,0BAA0B,EAAE,EAC5C,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChD,YAAY,EAAE,MAAM,EAI7B;IAED,sBAAsB,IAAI,4BAA4B,CAErD;IAED,UAAU,IAAI,OAAO,CAsBpB;IAEK,KAAK,CAAC,MAAM,EAAE,mBAAmB,mDAuFtC;IAED,OAAO,CAAC,wBAAwB;IA2BhC,OAAO,CAAC,8BAA8B;IA0EtC,OAAO,CAAC,+BAA+B;IAyEvC,OAAO,CAAC,+BAA+B;IAavC,OAAO,CAAC,uBAAuB;IA0F/B,OAAO,CAAC,mBAAmB;IAiB3B,OAAO,CAAC,mBAAmB;IAiB3B,OAAO,CAAC,oBAAoB;CAqB7B"}