@aztec/pxe 0.0.1-commit.7d4e6cd → 0.0.1-commit.8227e42

package/dest/oracle_version.js

@@ -4,7 +4,8 @@
 ///
 /// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called
 /// and if the oracle version is incompatible an error is thrown.
-export const ORACLE_VERSION = 5;
+export const ORACLE_VERSION = 12;
 /// This hash is computed as by hashing the Oracle interface and it is used to detect when the Oracle interface changes,
-/// which in turn implies that you need to update the ORACLE_VERSION constant.
-export const ORACLE_INTERFACE_HASH = 'd603c17a97034d978ca453d2bce3aacae139539dee28bbc46e8f8c7177a348ec';
+/// which in turn implies that you need to update the ORACLE_VERSION constant in this file and in
+/// `noir-projects/aztec-nr/aztec/src/oracle/version.nr`.
+export const ORACLE_INTERFACE_HASH = '666a8a7fc697f72b29dbf0ae7464db269cf5afa019acac8861f814543147dbb4';

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

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

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,sBAAsB,CAAC;AAC7E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAqBlD,wBAAgB,4BAA4B,CAC1C,cAAc,EAAE,gCAAgC,EAChD,UAAU,SAAkB,GAC3B,MAAM,CA+BR"}

package/dest/private_kernel/hints/{compute_tx_include_by_timestamp.js → compute_tx_expiration_timestamp.js}

@@ -1,41 +1,41 @@
-import { MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
+import { MAX_TX_LIFETIME } from '@aztec/constants';
 const ROUNDED_DURATIONS = [
     3600,
     1800,
     1
 ];
-function roundTimestamp(blockTimestamp, includeByTimestamp) {
+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 = includeByTimestamp - blockTimestamp;
+            const totalDuration = expirationTimestamp - blockTimestamp;
             const roundedDuration = totalDuration - totalDuration % BigInt(duration);
             return blockTimestamp + roundedDuration;
         }
         return timestamp;
     }, 0n);
 }
-export function computeTxIncludeByTimestamp(previousKernel, maxDuration = MAX_INCLUDE_BY_TIMESTAMP_DURATION) {
-    if (maxDuration > MAX_INCLUDE_BY_TIMESTAMP_DURATION) {
-        throw new Error(`Custom max duration cannot be greater than the max allowed. Max allowed: ${MAX_INCLUDE_BY_TIMESTAMP_DURATION}. Custom value: ${maxDuration}.`);
+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(maxDuration);
-    const includeByTimestamp = previousKernel.includeByTimestamp;
-    // If the includeByTimestamp set during the tx execution is greater than or equal to the max allowed duration,
+    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 (includeByTimestamp >= maxTimestamp) {
+    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, includeByTimestamp);
+    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: ${includeByTimestamp}.`);
+        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

@@ -1,3 +1,3 @@
-export * from './build_private_kernel_reset_private_inputs.js';
-export * from './compute_tx_include_by_timestamp.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcml2YXRlX2tlcm5lbC9oaW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdEQUFnRCxDQUFDO0FBQy9ELGNBQWMsc0NBQXNDLENBQUMifQ==
+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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/private_kernel/hints/index.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sCAAsC,CAAC"}
+{"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

@@ -1,2 +1,2 @@
-export * from './build_private_kernel_reset_private_inputs.js';
-export * from './compute_tx_include_by_timestamp.js';
+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/stdlib/kernel';
+import { type PrivateCallExecutionResult } from '@aztec/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9rZXJuZWxfcmVzZXRfcHJpdmF0ZV9pbnB1dHNfYnVpbGRlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3ByaXZhdGVfa2VybmVsL2hpbnRzL3ByaXZhdGVfa2VybmVsX3Jlc2V0X3ByaXZhdGVfaW5wdXRzX2J1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBZUEsT0FBTyxFQUtMLEtBQUssZ0NBQWdDLEVBRXJDLHNDQUFzQyxFQUN0Qyw0QkFBNEIsRUFFNUIsS0FBSywyQkFBMkIsRUFhakMsTUFBTSxzQkFBc0IsQ0FBQztBQUM5QixPQUFPLEVBQUUsS0FBSywwQkFBMEIsRUFBaUIsTUFBTSxrQkFBa0IsQ0FBQztBQUdsRixPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBbUN2RSxxQkFBYSxzQ0FBc0M7SUFlL0MsT0FBTyxDQUFDLG9CQUFvQjtJQUM1QixPQUFPLENBQUMsY0FBYztJQUN0QixPQUFPLENBQUMsMkJBQTJCO0lBQ25DLE9BQU8sQ0FBQyxZQUFZO0lBakJ0QixPQUFPLENBQUMsY0FBYyxDQUFtQztJQUV6RCxPQUFPLENBQUMsYUFBYSxDQUFDLENBQTZCO0lBRW5ELE9BQU8sQ0FBQyxvQkFBb0IsQ0FBcUU7SUFDakcsT0FBTyxDQUFDLHFCQUFxQixDQUFxRTtJQUNsRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBUztJQUNsQyxPQUFPLENBQUMsMkJBQTJCLENBR2pDO0lBQ0YsT0FBTyxDQUFDLG1CQUFtQixDQUF3QztJQUVuRSxZQUNVLG9CQUFvQixFQUFFLDJCQUEyQixDQUFDLGdDQUFnQyxDQUFDLEVBQ25GLGNBQWMsRUFBRSwwQkFBMEIsRUFBRSxFQUM1QywyQkFBMkIsRUFBRSxHQUFHLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxFQUNoRCxZQUFZLEVBQUUsTUFBTSxFQUk3QjtJQUVELHNCQUFzQixJQUFJLDRCQUE0QixDQUVyRDtJQUVELFVBQVUsSUFBSSxPQUFPLENBc0JwQjtJQUVLLEtBQUssQ0FBQyxNQUFNLEVBQUUsbUJBQW1CLG1EQThFdEM7SUFFRCxPQUFPLENBQUMsd0JBQXdCO0lBMkJoQyxPQUFPLENBQUMsOEJBQThCO0lBMEV0QyxPQUFPLENBQUMsK0JBQStCO0lBeUV2QyxPQUFPLENBQUMsK0JBQStCO0lBYXZDLE9BQU8sQ0FBQyx1QkFBdUI7SUEwRi9CLE9BQU8sQ0FBQyxtQkFBbUI7SUFpQjNCLE9BQU8sQ0FBQyxtQkFBbUI7SUFpQjNCLE9BQU8sQ0FBQyxvQkFBb0I7Q0FxQjdCIn0=

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":"AAeA,OAAO,EAKL,KAAK,gCAAgC,EAErC,sCAAsC,EACtC,4BAA4B,EAE5B,KAAK,2BAA2B,EAajC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,0BAA0B,EAAiB,MAAM,kBAAkB,CAAC;AAGlF,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,mDA8EtC;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"}

package/dest/private_kernel/hints/{build_private_kernel_reset_private_inputs.js → private_kernel_reset_private_inputs_builder.js}

@@ -4,14 +4,9 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 import { assertLength } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 import { privateKernelResetDimensionsConfig } from '@aztec/noir-protocol-circuits-types/client';
-import { KeyValidationHint, PaddedSideEffects, PrivateKernelData, PrivateKernelResetCircuitPrivateInputs, PrivateKernelResetDimensions, PrivateKernelResetHints, ReadRequestActionEnum, ReadRequestResetActions, ScopedNoteHash, ScopedNullifier, TransientDataSquashingHint, buildNoteHashReadRequestHintsFromResetActions, buildNullifierReadRequestHintsFromResetActions, buildTransientDataHints, findPrivateKernelResetDimensions, getNoteHashReadRequestResetActions, getNullifierReadRequestResetActions, privateKernelResetDimensionNames } from '@aztec/stdlib/kernel';
+import { KeyValidationHint, PaddedSideEffects, PrivateKernelData, PrivateKernelResetCircuitPrivateInputs, PrivateKernelResetDimensions, PrivateKernelResetHints, ReadRequestActionEnum, ReadRequestResetActions, TransientDataSquashingHint, buildNoteHashReadRequestHintsFromResetActions, buildNullifierReadRequestHintsFromResetActions, buildTransientDataHints, countSquashedLogs, findPrivateKernelResetDimensions, getNoteHashReadRequestResetActions, getNullifierReadRequestResetActions, privateKernelResetDimensionNames } from '@aztec/stdlib/kernel';
 import { collectNested } from '@aztec/stdlib/tx';
 import { VkData } from '@aztec/stdlib/vks';
-function collectNestedReadRequests(executionStack, extractReadRequests) {
-    return collectNested(executionStack, (executionResult)=>{
-        return extractReadRequests(executionResult).getActiveItems();
-    });
-}
 function getNullifierMembershipWitnessResolver(oracle) {
     return async (nullifier)=>{
         const res = await oracle.getNullifierMembershipWitness(nullifier);
@@ -25,7 +20,7 @@ function getNullifierMembershipWitnessResolver(oracle) {
         };
     };
 }
-async function getMasterSecretKeysAndAppKeyGenerators(keyValidationRequests, numRequestsToVerify, oracle) {
+async function getMasterSecretKeysAndKeyTypeDomainSeparators(keyValidationRequests, numRequestsToVerify, oracle) {
     const numRequestsToProcess = Math.min(keyValidationRequests.claimedLength, numRequestsToVerify);
     const keysHints = await Promise.all(keyValidationRequests.array.slice(0, numRequestsToProcess).map(async ({ request })=>{
         const secretKeys = await oracle.getMasterSecretKey(request.request.pkM);
@@ -51,18 +46,21 @@ export class PrivateKernelResetPrivateInputsBuilder {
         this.executionStack = executionStack;
         this.noteHashNullifierCounterMap = noteHashNullifierCounterMap;
         this.splitCounter = splitCounter;
-        this.previousKernel = previousKernelOutput.publicInputs;
-        this.requestedDimensions = PrivateKernelResetDimensions.empty();
         this.noteHashResetActions = ReadRequestResetActions.empty(MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
         this.nullifierResetActions = ReadRequestResetActions.empty(MAX_NULLIFIER_READ_REQUESTS_PER_TX);
         this.transientDataSquashingHints = makeTuple(MAX_NULLIFIERS_PER_TX, ()=>new TransientDataSquashingHint(MAX_NULLIFIERS_PER_TX, MAX_NOTE_HASHES_PER_TX));
+        this.requestedDimensions = PrivateKernelResetDimensions.empty();
+        this.previousKernel = previousKernelOutput.publicInputs;
         this.nextIteration = executionStack[this.executionStack.length - 1]?.publicInputs;
     }
+    getRequestedDimensions() {
+        return this.requestedDimensions;
+    }
     needsReset() {
         const fns = [
             ()=>this.needsResetNoteHashReadRequests(),
             ()=>this.needsResetNullifierReadRequests(),
-            ()=>this.needsResetNullifierKeys(),
+            ()=>this.needsResetKeyValidationRequests(),
             ()=>this.needsResetTransientData()
         ];
         if (this.nextIteration) {
@@ -87,21 +85,26 @@ export class PrivateKernelResetPrivateInputsBuilder {
             throw new Error('Reset is not required.');
         }
         const isInner = !!this.nextIteration;
-        // "final" reset must be done at most once.
-        // Because the code that silo note hashes can't be run repeatedly.
+        // "final" reset must be done exactly once, because siloing can't be run repeatedly.
         // The dimensions found must be big enough to reset all values, i.e. empty remainder.
         const allowRemainder = isInner;
         const dimensions = findPrivateKernelResetDimensions(this.requestedDimensions, privateKernelResetDimensionsConfig, isInner, allowRemainder);
-        const previousVkMembershipWitness = await oracle.getVkMembershipWitness(this.previousKernelOutput.verificationKey.keyAsFields);
-        const vkData = new VkData(this.previousKernelOutput.verificationKey, Number(previousVkMembershipWitness.leafIndex), previousVkMembershipWitness.siblingPath);
-        const previousKernelData = new PrivateKernelData(this.previousKernelOutput.publicInputs, vkData);
         this.reduceReadRequestActions(this.noteHashResetActions, dimensions.NOTE_HASH_PENDING_READ, dimensions.NOTE_HASH_SETTLED_READ);
         this.reduceReadRequestActions(this.nullifierResetActions, dimensions.NULLIFIER_PENDING_READ, dimensions.NULLIFIER_SETTLED_READ);
+        // Execute all the expensive node querying operations in parallel.
+        const [previousVkMembershipWitness, noteHashReadRequestHints, nullifierReadRequestHints, keyValidationHints] = await Promise.all([
+            oracle.getVkMembershipWitness(this.previousKernelOutput.verificationKey.keyAsFields),
+            buildNoteHashReadRequestHintsFromResetActions(oracle, this.previousKernel.validationRequests.noteHashReadRequests, this.previousKernel.end.noteHashes, this.noteHashResetActions),
+            buildNullifierReadRequestHintsFromResetActions({
+                getNullifierMembershipWitness: getNullifierMembershipWitnessResolver(oracle)
+            }, this.previousKernel.validationRequests.nullifierReadRequests, this.nullifierResetActions),
+            getMasterSecretKeysAndKeyTypeDomainSeparators(this.previousKernel.validationRequests.scopedKeyValidationRequestsAndSeparators, dimensions.KEY_VALIDATION, oracle)
+        ]);
+        const vkData = new VkData(this.previousKernelOutput.verificationKey, Number(previousVkMembershipWitness.leafIndex), previousVkMembershipWitness.siblingPath);
+        const previousKernelData = new PrivateKernelData(this.previousKernelOutput.publicInputs, vkData);
         // TODO: Enable padding when we have a better idea what are the final amounts we should pad to.
         const paddedSideEffects = PaddedSideEffects.empty();
-        return new PrivateKernelResetCircuitPrivateInputs(previousKernelData, paddedSideEffects, new PrivateKernelResetHints(await buildNoteHashReadRequestHintsFromResetActions(oracle, this.previousKernel.validationRequests.noteHashReadRequests, this.previousKernel.end.noteHashes, this.noteHashResetActions), await buildNullifierReadRequestHintsFromResetActions({
-            getNullifierMembershipWitness: getNullifierMembershipWitnessResolver(oracle)
-        }, this.previousKernel.validationRequests.nullifierReadRequests, this.nullifierResetActions), await getMasterSecretKeysAndAppKeyGenerators(this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators, dimensions.KEY_VALIDATION, oracle), this.transientDataSquashingHints), dimensions);
+        return new PrivateKernelResetCircuitPrivateInputs(previousKernelData, paddedSideEffects, new PrivateKernelResetHints(noteHashReadRequestHints, nullifierReadRequestHints, keyValidationHints, this.transientDataSquashingHints), dimensions);
     }
     reduceReadRequestActions(resetActions, maxPending, maxSettled) {
         let numPending = 0;
@@ -124,69 +127,112 @@ export class PrivateKernelResetPrivateInputsBuilder {
         }
         resetActions.pendingReadHints = resetActions.pendingReadHints.slice(0, maxPending);
     }
-    needsResetNoteHashReadRequests(forceResetAll = false) {
+    needsResetNoteHashReadRequests(forceReset = false) {
         const numCurr = this.previousKernel.validationRequests.noteHashReadRequests.claimedLength;
         const numNext = this.nextIteration ? this.nextIteration.noteHashReadRequests.claimedLength : 0;
-        const maxAmountToKeep = !this.nextIteration || forceResetAll ? 0 : MAX_NOTE_HASH_READ_REQUESTS_PER_TX;
+        const maxAmountToKeep = !this.nextIteration || forceReset ? 0 : MAX_NOTE_HASH_READ_REQUESTS_PER_TX;
         if (numCurr + numNext <= maxAmountToKeep) {
             return false;
         }
-        const futureNoteHashes = collectNested(this.executionStack, (executionResult)=>{
-            return executionResult.publicInputs.noteHashes.getActiveItems().map((noteHash)=>new ScopedNoteHash(noteHash, executionResult.publicInputs.callContext.contractAddress));
-        });
-        const resetActions = getNoteHashReadRequestResetActions(this.previousKernel.validationRequests.noteHashReadRequests, this.previousKernel.end.noteHashes, futureNoteHashes);
+        const resetActions = getNoteHashReadRequestResetActions(this.previousKernel.validationRequests.noteHashReadRequests, this.previousKernel.end.noteHashes);
         const numPendingReads = resetActions.pendingReadHints.length;
         const numSettledReads = resetActions.actions.reduce((accum, action)=>accum + (action === ReadRequestActionEnum.READ_AS_SETTLED ? 1 : 0), 0);
+        const totalReadsToReset = numPendingReads + numSettledReads;
+        const minResetNeeded = numCurr + numNext - maxAmountToKeep;
+        if (totalReadsToReset < minResetNeeded) {
+            if (!this.nextIteration) {
+                // In the final reset, all note hashes have been emitted. So if we can't reset all requests, at least one
+                // pending read request doesn't match any of them.
+                throw new Error('No matching note hash found for note hash read request.');
+            } else if (!forceReset) {
+                // A pending read request can only be reset if its note hash has already been included (e.g. a parent call might
+                // be reading a note hash emitted by a child call. The read request of the parent call is included before the note
+                // hash of the child call).
+                // If we can't clear enough read requests to make room for the next iteration's reads, we're stuck.
+                throw new Error('Number of note hash read requests exceeds the limit.');
+            } else if (totalReadsToReset == 0) {
+                // It's transient data squashing asking for the read requests to be reset first (forceReset == true), and
+                // there's nothing to reset, returns false and let needsResetTransientData throw a more descriptive error.
+                return false;
+            }
+        // Otherwise, forceReset is true, we should proceed to reset as many as we can.
+        }
         if (!this.nextIteration) {
+            // If there's no next iteration, we need to reset all the read requests.
             this.noteHashResetActions = resetActions;
             this.requestedDimensions.NOTE_HASH_PENDING_READ = numPendingReads;
             this.requestedDimensions.NOTE_HASH_SETTLED_READ = numSettledReads;
         } else {
-            // Pick only one dimension to reset if next iteration is not empty.
+            // If there's a next iteration, only one dimension can be reset at a time.
+            // So we pick the dimension that has more read requests to reset.
             if (numPendingReads > numSettledReads) {
+                // Reset the pending read requests.
+                const pendingOnlyActions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_PENDING ? action : ReadRequestActionEnum.SKIP), MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
+                this.noteHashResetActions = new ReadRequestResetActions(pendingOnlyActions, resetActions.pendingReadHints);
                 this.requestedDimensions.NOTE_HASH_PENDING_READ = numPendingReads;
-                this.noteHashResetActions.actions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_PENDING ? action : ReadRequestActionEnum.SKIP), MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
-                this.noteHashResetActions.pendingReadHints = resetActions.pendingReadHints;
             } else {
+                // Reset the settled read requests.
+                const settledOnlyActions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_SETTLED ? action : ReadRequestActionEnum.SKIP), MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
+                this.noteHashResetActions = new ReadRequestResetActions(settledOnlyActions, []);
                 this.requestedDimensions.NOTE_HASH_SETTLED_READ = numSettledReads;
-                this.noteHashResetActions.actions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_SETTLED ? action : ReadRequestActionEnum.SKIP), MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
             }
         }
         return true;
     }
-    needsResetNullifierReadRequests(forceResetAll = false) {
+    needsResetNullifierReadRequests(forceReset = false) {
         const numCurr = this.previousKernel.validationRequests.nullifierReadRequests.claimedLength;
         const numNext = this.nextIteration ? this.nextIteration.nullifierReadRequests.claimedLength : 0;
-        const maxAmountToKeep = !this.nextIteration || forceResetAll ? 0 : MAX_NULLIFIER_READ_REQUESTS_PER_TX;
+        const maxAmountToKeep = !this.nextIteration || forceReset ? 0 : MAX_NULLIFIER_READ_REQUESTS_PER_TX;
         if (numCurr + numNext <= maxAmountToKeep) {
             return false;
         }
-        const futureNullifiers = collectNested(this.executionStack, (executionResult)=>{
-            return executionResult.publicInputs.nullifiers.getActiveItems().map((nullifier)=>new ScopedNullifier(nullifier, executionResult.publicInputs.callContext.contractAddress));
-        });
-        const resetActions = getNullifierReadRequestResetActions(this.previousKernel.validationRequests.nullifierReadRequests, this.previousKernel.end.nullifiers, futureNullifiers);
+        const resetActions = getNullifierReadRequestResetActions(this.previousKernel.validationRequests.nullifierReadRequests, this.previousKernel.end.nullifiers);
         const numPendingReads = resetActions.pendingReadHints.length;
         const numSettledReads = resetActions.actions.reduce((accum, action)=>accum + (action === ReadRequestActionEnum.READ_AS_SETTLED ? 1 : 0), 0);
+        const totalReadsToReset = numPendingReads + numSettledReads;
+        const minResetNeeded = numCurr + numNext - maxAmountToKeep;
+        if (totalReadsToReset < minResetNeeded) {
+            if (!this.nextIteration) {
+                // In the final reset, all nullifiers have been emitted. So if we can't reset all requests, at least one pending
+                // read request doesn't match any of them.
+                throw new Error('No matching nullifier found for nullifier read request.');
+            } else if (!forceReset) {
+                // A pending read request can only be reset if its nullifier has already been included (e.g. a parent call might
+                // be reading a nullifier emitted by a child call. The read request of the parent call is included before the
+                // nullifier of the child call).
+                // If we can't clear enough read requests to make room for the next iteration's reads, we're stuck.
+                throw new Error('Number of nullifier read requests exceeds the limit.');
+            } else if (totalReadsToReset == 0) {
+                // It's transient data squashing asking for the read requests to be reset first (forceReset == true), and
+                // there's nothing to reset, returns false and let needsResetTransientData throw a more descriptive error.
+                return false;
+            }
+        // Otherwise, forceReset is true, we should proceed to reset as many as we can.
+        }
         if (!this.nextIteration) {
+            // If there's no next iteration, we need to reset all the read requests.
             this.nullifierResetActions = resetActions;
             this.requestedDimensions.NULLIFIER_PENDING_READ = numPendingReads;
             this.requestedDimensions.NULLIFIER_SETTLED_READ = numSettledReads;
         } else {
-            // Pick only one dimension to reset if next iteration is not empty.
+            // If there's a next iteration, we can only reset one dimension at a time.
             if (numPendingReads > numSettledReads) {
+                // Reset the pending read requests.
+                const pendingOnlyActions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_PENDING ? action : ReadRequestActionEnum.SKIP), MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+                this.nullifierResetActions = new ReadRequestResetActions(pendingOnlyActions, resetActions.pendingReadHints);
                 this.requestedDimensions.NULLIFIER_PENDING_READ = numPendingReads;
-                this.nullifierResetActions.actions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_PENDING ? action : ReadRequestActionEnum.SKIP), MAX_NULLIFIER_READ_REQUESTS_PER_TX);
-                this.nullifierResetActions.pendingReadHints = resetActions.pendingReadHints;
             } else {
+                // Reset the settled read requests.
+                const settledOnlyActions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_SETTLED ? action : ReadRequestActionEnum.SKIP), MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+                this.nullifierResetActions = new ReadRequestResetActions(settledOnlyActions, []);
                 this.requestedDimensions.NULLIFIER_SETTLED_READ = numSettledReads;
-                this.nullifierResetActions.actions = assertLength(resetActions.actions.map((action)=>action === ReadRequestActionEnum.READ_AS_SETTLED ? action : ReadRequestActionEnum.SKIP), MAX_NULLIFIER_READ_REQUESTS_PER_TX);
             }
         }
         return true;
     }
-    needsResetNullifierKeys() {
-        const numCurr = this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators.claimedLength;
-        const numNext = this.nextIteration ? this.nextIteration.keyValidationRequestsAndGenerators.claimedLength : 0;
+    needsResetKeyValidationRequests() {
+        const numCurr = this.previousKernel.validationRequests.scopedKeyValidationRequestsAndSeparators.claimedLength;
+        const numNext = this.nextIteration ? this.nextIteration.keyValidationRequestsAndSeparators.claimedLength : 0;
         const maxAmountToKeep = !this.nextIteration ? 0 : MAX_KEY_VALIDATION_REQUESTS_PER_TX;
         if (numCurr + numNext <= maxAmountToKeep) {
             return false;
@@ -195,8 +241,6 @@ export class PrivateKernelResetPrivateInputsBuilder {
         return true;
     }
     needsResetTransientData() {
-        // Initialize this to 0 so that needsSilo can be run.
-        this.numTransientData = 0;
         const nextAccumNoteHashes = this.previousKernel.end.noteHashes.claimedLength + (this.nextIteration?.noteHashes.claimedLength ?? 0);
         const noteHashWillOverflow = nextAccumNoteHashes > MAX_NOTE_HASHES_PER_TX;
         const nextAccumNullifiers = this.previousKernel.end.nullifiers.claimedLength + (this.nextIteration?.nullifiers.claimedLength ?? 0);
@@ -206,27 +250,45 @@ export class PrivateKernelResetPrivateInputsBuilder {
         if (this.nextIteration && !noteHashWillOverflow && !nullifierWillOverflow && !logsWillOverflow) {
             return false;
         }
-        const futureNoteHashReads = collectNestedReadRequests(this.executionStack, (executionResult)=>executionResult.publicInputs.noteHashReadRequests);
-        const futureNullifierReads = collectNestedReadRequests(this.executionStack, (executionResult)=>executionResult.publicInputs.nullifierReadRequests);
-        // TODO(#15902): Collect future logs and only allow squashing a note hash when all its logs have been emitted
-        // (i.e. none of the future logs are linked to the to-be-squashed note hashes).
+        const futureNoteHashReads = collectNested(this.executionStack, (executionResult)=>executionResult.publicInputs.noteHashReadRequests.getActiveItems());
+        const futureNullifierReads = collectNested(this.executionStack, (executionResult)=>executionResult.publicInputs.nullifierReadRequests.getActiveItems());
+        const futureLogs = collectNested(this.executionStack, (executionResult)=>executionResult.publicInputs.privateLogs.getActiveItems());
         if (this.nextIteration) {
-            // If it's not the final reset, only one dimension will be reset at a time.
-            // The note hashes and nullifiers for the remaining read requests can't be squashed.
+            // If it's not the final reset, only one dimension will be reset at a time. Since we are resetting the transient
+            // data, the note hash and nullifier read requests in the previous kernel won't be squashed and need to be
+            // included in the future read requests.
             futureNoteHashReads.push(...this.previousKernel.validationRequests.noteHashReadRequests.getActiveItems());
             futureNullifierReads.push(...this.previousKernel.validationRequests.nullifierReadRequests.getActiveItems());
         }
-        const { numTransientData, hints: transientDataSquashingHints } = buildTransientDataHints(this.previousKernel.end.noteHashes, this.previousKernel.end.nullifiers, futureNoteHashReads, futureNullifierReads, this.noteHashNullifierCounterMap, this.splitCounter);
-        if (this.nextIteration && !numTransientData) {
-            const forceResetAll = true;
-            const canClearReadRequests = noteHashWillOverflow && this.needsResetNoteHashReadRequests(forceResetAll) || nullifierWillOverflow && this.needsResetNullifierReadRequests(forceResetAll) || logsWillOverflow && this.needsResetNoteHashReadRequests(forceResetAll);
-            if (!canClearReadRequests) {
-                const overflownData = noteHashWillOverflow ? 'note hashes' : nullifierWillOverflow ? 'nullifiers' : 'private logs';
-                throw new Error(`Number of ${overflownData} exceeds the limit.`);
+        const { numTransientData, hints: transientDataSquashingHints } = buildTransientDataHints(this.previousKernel.end.noteHashes, this.previousKernel.end.nullifiers, futureNoteHashReads, futureNullifierReads, futureLogs, this.noteHashNullifierCounterMap, this.splitCounter);
+        if (this.nextIteration) {
+            const noteHashOverflowBy = noteHashWillOverflow ? nextAccumNoteHashes - MAX_NOTE_HASHES_PER_TX - numTransientData : 0;
+            const nullifierOverflowBy = nullifierWillOverflow ? nextAccumNullifiers - MAX_NULLIFIERS_PER_TX - numTransientData : 0;
+            const numSquashedLogs = logsWillOverflow ? countSquashedLogs(this.previousKernel.end.noteHashes, this.previousKernel.end.privateLogs, transientDataSquashingHints.slice(0, numTransientData)) : 0;
+            const logsOverflowBy = logsWillOverflow ? nextAccumLogs - MAX_PRIVATE_LOGS_PER_TX - numSquashedLogs : 0;
+            if (noteHashOverflowBy > 0 || nullifierOverflowBy > 0 || logsOverflowBy > 0) {
+                // There's not enough transient data to squash to clear space for the overflow. It may be because some data is
+                // still required for read requests. Force a reset of the read requests first, and return to transient data
+                // squashing in the next round of reset.
+                // Note that clearing the read requests might not be enough to clear more space for the overflow. In this case,
+                // running the next reset will fail at the following check.
+                // Only one dimension can be reset at a time for an inner reset, so we try the note hash read requests first
+                // (which also helps with log overflow), then fall back to nullifier read requests.
+                const forceReset = true;
+                if ((noteHashOverflowBy > 0 || logsOverflowBy > 0) && this.needsResetNoteHashReadRequests(forceReset)) {
+                    return true;
+                }
+                if (nullifierOverflowBy > 0 && this.needsResetNullifierReadRequests(forceReset)) {
+                    return true;
+                }
+                if (noteHashWillOverflow) {
+                    throw new Error('Number of note hashes exceeds the limit.');
+                }
+                if (nullifierWillOverflow) {
+                    throw new Error('Number of nullifiers exceeds the limit.');
+                }
+                throw new Error('Number of private logs exceeds the limit.');
             }
-            // Clearing the read requests might not be enough to squash the overflown data.
-            // In this case, the next iteration will fail at the above check.
-            return true;
         }
         this.numTransientData = numTransientData;
         this.transientDataSquashingHints = transientDataSquashingHints;
@@ -237,8 +299,12 @@ export class PrivateKernelResetPrivateInputsBuilder {
         if (this.numTransientData === undefined) {
             throw new Error('`needsResetTransientData` must be run before `needsSiloNoteHashes`.');
         }
-        const numNoteHashes = this.previousKernel.end.noteHashes.getActiveItems().filter((n)=>!n.contractAddress.isZero()).length;
-        const numToSilo = Math.max(0, numNoteHashes - this.numTransientData);
+        const noteHashes = this.previousKernel.end.noteHashes;
+        if (noteHashes.claimedLength > 0 && noteHashes.array[0].contractAddress.isZero()) {
+            // Already siloed.
+            return false;
+        }
+        const numToSilo = noteHashes.claimedLength - this.numTransientData;
         this.requestedDimensions.NOTE_HASH_SILOING = numToSilo;
         return numToSilo > 0;
     }
@@ -246,13 +312,13 @@ export class PrivateKernelResetPrivateInputsBuilder {
         if (this.numTransientData === undefined) {
             throw new Error('`needsResetTransientData` must be run before `needsSiloNullifiers`.');
         }
-        const numNullifiers = this.previousKernel.end.nullifiers.getActiveItems().filter((n)=>!n.contractAddress.isZero()).length;
-        const numToSilo = Math.max(0, numNullifiers - this.numTransientData);
-        // Include the first nullifier if there's something to silo.
-        // The reset circuit checks that capped_size must be greater than or equal to all non-empty nullifiers.
-        // Which includes the first nullifier, even though its contract address is always zero and doesn't need siloing.
-        const cappedSize = numToSilo ? numToSilo + 1 : 0;
-        this.requestedDimensions.NULLIFIER_SILOING = cappedSize;
+        const nullifiers = this.previousKernel.end.nullifiers;
+        if (nullifiers.claimedLength > 0 && nullifiers.array[0].contractAddress.isZero()) {
+            // Already siloed.
+            return false;
+        }
+        const numToSilo = nullifiers.claimedLength - this.numTransientData;
+        this.requestedDimensions.NULLIFIER_SILOING = numToSilo;
         return numToSilo > 0;
     }
     needsSiloPrivateLogs() {
@@ -260,11 +326,12 @@ export class PrivateKernelResetPrivateInputsBuilder {
             throw new Error('`needsResetTransientData` must be run before `needsSiloPrivateLogs`.');
         }
         const privateLogs = this.previousKernel.end.privateLogs;
-        const numLogs = privateLogs.getActiveItems().filter((l)=>!l.contractAddress.isZero()).length;
-        const noteHashes = this.previousKernel.end.noteHashes;
-        const squashedNoteHashCounters = this.transientDataSquashingHints.filter((h)=>h.noteHashIndex < noteHashes.claimedLength).map((h)=>noteHashes.array[h.noteHashIndex].counter);
-        const numSquashedLogs = privateLogs.getActiveItems().filter((l)=>squashedNoteHashCounters.includes(l.inner.noteHashCounter)).length;
-        const numToSilo = numLogs - numSquashedLogs;
+        if (privateLogs.claimedLength > 0 && privateLogs.array[0].contractAddress.isZero()) {
+            // Already siloed.
+            return false;
+        }
+        const numSquashedLogs = countSquashedLogs(this.previousKernel.end.noteHashes, privateLogs, this.transientDataSquashingHints.slice(0, this.numTransientData));
+        const numToSilo = privateLogs.claimedLength - numSquashedLogs;
         this.requestedDimensions.PRIVATE_LOG_SILOING = numToSilo;
         return numToSilo > 0;
     }

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

@@ -0,0 +1,122 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { PrivateCircuitPublicInputs, PrivateKernelCircuitPublicInputs, type PrivateKernelSimulateOutput } from '@aztec/stdlib/kernel';
+import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
+/** Builder for PrivateKernelCircuitPublicInputs with fluent API for adding side effects. */
+export declare class PrivateKernelCircuitPublicInputsBuilder {
+    private contractAddress;
+    private noteHashes;
+    private nullifiers;
+    private noteHashReadRequests;
+    private nullifierReadRequests;
+    private keyValidationRequests;
+    private privateLogs;
+    private nextCounter;
+    constructor(contractAddress?: AztecAddress, startCounter?: number);
+    private getCounter;
+    /** Adds a note hash to the accumulated data. Defaults are generated randomly. */
+    addNoteHash(opts?: {
+        value?: Fr;
+        counter?: number;
+        contractAddress?: AztecAddress;
+    }): this;
+    /** Adds a nullifier to the accumulated data. Defaults are generated randomly. */
+    addNullifier(opts?: {
+        value?: Fr;
+        noteHash?: Fr;
+        counter?: number;
+        contractAddress?: AztecAddress;
+    }): this;
+    /** Adds a pending note hash read request (non-empty contract address, can match a pending note hash). */
+    addPendingNoteHashReadRequest(opts?: {
+        value?: Fr;
+        counter?: number;
+        contractAddress?: AztecAddress;
+    }): this;
+    /** Adds a settled note hash read request (empty contract address, resolved against the note hash tree). */
+    addSettledNoteHashReadRequest(opts?: {
+        value?: Fr;
+        counter?: number;
+    }): this;
+    /** Adds a pending nullifier read request (non-empty contract address, can match a pending nullifier). */
+    addPendingNullifierReadRequest(opts?: {
+        value?: Fr;
+        counter?: number;
+        contractAddress?: AztecAddress;
+    }): this;
+    /** Adds a settled nullifier read request (empty contract address, resolved against the nullifier tree). */
+    addSettledNullifierReadRequest(opts?: {
+        value?: Fr;
+        counter?: number;
+    }): this;
+    /** Adds a key validation request to validation requests. */
+    addKeyValidationRequest(opts?: {
+        contractAddress?: AztecAddress;
+    }): this;
+    /** Adds a private log to the accumulated data. Defaults are generated randomly. */
+    addPrivateLog(opts?: {
+        noteHashCounter?: number;
+        counter?: number;
+        contractAddress?: AztecAddress;
+    }): this;
+    /** Builds the PrivateKernelCircuitPublicInputs with all added side effects. */
+    build(): PrivateKernelCircuitPublicInputs;
+}
+/** Builder for PrivateCircuitPublicInputs (call-level) with fluent API for adding side effects. */
+export declare class PrivateCircuitPublicInputsBuilder {
+    private contractAddress;
+    private noteHashes;
+    private nullifiers;
+    private noteHashReadRequests;
+    private nullifierReadRequests;
+    private keyValidationRequests;
+    private privateLogs;
+    private nextCounter;
+    constructor(contractAddress?: AztecAddress, startCounter?: number);
+    private getCounter;
+    /** Adds a note hash. Defaults are generated randomly. */
+    addNoteHash(opts?: {
+        value?: Fr;
+        counter?: number;
+    }): this;
+    /** Adds a nullifier. Defaults are generated randomly. */
+    addNullifier(opts?: {
+        value?: Fr;
+        noteHash?: Fr;
+        counter?: number;
+    }): this;
+    /** Adds a pending note hash read request (non-empty contract address, can match a pending note hash). */
+    addPendingNoteHashReadRequest(opts?: {
+        value?: Fr;
+        counter?: number;
+    }): this;
+    /** Adds a settled note hash read request (empty contract address, resolved against the note hash tree). */
+    addSettledNoteHashReadRequest(opts?: {
+        value?: Fr;
+        counter?: number;
+    }): this;
+    /** Adds a pending nullifier read request (non-empty contract address, can match a pending nullifier). */
+    addPendingNullifierReadRequest(opts?: {
+        value?: Fr;
+        counter?: number;
+    }): this;
+    /** Adds a settled nullifier read request (empty contract address, resolved against the nullifier tree). */
+    addSettledNullifierReadRequest(opts?: {
+        value?: Fr;
+        counter?: number;
+    }): this;
+    /** Adds a key validation request. */
+    addKeyValidationRequest(): this;
+    /** Adds a private log. Defaults are generated randomly. */
+    addPrivateLog(opts?: {
+        noteHashCounter?: number;
+        counter?: number;
+    }): this;
+    /** Builds the PrivateCircuitPublicInputs with all added side effects. */
+    build(): PrivateCircuitPublicInputs;
+}
+/** Wraps a PrivateKernelCircuitPublicInputs in a PrivateKernelSimulateOutput. */
+export declare function makeKernelOutput(publicInputs?: PrivateKernelCircuitPublicInputs): PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>;
+/** Wraps a PrivateCircuitPublicInputs in a PrivateCallExecutionResult. */
+export declare function makeExecutionResult(publicInputs?: PrivateCircuitPublicInputs): PrivateCallExecutionResult;
+//# sourceMappingURL=data:application/json;base64,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